#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 r19590 = b;
        float r19591 = -r19590;
        float r19592 = r19590 * r19590;
        float r19593 = 4.0f;
        float r19594 = a;
        float r19595 = c;
        float r19596 = r19594 * r19595;
        float r19597 = r19593 * r19596;
        float r19598 = r19592 - r19597;
        float r19599 = sqrt(r19598);
        float r19600 = r19591 - r19599;
        float r19601 = 2.0f;
        float r19602 = r19601 * r19594;
        float r19603 = r19600 / r19602;
        return r19603;
}

double f_id(double a, double b, double c) {
        double r19604 = b;
        double r19605 = -r19604;
        double r19606 = r19604 * r19604;
        double r19607 = 4.0;
        double r19608 = a;
        double r19609 = c;
        double r19610 = r19608 * r19609;
        double r19611 = r19607 * r19610;
        double r19612 = r19606 - r19611;
        double r19613 = sqrt(r19612);
        double r19614 = r19605 - r19613;
        double r19615 = 2.0;
        double r19616 = r19615 * r19608;
        double r19617 = r19614 / r19616;
        return r19617;
}


double f_of(float a, float b, float c) {
        float r19618 = b;
        float r19619 = -9.612559777483023e+27f;
        bool r19620 = r19618 <= r19619;
        float r19621 = c;
        float r19622 = 4.0f;
        float r19623 = 1.0f;
        float r19624 = r19622 / r19623;
        float r19625 = 2.0f;
        float r19626 = r19624 / r19625;
        float r19627 = r19621 * r19626;
        float r19628 = a;
        float r19629 = r19628 + r19628;
        float r19630 = r19618 / r19621;
        float r19631 = r19629 / r19630;
        float r19632 = -r19618;
        float r19633 = r19618 - r19632;
        float r19634 = r19631 - r19633;
        float r19635 = r19627 / r19634;
        float r19636 = -1.4807562139587436e-235f;
        bool r19637 = r19618 <= r19636;
        float r19638 = r19628 / r19623;
        float r19639 = r19622 * r19621;
        float r19640 = r19618 * r19618;
        float r19641 = r19628 * r19621;
        float r19642 = r19622 * r19641;
        float r19643 = r19640 - r19642;
        float r19644 = sqrt(r19643);
        float r19645 = r19632 + r19644;
        float r19646 = r19639 / r19645;
        float r19647 = r19638 * r19646;
        float r19648 = r19625 * r19628;
        float r19649 = r19647 / r19648;
        float r19650 = 2.0227608047655974e+110f;
        bool r19651 = r19618 <= r19650;
        float r19652 = r19632 - r19644;
        float r19653 = r19652 / r19648;
        float r19654 = r19621 / r19618;
        float r19655 = r19618 / r19628;
        float r19656 = r19654 - r19655;
        float r19657 = r19651 ? r19653 : r19656;
        float r19658 = r19637 ? r19649 : r19657;
        float r19659 = r19620 ? r19635 : r19658;
        return r19659;
}

