#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 r8467 = b;
        float r8468 = -r8467;
        float r8469 = r8467 * r8467;
        float r8470 = 4;
        float r8471 = a;
        float r8472 = r8470 * r8471;
        float r8473 = c;
        float r8474 = r8472 * r8473;
        float r8475 = r8469 - r8474;
        float r8476 = sqrt(r8475);
        float r8477 = r8468 + r8476;
        float r8478 = 2;
        float r8479 = r8478 * r8471;
        float r8480 = r8477 / r8479;
        return r8480;
}

double f_id(double a, double b, double c) {
        double r8481 = b;
        double r8482 = -r8481;
        double r8483 = r8481 * r8481;
        double r8484 = 4;
        double r8485 = a;
        double r8486 = r8484 * r8485;
        double r8487 = c;
        double r8488 = r8486 * r8487;
        double r8489 = r8483 - r8488;
        double r8490 = sqrt(r8489);
        double r8491 = r8482 + r8490;
        double r8492 = 2;
        double r8493 = r8492 * r8485;
        double r8494 = r8491 / r8493;
        return r8494;
}


double f_of(float a, float b, float c) {
        float r8495 = b;
        float r8496 = -r8495;
        float r8497 = -5.821596402918175e+115;
        bool r8498 = r8496 <= r8497;
        float r8499 = c;
        float r8500 = r8499 / r8495;
        float r8501 = -r8500;
        float r8502 = -1.9516615171416054e-122;
        bool r8503 = r8496 <= r8502;
        float r8504 = 4;
        float r8505 = a;
        float r8506 = r8499 * r8505;
        float r8507 = r8504 * r8506;
        float r8508 = r8495 * r8495;
        float r8509 = r8504 * r8505;
        float r8510 = r8509 * r8499;
        float r8511 = r8508 - r8510;
        float r8512 = sqrt(r8511);
        float r8513 = r8496 - r8512;
        float r8514 = r8507 / r8513;
        float r8515 = 2;
        float r8516 = r8505 * r8515;
        float r8517 = r8514 / r8516;
        float r8518 = 3.092591079713731e+103;
        bool r8519 = r8496 <= r8518;
        float r8520 = r8512 + r8496;
        float r8521 = r8520 / r8516;
        float r8522 = r8495 / r8505;
        float r8523 = r8500 - r8522;
        float r8524 = r8519 ? r8521 : r8523;
        float r8525 = r8503 ? r8517 : r8524;
        float r8526 = r8498 ? r8501 : r8525;
        return r8526;
}

double f_od(double a, double b, double c) {
        double r8527 = b;
        double r8528 = -r8527;
        double r8529 = -5.821596402918175e+115;
        bool r8530 = r8528 <= r8529;
        double r8531 = c;
        double r8532 = r8531 / r8527;
        double r8533 = -r8532;
        double r8534 = -1.9516615171416054e-122;
        bool r8535 = r8528 <= r8534;
        double r8536 = 4;
        double r8537 = a;
        double r8538 = r8531 * r8537;
        double r8539 = r8536 * r8538;
        double r8540 = r8527 * r8527;
        double r8541 = r8536 * r8537;
        double r8542 = r8541 * r8531;
        double r8543 = r8540 - r8542;
        double r8544 = sqrt(r8543);
        double r8545 = r8528 - r8544;
        double r8546 = r8539 / r8545;
        double r8547 = 2;
        double r8548 = r8537 * r8547;
        double r8549 = r8546 / r8548;
        double r8550 = 3.092591079713731e+103;
        bool r8551 = r8528 <= r8550;
        double r8552 = r8544 + r8528;
        double r8553 = r8552 / r8548;
        double r8554 = r8527 / r8537;
        double r8555 = r8532 - r8554;
        double r8556 = r8551 ? r8553 : r8555;
        double r8557 = r8535 ? r8549 : r8556;
        double r8558 = r8530 ? r8533 : r8557;
        return r8558;
}

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 r8559, r8560, r8561, r8562, r8563, r8564, r8565, r8566, r8567, r8568, r8569, r8570, r8571, r8572;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8559);
        mpfr_init(r8560);
        mpfr_init(r8561);
        mpfr_init_set_str(r8562, "4", 10, MPFR_RNDN);
        mpfr_init(r8563);
        mpfr_init(r8564);
        mpfr_init(r8565);
        mpfr_init(r8566);
        mpfr_init(r8567);
        mpfr_init(r8568);
        mpfr_init(r8569);
        mpfr_init_set_str(r8570, "2", 10, MPFR_RNDN);
        mpfr_init(r8571);
        mpfr_init(r8572);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r8559, b, MPFR_RNDN);
        mpfr_neg(r8560, r8559, MPFR_RNDN);
        mpfr_mul(r8561, r8559, r8559, MPFR_RNDN);
        ;
        mpfr_set_d(r8563, a, MPFR_RNDN);
        mpfr_mul(r8564, r8562, r8563, MPFR_RNDN);
        mpfr_set_d(r8565, c, MPFR_RNDN);
        mpfr_mul(r8566, r8564, r8565, MPFR_RNDN);
        mpfr_sub(r8567, r8561, r8566, MPFR_RNDN);
        mpfr_sqrt(r8568, r8567, MPFR_RNDN);
        mpfr_add(r8569, r8560, r8568, MPFR_RNDN);
        ;
        mpfr_mul(r8571, r8570, r8563, MPFR_RNDN);
        mpfr_div(r8572, r8569, r8571, MPFR_RNDN);
        return mpfr_get_d(r8572, MPFR_RNDN);
}

