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

char *name = "The quadratic formula (r2)";

double f_if(float a, float b, float c) {
        float r39504 = b;
        float r39505 = -r39504;
        float r39506 = r39504 * r39504;
        float r39507 = 4;
        float r39508 = a;
        float r39509 = c;
        float r39510 = r39508 * r39509;
        float r39511 = r39507 * r39510;
        float r39512 = r39506 - r39511;
        float r39513 = sqrt(r39512);
        float r39514 = r39505 - r39513;
        float r39515 = 2;
        float r39516 = r39515 * r39508;
        float r39517 = r39514 / r39516;
        return r39517;
}

double f_id(double a, double b, double c) {
        double r39518 = b;
        double r39519 = -r39518;
        double r39520 = r39518 * r39518;
        double r39521 = 4;
        double r39522 = a;
        double r39523 = c;
        double r39524 = r39522 * r39523;
        double r39525 = r39521 * r39524;
        double r39526 = r39520 - r39525;
        double r39527 = sqrt(r39526);
        double r39528 = r39519 - r39527;
        double r39529 = 2;
        double r39530 = r39529 * r39522;
        double r39531 = r39528 / r39530;
        return r39531;
}


double f_of(float a, float b, float c) {
        float r39532 = b;
        float r39533 = -1.0524347947917307e+32;
        bool r39534 = r39532 <= r39533;
        float r39535 = -r39532;
        float r39536 = r39535 + r39532;
        float r39537 = a;
        float r39538 = r39537 + r39537;
        float r39539 = r39536 / r39538;
        float r39540 = c;
        float r39541 = r39540 / r39532;
        float r39542 = r39539 - r39541;
        float r39543 = -8.424346933460515e-49;
        bool r39544 = r39532 <= r39543;
        float r39545 = r39540 * r39537;
        float r39546 = 4;
        float r39547 = r39545 * r39546;
        float r39548 = r39532 * r39532;
        float r39549 = r39537 * r39540;
        float r39550 = r39546 * r39549;
        float r39551 = r39548 - r39550;
        float r39552 = sqrt(r39551);
        float r39553 = r39535 + r39552;
        float r39554 = r39547 / r39553;
        float r39555 = 2;
        float r39556 = r39555 * r39537;
        float r39557 = r39554 / r39556;
        float r39558 = -2.725780123328718e-107;
        bool r39559 = r39532 <= r39558;
        float r39560 = 1.6902485387421231e+81;
        bool r39561 = r39532 <= r39560;
        float r39562 = r39546 * r39537;
        float r39563 = r39562 * r39540;
        float r39564 = r39548 - r39563;
        float r39565 = sqrt(r39564);
        float r39566 = r39535 - r39565;
        float r39567 = r39566 / r39556;
        float r39568 = r39535 / r39537;
        float r39569 = r39561 ? r39567 : r39568;
        float r39570 = r39559 ? r39542 : r39569;
        float r39571 = r39544 ? r39557 : r39570;
        float r39572 = r39534 ? r39542 : r39571;
        return r39572;
}

