#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 r20826 = b_2F2;
        float r20827 = -r20826;
        float r20828 = r20826 * r20826;
        float r20829 = a;
        float r20830 = c;
        float r20831 = r20829 * r20830;
        float r20832 = r20828 - r20831;
        float r20833 = sqrt(r20832);
        float r20834 = r20827 - r20833;
        float r20835 = r20834 / r20829;
        return r20835;
}

double f_id(double a, double b_2F2, double c) {
        double r20836 = b_2F2;
        double r20837 = -r20836;
        double r20838 = r20836 * r20836;
        double r20839 = a;
        double r20840 = c;
        double r20841 = r20839 * r20840;
        double r20842 = r20838 - r20841;
        double r20843 = sqrt(r20842);
        double r20844 = r20837 - r20843;
        double r20845 = r20844 / r20839;
        return r20845;
}


double f_of(float a, float b_2F2, float c) {
        float r20846 = b_2F2;
        float r20847 = -4.08238009793696e+80;
        bool r20848 = r20846 <= r20847;
        float r20849 = c;
        float r20850 = 1/2;
        float r20851 = r20849 * r20850;
        float r20852 = a;
        float r20853 = r20846 / r20852;
        float r20854 = r20851 / r20853;
        float r20855 = r20846 + r20846;
        float r20856 = r20854 - r20855;
        float r20857 = r20849 / r20856;
        float r20858 = -5.586135086711939e-287;
        bool r20859 = r20846 <= r20858;
        float r20860 = 1;
        float r20861 = r20846 * r20846;
        float r20862 = r20849 * r20852;
        float r20863 = r20861 - r20862;
        float r20864 = sqrt(r20863);
        float r20865 = -r20846;
        float r20866 = r20864 + r20865;
        float r20867 = r20866 / r20849;
        float r20868 = r20860 / r20867;
        float r20869 = 2.766211155591128e+18;
        bool r20870 = r20846 <= r20869;
        float r20871 = r20852 * r20849;
        float r20872 = r20861 - r20871;
        float r20873 = sqrt(r20872);
        float r20874 = r20865 - r20873;
        float r20875 = r20860 / r20852;
        float r20876 = r20874 * r20875;
        float r20877 = -2;
        float r20878 = r20877 * r20853;
        float r20879 = r20870 ? r20876 : r20878;
        float r20880 = r20859 ? r20868 : r20879;
        float r20881 = r20848 ? r20857 : r20880;
        return r20881;
}

double f_od(double a, double b_2F2, double c) {
        double r20882 = b_2F2;
        double r20883 = -4.08238009793696e+80;
        bool r20884 = r20882 <= r20883;
        double r20885 = c;
        double r20886 = 1/2;
        double r20887 = r20885 * r20886;
        double r20888 = a;
        double r20889 = r20882 / r20888;
        double r20890 = r20887 / r20889;
        double r20891 = r20882 + r20882;
        double r20892 = r20890 - r20891;
        double r20893 = r20885 / r20892;
        double r20894 = -5.586135086711939e-287;
        bool r20895 = r20882 <= r20894;
        double r20896 = 1;
        double r20897 = r20882 * r20882;
        double r20898 = r20885 * r20888;
        double r20899 = r20897 - r20898;
        double r20900 = sqrt(r20899);
        double r20901 = -r20882;
        double r20902 = r20900 + r20901;
        double r20903 = r20902 / r20885;
        double r20904 = r20896 / r20903;
        double r20905 = 2.766211155591128e+18;
        bool r20906 = r20882 <= r20905;
        double r20907 = r20888 * r20885;
        double r20908 = r20897 - r20907;
        double r20909 = sqrt(r20908);
        double r20910 = r20901 - r20909;
        double r20911 = r20896 / r20888;
        double r20912 = r20910 * r20911;
        double r20913 = -2;
        double r20914 = r20913 * r20889;
        double r20915 = r20906 ? r20912 : r20914;
        double r20916 = r20895 ? r20904 : r20915;
        double r20917 = r20884 ? r20893 : r20916;
        return r20917;
}

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 r20918, r20919, r20920, r20921, r20922, r20923, r20924, r20925, r20926, r20927;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20918);
        mpfr_init(r20919);
        mpfr_init(r20920);
        mpfr_init(r20921);
        mpfr_init(r20922);
        mpfr_init(r20923);
        mpfr_init(r20924);
        mpfr_init(r20925);
        mpfr_init(r20926);
        mpfr_init(r20927);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20918, b_2F2, MPFR_RNDN);
        mpfr_neg(r20919, r20918, MPFR_RNDN);
        mpfr_mul(r20920, r20918, r20918, MPFR_RNDN);
        mpfr_set_d(r20921, a, MPFR_RNDN);
        mpfr_set_d(r20922, c, MPFR_RNDN);
        mpfr_mul(r20923, r20921, r20922, MPFR_RNDN);
        mpfr_sub(r20924, r20920, r20923, MPFR_RNDN);
        mpfr_sqrt(r20925, r20924, MPFR_RNDN);
        mpfr_sub(r20926, r20919, r20925, MPFR_RNDN);
        mpfr_div(r20927, r20926, r20921, MPFR_RNDN);
        return mpfr_get_d(r20927, MPFR_RNDN);
}