static mpfr_t r8573, r8574, r8575, r8576, r8577, r8578, r8579, r8580, r8581, r8582, r8583, r8584, r8585, r8586, r8587, r8588, r8589, r8590, r8591, r8592, r8593, r8594, r8595, r8596, r8597, r8598, r8599, r8600, r8601, r8602, r8603, r8604;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8573);
        mpfr_init(r8574);
        mpfr_init_set_str(r8575, "-5.821596402918175e+115", 10, MPFR_RNDN);
        mpfr_init(r8576);
        mpfr_init(r8577);
        mpfr_init(r8578);
        mpfr_init(r8579);
        mpfr_init_set_str(r8580, "-1.9516615171416054e-122", 10, MPFR_RNDN);
        mpfr_init(r8581);
        mpfr_init_set_str(r8582, "4", 10, MPFR_RNDN);
        mpfr_init(r8583);
        mpfr_init(r8584);
        mpfr_init(r8585);
        mpfr_init(r8586);
        mpfr_init(r8587);
        mpfr_init(r8588);
        mpfr_init(r8589);
        mpfr_init(r8590);
        mpfr_init(r8591);
        mpfr_init(r8592);
        mpfr_init_set_str(r8593, "2", 10, MPFR_RNDN);
        mpfr_init(r8594);
        mpfr_init(r8595);
        mpfr_init_set_str(r8596, "3.092591079713731e+103", 10, MPFR_RNDN);
        mpfr_init(r8597);
        mpfr_init(r8598);
        mpfr_init(r8599);
        mpfr_init(r8600);
        mpfr_init(r8601);
        mpfr_init(r8602);
        mpfr_init(r8603);
        mpfr_init(r8604);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r8573, b, MPFR_RNDN);
        mpfr_neg(r8574, r8573, MPFR_RNDN);
        ;
        mpfr_set_si(r8576, mpfr_cmp(r8574, r8575) <= 0, MPFR_RNDN);
        mpfr_set_d(r8577, c, MPFR_RNDN);
        mpfr_div(r8578, r8577, r8573, MPFR_RNDN);
        mpfr_neg(r8579, r8578, MPFR_RNDN);
        ;
        mpfr_set_si(r8581, mpfr_cmp(r8574, r8580) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r8583, a, MPFR_RNDN);
        mpfr_mul(r8584, r8577, r8583, MPFR_RNDN);
        mpfr_mul(r8585, r8582, r8584, MPFR_RNDN);
        mpfr_mul(r8586, r8573, r8573, MPFR_RNDN);
        mpfr_mul(r8587, r8582, r8583, MPFR_RNDN);
        mpfr_mul(r8588, r8587, r8577, MPFR_RNDN);
        mpfr_sub(r8589, r8586, r8588, MPFR_RNDN);
        mpfr_sqrt(r8590, r8589, MPFR_RNDN);
        mpfr_sub(r8591, r8574, r8590, MPFR_RNDN);
        mpfr_div(r8592, r8585, r8591, MPFR_RNDN);
        ;
        mpfr_mul(r8594, r8583, r8593, MPFR_RNDN);
        mpfr_div(r8595, r8592, r8594, MPFR_RNDN);
        ;
        mpfr_set_si(r8597, mpfr_cmp(r8574, r8596) <= 0, MPFR_RNDN);
        mpfr_add(r8598, r8590, r8574, MPFR_RNDN);
        mpfr_div(r8599, r8598, r8594, MPFR_RNDN);
        mpfr_div(r8600, r8573, r8583, MPFR_RNDN);
        mpfr_sub(r8601, r8578, r8600, MPFR_RNDN);
        if (mpfr_get_si(r8597, MPFR_RNDN)) { mpfr_set(r8602, r8599, MPFR_RNDN); } else { mpfr_set(r8602, r8601, MPFR_RNDN); };
        if (mpfr_get_si(r8581, MPFR_RNDN)) { mpfr_set(r8603, r8595, MPFR_RNDN); } else { mpfr_set(r8603, r8602, MPFR_RNDN); };
        if (mpfr_get_si(r8576, MPFR_RNDN)) { mpfr_set(r8604, r8579, MPFR_RNDN); } else { mpfr_set(r8604, r8603, MPFR_RNDN); };
        return mpfr_get_d(r8604, MPFR_RNDN);
}

