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

char *name = "quad2m (problem 3.2.1, negative)";

double f_if(float a, float b_2F2, float c) {
        float r20849 = b_2F2;
        float r20850 = -r20849;
        float r20851 = r20849 * r20849;
        float r20852 = a;
        float r20853 = c;
        float r20854 = r20852 * r20853;
        float r20855 = r20851 - r20854;
        float r20856 = sqrt(r20855);
        float r20857 = r20850 - r20856;
        float r20858 = r20857 / r20852;
        return r20858;
}

double f_id(double a, double b_2F2, double c) {
        double r20859 = b_2F2;
        double r20860 = -r20859;
        double r20861 = r20859 * r20859;
        double r20862 = a;
        double r20863 = c;
        double r20864 = r20862 * r20863;
        double r20865 = r20861 - r20864;
        double r20866 = sqrt(r20865);
        double r20867 = r20860 - r20866;
        double r20868 = r20867 / r20862;
        return r20868;
}


double f_of(float a, float b_2F2, float c) {
        float r20869 = b_2F2;
        float r20870 = -9.355156905614978e+153;
        bool r20871 = r20869 <= r20870;
        float r20872 = c;
        float r20873 = 1/2;
        float r20874 = a;
        float r20875 = r20873 * r20874;
        float r20876 = r20869 / r20872;
        float r20877 = r20875 / r20876;
        float r20878 = -r20869;
        float r20879 = r20869 - r20878;
        float r20880 = r20877 - r20879;
        float r20881 = r20872 / r20880;
        float r20882 = 1.9173617889725583e-255;
        bool r20883 = r20869 <= r20882;
        float r20884 = 1;
        float r20885 = r20872 / r20884;
        float r20886 = r20869 * r20869;
        float r20887 = r20874 * r20872;
        float r20888 = r20886 - r20887;
        float r20889 = sqrt(r20888);
        float r20890 = r20889 + r20878;
        float r20891 = r20885 / r20890;
        float r20892 = 8.064324250100004e+121;
        bool r20893 = r20869 <= r20892;
        float r20894 = r20878 - r20889;
        float r20895 = r20894 / r20874;
        float r20896 = +inf.0;
        bool r20897 = r20869 <= r20896;
        float r20898 = -2;
        float r20899 = r20869 / r20874;
        float r20900 = r20898 * r20899;
        float r20901 = r20897 ? r20900 : r20900;
        float r20902 = r20893 ? r20895 : r20901;
        float r20903 = r20883 ? r20891 : r20902;
        float r20904 = r20871 ? r20881 : r20903;
        return r20904;
}

double f_od(double a, double b_2F2, double c) {
        double r20905 = b_2F2;
        double r20906 = -9.355156905614978e+153;
        bool r20907 = r20905 <= r20906;
        double r20908 = c;
        double r20909 = 1/2;
        double r20910 = a;
        double r20911 = r20909 * r20910;
        double r20912 = r20905 / r20908;
        double r20913 = r20911 / r20912;
        double r20914 = -r20905;
        double r20915 = r20905 - r20914;
        double r20916 = r20913 - r20915;
        double r20917 = r20908 / r20916;
        double r20918 = 1.9173617889725583e-255;
        bool r20919 = r20905 <= r20918;
        double r20920 = 1;
        double r20921 = r20908 / r20920;
        double r20922 = r20905 * r20905;
        double r20923 = r20910 * r20908;
        double r20924 = r20922 - r20923;
        double r20925 = sqrt(r20924);
        double r20926 = r20925 + r20914;
        double r20927 = r20921 / r20926;
        double r20928 = 8.064324250100004e+121;
        bool r20929 = r20905 <= r20928;
        double r20930 = r20914 - r20925;
        double r20931 = r20930 / r20910;
        double r20932 = +inf.0;
        bool r20933 = r20905 <= r20932;
        double r20934 = -2;
        double r20935 = r20905 / r20910;
        double r20936 = r20934 * r20935;
        double r20937 = r20933 ? r20936 : r20936;
        double r20938 = r20929 ? r20931 : r20937;
        double r20939 = r20919 ? r20927 : r20938;
        double r20940 = r20907 ? r20917 : r20939;
        return r20940;
}

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 r20941, r20942, r20943, r20944, r20945, r20946, r20947, r20948, r20949, r20950;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20941);
        mpfr_init(r20942);
        mpfr_init(r20943);
        mpfr_init(r20944);
        mpfr_init(r20945);
        mpfr_init(r20946);
        mpfr_init(r20947);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init(r20950);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20941, b_2F2, MPFR_RNDN);
        mpfr_neg(r20942, r20941, MPFR_RNDN);
        mpfr_mul(r20943, r20941, r20941, MPFR_RNDN);
        mpfr_set_d(r20944, a, MPFR_RNDN);
        mpfr_set_d(r20945, c, MPFR_RNDN);
        mpfr_mul(r20946, r20944, r20945, MPFR_RNDN);
        mpfr_sub(r20947, r20943, r20946, MPFR_RNDN);
        mpfr_sqrt(r20948, r20947, MPFR_RNDN);
        mpfr_sub(r20949, r20942, r20948, MPFR_RNDN);
        mpfr_div(r20950, r20949, r20944, MPFR_RNDN);
        return mpfr_get_d(r20950, MPFR_RNDN);
}

