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

char *name = "jeff quadratic root 1";

double f_if(float a, float b, float c) {
        float r8431 = b;
        float r8432 = 0;
        bool r8433 = r8431 >= r8432;
        float r8434 = -r8431;
        float r8435 = r8431 * r8431;
        float r8436 = 4;
        float r8437 = a;
        float r8438 = r8436 * r8437;
        float r8439 = c;
        float r8440 = r8438 * r8439;
        float r8441 = r8435 - r8440;
        float r8442 = sqrt(r8441);
        float r8443 = r8434 - r8442;
        float r8444 = 2;
        float r8445 = r8444 * r8437;
        float r8446 = r8443 / r8445;
        float r8447 = r8444 * r8439;
        float r8448 = r8434 + r8442;
        float r8449 = r8447 / r8448;
        float r8450 = r8433 ? r8446 : r8449;
        return r8450;
}

double f_id(double a, double b, double c) {
        double r8451 = b;
        double r8452 = 0;
        bool r8453 = r8451 >= r8452;
        double r8454 = -r8451;
        double r8455 = r8451 * r8451;
        double r8456 = 4;
        double r8457 = a;
        double r8458 = r8456 * r8457;
        double r8459 = c;
        double r8460 = r8458 * r8459;
        double r8461 = r8455 - r8460;
        double r8462 = sqrt(r8461);
        double r8463 = r8454 - r8462;
        double r8464 = 2;
        double r8465 = r8464 * r8457;
        double r8466 = r8463 / r8465;
        double r8467 = r8464 * r8459;
        double r8468 = r8454 + r8462;
        double r8469 = r8467 / r8468;
        double r8470 = r8453 ? r8466 : r8469;
        return r8470;
}


double f_of(float a, float b, float c) {
        float r8471 = b;
        float r8472 = 0;
        bool r8473 = r8471 >= r8472;
        float r8474 = -r8471;
        float r8475 = r8471 * r8471;
        float r8476 = a;
        float r8477 = c;
        float r8478 = r8476 * r8477;
        float r8479 = 4;
        float r8480 = r8478 * r8479;
        float r8481 = r8475 - r8480;
        float r8482 = sqrt(r8481);
        float r8483 = r8474 - r8482;
        float r8484 = 2;
        float r8485 = r8484 * r8476;
        float r8486 = r8483 / r8485;
        float r8487 = r8484 * r8477;
        float r8488 = r8477 * r8479;
        float r8489 = -r8476;
        float r8490 = r8488 * r8489;
        float r8491 = r8482 + r8471;
        float r8492 = r8490 / r8491;
        float r8493 = r8487 / r8492;
        float r8494 = r8473 ? r8486 : r8493;
        float r8495 = -7.362640111226769e+282;
        bool r8496 = r8494 <= r8495;
        float r8497 = r8477 / r8471;
        float r8498 = r8471 / r8476;
        float r8499 = r8497 - r8498;
        float r8500 = r8484 / r8498;
        float r8501 = r8471 + r8471;
        float r8502 = r8501 / r8477;
        float r8503 = r8500 - r8502;
        float r8504 = r8484 / r8503;
        float r8505 = r8473 ? r8499 : r8504;
        float r8506 = 8.238263215483767e+276;
        bool r8507 = r8494 <= r8506;
        float r8508 = cbrt(r8482);
        float r8509 = r8508 * r8508;
        float r8510 = r8509 * r8508;
        float r8511 = r8474 - r8510;
        float r8512 = r8511 / r8485;
        float r8513 = r8482 - r8471;
        float r8514 = r8487 / r8513;
        float r8515 = r8473 ? r8512 : r8514;
        float r8516 = r8507 ? r8515 : r8505;
        float r8517 = r8496 ? r8505 : r8516;
        return r8517;
}