double f_od(double a, double b, double c) {
        double r19660 = b;
        double r19661 = -9.612559777483023e+27;
        bool r19662 = r19660 <= r19661;
        double r19663 = c;
        double r19664 = 4.0;
        double r19665 = 1.0;
        double r19666 = r19664 / r19665;
        double r19667 = 2.0;
        double r19668 = r19666 / r19667;
        double r19669 = r19663 * r19668;
        double r19670 = a;
        double r19671 = r19670 + r19670;
        double r19672 = r19660 / r19663;
        double r19673 = r19671 / r19672;
        double r19674 = -r19660;
        double r19675 = r19660 - r19674;
        double r19676 = r19673 - r19675;
        double r19677 = r19669 / r19676;
        double r19678 = -1.4807562139587436e-235;
        bool r19679 = r19660 <= r19678;
        double r19680 = r19670 / r19665;
        double r19681 = r19664 * r19663;
        double r19682 = r19660 * r19660;
        double r19683 = r19670 * r19663;
        double r19684 = r19664 * r19683;
        double r19685 = r19682 - r19684;
        double r19686 = sqrt(r19685);
        double r19687 = r19674 + r19686;
        double r19688 = r19681 / r19687;
        double r19689 = r19680 * r19688;
        double r19690 = r19667 * r19670;
        double r19691 = r19689 / r19690;
        double r19692 = 2.0227608047655974e+110;
        bool r19693 = r19660 <= r19692;
        double r19694 = r19674 - r19686;
        double r19695 = r19694 / r19690;
        double r19696 = r19663 / r19660;
        double r19697 = r19660 / r19670;
        double r19698 = r19696 - r19697;
        double r19699 = r19693 ? r19695 : r19698;
        double r19700 = r19679 ? r19691 : r19699;
        double r19701 = r19662 ? r19677 : r19700;
        return r19701;
}

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 r19702, r19703, r19704, r19705, r19706, r19707, r19708, r19709, r19710, r19711, r19712, r19713, r19714, r19715;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r19702);
        mpfr_init(r19703);
        mpfr_init(r19704);
        mpfr_init_set_str(r19705, "4", 10, MPFR_RNDN);
        mpfr_init(r19706);
        mpfr_init(r19707);
        mpfr_init(r19708);
        mpfr_init(r19709);
        mpfr_init(r19710);
        mpfr_init(r19711);
        mpfr_init(r19712);
        mpfr_init_set_str(r19713, "2", 10, MPFR_RNDN);
        mpfr_init(r19714);
        mpfr_init(r19715);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r19702, b, MPFR_RNDN);
        mpfr_neg(r19703, r19702, MPFR_RNDN);
        mpfr_sqr(r19704, r19702, MPFR_RNDN);
        ;
        mpfr_set_d(r19706, a, MPFR_RNDN);
        mpfr_set_d(r19707, c, MPFR_RNDN);
        mpfr_mul(r19708, r19706, r19707, MPFR_RNDN);
        mpfr_mul(r19709, r19705, r19708, MPFR_RNDN);
        mpfr_sub(r19710, r19704, r19709, MPFR_RNDN);
        mpfr_sqrt(r19711, r19710, MPFR_RNDN);
        mpfr_sub(r19712, r19703, r19711, MPFR_RNDN);
        ;
        mpfr_mul(r19714, r19713, r19706, MPFR_RNDN);
        mpfr_div(r19715, r19712, r19714, MPFR_RNDN);
        return mpfr_get_d(r19715, MPFR_RNDN);
}