double f_od(double a, double b, double c) {
        double r39573 = b;
        double r39574 = -1.0524347947917307e+32;
        bool r39575 = r39573 <= r39574;
        double r39576 = -r39573;
        double r39577 = r39576 + r39573;
        double r39578 = a;
        double r39579 = r39578 + r39578;
        double r39580 = r39577 / r39579;
        double r39581 = c;
        double r39582 = r39581 / r39573;
        double r39583 = r39580 - r39582;
        double r39584 = -8.424346933460515e-49;
        bool r39585 = r39573 <= r39584;
        double r39586 = r39581 * r39578;
        double r39587 = 4;
        double r39588 = r39586 * r39587;
        double r39589 = r39573 * r39573;
        double r39590 = r39578 * r39581;
        double r39591 = r39587 * r39590;
        double r39592 = r39589 - r39591;
        double r39593 = sqrt(r39592);
        double r39594 = r39576 + r39593;
        double r39595 = r39588 / r39594;
        double r39596 = 2;
        double r39597 = r39596 * r39578;
        double r39598 = r39595 / r39597;
        double r39599 = -2.725780123328718e-107;
        bool r39600 = r39573 <= r39599;
        double r39601 = 1.6902485387421231e+81;
        bool r39602 = r39573 <= r39601;
        double r39603 = r39587 * r39578;
        double r39604 = r39603 * r39581;
        double r39605 = r39589 - r39604;
        double r39606 = sqrt(r39605);
        double r39607 = r39576 - r39606;
        double r39608 = r39607 / r39597;
        double r39609 = r39576 / r39578;
        double r39610 = r39602 ? r39608 : r39609;
        double r39611 = r39600 ? r39583 : r39610;
        double r39612 = r39585 ? r39598 : r39611;
        double r39613 = r39575 ? r39583 : r39612;
        return r39613;
}

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 r39614, r39615, r39616, r39617, r39618, r39619, r39620, r39621, r39622, r39623, r39624, r39625, r39626, r39627;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r39614);
        mpfr_init(r39615);
        mpfr_init(r39616);
        mpfr_init_set_str(r39617, "4", 10, MPFR_RNDN);
        mpfr_init(r39618);
        mpfr_init(r39619);
        mpfr_init(r39620);
        mpfr_init(r39621);
        mpfr_init(r39622);
        mpfr_init(r39623);
        mpfr_init(r39624);
        mpfr_init_set_str(r39625, "2", 10, MPFR_RNDN);
        mpfr_init(r39626);
        mpfr_init(r39627);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r39614, b, MPFR_RNDN);
        mpfr_neg(r39615, r39614, MPFR_RNDN);
        mpfr_mul(r39616, r39614, r39614, MPFR_RNDN);
        ;
        mpfr_set_d(r39618, a, MPFR_RNDN);
        mpfr_set_d(r39619, c, MPFR_RNDN);
        mpfr_mul(r39620, r39618, r39619, MPFR_RNDN);
        mpfr_mul(r39621, r39617, r39620, MPFR_RNDN);
        mpfr_sub(r39622, r39616, r39621, MPFR_RNDN);
        mpfr_sqrt(r39623, r39622, MPFR_RNDN);
        mpfr_sub(r39624, r39615, r39623, MPFR_RNDN);
        ;
        mpfr_mul(r39626, r39625, r39618, MPFR_RNDN);
        mpfr_div(r39627, r39624, r39626, MPFR_RNDN);
        return mpfr_get_d(r39627, MPFR_RNDN);
}