static mpfr_t r20951, r20952, r20953, r20954, r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962, r20963, r20964, r20965, r20966, r20967, r20968, r20969, r20970, r20971, r20972, r20973, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981, r20982, r20983, r20984, r20985, r20986;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20951);
        mpfr_init_set_str(r20952, "-9.355156905614978e+153", 10, MPFR_RNDN);
        mpfr_init(r20953);
        mpfr_init(r20954);
        mpfr_init_set_str(r20955, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init(r20958);
        mpfr_init(r20959);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
        mpfr_init(r20963);
        mpfr_init_set_str(r20964, "1.9173617889725583e-255", 10, MPFR_RNDN);
        mpfr_init(r20965);
        mpfr_init_set_str(r20966, "1", 10, MPFR_RNDN);
        mpfr_init(r20967);
        mpfr_init(r20968);
        mpfr_init(r20969);
        mpfr_init(r20970);
        mpfr_init(r20971);
        mpfr_init(r20972);
        mpfr_init(r20973);
        mpfr_init_set_str(r20974, "8.064324250100004e+121", 10, MPFR_RNDN);
        mpfr_init(r20975);
        mpfr_init(r20976);
        mpfr_init(r20977);
        mpfr_init_set_str(r20978, "+inf.0", 10, MPFR_RNDN);
        mpfr_init(r20979);
        mpfr_init_set_str(r20980, "-2", 10, MPFR_RNDN);
        mpfr_init(r20981);
        mpfr_init(r20982);
        mpfr_init(r20983);
        mpfr_init(r20984);
        mpfr_init(r20985);
        mpfr_init(r20986);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r20951, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20953, mpfr_cmp(r20951, r20952) <= 0, MPFR_RNDN);
        mpfr_set_d(r20954, c, MPFR_RNDN);
        ;
        mpfr_set_d(r20956, a, MPFR_RNDN);
        mpfr_mul(r20957, r20955, r20956, MPFR_RNDN);
        mpfr_div(r20958, r20951, r20954, MPFR_RNDN);
        mpfr_div(r20959, r20957, r20958, MPFR_RNDN);
        mpfr_neg(r20960, r20951, MPFR_RNDN);
        mpfr_sub(r20961, r20951, r20960, MPFR_RNDN);
        mpfr_sub(r20962, r20959, r20961, MPFR_RNDN);
        mpfr_div(r20963, r20954, r20962, MPFR_RNDN);
        ;
        mpfr_set_si(r20965, mpfr_cmp(r20951, r20964) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20967, r20954, r20966, MPFR_RNDN);
        mpfr_mul(r20968, r20951, r20951, MPFR_RNDN);
        mpfr_mul(r20969, r20956, r20954, MPFR_RNDN);
        mpfr_sub(r20970, r20968, r20969, MPFR_RNDN);
        mpfr_sqrt(r20971, r20970, MPFR_RNDN);
        mpfr_add(r20972, r20971, r20960, MPFR_RNDN);
        mpfr_div(r20973, r20967, r20972, MPFR_RNDN);
        ;
        mpfr_set_si(r20975, mpfr_cmp(r20951, r20974) <= 0, MPFR_RNDN);
        mpfr_sub(r20976, r20960, r20971, MPFR_RNDN);
        mpfr_div(r20977, r20976, r20956, MPFR_RNDN);
        ;
        mpfr_set_si(r20979, mpfr_cmp(r20951, r20978) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20981, r20951, r20956, MPFR_RNDN);
        mpfr_mul(r20982, r20980, r20981, MPFR_RNDN);
        if (mpfr_get_si(r20979, MPFR_RNDN)) { mpfr_set(r20983, r20982, MPFR_RNDN); } else { mpfr_set(r20983, r20982, MPFR_RNDN); };
        if (mpfr_get_si(r20975, MPFR_RNDN)) { mpfr_set(r20984, r20977, MPFR_RNDN); } else { mpfr_set(r20984, r20983, MPFR_RNDN); };
        if (mpfr_get_si(r20965, MPFR_RNDN)) { mpfr_set(r20985, r20973, MPFR_RNDN); } else { mpfr_set(r20985, r20984, MPFR_RNDN); };
        if (mpfr_get_si(r20953, MPFR_RNDN)) { mpfr_set(r20986, r20963, MPFR_RNDN); } else { mpfr_set(r20986, r20985, MPFR_RNDN); };
        return mpfr_get_d(r20986, MPFR_RNDN);
}