static mpfr_t r20928, r20929, r20930, r20931, r20932, r20933, r20934, r20935, r20936, r20937, r20938, r20939, r20940, r20941, r20942, r20943, r20944, r20945, r20946, r20947, r20948, r20949, r20950, r20951, r20952, r20953, r20954, r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962, r20963;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20928);
        mpfr_init_set_str(r20929, "-4.08238009793696e+80", 10, MPFR_RNDN);
        mpfr_init(r20930);
        mpfr_init(r20931);
        mpfr_init_set_str(r20932, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20933);
        mpfr_init(r20934);
        mpfr_init(r20935);
        mpfr_init(r20936);
        mpfr_init(r20937);
        mpfr_init(r20938);
        mpfr_init(r20939);
        mpfr_init_set_str(r20940, "-5.586135086711939e-287", 10, MPFR_RNDN);
        mpfr_init(r20941);
        mpfr_init_set_str(r20942, "1", 10, MPFR_RNDN);
        mpfr_init(r20943);
        mpfr_init(r20944);
        mpfr_init(r20945);
        mpfr_init(r20946);
        mpfr_init(r20947);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init(r20950);
        mpfr_init_set_str(r20951, "2.766211155591128e+18", 10, MPFR_RNDN);
        mpfr_init(r20952);
        mpfr_init(r20953);
        mpfr_init(r20954);
        mpfr_init(r20955);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init(r20958);
        mpfr_init_set_str(r20959, "-2", 10, MPFR_RNDN);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
        mpfr_init(r20963);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r20928, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20930, mpfr_cmp(r20928, r20929) <= 0, MPFR_RNDN);
        mpfr_set_d(r20931, c, MPFR_RNDN);
        ;
        mpfr_mul(r20933, r20931, r20932, MPFR_RNDN);
        mpfr_set_d(r20934, a, MPFR_RNDN);
        mpfr_div(r20935, r20928, r20934, MPFR_RNDN);
        mpfr_div(r20936, r20933, r20935, MPFR_RNDN);
        mpfr_add(r20937, r20928, r20928, MPFR_RNDN);
        mpfr_sub(r20938, r20936, r20937, MPFR_RNDN);
        mpfr_div(r20939, r20931, r20938, MPFR_RNDN);
        ;
        mpfr_set_si(r20941, mpfr_cmp(r20928, r20940) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r20943, r20928, r20928, MPFR_RNDN);
        mpfr_mul(r20944, r20931, r20934, MPFR_RNDN);
        mpfr_sub(r20945, r20943, r20944, MPFR_RNDN);
        mpfr_sqrt(r20946, r20945, MPFR_RNDN);
        mpfr_neg(r20947, r20928, MPFR_RNDN);
        mpfr_add(r20948, r20946, r20947, MPFR_RNDN);
        mpfr_div(r20949, r20948, r20931, MPFR_RNDN);
        mpfr_div(r20950, r20942, r20949, MPFR_RNDN);
        ;
        mpfr_set_si(r20952, mpfr_cmp(r20928, r20951) <= 0, MPFR_RNDN);
        mpfr_mul(r20953, r20934, r20931, MPFR_RNDN);
        mpfr_sub(r20954, r20943, r20953, MPFR_RNDN);
        mpfr_sqrt(r20955, r20954, MPFR_RNDN);
        mpfr_sub(r20956, r20947, r20955, MPFR_RNDN);
        mpfr_div(r20957, r20942, r20934, MPFR_RNDN);
        mpfr_mul(r20958, r20956, r20957, MPFR_RNDN);
        ;
        mpfr_mul(r20960, r20959, r20935, MPFR_RNDN);
        if (mpfr_get_si(r20952, MPFR_RNDN)) { mpfr_set(r20961, r20958, MPFR_RNDN); } else { mpfr_set(r20961, r20960, MPFR_RNDN); };
        if (mpfr_get_si(r20941, MPFR_RNDN)) { mpfr_set(r20962, r20950, MPFR_RNDN); } else { mpfr_set(r20962, r20961, MPFR_RNDN); };
        if (mpfr_get_si(r20930, MPFR_RNDN)) { mpfr_set(r20963, r20939, MPFR_RNDN); } else { mpfr_set(r20963, r20962, MPFR_RNDN); };
        return mpfr_get_d(r20963, MPFR_RNDN);
}