static mpfr_t r19716, r19717, r19718, r19719, r19720, r19721, r19722, r19723, r19724, r19725, r19726, r19727, r19728, r19729, r19730, r19731, r19732, r19733, r19734, r19735, r19736, r19737, r19738, r19739, r19740, r19741, r19742, r19743, r19744, r19745, r19746, r19747, r19748, r19749, r19750, r19751, r19752, r19753, r19754, r19755, r19756, r19757;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r19716);
        mpfr_init_set_str(r19717, "-9.612559777483023e+27", 10, MPFR_RNDN);
        mpfr_init(r19718);
        mpfr_init(r19719);
        mpfr_init_set_str(r19720, "4", 10, MPFR_RNDN);
        mpfr_init_set_str(r19721, "1", 10, MPFR_RNDN);
        mpfr_init(r19722);
        mpfr_init_set_str(r19723, "2", 10, MPFR_RNDN);
        mpfr_init(r19724);
        mpfr_init(r19725);
        mpfr_init(r19726);
        mpfr_init(r19727);
        mpfr_init(r19728);
        mpfr_init(r19729);
        mpfr_init(r19730);
        mpfr_init(r19731);
        mpfr_init(r19732);
        mpfr_init(r19733);
        mpfr_init_set_str(r19734, "-1.4807562139587436e-235", 10, MPFR_RNDN);
        mpfr_init(r19735);
        mpfr_init(r19736);
        mpfr_init(r19737);
        mpfr_init(r19738);
        mpfr_init(r19739);
        mpfr_init(r19740);
        mpfr_init(r19741);
        mpfr_init(r19742);
        mpfr_init(r19743);
        mpfr_init(r19744);
        mpfr_init(r19745);
        mpfr_init(r19746);
        mpfr_init(r19747);
        mpfr_init_set_str(r19748, "2.0227608047655974e+110", 10, MPFR_RNDN);
        mpfr_init(r19749);
        mpfr_init(r19750);
        mpfr_init(r19751);
        mpfr_init(r19752);
        mpfr_init(r19753);
        mpfr_init(r19754);
        mpfr_init(r19755);
        mpfr_init(r19756);
        mpfr_init(r19757);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r19716, b, MPFR_RNDN);
        ;
        mpfr_set_si(r19718, mpfr_cmp(r19716, r19717) <= 0, MPFR_RNDN);
        mpfr_set_d(r19719, c, MPFR_RNDN);
        ;
        ;
        mpfr_div(r19722, r19720, r19721, MPFR_RNDN);
        ;
        mpfr_div(r19724, r19722, r19723, MPFR_RNDN);
        mpfr_mul(r19725, r19719, r19724, MPFR_RNDN);
        mpfr_set_d(r19726, a, MPFR_RNDN);
        mpfr_add(r19727, r19726, r19726, MPFR_RNDN);
        mpfr_div(r19728, r19716, r19719, MPFR_RNDN);
        mpfr_div(r19729, r19727, r19728, MPFR_RNDN);
        mpfr_neg(r19730, r19716, MPFR_RNDN);
        mpfr_sub(r19731, r19716, r19730, MPFR_RNDN);
        mpfr_sub(r19732, r19729, r19731, MPFR_RNDN);
        mpfr_div(r19733, r19725, r19732, MPFR_RNDN);
        ;
        mpfr_set_si(r19735, mpfr_cmp(r19716, r19734) <= 0, MPFR_RNDN);
        mpfr_div(r19736, r19726, r19721, MPFR_RNDN);
        mpfr_mul(r19737, r19720, r19719, MPFR_RNDN);
        mpfr_sqr(r19738, r19716, MPFR_RNDN);
        mpfr_mul(r19739, r19726, r19719, MPFR_RNDN);
        mpfr_mul(r19740, r19720, r19739, MPFR_RNDN);
        mpfr_sub(r19741, r19738, r19740, MPFR_RNDN);
        mpfr_sqrt(r19742, r19741, MPFR_RNDN);
        mpfr_add(r19743, r19730, r19742, MPFR_RNDN);
        mpfr_div(r19744, r19737, r19743, MPFR_RNDN);
        mpfr_mul(r19745, r19736, r19744, MPFR_RNDN);
        mpfr_mul(r19746, r19723, r19726, MPFR_RNDN);
        mpfr_div(r19747, r19745, r19746, MPFR_RNDN);
        ;
        mpfr_set_si(r19749, mpfr_cmp(r19716, r19748) <= 0, MPFR_RNDN);
        mpfr_sub(r19750, r19730, r19742, MPFR_RNDN);
        mpfr_div(r19751, r19750, r19746, MPFR_RNDN);
        mpfr_div(r19752, r19719, r19716, MPFR_RNDN);
        mpfr_div(r19753, r19716, r19726, MPFR_RNDN);
        mpfr_sub(r19754, r19752, r19753, MPFR_RNDN);
        if (mpfr_get_si(r19749, MPFR_RNDN)) { mpfr_set(r19755, r19751, MPFR_RNDN); } else { mpfr_set(r19755, r19754, MPFR_RNDN); };
        if (mpfr_get_si(r19735, MPFR_RNDN)) { mpfr_set(r19756, r19747, MPFR_RNDN); } else { mpfr_set(r19756, r19755, MPFR_RNDN); };
        if (mpfr_get_si(r19718, MPFR_RNDN)) { mpfr_set(r19757, r19733, MPFR_RNDN); } else { mpfr_set(r19757, r19756, MPFR_RNDN); };
        return mpfr_get_d(r19757, MPFR_RNDN);
}

