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

char *name = "quadm (p42, negative)";

double f_if(float a, float b, float c) {
        float r38433 = b;
        float r38434 = -r38433;
        float r38435 = r38433 * r38433;
        float r38436 = 4;
        float r38437 = a;
        float r38438 = c;
        float r38439 = r38437 * r38438;
        float r38440 = r38436 * r38439;
        float r38441 = r38435 - r38440;
        float r38442 = sqrt(r38441);
        float r38443 = r38434 - r38442;
        float r38444 = 2;
        float r38445 = r38444 * r38437;
        float r38446 = r38443 / r38445;
        return r38446;
}

double f_id(double a, double b, double c) {
        double r38447 = b;
        double r38448 = -r38447;
        double r38449 = r38447 * r38447;
        double r38450 = 4;
        double r38451 = a;
        double r38452 = c;
        double r38453 = r38451 * r38452;
        double r38454 = r38450 * r38453;
        double r38455 = r38449 - r38454;
        double r38456 = sqrt(r38455);
        double r38457 = r38448 - r38456;
        double r38458 = 2;
        double r38459 = r38458 * r38451;
        double r38460 = r38457 / r38459;
        return r38460;
}


double f_of(float a, float b, float c) {
        float r38461 = b;
        float r38462 = -5.018034098196628e+28;
        bool r38463 = r38461 <= r38462;
        float r38464 = -r38461;
        float r38465 = r38464 + r38461;
        float r38466 = a;
        float r38467 = r38466 + r38466;
        float r38468 = r38465 / r38467;
        float r38469 = c;
        float r38470 = r38469 / r38461;
        float r38471 = r38468 - r38470;
        float r38472 = -1.992853954034314e-66;
        bool r38473 = r38461 <= r38472;
        float r38474 = r38469 * r38466;
        float r38475 = 4;
        float r38476 = r38474 * r38475;
        float r38477 = r38461 * r38461;
        float r38478 = r38466 * r38469;
        float r38479 = r38475 * r38478;
        float r38480 = r38477 - r38479;
        float r38481 = sqrt(r38480);
        float r38482 = r38464 + r38481;
        float r38483 = r38476 / r38482;
        float r38484 = 2;
        float r38485 = r38484 * r38466;
        float r38486 = r38483 / r38485;
        float r38487 = -5.3589749776329416e-108;
        bool r38488 = r38461 <= r38487;
        float r38489 = 1.7007616628281973e+81;
        bool r38490 = r38461 <= r38489;
        float r38491 = r38475 * r38466;
        float r38492 = r38491 * r38469;
        float r38493 = r38477 - r38492;
        float r38494 = sqrt(r38493);
        float r38495 = r38464 - r38494;
        float r38496 = r38495 / r38485;
        float r38497 = r38464 / r38466;
        float r38498 = r38490 ? r38496 : r38497;
        float r38499 = r38488 ? r38471 : r38498;
        float r38500 = r38473 ? r38486 : r38499;
        float r38501 = r38463 ? r38471 : r38500;
        return r38501;
}