static mpfr_t r20964, r20965, r20966, r20967, r20968, r20969, r20970, r20971, r20972, r20973, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981, r20982, r20983, r20984, r20985, r20986, r20987, r20988, r20989, r20990, r20991, r20992, r20993, r20994, r20995, r20996, r20997, r20998, r20999;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20964);
        mpfr_init_set_str(r20965, "-4.08238009793696e+80", 10, MPFR_RNDN);
        mpfr_init(r20966);
        mpfr_init(r20967);
        mpfr_init_set_str(r20968, "1/2", 10, MPFR_RNDN);
        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, "-5.586135086711939e-287", 10, MPFR_RNDN);
        mpfr_init(r20977);
        mpfr_init_set_str(r20978, "1", 10, MPFR_RNDN);
        mpfr_init(r20979);
        mpfr_init(r20980);
        mpfr_init(r20981);
        mpfr_init(r20982);
        mpfr_init(r20983);
        mpfr_init(r20984);
        mpfr_init(r20985);
        mpfr_init(r20986);
        mpfr_init_set_str(r20987, "2.766211155591128e+18", 10, MPFR_RNDN);
        mpfr_init(r20988);
        mpfr_init(r20989);
        mpfr_init(r20990);
        mpfr_init(r20991);
        mpfr_init(r20992);
        mpfr_init(r20993);
        mpfr_init(r20994);
        mpfr_init_set_str(r20995, "-2", 10, MPFR_RNDN);
        mpfr_init(r20996);
        mpfr_init(r20997);
        mpfr_init(r20998);
        mpfr_init(r20999);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r20964, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20966, mpfr_cmp(r20964, r20965) <= 0, MPFR_RNDN);
        mpfr_set_d(r20967, c, MPFR_RNDN);
        ;
        mpfr_mul(r20969, r20967, r20968, MPFR_RNDN);
        mpfr_set_d(r20970, a, MPFR_RNDN);
        mpfr_div(r20971, r20964, r20970, MPFR_RNDN);
        mpfr_div(r20972, r20969, r20971, MPFR_RNDN);
        mpfr_add(r20973, r20964, r20964, MPFR_RNDN);
        mpfr_sub(r20974, r20972, r20973, MPFR_RNDN);
        mpfr_div(r20975, r20967, r20974, MPFR_RNDN);
        ;
        mpfr_set_si(r20977, mpfr_cmp(r20964, r20976) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r20979, r20964, r20964, MPFR_RNDN);
        mpfr_mul(r20980, r20967, r20970, MPFR_RNDN);
        mpfr_sub(r20981, r20979, r20980, MPFR_RNDN);
        mpfr_sqrt(r20982, r20981, MPFR_RNDN);
        mpfr_neg(r20983, r20964, MPFR_RNDN);
        mpfr_add(r20984, r20982, r20983, MPFR_RNDN);
        mpfr_div(r20985, r20984, r20967, MPFR_RNDN);
        mpfr_div(r20986, r20978, r20985, MPFR_RNDN);
        ;
        mpfr_set_si(r20988, mpfr_cmp(r20964, r20987) <= 0, MPFR_RNDN);
        mpfr_mul(r20989, r20970, r20967, MPFR_RNDN);
        mpfr_sub(r20990, r20979, r20989, MPFR_RNDN);
        mpfr_sqrt(r20991, r20990, MPFR_RNDN);
        mpfr_sub(r20992, r20983, r20991, MPFR_RNDN);
        mpfr_div(r20993, r20978, r20970, MPFR_RNDN);
        mpfr_mul(r20994, r20992, r20993, MPFR_RNDN);
        ;
        mpfr_mul(r20996, r20995, r20971, MPFR_RNDN);
        if (mpfr_get_si(r20988, MPFR_RNDN)) { mpfr_set(r20997, r20994, MPFR_RNDN); } else { mpfr_set(r20997, r20996, MPFR_RNDN); };
        if (mpfr_get_si(r20977, MPFR_RNDN)) { mpfr_set(r20998, r20986, MPFR_RNDN); } else { mpfr_set(r20998, r20997, MPFR_RNDN); };
        if (mpfr_get_si(r20966, MPFR_RNDN)) { mpfr_set(r20999, r20975, MPFR_RNDN); } else { mpfr_set(r20999, r20998, MPFR_RNDN); };
        return mpfr_get_d(r20999, MPFR_RNDN);
}