#include <tgmath.h>
#include <gmp.h>
#include <mpfr.h>
#include <stdio.h>
#include <stdbool.h>

char *name = "Quadratic roots, full range";

double f_if(float a, float b, float c) {
        float r8495 = b;
        float r8496 = -r8495;
        float r8497 = r8495 * r8495;
        float r8498 = 4;
        float r8499 = a;
        float r8500 = r8498 * r8499;
        float r8501 = c;
        float r8502 = r8500 * r8501;
        float r8503 = r8497 - r8502;
        float r8504 = sqrt(r8503);
        float r8505 = r8496 + r8504;
        float r8506 = 2;
        float r8507 = r8506 * r8499;
        float r8508 = r8505 / r8507;
        return r8508;
}

double f_id(double a, double b, double c) {
        double r8509 = b;
        double r8510 = -r8509;
        double r8511 = r8509 * r8509;
        double r8512 = 4;
        double r8513 = a;
        double r8514 = r8512 * r8513;
        double r8515 = c;
        double r8516 = r8514 * r8515;
        double r8517 = r8511 - r8516;
        double r8518 = sqrt(r8517);
        double r8519 = r8510 + r8518;
        double r8520 = 2;
        double r8521 = r8520 * r8513;
        double r8522 = r8519 / r8521;
        return r8522;
}


double f_of(float a, float b, float c) {
        float r8523 = b;
        float r8524 = -3.5854635547346624e+145;
        bool r8525 = r8523 <= r8524;
        float r8526 = c;
        float r8527 = 2;
        float r8528 = r8526 / r8527;
        float r8529 = -r8528;
        float r8530 = 4;
        float r8531 = a;
        float r8532 = r8531 * r8526;
        float r8533 = r8532 / r8523;
        float r8534 = r8527 * r8533;
        float r8535 = r8530 / r8534;
        float r8536 = r8529 * r8535;
        float r8537 = -4.0540026836322524e-192;
        bool r8538 = r8523 <= r8537;
        float r8539 = 1;
        float r8540 = r8527 * r8531;
        float r8541 = r8530 * r8531;
        float r8542 = -r8526;
        float r8543 = r8523 * r8523;
        float r8544 = fma(r8541, r8542, r8543);
        float r8545 = sqrt(r8544);
        float r8546 = r8545 - r8523;
        float r8547 = r8540 / r8546;
        float r8548 = r8539 / r8547;
        float r8549 = 2.696518439055105e+143;
        bool r8550 = r8523 <= r8549;
        float r8551 = pow(r8523, r8527);
        float r8552 = r8530 * r8532;
        float r8553 = r8551 - r8552;
        float r8554 = sqrt(r8553);
        float r8555 = r8523 + r8554;
        float r8556 = r8530 / r8555;
        float r8557 = r8529 * r8556;
        float r8558 = r8530 / r8527;
        float r8559 = r8558 / r8527;
        float r8560 = r8531 / r8523;
        float r8561 = fma(r8560, r8542, r8523);
        float r8562 = r8542 / r8561;
        float r8563 = r8559 * r8562;
        float r8564 = r8550 ? r8557 : r8563;
        float r8565 = r8538 ? r8548 : r8564;
        float r8566 = r8525 ? r8536 : r8565;
        return r8566;
}

double f_od(double a, double b, double c) {
        double r8567 = b;
        double r8568 = -3.5854635547346624e+145;
        bool r8569 = r8567 <= r8568;
        double r8570 = c;
        double r8571 = 2;
        double r8572 = r8570 / r8571;
        double r8573 = -r8572;
        double r8574 = 4;
        double r8575 = a;
        double r8576 = r8575 * r8570;
        double r8577 = r8576 / r8567;
        double r8578 = r8571 * r8577;
        double r8579 = r8574 / r8578;
        double r8580 = r8573 * r8579;
        double r8581 = -4.0540026836322524e-192;
        bool r8582 = r8567 <= r8581;
        double r8583 = 1;
        double r8584 = r8571 * r8575;
        double r8585 = r8574 * r8575;
        double r8586 = -r8570;
        double r8587 = r8567 * r8567;
        double r8588 = fma(r8585, r8586, r8587);
        double r8589 = sqrt(r8588);
        double r8590 = r8589 - r8567;
        double r8591 = r8584 / r8590;
        double r8592 = r8583 / r8591;
        double r8593 = 2.696518439055105e+143;
        bool r8594 = r8567 <= r8593;
        double r8595 = pow(r8567, r8571);
        double r8596 = r8574 * r8576;
        double r8597 = r8595 - r8596;
        double r8598 = sqrt(r8597);
        double r8599 = r8567 + r8598;
        double r8600 = r8574 / r8599;
        double r8601 = r8573 * r8600;
        double r8602 = r8574 / r8571;
        double r8603 = r8602 / r8571;
        double r8604 = r8575 / r8567;
        double r8605 = fma(r8604, r8586, r8567);
        double r8606 = r8586 / r8605;
        double r8607 = r8603 * r8606;
        double r8608 = r8594 ? r8601 : r8607;
        double r8609 = r8582 ? r8592 : r8608;
        double r8610 = r8569 ? r8580 : r8609;
        return r8610;
}