static mpfr_t r39628, r39629, r39630, r39631, r39632, r39633, r39634, r39635, r39636, r39637, r39638, r39639, r39640, r39641, r39642, r39643, r39644, r39645, r39646, r39647, r39648, r39649, r39650, r39651, r39652, r39653, r39654, r39655, r39656, r39657, r39658, r39659, r39660, r39661, r39662, r39663, r39664, r39665, r39666, r39667, r39668;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r39628);
        mpfr_init_set_str(r39629, "-1.0524347947917307e+32", 10, MPFR_RNDN);
        mpfr_init(r39630);
        mpfr_init(r39631);
        mpfr_init(r39632);
        mpfr_init(r39633);
        mpfr_init(r39634);
        mpfr_init(r39635);
        mpfr_init(r39636);
        mpfr_init(r39637);
        mpfr_init(r39638);
        mpfr_init_set_str(r39639, "-8.424346933460515e-49", 10, MPFR_RNDN);
        mpfr_init(r39640);
        mpfr_init(r39641);
        mpfr_init_set_str(r39642, "4", 10, MPFR_RNDN);
        mpfr_init(r39643);
        mpfr_init(r39644);
        mpfr_init(r39645);
        mpfr_init(r39646);
        mpfr_init(r39647);
        mpfr_init(r39648);
        mpfr_init(r39649);
        mpfr_init(r39650);
        mpfr_init_set_str(r39651, "2", 10, MPFR_RNDN);
        mpfr_init(r39652);
        mpfr_init(r39653);
        mpfr_init_set_str(r39654, "-2.725780123328718e-107", 10, MPFR_RNDN);
        mpfr_init(r39655);
        mpfr_init_set_str(r39656, "1.6902485387421231e+81", 10, MPFR_RNDN);
        mpfr_init(r39657);
        mpfr_init(r39658);
        mpfr_init(r39659);
        mpfr_init(r39660);
        mpfr_init(r39661);
        mpfr_init(r39662);
        mpfr_init(r39663);
        mpfr_init(r39664);
        mpfr_init(r39665);
        mpfr_init(r39666);
        mpfr_init(r39667);
        mpfr_init(r39668);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r39628, b, MPFR_RNDN);
        ;
        mpfr_set_si(r39630, mpfr_cmp(r39628, r39629) <= 0, MPFR_RNDN);
        mpfr_neg(r39631, r39628, MPFR_RNDN);
        mpfr_add(r39632, r39631, r39628, MPFR_RNDN);
        mpfr_set_d(r39633, a, MPFR_RNDN);
        mpfr_add(r39634, r39633, r39633, MPFR_RNDN);
        mpfr_div(r39635, r39632, r39634, MPFR_RNDN);
        mpfr_set_d(r39636, c, MPFR_RNDN);
        mpfr_div(r39637, r39636, r39628, MPFR_RNDN);
        mpfr_sub(r39638, r39635, r39637, MPFR_RNDN);
        ;
        mpfr_set_si(r39640, mpfr_cmp(r39628, r39639) <= 0, MPFR_RNDN);
        mpfr_mul(r39641, r39636, r39633, MPFR_RNDN);
        ;
        mpfr_mul(r39643, r39641, r39642, MPFR_RNDN);
        mpfr_mul(r39644, r39628, r39628, MPFR_RNDN);
        mpfr_mul(r39645, r39633, r39636, MPFR_RNDN);
        mpfr_mul(r39646, r39642, r39645, MPFR_RNDN);
        mpfr_sub(r39647, r39644, r39646, MPFR_RNDN);
        mpfr_sqrt(r39648, r39647, MPFR_RNDN);
        mpfr_add(r39649, r39631, r39648, MPFR_RNDN);
        mpfr_div(r39650, r39643, r39649, MPFR_RNDN);
        ;
        mpfr_mul(r39652, r39651, r39633, MPFR_RNDN);
        mpfr_div(r39653, r39650, r39652, MPFR_RNDN);
        ;
        mpfr_set_si(r39655, mpfr_cmp(r39628, r39654) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r39657, mpfr_cmp(r39628, r39656) <= 0, MPFR_RNDN);
        mpfr_mul(r39658, r39642, r39633, MPFR_RNDN);
        mpfr_mul(r39659, r39658, r39636, MPFR_RNDN);
        mpfr_sub(r39660, r39644, r39659, MPFR_RNDN);
        mpfr_sqrt(r39661, r39660, MPFR_RNDN);
        mpfr_sub(r39662, r39631, r39661, MPFR_RNDN);
        mpfr_div(r39663, r39662, r39652, MPFR_RNDN);
        mpfr_div(r39664, r39631, r39633, MPFR_RNDN);
        if (mpfr_get_si(r39657, MPFR_RNDN)) { mpfr_set(r39665, r39663, MPFR_RNDN); } else { mpfr_set(r39665, r39664, MPFR_RNDN); };
        if (mpfr_get_si(r39655, MPFR_RNDN)) { mpfr_set(r39666, r39638, MPFR_RNDN); } else { mpfr_set(r39666, r39665, MPFR_RNDN); };
        if (mpfr_get_si(r39640, MPFR_RNDN)) { mpfr_set(r39667, r39653, MPFR_RNDN); } else { mpfr_set(r39667, r39666, MPFR_RNDN); };
        if (mpfr_get_si(r39630, MPFR_RNDN)) { mpfr_set(r39668, r39638, MPFR_RNDN); } else { mpfr_set(r39668, r39667, MPFR_RNDN); };
        return mpfr_get_d(r39668, MPFR_RNDN);
}