double f_od(double a, double b, double c) {
        double r8518 = b;
        double r8519 = 0;
        bool r8520 = r8518 >= r8519;
        double r8521 = -r8518;
        double r8522 = r8518 * r8518;
        double r8523 = a;
        double r8524 = c;
        double r8525 = r8523 * r8524;
        double r8526 = 4;
        double r8527 = r8525 * r8526;
        double r8528 = r8522 - r8527;
        double r8529 = sqrt(r8528);
        double r8530 = r8521 - r8529;
        double r8531 = 2;
        double r8532 = r8531 * r8523;
        double r8533 = r8530 / r8532;
        double r8534 = r8531 * r8524;
        double r8535 = r8524 * r8526;
        double r8536 = -r8523;
        double r8537 = r8535 * r8536;
        double r8538 = r8529 + r8518;
        double r8539 = r8537 / r8538;
        double r8540 = r8534 / r8539;
        double r8541 = r8520 ? r8533 : r8540;
        double r8542 = -7.362640111226769e+282;
        bool r8543 = r8541 <= r8542;
        double r8544 = r8524 / r8518;
        double r8545 = r8518 / r8523;
        double r8546 = r8544 - r8545;
        double r8547 = r8531 / r8545;
        double r8548 = r8518 + r8518;
        double r8549 = r8548 / r8524;
        double r8550 = r8547 - r8549;
        double r8551 = r8531 / r8550;
        double r8552 = r8520 ? r8546 : r8551;
        double r8553 = 8.238263215483767e+276;
        bool r8554 = r8541 <= r8553;
        double r8555 = cbrt(r8529);
        double r8556 = r8555 * r8555;
        double r8557 = r8556 * r8555;
        double r8558 = r8521 - r8557;
        double r8559 = r8558 / r8532;
        double r8560 = r8529 - r8518;
        double r8561 = r8534 / r8560;
        double r8562 = r8520 ? r8559 : r8561;
        double r8563 = r8554 ? r8562 : r8552;
        double r8564 = r8543 ? r8552 : r8563;
        return r8564;
}

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 r8565, r8566, r8567, r8568, r8569, r8570, r8571, r8572, r8573, r8574, r8575, r8576, r8577, r8578, r8579, r8580, r8581, r8582, r8583, r8584;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(592);
        mpfr_init(r8565);
        mpfr_init_set_str(r8566, "0", 10, MPFR_RNDN);
        mpfr_init(r8567);
        mpfr_init(r8568);
        mpfr_init(r8569);
        mpfr_init_set_str(r8570, "4", 10, MPFR_RNDN);
        mpfr_init(r8571);
        mpfr_init(r8572);
        mpfr_init(r8573);
        mpfr_init(r8574);
        mpfr_init(r8575);
        mpfr_init(r8576);
        mpfr_init(r8577);
        mpfr_init_set_str(r8578, "2", 10, MPFR_RNDN);
        mpfr_init(r8579);
        mpfr_init(r8580);
        mpfr_init(r8581);
        mpfr_init(r8582);
        mpfr_init(r8583);
        mpfr_init(r8584);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r8565, b, MPFR_RNDN);
        ;
        mpfr_set_si(r8567, mpfr_cmp(r8565, r8566) >= 0, MPFR_RNDN);
        mpfr_neg(r8568, r8565, MPFR_RNDN);
        mpfr_mul(r8569, r8565, r8565, MPFR_RNDN);
        ;
        mpfr_set_d(r8571, a, MPFR_RNDN);
        mpfr_mul(r8572, r8570, r8571, MPFR_RNDN);
        mpfr_set_d(r8573, c, MPFR_RNDN);
        mpfr_mul(r8574, r8572, r8573, MPFR_RNDN);
        mpfr_sub(r8575, r8569, r8574, MPFR_RNDN);
        mpfr_sqrt(r8576, r8575, MPFR_RNDN);
        mpfr_sub(r8577, r8568, r8576, MPFR_RNDN);
        ;
        mpfr_mul(r8579, r8578, r8571, MPFR_RNDN);
        mpfr_div(r8580, r8577, r8579, MPFR_RNDN);
        mpfr_mul(r8581, r8578, r8573, MPFR_RNDN);
        mpfr_add(r8582, r8568, r8576, MPFR_RNDN);
        mpfr_div(r8583, r8581, r8582, MPFR_RNDN);
        if (mpfr_get_si(r8567, MPFR_RNDN)) { mpfr_set(r8584, r8580, MPFR_RNDN); } else { mpfr_set(r8584, r8583, MPFR_RNDN); };
        return mpfr_get_d(r8584, MPFR_RNDN);
}