void mpfr_fmod2(mpfr_t r, mpfr_t n, mpfr_t d, mpfr_rnd_t rmd) {
        mpfr_fmod(r, n, d, rmd);
        if (mpfr_cmp_ui(r, 0) < 0) mpfr_add(r, r, d, rmd);
}


static mpfr_t r8611, r8612, r8613, r8614, r8615, r8616, r8617, r8618, r8619, r8620, r8621, r8622, r8623, r8624;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8611);
        mpfr_init(r8612);
        mpfr_init(r8613);
        mpfr_init_set_str(r8614, "4", 10, MPFR_RNDN);
        mpfr_init(r8615);
        mpfr_init(r8616);
        mpfr_init(r8617);
        mpfr_init(r8618);
        mpfr_init(r8619);
        mpfr_init(r8620);
        mpfr_init(r8621);
        mpfr_init_set_str(r8622, "2", 10, MPFR_RNDN);
        mpfr_init(r8623);
        mpfr_init(r8624);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r8611, b, MPFR_RNDN);
        mpfr_neg(r8612, r8611, MPFR_RNDN);
        mpfr_mul(r8613, r8611, r8611, MPFR_RNDN);
        ;
        mpfr_set_d(r8615, a, MPFR_RNDN);
        mpfr_mul(r8616, r8614, r8615, MPFR_RNDN);
        mpfr_set_d(r8617, c, MPFR_RNDN);
        mpfr_mul(r8618, r8616, r8617, MPFR_RNDN);
        mpfr_sub(r8619, r8613, r8618, MPFR_RNDN);
        mpfr_sqrt(r8620, r8619, MPFR_RNDN);
        mpfr_add(r8621, r8612, r8620, MPFR_RNDN);
        ;
        mpfr_mul(r8623, r8622, r8615, MPFR_RNDN);
        mpfr_div(r8624, r8621, r8623, MPFR_RNDN);
        return mpfr_get_d(r8624, MPFR_RNDN);
}