static mpfr_t r39669, r39670, r39671, r39672, r39673, r39674, r39675, r39676, r39677, r39678, r39679, r39680, r39681, r39682, r39683, r39684, r39685, r39686, r39687, r39688, r39689, r39690, r39691, r39692, r39693, r39694, r39695, r39696, r39697, r39698, r39699, r39700, r39701, r39702, r39703, r39704, r39705, r39706, r39707, r39708, r39709;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r39669);
        mpfr_init_set_str(r39670, "-1.0524347947917307e+32", 10, MPFR_RNDN);
        mpfr_init(r39671);
        mpfr_init(r39672);
        mpfr_init(r39673);
        mpfr_init(r39674);
        mpfr_init(r39675);
        mpfr_init(r39676);
        mpfr_init(r39677);
        mpfr_init(r39678);
        mpfr_init(r39679);
        mpfr_init_set_str(r39680, "-8.424346933460515e-49", 10, MPFR_RNDN);
        mpfr_init(r39681);
        mpfr_init(r39682);
        mpfr_init_set_str(r39683, "4", 10, MPFR_RNDN);
        mpfr_init(r39684);
        mpfr_init(r39685);
        mpfr_init(r39686);
        mpfr_init(r39687);
        mpfr_init(r39688);
        mpfr_init(r39689);
        mpfr_init(r39690);
        mpfr_init(r39691);
        mpfr_init_set_str(r39692, "2", 10, MPFR_RNDN);
        mpfr_init(r39693);
        mpfr_init(r39694);
        mpfr_init_set_str(r39695, "-2.725780123328718e-107", 10, MPFR_RNDN);
        mpfr_init(r39696);
        mpfr_init_set_str(r39697, "1.6902485387421231e+81", 10, MPFR_RNDN);
        mpfr_init(r39698);
        mpfr_init(r39699);
        mpfr_init(r39700);
        mpfr_init(r39701);
        mpfr_init(r39702);
        mpfr_init(r39703);
        mpfr_init(r39704);
        mpfr_init(r39705);
        mpfr_init(r39706);
        mpfr_init(r39707);
        mpfr_init(r39708);
        mpfr_init(r39709);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r39669, b, MPFR_RNDN);
        ;
        mpfr_set_si(r39671, mpfr_cmp(r39669, r39670) <= 0, MPFR_RNDN);
        mpfr_neg(r39672, r39669, MPFR_RNDN);
        mpfr_add(r39673, r39672, r39669, MPFR_RNDN);
        mpfr_set_d(r39674, a, MPFR_RNDN);
        mpfr_add(r39675, r39674, r39674, MPFR_RNDN);
        mpfr_div(r39676, r39673, r39675, MPFR_RNDN);
        mpfr_set_d(r39677, c, MPFR_RNDN);
        mpfr_div(r39678, r39677, r39669, MPFR_RNDN);
        mpfr_sub(r39679, r39676, r39678, MPFR_RNDN);
        ;
        mpfr_set_si(r39681, mpfr_cmp(r39669, r39680) <= 0, MPFR_RNDN);
        mpfr_mul(r39682, r39677, r39674, MPFR_RNDN);
        ;
        mpfr_mul(r39684, r39682, r39683, MPFR_RNDN);
        mpfr_mul(r39685, r39669, r39669, MPFR_RNDN);
        mpfr_mul(r39686, r39674, r39677, MPFR_RNDN);
        mpfr_mul(r39687, r39683, r39686, MPFR_RNDN);
        mpfr_sub(r39688, r39685, r39687, MPFR_RNDN);
        mpfr_sqrt(r39689, r39688, MPFR_RNDN);
        mpfr_add(r39690, r39672, r39689, MPFR_RNDN);
        mpfr_div(r39691, r39684, r39690, MPFR_RNDN);
        ;
        mpfr_mul(r39693, r39692, r39674, MPFR_RNDN);
        mpfr_div(r39694, r39691, r39693, MPFR_RNDN);
        ;
        mpfr_set_si(r39696, mpfr_cmp(r39669, r39695) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r39698, mpfr_cmp(r39669, r39697) <= 0, MPFR_RNDN);
        mpfr_mul(r39699, r39683, r39674, MPFR_RNDN);
        mpfr_mul(r39700, r39699, r39677, MPFR_RNDN);
        mpfr_sub(r39701, r39685, r39700, MPFR_RNDN);
        mpfr_sqrt(r39702, r39701, MPFR_RNDN);
        mpfr_sub(r39703, r39672, r39702, MPFR_RNDN);
        mpfr_div(r39704, r39703, r39693, MPFR_RNDN);
        mpfr_div(r39705, r39672, r39674, MPFR_RNDN);
        if (mpfr_get_si(r39698, MPFR_RNDN)) { mpfr_set(r39706, r39704, MPFR_RNDN); } else { mpfr_set(r39706, r39705, MPFR_RNDN); };
        if (mpfr_get_si(r39696, MPFR_RNDN)) { mpfr_set(r39707, r39679, MPFR_RNDN); } else { mpfr_set(r39707, r39706, MPFR_RNDN); };
        if (mpfr_get_si(r39681, MPFR_RNDN)) { mpfr_set(r39708, r39694, MPFR_RNDN); } else { mpfr_set(r39708, r39707, MPFR_RNDN); };
        if (mpfr_get_si(r39671, MPFR_RNDN)) { mpfr_set(r39709, r39679, MPFR_RNDN); } else { mpfr_set(r39709, r39708, MPFR_RNDN); };
        return mpfr_get_d(r39709, MPFR_RNDN);
}