double f_od(double a, double b, double c) {
        double r38502 = b;
        double r38503 = -5.018034098196628e+28;
        bool r38504 = r38502 <= r38503;
        double r38505 = -r38502;
        double r38506 = r38505 + r38502;
        double r38507 = a;
        double r38508 = r38507 + r38507;
        double r38509 = r38506 / r38508;
        double r38510 = c;
        double r38511 = r38510 / r38502;
        double r38512 = r38509 - r38511;
        double r38513 = -1.992853954034314e-66;
        bool r38514 = r38502 <= r38513;
        double r38515 = r38510 * r38507;
        double r38516 = 4;
        double r38517 = r38515 * r38516;
        double r38518 = r38502 * r38502;
        double r38519 = r38507 * r38510;
        double r38520 = r38516 * r38519;
        double r38521 = r38518 - r38520;
        double r38522 = sqrt(r38521);
        double r38523 = r38505 + r38522;
        double r38524 = r38517 / r38523;
        double r38525 = 2;
        double r38526 = r38525 * r38507;
        double r38527 = r38524 / r38526;
        double r38528 = -5.3589749776329416e-108;
        bool r38529 = r38502 <= r38528;
        double r38530 = 1.7007616628281973e+81;
        bool r38531 = r38502 <= r38530;
        double r38532 = r38516 * r38507;
        double r38533 = r38532 * r38510;
        double r38534 = r38518 - r38533;
        double r38535 = sqrt(r38534);
        double r38536 = r38505 - r38535;
        double r38537 = r38536 / r38526;
        double r38538 = r38505 / r38507;
        double r38539 = r38531 ? r38537 : r38538;
        double r38540 = r38529 ? r38512 : r38539;
        double r38541 = r38514 ? r38527 : r38540;
        double r38542 = r38504 ? r38512 : r38541;
        return r38542;
}

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 r38543, r38544, r38545, r38546, r38547, r38548, r38549, r38550, r38551, r38552, r38553, r38554, r38555, r38556;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2704);
        mpfr_init(r38543);
        mpfr_init(r38544);
        mpfr_init(r38545);
        mpfr_init_set_str(r38546, "4", 10, MPFR_RNDN);
        mpfr_init(r38547);
        mpfr_init(r38548);
        mpfr_init(r38549);
        mpfr_init(r38550);
        mpfr_init(r38551);
        mpfr_init(r38552);
        mpfr_init(r38553);
        mpfr_init_set_str(r38554, "2", 10, MPFR_RNDN);
        mpfr_init(r38555);
        mpfr_init(r38556);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r38543, b, MPFR_RNDN);
        mpfr_neg(r38544, r38543, MPFR_RNDN);
        mpfr_mul(r38545, r38543, r38543, MPFR_RNDN);
        ;
        mpfr_set_d(r38547, a, MPFR_RNDN);
        mpfr_set_d(r38548, c, MPFR_RNDN);
        mpfr_mul(r38549, r38547, r38548, MPFR_RNDN);
        mpfr_mul(r38550, r38546, r38549, MPFR_RNDN);
        mpfr_sub(r38551, r38545, r38550, MPFR_RNDN);
        mpfr_sqrt(r38552, r38551, MPFR_RNDN);
        mpfr_sub(r38553, r38544, r38552, MPFR_RNDN);
        ;
        mpfr_mul(r38555, r38554, r38547, MPFR_RNDN);
        mpfr_div(r38556, r38553, r38555, MPFR_RNDN);
        return mpfr_get_d(r38556, MPFR_RNDN);
}