static mpfr_t r20987, r20988, r20989, r20990, r20991, r20992, r20993, r20994, r20995, r20996, r20997, r20998, r20999, r21000, r21001, r21002, r21003, r21004, r21005, r21006, r21007, r21008, r21009, r21010, r21011, r21012, r21013, r21014, r21015, r21016, r21017, r21018, r21019, r21020, r21021, r21022;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20987);
        mpfr_init_set_str(r20988, "-9.355156905614978e+153", 10, MPFR_RNDN);
        mpfr_init(r20989);
        mpfr_init(r20990);
        mpfr_init_set_str(r20991, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20992);
        mpfr_init(r20993);
        mpfr_init(r20994);
        mpfr_init(r20995);
        mpfr_init(r20996);
        mpfr_init(r20997);
        mpfr_init(r20998);
        mpfr_init(r20999);
        mpfr_init_set_str(r21000, "1.9173617889725583e-255", 10, MPFR_RNDN);
        mpfr_init(r21001);
        mpfr_init_set_str(r21002, "1", 10, MPFR_RNDN);
        mpfr_init(r21003);
        mpfr_init(r21004);
        mpfr_init(r21005);
        mpfr_init(r21006);
        mpfr_init(r21007);
        mpfr_init(r21008);
        mpfr_init(r21009);
        mpfr_init_set_str(r21010, "8.064324250100004e+121", 10, MPFR_RNDN);
        mpfr_init(r21011);
        mpfr_init(r21012);
        mpfr_init(r21013);
        mpfr_init_set_str(r21014, "+inf.0", 10, MPFR_RNDN);
        mpfr_init(r21015);
        mpfr_init_set_str(r21016, "-2", 10, MPFR_RNDN);
        mpfr_init(r21017);
        mpfr_init(r21018);
        mpfr_init(r21019);
        mpfr_init(r21020);
        mpfr_init(r21021);
        mpfr_init(r21022);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r20987, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20989, mpfr_cmp(r20987, r20988) <= 0, MPFR_RNDN);
        mpfr_set_d(r20990, c, MPFR_RNDN);
        ;
        mpfr_set_d(r20992, a, MPFR_RNDN);
        mpfr_mul(r20993, r20991, r20992, MPFR_RNDN);
        mpfr_div(r20994, r20987, r20990, MPFR_RNDN);
        mpfr_div(r20995, r20993, r20994, MPFR_RNDN);
        mpfr_neg(r20996, r20987, MPFR_RNDN);
        mpfr_sub(r20997, r20987, r20996, MPFR_RNDN);
        mpfr_sub(r20998, r20995, r20997, MPFR_RNDN);
        mpfr_div(r20999, r20990, r20998, MPFR_RNDN);
        ;
        mpfr_set_si(r21001, mpfr_cmp(r20987, r21000) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r21003, r20990, r21002, MPFR_RNDN);
        mpfr_mul(r21004, r20987, r20987, MPFR_RNDN);
        mpfr_mul(r21005, r20992, r20990, MPFR_RNDN);
        mpfr_sub(r21006, r21004, r21005, MPFR_RNDN);
        mpfr_sqrt(r21007, r21006, MPFR_RNDN);
        mpfr_add(r21008, r21007, r20996, MPFR_RNDN);
        mpfr_div(r21009, r21003, r21008, MPFR_RNDN);
        ;
        mpfr_set_si(r21011, mpfr_cmp(r20987, r21010) <= 0, MPFR_RNDN);
        mpfr_sub(r21012, r20996, r21007, MPFR_RNDN);
        mpfr_div(r21013, r21012, r20992, MPFR_RNDN);
        ;
        mpfr_set_si(r21015, mpfr_cmp(r20987, r21014) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r21017, r20987, r20992, MPFR_RNDN);
        mpfr_mul(r21018, r21016, r21017, MPFR_RNDN);
        if (mpfr_get_si(r21015, MPFR_RNDN)) { mpfr_set(r21019, r21018, MPFR_RNDN); } else { mpfr_set(r21019, r21018, MPFR_RNDN); };
        if (mpfr_get_si(r21011, MPFR_RNDN)) { mpfr_set(r21020, r21013, MPFR_RNDN); } else { mpfr_set(r21020, r21019, MPFR_RNDN); };
        if (mpfr_get_si(r21001, MPFR_RNDN)) { mpfr_set(r21021, r21009, MPFR_RNDN); } else { mpfr_set(r21021, r21020, MPFR_RNDN); };
        if (mpfr_get_si(r20989, MPFR_RNDN)) { mpfr_set(r21022, r20999, MPFR_RNDN); } else { mpfr_set(r21022, r21021, MPFR_RNDN); };
        return mpfr_get_d(r21022, MPFR_RNDN);
}