#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 r20838 = b_2F2;
        float r20839 = -r20838;
        float r20840 = r20838 * r20838;
        float r20841 = a;
        float r20842 = c;
        float r20843 = r20841 * r20842;
        float r20844 = r20840 - r20843;
        float r20845 = sqrt(r20844);
        float r20846 = r20839 - r20845;
        float r20847 = r20846 / r20841;
        return r20847;
}

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


double f_of(float a, float b_2F2, float c) {
        float r20858 = b_2F2;
        float r20859 = -4.08238009793696e+80;
        bool r20860 = r20858 <= r20859;
        float r20861 = c;
        float r20862 = 1/2;
        float r20863 = a;
        float r20864 = r20862 * r20863;
        float r20865 = r20858 / r20861;
        float r20866 = r20864 / r20865;
        float r20867 = r20858 + r20858;
        float r20868 = r20866 - r20867;
        float r20869 = r20861 / r20868;
        float r20870 = -3.0251069177626306e-285;
        bool r20871 = r20858 <= r20870;
        float r20872 = 1;
        float r20873 = r20858 * r20858;
        float r20874 = r20861 * r20863;
        float r20875 = r20873 - r20874;
        float r20876 = sqrt(r20875);
        float r20877 = r20872 / r20861;
        float r20878 = -r20865;
        float r20879 = fma(r20876, r20877, r20878);
        float r20880 = r20872 / r20879;
        float r20881 = 2.766211155591128e+18;
        bool r20882 = r20858 <= r20881;
        float r20883 = -r20858;
        float r20884 = r20863 * r20861;
        float r20885 = r20873 - r20884;
        float r20886 = sqrt(r20885);
        float r20887 = r20883 - r20886;
        float r20888 = r20872 / r20863;
        float r20889 = r20887 * r20888;
        float r20890 = -2;
        float r20891 = r20858 / r20863;
        float r20892 = r20890 * r20891;
        float r20893 = r20882 ? r20889 : r20892;
        float r20894 = r20871 ? r20880 : r20893;
        float r20895 = r20860 ? r20869 : r20894;
        return r20895;
}

double f_od(double a, double b_2F2, double c) {
        double r20896 = b_2F2;
        double r20897 = -4.08238009793696e+80;
        bool r20898 = r20896 <= r20897;
        double r20899 = c;
        double r20900 = 1/2;
        double r20901 = a;
        double r20902 = r20900 * r20901;
        double r20903 = r20896 / r20899;
        double r20904 = r20902 / r20903;
        double r20905 = r20896 + r20896;
        double r20906 = r20904 - r20905;
        double r20907 = r20899 / r20906;
        double r20908 = -3.0251069177626306e-285;
        bool r20909 = r20896 <= r20908;
        double r20910 = 1;
        double r20911 = r20896 * r20896;
        double r20912 = r20899 * r20901;
        double r20913 = r20911 - r20912;
        double r20914 = sqrt(r20913);
        double r20915 = r20910 / r20899;
        double r20916 = -r20903;
        double r20917 = fma(r20914, r20915, r20916);
        double r20918 = r20910 / r20917;
        double r20919 = 2.766211155591128e+18;
        bool r20920 = r20896 <= r20919;
        double r20921 = -r20896;
        double r20922 = r20901 * r20899;
        double r20923 = r20911 - r20922;
        double r20924 = sqrt(r20923);
        double r20925 = r20921 - r20924;
        double r20926 = r20910 / r20901;
        double r20927 = r20925 * r20926;
        double r20928 = -2;
        double r20929 = r20896 / r20901;
        double r20930 = r20928 * r20929;
        double r20931 = r20920 ? r20927 : r20930;
        double r20932 = r20909 ? r20918 : r20931;
        double r20933 = r20898 ? r20907 : r20932;
        return r20933;
}

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 r20934, r20935, r20936, r20937, r20938, r20939, r20940, r20941, r20942, r20943;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20934);
        mpfr_init(r20935);
        mpfr_init(r20936);
        mpfr_init(r20937);
        mpfr_init(r20938);
        mpfr_init(r20939);
        mpfr_init(r20940);
        mpfr_init(r20941);
        mpfr_init(r20942);
        mpfr_init(r20943);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20934, b_2F2, MPFR_RNDN);
        mpfr_neg(r20935, r20934, MPFR_RNDN);
        mpfr_mul(r20936, r20934, r20934, MPFR_RNDN);
        mpfr_set_d(r20937, a, MPFR_RNDN);
        mpfr_set_d(r20938, c, MPFR_RNDN);
        mpfr_mul(r20939, r20937, r20938, MPFR_RNDN);
        mpfr_sub(r20940, r20936, r20939, MPFR_RNDN);
        mpfr_sqrt(r20941, r20940, MPFR_RNDN);
        mpfr_sub(r20942, r20935, r20941, MPFR_RNDN);
        mpfr_div(r20943, r20942, r20937, MPFR_RNDN);
        return mpfr_get_d(r20943, MPFR_RNDN);
}