static mpfr_t r38557, r38558, r38559, r38560, r38561, r38562, r38563, r38564, r38565, r38566, r38567, r38568, r38569, r38570, r38571, r38572, r38573, r38574, r38575, r38576, r38577, r38578, r38579, r38580, r38581, r38582, r38583, r38584, r38585, r38586, r38587, r38588, r38589, r38590, r38591, r38592, r38593, r38594, r38595, r38596, r38597;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2704);
        mpfr_init(r38557);
        mpfr_init_set_str(r38558, "-5.018034098196628e+28", 10, MPFR_RNDN);
        mpfr_init(r38559);
        mpfr_init(r38560);
        mpfr_init(r38561);
        mpfr_init(r38562);
        mpfr_init(r38563);
        mpfr_init(r38564);
        mpfr_init(r38565);
        mpfr_init(r38566);
        mpfr_init(r38567);
        mpfr_init_set_str(r38568, "-1.992853954034314e-66", 10, MPFR_RNDN);
        mpfr_init(r38569);
        mpfr_init(r38570);
        mpfr_init_set_str(r38571, "4", 10, MPFR_RNDN);
        mpfr_init(r38572);
        mpfr_init(r38573);
        mpfr_init(r38574);
        mpfr_init(r38575);
        mpfr_init(r38576);
        mpfr_init(r38577);
        mpfr_init(r38578);
        mpfr_init(r38579);
        mpfr_init_set_str(r38580, "2", 10, MPFR_RNDN);
        mpfr_init(r38581);
        mpfr_init(r38582);
        mpfr_init_set_str(r38583, "-5.3589749776329416e-108", 10, MPFR_RNDN);
        mpfr_init(r38584);
        mpfr_init_set_str(r38585, "1.7007616628281973e+81", 10, MPFR_RNDN);
        mpfr_init(r38586);
        mpfr_init(r38587);
        mpfr_init(r38588);
        mpfr_init(r38589);
        mpfr_init(r38590);
        mpfr_init(r38591);
        mpfr_init(r38592);
        mpfr_init(r38593);
        mpfr_init(r38594);
        mpfr_init(r38595);
        mpfr_init(r38596);
        mpfr_init(r38597);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r38557, b, MPFR_RNDN);
        ;
        mpfr_set_si(r38559, mpfr_cmp(r38557, r38558) <= 0, MPFR_RNDN);
        mpfr_neg(r38560, r38557, MPFR_RNDN);
        mpfr_add(r38561, r38560, r38557, MPFR_RNDN);
        mpfr_set_d(r38562, a, MPFR_RNDN);
        mpfr_add(r38563, r38562, r38562, MPFR_RNDN);
        mpfr_div(r38564, r38561, r38563, MPFR_RNDN);
        mpfr_set_d(r38565, c, MPFR_RNDN);
        mpfr_div(r38566, r38565, r38557, MPFR_RNDN);
        mpfr_sub(r38567, r38564, r38566, MPFR_RNDN);
        ;
        mpfr_set_si(r38569, mpfr_cmp(r38557, r38568) <= 0, MPFR_RNDN);
        mpfr_mul(r38570, r38565, r38562, MPFR_RNDN);
        ;
        mpfr_mul(r38572, r38570, r38571, MPFR_RNDN);
        mpfr_mul(r38573, r38557, r38557, MPFR_RNDN);
        mpfr_mul(r38574, r38562, r38565, MPFR_RNDN);
        mpfr_mul(r38575, r38571, r38574, MPFR_RNDN);
        mpfr_sub(r38576, r38573, r38575, MPFR_RNDN);
        mpfr_sqrt(r38577, r38576, MPFR_RNDN);
        mpfr_add(r38578, r38560, r38577, MPFR_RNDN);
        mpfr_div(r38579, r38572, r38578, MPFR_RNDN);
        ;
        mpfr_mul(r38581, r38580, r38562, MPFR_RNDN);
        mpfr_div(r38582, r38579, r38581, MPFR_RNDN);
        ;
        mpfr_set_si(r38584, mpfr_cmp(r38557, r38583) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r38586, mpfr_cmp(r38557, r38585) <= 0, MPFR_RNDN);
        mpfr_mul(r38587, r38571, r38562, MPFR_RNDN);
        mpfr_mul(r38588, r38587, r38565, MPFR_RNDN);
        mpfr_sub(r38589, r38573, r38588, MPFR_RNDN);
        mpfr_sqrt(r38590, r38589, MPFR_RNDN);
        mpfr_sub(r38591, r38560, r38590, MPFR_RNDN);
        mpfr_div(r38592, r38591, r38581, MPFR_RNDN);
        mpfr_div(r38593, r38560, r38562, MPFR_RNDN);
        if (mpfr_get_si(r38586, MPFR_RNDN)) { mpfr_set(r38594, r38592, MPFR_RNDN); } else { mpfr_set(r38594, r38593, MPFR_RNDN); };
        if (mpfr_get_si(r38584, MPFR_RNDN)) { mpfr_set(r38595, r38567, MPFR_RNDN); } else { mpfr_set(r38595, r38594, MPFR_RNDN); };
        if (mpfr_get_si(r38569, MPFR_RNDN)) { mpfr_set(r38596, r38582, MPFR_RNDN); } else { mpfr_set(r38596, r38595, MPFR_RNDN); };
        if (mpfr_get_si(r38559, MPFR_RNDN)) { mpfr_set(r38597, r38567, MPFR_RNDN); } else { mpfr_set(r38597, r38596, MPFR_RNDN); };
        return mpfr_get_d(r38597, MPFR_RNDN);
}