static mpfr_t 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, r8632, r8633, r8634, r8635, r8636;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r8605);
        mpfr_init(r8606);
        mpfr_init_set_str(r8607, "-5.821596402918175e+115", 10, MPFR_RNDN);
        mpfr_init(r8608);
        mpfr_init(r8609);
        mpfr_init(r8610);
        mpfr_init(r8611);
        mpfr_init_set_str(r8612, "-1.9516615171416054e-122", 10, MPFR_RNDN);
        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(r8622);
        mpfr_init(r8623);
        mpfr_init(r8624);
        mpfr_init_set_str(r8625, "2", 10, MPFR_RNDN);
        mpfr_init(r8626);
        mpfr_init(r8627);
        mpfr_init_set_str(r8628, "3.092591079713731e+103", 10, MPFR_RNDN);
        mpfr_init(r8629);
        mpfr_init(r8630);
        mpfr_init(r8631);
        mpfr_init(r8632);
        mpfr_init(r8633);
        mpfr_init(r8634);
        mpfr_init(r8635);
        mpfr_init(r8636);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r8605, b, MPFR_RNDN);
        mpfr_neg(r8606, r8605, MPFR_RNDN);
        ;
        mpfr_set_si(r8608, mpfr_cmp(r8606, r8607) <= 0, MPFR_RNDN);
        mpfr_set_d(r8609, c, MPFR_RNDN);
        mpfr_div(r8610, r8609, r8605, MPFR_RNDN);
        mpfr_neg(r8611, r8610, MPFR_RNDN);
        ;
        mpfr_set_si(r8613, mpfr_cmp(r8606, r8612) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r8615, a, MPFR_RNDN);
        mpfr_mul(r8616, r8609, r8615, MPFR_RNDN);
        mpfr_mul(r8617, r8614, r8616, MPFR_RNDN);
        mpfr_mul(r8618, r8605, r8605, MPFR_RNDN);
        mpfr_mul(r8619, r8614, r8615, MPFR_RNDN);
        mpfr_mul(r8620, r8619, r8609, MPFR_RNDN);
        mpfr_sub(r8621, r8618, r8620, MPFR_RNDN);
        mpfr_sqrt(r8622, r8621, MPFR_RNDN);
        mpfr_sub(r8623, r8606, r8622, MPFR_RNDN);
        mpfr_div(r8624, r8617, r8623, MPFR_RNDN);
        ;
        mpfr_mul(r8626, r8615, r8625, MPFR_RNDN);
        mpfr_div(r8627, r8624, r8626, MPFR_RNDN);
        ;
        mpfr_set_si(r8629, mpfr_cmp(r8606, r8628) <= 0, MPFR_RNDN);
        mpfr_add(r8630, r8622, r8606, MPFR_RNDN);
        mpfr_div(r8631, r8630, r8626, MPFR_RNDN);
        mpfr_div(r8632, r8605, r8615, MPFR_RNDN);
        mpfr_sub(r8633, r8610, r8632, MPFR_RNDN);
        if (mpfr_get_si(r8629, MPFR_RNDN)) { mpfr_set(r8634, r8631, MPFR_RNDN); } else { mpfr_set(r8634, r8633, MPFR_RNDN); };
        if (mpfr_get_si(r8613, MPFR_RNDN)) { mpfr_set(r8635, r8627, MPFR_RNDN); } else { mpfr_set(r8635, r8634, MPFR_RNDN); };
        if (mpfr_get_si(r8608, MPFR_RNDN)) { mpfr_set(r8636, r8611, MPFR_RNDN); } else { mpfr_set(r8636, r8635, MPFR_RNDN); };
        return mpfr_get_d(r8636, MPFR_RNDN);
}