static mpfr_t r8585, r8586, r8587, r8588, r8589, r8590, r8591, r8592, r8593, r8594, r8595, r8596, r8597, r8598, r8599, r8600, r8601, r8602, r8603, r8604, r8605, r8606, r8607, r8608, r8609, r8610, r8611, r8612, r8613, r8614, r8615, r8616, r8617, r8618, r8619, r8620, r8621, r8622, r8623, r8624, r8625, r8626, r8627, r8628, r8629, r8630, r8631;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(592);
        mpfr_init(r8585);
        mpfr_init_set_str(r8586, "0", 10, MPFR_RNDN);
        mpfr_init(r8587);
        mpfr_init(r8588);
        mpfr_init(r8589);
        mpfr_init(r8590);
        mpfr_init(r8591);
        mpfr_init(r8592);
        mpfr_init_set_str(r8593, "4", 10, MPFR_RNDN);
        mpfr_init(r8594);
        mpfr_init(r8595);
        mpfr_init(r8596);
        mpfr_init(r8597);
        mpfr_init_set_str(r8598, "2", 10, MPFR_RNDN);
        mpfr_init(r8599);
        mpfr_init(r8600);
        mpfr_init(r8601);
        mpfr_init(r8602);
        mpfr_init(r8603);
        mpfr_init(r8604);
        mpfr_init(r8605);
        mpfr_init(r8606);
        mpfr_init(r8607);
        mpfr_init(r8608);
        mpfr_init_set_str(r8609, "-7.362640111226769e+282", 10, MPFR_RNDN);
        mpfr_init(r8610);
        mpfr_init(r8611);
        mpfr_init(r8612);
        mpfr_init(r8613);
        mpfr_init(r8614);
        mpfr_init(r8615);
        mpfr_init(r8616);
        mpfr_init(r8617);
        mpfr_init(r8618);
        mpfr_init(r8619);
        mpfr_init_set_str(r8620, "8.238263215483767e+276", 10, MPFR_RNDN);
        mpfr_init(r8621);
        mpfr_init(r8622);
        mpfr_init(r8623);
        mpfr_init(r8624);
        mpfr_init(r8625);
        mpfr_init(r8626);
        mpfr_init(r8627);
        mpfr_init(r8628);
        mpfr_init(r8629);
        mpfr_init(r8630);
        mpfr_init(r8631);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r8585, b, MPFR_RNDN);
        ;
        mpfr_set_si(r8587, mpfr_cmp(r8585, r8586) >= 0, MPFR_RNDN);
        mpfr_neg(r8588, r8585, MPFR_RNDN);
        mpfr_mul(r8589, r8585, r8585, MPFR_RNDN);
        mpfr_set_d(r8590, a, MPFR_RNDN);
        mpfr_set_d(r8591, c, MPFR_RNDN);
        mpfr_mul(r8592, r8590, r8591, MPFR_RNDN);
        ;
        mpfr_mul(r8594, r8592, r8593, MPFR_RNDN);
        mpfr_sub(r8595, r8589, r8594, MPFR_RNDN);
        mpfr_sqrt(r8596, r8595, MPFR_RNDN);
        mpfr_sub(r8597, r8588, r8596, MPFR_RNDN);
        ;
        mpfr_mul(r8599, r8598, r8590, MPFR_RNDN);
        mpfr_div(r8600, r8597, r8599, MPFR_RNDN);
        mpfr_mul(r8601, r8598, r8591, MPFR_RNDN);
        mpfr_mul(r8602, r8591, r8593, MPFR_RNDN);
        mpfr_neg(r8603, r8590, MPFR_RNDN);
        mpfr_mul(r8604, r8602, r8603, MPFR_RNDN);
        mpfr_add(r8605, r8596, r8585, MPFR_RNDN);
        mpfr_div(r8606, r8604, r8605, MPFR_RNDN);
        mpfr_div(r8607, r8601, r8606, MPFR_RNDN);
        if (mpfr_get_si(r8587, MPFR_RNDN)) { mpfr_set(r8608, r8600, MPFR_RNDN); } else { mpfr_set(r8608, r8607, MPFR_RNDN); };
        ;
        mpfr_set_si(r8610, mpfr_cmp(r8608, r8609) <= 0, MPFR_RNDN);
        mpfr_div(r8611, r8591, r8585, MPFR_RNDN);
        mpfr_div(r8612, r8585, r8590, MPFR_RNDN);
        mpfr_sub(r8613, r8611, r8612, MPFR_RNDN);
        mpfr_div(r8614, r8598, r8612, MPFR_RNDN);
        mpfr_add(r8615, r8585, r8585, MPFR_RNDN);
        mpfr_div(r8616, r8615, r8591, MPFR_RNDN);
        mpfr_sub(r8617, r8614, r8616, MPFR_RNDN);
        mpfr_div(r8618, r8598, r8617, MPFR_RNDN);
        if (mpfr_get_si(r8587, MPFR_RNDN)) { mpfr_set(r8619, r8613, MPFR_RNDN); } else { mpfr_set(r8619, r8618, MPFR_RNDN); };
        ;
        mpfr_set_si(r8621, mpfr_cmp(r8608, r8620) <= 0, MPFR_RNDN);
        mpfr_cbrt(r8622, r8596, MPFR_RNDN);
        mpfr_mul(r8623, r8622, r8622, MPFR_RNDN);
        mpfr_mul(r8624, r8623, r8622, MPFR_RNDN);
        mpfr_sub(r8625, r8588, r8624, MPFR_RNDN);
        mpfr_div(r8626, r8625, r8599, MPFR_RNDN);
        mpfr_sub(r8627, r8596, r8585, MPFR_RNDN);
        mpfr_div(r8628, r8601, r8627, MPFR_RNDN);
        if (mpfr_get_si(r8587, MPFR_RNDN)) { mpfr_set(r8629, r8626, MPFR_RNDN); } else { mpfr_set(r8629, r8628, MPFR_RNDN); };
        if (mpfr_get_si(r8621, MPFR_RNDN)) { mpfr_set(r8630, r8629, MPFR_RNDN); } else { mpfr_set(r8630, r8619, MPFR_RNDN); };
        if (mpfr_get_si(r8610, MPFR_RNDN)) { mpfr_set(r8631, r8619, MPFR_RNDN); } else { mpfr_set(r8631, r8630, MPFR_RNDN); };
        return mpfr_get_d(r8631, MPFR_RNDN);
}