static mpfr_t r20944, r20945, r20946, r20947, r20948, r20949, r20950, 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;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20944);
        mpfr_init_set_str(r20945, "-4.08238009793696e+80", 10, MPFR_RNDN);
        mpfr_init(r20946);
        mpfr_init(r20947);
        mpfr_init_set_str(r20948, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20949);
        mpfr_init(r20950);
        mpfr_init(r20951);
        mpfr_init(r20952);
        mpfr_init(r20953);
        mpfr_init(r20954);
        mpfr_init(r20955);
        mpfr_init_set_str(r20956, "-3.0251069177626306e-285", 10, MPFR_RNDN);
        mpfr_init(r20957);
        mpfr_init_set_str(r20958, "1", 10, MPFR_RNDN);
        mpfr_init(r20959);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
        mpfr_init(r20963);
        mpfr_init(r20964);
        mpfr_init(r20965);
        mpfr_init(r20966);
        mpfr_init_set_str(r20967, "2.766211155591128e+18", 10, MPFR_RNDN);
        mpfr_init(r20968);
        mpfr_init(r20969);
        mpfr_init(r20970);
        mpfr_init(r20971);
        mpfr_init(r20972);
        mpfr_init(r20973);
        mpfr_init(r20974);
        mpfr_init(r20975);
        mpfr_init_set_str(r20976, "-2", 10, MPFR_RNDN);
        mpfr_init(r20977);
        mpfr_init(r20978);
        mpfr_init(r20979);
        mpfr_init(r20980);
        mpfr_init(r20981);
}

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

static mpfr_t r20982, r20983, r20984, r20985, r20986, 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;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20982);
        mpfr_init_set_str(r20983, "-4.08238009793696e+80", 10, MPFR_RNDN);
        mpfr_init(r20984);
        mpfr_init(r20985);
        mpfr_init_set_str(r20986, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20987);
        mpfr_init(r20988);
        mpfr_init(r20989);
        mpfr_init(r20990);
        mpfr_init(r20991);
        mpfr_init(r20992);
        mpfr_init(r20993);
        mpfr_init_set_str(r20994, "-3.0251069177626306e-285", 10, MPFR_RNDN);
        mpfr_init(r20995);
        mpfr_init_set_str(r20996, "1", 10, MPFR_RNDN);
        mpfr_init(r20997);
        mpfr_init(r20998);
        mpfr_init(r20999);
        mpfr_init(r21000);
        mpfr_init(r21001);
        mpfr_init(r21002);
        mpfr_init(r21003);
        mpfr_init(r21004);
        mpfr_init_set_str(r21005, "2.766211155591128e+18", 10, MPFR_RNDN);
        mpfr_init(r21006);
        mpfr_init(r21007);
        mpfr_init(r21008);
        mpfr_init(r21009);
        mpfr_init(r21010);
        mpfr_init(r21011);
        mpfr_init(r21012);
        mpfr_init(r21013);
        mpfr_init_set_str(r21014, "-2", 10, MPFR_RNDN);
        mpfr_init(r21015);
        mpfr_init(r21016);
        mpfr_init(r21017);
        mpfr_init(r21018);
        mpfr_init(r21019);
}

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