static mpfr_t r8625, r8626, r8627, r8628, r8629, r8630, r8631, r8632, r8633, r8634, r8635, r8636, r8637, r8638, r8639, r8640, r8641, r8642, r8643, r8644, r8645, r8646, r8647, r8648, r8649, r8650, r8651, r8652, r8653, r8654, r8655, r8656, r8657, r8658, r8659, r8660, r8661, r8662, r8663, r8664, r8665, r8666, r8667, r8668;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8625);
        mpfr_init_set_str(r8626, "-3.5854635547346624e+145", 10, MPFR_RNDN);
        mpfr_init(r8627);
        mpfr_init(r8628);
        mpfr_init_set_str(r8629, "2", 10, MPFR_RNDN);
        mpfr_init(r8630);
        mpfr_init(r8631);
        mpfr_init_set_str(r8632, "4", 10, MPFR_RNDN);
        mpfr_init(r8633);
        mpfr_init(r8634);
        mpfr_init(r8635);
        mpfr_init(r8636);
        mpfr_init(r8637);
        mpfr_init(r8638);
        mpfr_init_set_str(r8639, "-4.0540026836322524e-192", 10, MPFR_RNDN);
        mpfr_init(r8640);
        mpfr_init_set_str(r8641, "1", 10, MPFR_RNDN);
        mpfr_init(r8642);
        mpfr_init(r8643);
        mpfr_init(r8644);
        mpfr_init(r8645);
        mpfr_init(r8646);
        mpfr_init(r8647);
        mpfr_init(r8648);
        mpfr_init(r8649);
        mpfr_init(r8650);
        mpfr_init_set_str(r8651, "2.696518439055105e+143", 10, MPFR_RNDN);
        mpfr_init(r8652);
        mpfr_init(r8653);
        mpfr_init(r8654);
        mpfr_init(r8655);
        mpfr_init(r8656);
        mpfr_init(r8657);
        mpfr_init(r8658);
        mpfr_init(r8659);
        mpfr_init(r8660);
        mpfr_init(r8661);
        mpfr_init(r8662);
        mpfr_init(r8663);
        mpfr_init(r8664);
        mpfr_init(r8665);
        mpfr_init(r8666);
        mpfr_init(r8667);
        mpfr_init(r8668);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r8625, b, MPFR_RNDN);
        ;
        mpfr_set_si(r8627, mpfr_cmp(r8625, r8626) <= 0, MPFR_RNDN);
        mpfr_set_d(r8628, c, MPFR_RNDN);
        ;
        mpfr_div(r8630, r8628, r8629, MPFR_RNDN);
        mpfr_neg(r8631, r8630, MPFR_RNDN);
        ;
        mpfr_set_d(r8633, a, MPFR_RNDN);
        mpfr_mul(r8634, r8633, r8628, MPFR_RNDN);
        mpfr_div(r8635, r8634, r8625, MPFR_RNDN);
        mpfr_mul(r8636, r8629, r8635, MPFR_RNDN);
        mpfr_div(r8637, r8632, r8636, MPFR_RNDN);
        mpfr_mul(r8638, r8631, r8637, MPFR_RNDN);
        ;
        mpfr_set_si(r8640, mpfr_cmp(r8625, r8639) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r8642, r8629, r8633, MPFR_RNDN);
        mpfr_mul(r8643, r8632, r8633, MPFR_RNDN);
        mpfr_neg(r8644, r8628, MPFR_RNDN);
        mpfr_mul(r8645, r8625, r8625, MPFR_RNDN);
        mpfr_fma(r8646, r8643, r8644, r8645, MPFR_RNDN);
        mpfr_sqrt(r8647, r8646, MPFR_RNDN);
        mpfr_sub(r8648, r8647, r8625, MPFR_RNDN);
        mpfr_div(r8649, r8642, r8648, MPFR_RNDN);
        mpfr_div(r8650, r8641, r8649, MPFR_RNDN);
        ;
        mpfr_set_si(r8652, mpfr_cmp(r8625, r8651) <= 0, MPFR_RNDN);
        mpfr_pow(r8653, r8625, r8629, MPFR_RNDN);
        mpfr_mul(r8654, r8632, r8634, MPFR_RNDN);
        mpfr_sub(r8655, r8653, r8654, MPFR_RNDN);
        mpfr_sqrt(r8656, r8655, MPFR_RNDN);
        mpfr_add(r8657, r8625, r8656, MPFR_RNDN);
        mpfr_div(r8658, r8632, r8657, MPFR_RNDN);
        mpfr_mul(r8659, r8631, r8658, MPFR_RNDN);
        mpfr_div(r8660, r8632, r8629, MPFR_RNDN);
        mpfr_div(r8661, r8660, r8629, MPFR_RNDN);
        mpfr_div(r8662, r8633, r8625, MPFR_RNDN);
        mpfr_fma(r8663, r8662, r8644, r8625, MPFR_RNDN);
        mpfr_div(r8664, r8644, r8663, MPFR_RNDN);
        mpfr_mul(r8665, r8661, r8664, MPFR_RNDN);
        if (mpfr_get_si(r8652, MPFR_RNDN)) { mpfr_set(r8666, r8659, MPFR_RNDN); } else { mpfr_set(r8666, r8665, MPFR_RNDN); };
        if (mpfr_get_si(r8640, MPFR_RNDN)) { mpfr_set(r8667, r8650, MPFR_RNDN); } else { mpfr_set(r8667, r8666, MPFR_RNDN); };
        if (mpfr_get_si(r8627, MPFR_RNDN)) { mpfr_set(r8668, r8638, MPFR_RNDN); } else { mpfr_set(r8668, r8667, MPFR_RNDN); };
        return mpfr_get_d(r8668, MPFR_RNDN);
}