static mpfr_t r38598, r38599, r38600, r38601, r38602, r38603, r38604, r38605, r38606, r38607, r38608, r38609, r38610, r38611, r38612, r38613, r38614, r38615, r38616, r38617, r38618, r38619, r38620, r38621, r38622, r38623, r38624, r38625, r38626, r38627, r38628, r38629, r38630, r38631, r38632, r38633, r38634, r38635, r38636, r38637, r38638;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2704);
        mpfr_init(r38598);
        mpfr_init_set_str(r38599, "-5.018034098196628e+28", 10, MPFR_RNDN);
        mpfr_init(r38600);
        mpfr_init(r38601);
        mpfr_init(r38602);
        mpfr_init(r38603);
        mpfr_init(r38604);
        mpfr_init(r38605);
        mpfr_init(r38606);
        mpfr_init(r38607);
        mpfr_init(r38608);
        mpfr_init_set_str(r38609, "-1.992853954034314e-66", 10, MPFR_RNDN);
        mpfr_init(r38610);
        mpfr_init(r38611);
        mpfr_init_set_str(r38612, "4", 10, MPFR_RNDN);
        mpfr_init(r38613);
        mpfr_init(r38614);
        mpfr_init(r38615);
        mpfr_init(r38616);
        mpfr_init(r38617);
        mpfr_init(r38618);
        mpfr_init(r38619);
        mpfr_init(r38620);
        mpfr_init_set_str(r38621, "2", 10, MPFR_RNDN);
        mpfr_init(r38622);
        mpfr_init(r38623);
        mpfr_init_set_str(r38624, "-5.3589749776329416e-108", 10, MPFR_RNDN);
        mpfr_init(r38625);
        mpfr_init_set_str(r38626, "1.7007616628281973e+81", 10, MPFR_RNDN);
        mpfr_init(r38627);
        mpfr_init(r38628);
        mpfr_init(r38629);
        mpfr_init(r38630);
        mpfr_init(r38631);
        mpfr_init(r38632);
        mpfr_init(r38633);
        mpfr_init(r38634);
        mpfr_init(r38635);
        mpfr_init(r38636);
        mpfr_init(r38637);
        mpfr_init(r38638);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r38598, b, MPFR_RNDN);
        ;
        mpfr_set_si(r38600, mpfr_cmp(r38598, r38599) <= 0, MPFR_RNDN);
        mpfr_neg(r38601, r38598, MPFR_RNDN);
        mpfr_add(r38602, r38601, r38598, MPFR_RNDN);
        mpfr_set_d(r38603, a, MPFR_RNDN);
        mpfr_add(r38604, r38603, r38603, MPFR_RNDN);
        mpfr_div(r38605, r38602, r38604, MPFR_RNDN);
        mpfr_set_d(r38606, c, MPFR_RNDN);
        mpfr_div(r38607, r38606, r38598, MPFR_RNDN);
        mpfr_sub(r38608, r38605, r38607, MPFR_RNDN);
        ;
        mpfr_set_si(r38610, mpfr_cmp(r38598, r38609) <= 0, MPFR_RNDN);
        mpfr_mul(r38611, r38606, r38603, MPFR_RNDN);
        ;
        mpfr_mul(r38613, r38611, r38612, MPFR_RNDN);
        mpfr_mul(r38614, r38598, r38598, MPFR_RNDN);
        mpfr_mul(r38615, r38603, r38606, MPFR_RNDN);
        mpfr_mul(r38616, r38612, r38615, MPFR_RNDN);
        mpfr_sub(r38617, r38614, r38616, MPFR_RNDN);
        mpfr_sqrt(r38618, r38617, MPFR_RNDN);
        mpfr_add(r38619, r38601, r38618, MPFR_RNDN);
        mpfr_div(r38620, r38613, r38619, MPFR_RNDN);
        ;
        mpfr_mul(r38622, r38621, r38603, MPFR_RNDN);
        mpfr_div(r38623, r38620, r38622, MPFR_RNDN);
        ;
        mpfr_set_si(r38625, mpfr_cmp(r38598, r38624) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r38627, mpfr_cmp(r38598, r38626) <= 0, MPFR_RNDN);
        mpfr_mul(r38628, r38612, r38603, MPFR_RNDN);
        mpfr_mul(r38629, r38628, r38606, MPFR_RNDN);
        mpfr_sub(r38630, r38614, r38629, MPFR_RNDN);
        mpfr_sqrt(r38631, r38630, MPFR_RNDN);
        mpfr_sub(r38632, r38601, r38631, MPFR_RNDN);
        mpfr_div(r38633, r38632, r38622, MPFR_RNDN);
        mpfr_div(r38634, r38601, r38603, MPFR_RNDN);
        if (mpfr_get_si(r38627, MPFR_RNDN)) { mpfr_set(r38635, r38633, MPFR_RNDN); } else { mpfr_set(r38635, r38634, MPFR_RNDN); };
        if (mpfr_get_si(r38625, MPFR_RNDN)) { mpfr_set(r38636, r38608, MPFR_RNDN); } else { mpfr_set(r38636, r38635, MPFR_RNDN); };
        if (mpfr_get_si(r38610, MPFR_RNDN)) { mpfr_set(r38637, r38623, MPFR_RNDN); } else { mpfr_set(r38637, r38636, MPFR_RNDN); };
        if (mpfr_get_si(r38600, MPFR_RNDN)) { mpfr_set(r38638, r38608, MPFR_RNDN); } else { mpfr_set(r38638, r38637, MPFR_RNDN); };
        return mpfr_get_d(r38638, MPFR_RNDN);
}