static mpfr_t 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, r8669, r8670, r8671, r8672, r8673, r8674, r8675, r8676, r8677, r8678;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(592);
        mpfr_init(r8632);
        mpfr_init_set_str(r8633, "0", 10, MPFR_RNDN);
        mpfr_init(r8634);
        mpfr_init(r8635);
        mpfr_init(r8636);
        mpfr_init(r8637);
        mpfr_init(r8638);
        mpfr_init(r8639);
        mpfr_init_set_str(r8640, "4", 10, MPFR_RNDN);
        mpfr_init(r8641);
        mpfr_init(r8642);
        mpfr_init(r8643);
        mpfr_init(r8644);
        mpfr_init_set_str(r8645, "2", 10, MPFR_RNDN);
        mpfr_init(r8646);
        mpfr_init(r8647);
        mpfr_init(r8648);
        mpfr_init(r8649);
        mpfr_init(r8650);
        mpfr_init(r8651);
        mpfr_init(r8652);
        mpfr_init(r8653);
        mpfr_init(r8654);
        mpfr_init(r8655);
        mpfr_init_set_str(r8656, "-7.362640111226769e+282", 10, MPFR_RNDN);
        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_set_str(r8667, "8.238263215483767e+276", 10, MPFR_RNDN);
        mpfr_init(r8668);
        mpfr_init(r8669);
        mpfr_init(r8670);
        mpfr_init(r8671);
        mpfr_init(r8672);
        mpfr_init(r8673);
        mpfr_init(r8674);
        mpfr_init(r8675);
        mpfr_init(r8676);
        mpfr_init(r8677);
        mpfr_init(r8678);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r8632, b, MPFR_RNDN);
        ;
        mpfr_set_si(r8634, mpfr_cmp(r8632, r8633) >= 0, MPFR_RNDN);
        mpfr_neg(r8635, r8632, MPFR_RNDN);
        mpfr_mul(r8636, r8632, r8632, MPFR_RNDN);
        mpfr_set_d(r8637, a, MPFR_RNDN);
        mpfr_set_d(r8638, c, MPFR_RNDN);
        mpfr_mul(r8639, r8637, r8638, MPFR_RNDN);
        ;
        mpfr_mul(r8641, r8639, r8640, MPFR_RNDN);
        mpfr_sub(r8642, r8636, r8641, MPFR_RNDN);
        mpfr_sqrt(r8643, r8642, MPFR_RNDN);
        mpfr_sub(r8644, r8635, r8643, MPFR_RNDN);
        ;
        mpfr_mul(r8646, r8645, r8637, MPFR_RNDN);
        mpfr_div(r8647, r8644, r8646, MPFR_RNDN);
        mpfr_mul(r8648, r8645, r8638, MPFR_RNDN);
        mpfr_mul(r8649, r8638, r8640, MPFR_RNDN);
        mpfr_neg(r8650, r8637, MPFR_RNDN);
        mpfr_mul(r8651, r8649, r8650, MPFR_RNDN);
        mpfr_add(r8652, r8643, r8632, MPFR_RNDN);
        mpfr_div(r8653, r8651, r8652, MPFR_RNDN);
        mpfr_div(r8654, r8648, r8653, MPFR_RNDN);
        if (mpfr_get_si(r8634, MPFR_RNDN)) { mpfr_set(r8655, r8647, MPFR_RNDN); } else { mpfr_set(r8655, r8654, MPFR_RNDN); };
        ;
        mpfr_set_si(r8657, mpfr_cmp(r8655, r8656) <= 0, MPFR_RNDN);
        mpfr_div(r8658, r8638, r8632, MPFR_RNDN);
        mpfr_div(r8659, r8632, r8637, MPFR_RNDN);
        mpfr_sub(r8660, r8658, r8659, MPFR_RNDN);
        mpfr_div(r8661, r8645, r8659, MPFR_RNDN);
        mpfr_add(r8662, r8632, r8632, MPFR_RNDN);
        mpfr_div(r8663, r8662, r8638, MPFR_RNDN);
        mpfr_sub(r8664, r8661, r8663, MPFR_RNDN);
        mpfr_div(r8665, r8645, r8664, MPFR_RNDN);
        if (mpfr_get_si(r8634, MPFR_RNDN)) { mpfr_set(r8666, r8660, MPFR_RNDN); } else { mpfr_set(r8666, r8665, MPFR_RNDN); };
        ;
        mpfr_set_si(r8668, mpfr_cmp(r8655, r8667) <= 0, MPFR_RNDN);
        mpfr_cbrt(r8669, r8643, MPFR_RNDN);
        mpfr_mul(r8670, r8669, r8669, MPFR_RNDN);
        mpfr_mul(r8671, r8670, r8669, MPFR_RNDN);
        mpfr_sub(r8672, r8635, r8671, MPFR_RNDN);
        mpfr_div(r8673, r8672, r8646, MPFR_RNDN);
        mpfr_sub(r8674, r8643, r8632, MPFR_RNDN);
        mpfr_div(r8675, r8648, r8674, MPFR_RNDN);
        if (mpfr_get_si(r8634, MPFR_RNDN)) { mpfr_set(r8676, r8673, MPFR_RNDN); } else { mpfr_set(r8676, r8675, MPFR_RNDN); };
        if (mpfr_get_si(r8668, MPFR_RNDN)) { mpfr_set(r8677, r8676, MPFR_RNDN); } else { mpfr_set(r8677, r8666, MPFR_RNDN); };
        if (mpfr_get_si(r8657, MPFR_RNDN)) { mpfr_set(r8678, r8666, MPFR_RNDN); } else { mpfr_set(r8678, r8677, MPFR_RNDN); };
        return mpfr_get_d(r8678, MPFR_RNDN);
}