static mpfr_t r8669, r8670, r8671, r8672, r8673, r8674, r8675, r8676, r8677, r8678, r8679, r8680, r8681, r8682, r8683, r8684, r8685, r8686, r8687, r8688, r8689, r8690, r8691, r8692, r8693, r8694, r8695, r8696, r8697, r8698, r8699, r8700, r8701, r8702, r8703, r8704, r8705, r8706, r8707, r8708, r8709, r8710, r8711, r8712;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8669);
        mpfr_init_set_str(r8670, "-3.5854635547346624e+145", 10, MPFR_RNDN);
        mpfr_init(r8671);
        mpfr_init(r8672);
        mpfr_init_set_str(r8673, "2", 10, MPFR_RNDN);
        mpfr_init(r8674);
        mpfr_init(r8675);
        mpfr_init_set_str(r8676, "4", 10, MPFR_RNDN);
        mpfr_init(r8677);
        mpfr_init(r8678);
        mpfr_init(r8679);
        mpfr_init(r8680);
        mpfr_init(r8681);
        mpfr_init(r8682);
        mpfr_init_set_str(r8683, "-4.0540026836322524e-192", 10, MPFR_RNDN);
        mpfr_init(r8684);
        mpfr_init_set_str(r8685, "1", 10, MPFR_RNDN);
        mpfr_init(r8686);
        mpfr_init(r8687);
        mpfr_init(r8688);
        mpfr_init(r8689);
        mpfr_init(r8690);
        mpfr_init(r8691);
        mpfr_init(r8692);
        mpfr_init(r8693);
        mpfr_init(r8694);
        mpfr_init_set_str(r8695, "2.696518439055105e+143", 10, MPFR_RNDN);
        mpfr_init(r8696);
        mpfr_init(r8697);
        mpfr_init(r8698);
        mpfr_init(r8699);
        mpfr_init(r8700);
        mpfr_init(r8701);
        mpfr_init(r8702);
        mpfr_init(r8703);
        mpfr_init(r8704);
        mpfr_init(r8705);
        mpfr_init(r8706);
        mpfr_init(r8707);
        mpfr_init(r8708);
        mpfr_init(r8709);
        mpfr_init(r8710);
        mpfr_init(r8711);
        mpfr_init(r8712);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r8669, b, MPFR_RNDN);
        ;
        mpfr_set_si(r8671, mpfr_cmp(r8669, r8670) <= 0, MPFR_RNDN);
        mpfr_set_d(r8672, c, MPFR_RNDN);
        ;
        mpfr_div(r8674, r8672, r8673, MPFR_RNDN);
        mpfr_neg(r8675, r8674, MPFR_RNDN);
        ;
        mpfr_set_d(r8677, a, MPFR_RNDN);
        mpfr_mul(r8678, r8677, r8672, MPFR_RNDN);
        mpfr_div(r8679, r8678, r8669, MPFR_RNDN);
        mpfr_mul(r8680, r8673, r8679, MPFR_RNDN);
        mpfr_div(r8681, r8676, r8680, MPFR_RNDN);
        mpfr_mul(r8682, r8675, r8681, MPFR_RNDN);
        ;
        mpfr_set_si(r8684, mpfr_cmp(r8669, r8683) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r8686, r8673, r8677, MPFR_RNDN);
        mpfr_mul(r8687, r8676, r8677, MPFR_RNDN);
        mpfr_neg(r8688, r8672, MPFR_RNDN);
        mpfr_mul(r8689, r8669, r8669, MPFR_RNDN);
        mpfr_fma(r8690, r8687, r8688, r8689, MPFR_RNDN);
        mpfr_sqrt(r8691, r8690, MPFR_RNDN);
        mpfr_sub(r8692, r8691, r8669, MPFR_RNDN);
        mpfr_div(r8693, r8686, r8692, MPFR_RNDN);
        mpfr_div(r8694, r8685, r8693, MPFR_RNDN);
        ;
        mpfr_set_si(r8696, mpfr_cmp(r8669, r8695) <= 0, MPFR_RNDN);
        mpfr_pow(r8697, r8669, r8673, MPFR_RNDN);
        mpfr_mul(r8698, r8676, r8678, MPFR_RNDN);
        mpfr_sub(r8699, r8697, r8698, MPFR_RNDN);
        mpfr_sqrt(r8700, r8699, MPFR_RNDN);
        mpfr_add(r8701, r8669, r8700, MPFR_RNDN);
        mpfr_div(r8702, r8676, r8701, MPFR_RNDN);
        mpfr_mul(r8703, r8675, r8702, MPFR_RNDN);
        mpfr_div(r8704, r8676, r8673, MPFR_RNDN);
        mpfr_div(r8705, r8704, r8673, MPFR_RNDN);
        mpfr_div(r8706, r8677, r8669, MPFR_RNDN);
        mpfr_fma(r8707, r8706, r8688, r8669, MPFR_RNDN);
        mpfr_div(r8708, r8688, r8707, MPFR_RNDN);
        mpfr_mul(r8709, r8705, r8708, MPFR_RNDN);
        if (mpfr_get_si(r8696, MPFR_RNDN)) { mpfr_set(r8710, r8703, MPFR_RNDN); } else { mpfr_set(r8710, r8709, MPFR_RNDN); };
        if (mpfr_get_si(r8684, MPFR_RNDN)) { mpfr_set(r8711, r8694, MPFR_RNDN); } else { mpfr_set(r8711, r8710, MPFR_RNDN); };
        if (mpfr_get_si(r8671, MPFR_RNDN)) { mpfr_set(r8712, r8682, MPFR_RNDN); } else { mpfr_set(r8712, r8711, MPFR_RNDN); };
        return mpfr_get_d(r8712, MPFR_RNDN);
}