static mpfr_t r19758, r19759, r19760, r19761, r19762, r19763, r19764, r19765, r19766, r19767, r19768, r19769, r19770, r19771, r19772, r19773, r19774, r19775, r19776, r19777, r19778, r19779, r19780, r19781, r19782, r19783, r19784, r19785, r19786, r19787, r19788, r19789, r19790, r19791, r19792, r19793, r19794, r19795, r19796, r19797, r19798, r19799;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r19758);
        mpfr_init_set_str(r19759, "-9.612559777483023e+27", 10, MPFR_RNDN);
        mpfr_init(r19760);
        mpfr_init(r19761);
        mpfr_init_set_str(r19762, "4", 10, MPFR_RNDN);
        mpfr_init_set_str(r19763, "1", 10, MPFR_RNDN);
        mpfr_init(r19764);
        mpfr_init_set_str(r19765, "2", 10, MPFR_RNDN);
        mpfr_init(r19766);
        mpfr_init(r19767);
        mpfr_init(r19768);
        mpfr_init(r19769);
        mpfr_init(r19770);
        mpfr_init(r19771);
        mpfr_init(r19772);
        mpfr_init(r19773);
        mpfr_init(r19774);
        mpfr_init(r19775);
        mpfr_init_set_str(r19776, "-1.4807562139587436e-235", 10, MPFR_RNDN);
        mpfr_init(r19777);
        mpfr_init(r19778);
        mpfr_init(r19779);
        mpfr_init(r19780);
        mpfr_init(r19781);
        mpfr_init(r19782);
        mpfr_init(r19783);
        mpfr_init(r19784);
        mpfr_init(r19785);
        mpfr_init(r19786);
        mpfr_init(r19787);
        mpfr_init(r19788);
        mpfr_init(r19789);
        mpfr_init_set_str(r19790, "2.0227608047655974e+110", 10, MPFR_RNDN);
        mpfr_init(r19791);
        mpfr_init(r19792);
        mpfr_init(r19793);
        mpfr_init(r19794);
        mpfr_init(r19795);
        mpfr_init(r19796);
        mpfr_init(r19797);
        mpfr_init(r19798);
        mpfr_init(r19799);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r19758, b, MPFR_RNDN);
        ;
        mpfr_set_si(r19760, mpfr_cmp(r19758, r19759) <= 0, MPFR_RNDN);
        mpfr_set_d(r19761, c, MPFR_RNDN);
        ;
        ;
        mpfr_div(r19764, r19762, r19763, MPFR_RNDN);
        ;
        mpfr_div(r19766, r19764, r19765, MPFR_RNDN);
        mpfr_mul(r19767, r19761, r19766, MPFR_RNDN);
        mpfr_set_d(r19768, a, MPFR_RNDN);
        mpfr_add(r19769, r19768, r19768, MPFR_RNDN);
        mpfr_div(r19770, r19758, r19761, MPFR_RNDN);
        mpfr_div(r19771, r19769, r19770, MPFR_RNDN);
        mpfr_neg(r19772, r19758, MPFR_RNDN);
        mpfr_sub(r19773, r19758, r19772, MPFR_RNDN);
        mpfr_sub(r19774, r19771, r19773, MPFR_RNDN);
        mpfr_div(r19775, r19767, r19774, MPFR_RNDN);
        ;
        mpfr_set_si(r19777, mpfr_cmp(r19758, r19776) <= 0, MPFR_RNDN);
        mpfr_div(r19778, r19768, r19763, MPFR_RNDN);
        mpfr_mul(r19779, r19762, r19761, MPFR_RNDN);
        mpfr_sqr(r19780, r19758, MPFR_RNDN);
        mpfr_mul(r19781, r19768, r19761, MPFR_RNDN);
        mpfr_mul(r19782, r19762, r19781, MPFR_RNDN);
        mpfr_sub(r19783, r19780, r19782, MPFR_RNDN);
        mpfr_sqrt(r19784, r19783, MPFR_RNDN);
        mpfr_add(r19785, r19772, r19784, MPFR_RNDN);
        mpfr_div(r19786, r19779, r19785, MPFR_RNDN);
        mpfr_mul(r19787, r19778, r19786, MPFR_RNDN);
        mpfr_mul(r19788, r19765, r19768, MPFR_RNDN);
        mpfr_div(r19789, r19787, r19788, MPFR_RNDN);
        ;
        mpfr_set_si(r19791, mpfr_cmp(r19758, r19790) <= 0, MPFR_RNDN);
        mpfr_sub(r19792, r19772, r19784, MPFR_RNDN);
        mpfr_div(r19793, r19792, r19788, MPFR_RNDN);
        mpfr_div(r19794, r19761, r19758, MPFR_RNDN);
        mpfr_div(r19795, r19758, r19768, MPFR_RNDN);
        mpfr_sub(r19796, r19794, r19795, MPFR_RNDN);
        if (mpfr_get_si(r19791, MPFR_RNDN)) { mpfr_set(r19797, r19793, MPFR_RNDN); } else { mpfr_set(r19797, r19796, MPFR_RNDN); };
        if (mpfr_get_si(r19777, MPFR_RNDN)) { mpfr_set(r19798, r19789, MPFR_RNDN); } else { mpfr_set(r19798, r19797, MPFR_RNDN); };
        if (mpfr_get_si(r19760, MPFR_RNDN)) { mpfr_set(r19799, r19775, MPFR_RNDN); } else { mpfr_set(r19799, r19798, MPFR_RNDN); };
        return mpfr_get_d(r19799, MPFR_RNDN);
}

