#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 r20065 = b_2F2;
        float r20066 = -r20065;
        float r20067 = r20065 * r20065;
        float r20068 = a;
        float r20069 = c;
        float r20070 = r20068 * r20069;
        float r20071 = r20067 - r20070;
        float r20072 = sqrt(r20071);
        float r20073 = r20066 - r20072;
        float r20074 = r20073 / r20068;
        return r20074;
}

double f_id(double a, double b_2F2, double c) {
        double r20075 = b_2F2;
        double r20076 = -r20075;
        double r20077 = r20075 * r20075;
        double r20078 = a;
        double r20079 = c;
        double r20080 = r20078 * r20079;
        double r20081 = r20077 - r20080;
        double r20082 = sqrt(r20081);
        double r20083 = r20076 - r20082;
        double r20084 = r20083 / r20078;
        return r20084;
}


double f_of(float a, float b_2F2, float c) {
        float r20085 = b_2F2;
        float r20086 = -1.5109696884710251e+32;
        bool r20087 = r20085 <= r20086;
        float r20088 = c;
        float r20089 = r20088 / r20085;
        float r20090 = -1/2;
        float r20091 = r20089 * r20090;
        float r20092 = -5.265216833412822e-50;
        bool r20093 = r20085 <= r20092;
        float r20094 = a;
        float r20095 = r20088 * r20094;
        float r20096 = -r20085;
        float r20097 = r20085 * r20085;
        float r20098 = r20094 * r20088;
        float r20099 = r20097 - r20098;
        float r20100 = sqrt(r20099);
        float r20101 = r20096 + r20100;
        float r20102 = r20095 / r20101;
        float r20103 = r20102 / r20094;
        float r20104 = -5.313823226269673e-107;
        bool r20105 = r20085 <= r20104;
        float r20106 = 1.6622135411792587e+81;
        bool r20107 = r20085 <= r20106;
        float r20108 = r20096 - r20100;
        float r20109 = r20108 / r20094;
        float r20110 = -2;
        float r20111 = r20085 / r20094;
        float r20112 = r20110 * r20111;
        float r20113 = r20107 ? r20109 : r20112;
        float r20114 = r20105 ? r20091 : r20113;
        float r20115 = r20093 ? r20103 : r20114;
        float r20116 = r20087 ? r20091 : r20115;
        return r20116;
}

double f_od(double a, double b_2F2, double c) {
        double r20117 = b_2F2;
        double r20118 = -1.5109696884710251e+32;
        bool r20119 = r20117 <= r20118;
        double r20120 = c;
        double r20121 = r20120 / r20117;
        double r20122 = -1/2;
        double r20123 = r20121 * r20122;
        double r20124 = -5.265216833412822e-50;
        bool r20125 = r20117 <= r20124;
        double r20126 = a;
        double r20127 = r20120 * r20126;
        double r20128 = -r20117;
        double r20129 = r20117 * r20117;
        double r20130 = r20126 * r20120;
        double r20131 = r20129 - r20130;
        double r20132 = sqrt(r20131);
        double r20133 = r20128 + r20132;
        double r20134 = r20127 / r20133;
        double r20135 = r20134 / r20126;
        double r20136 = -5.313823226269673e-107;
        bool r20137 = r20117 <= r20136;
        double r20138 = 1.6622135411792587e+81;
        bool r20139 = r20117 <= r20138;
        double r20140 = r20128 - r20132;
        double r20141 = r20140 / r20126;
        double r20142 = -2;
        double r20143 = r20117 / r20126;
        double r20144 = r20142 * r20143;
        double r20145 = r20139 ? r20141 : r20144;
        double r20146 = r20137 ? r20123 : r20145;
        double r20147 = r20125 ? r20135 : r20146;
        double r20148 = r20119 ? r20123 : r20147;
        return r20148;
}

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 r20149, r20150, r20151, r20152, r20153, r20154, r20155, r20156, r20157, r20158;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20149);
        mpfr_init(r20150);
        mpfr_init(r20151);
        mpfr_init(r20152);
        mpfr_init(r20153);
        mpfr_init(r20154);
        mpfr_init(r20155);
        mpfr_init(r20156);
        mpfr_init(r20157);
        mpfr_init(r20158);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20149, b_2F2, MPFR_RNDN);
        mpfr_neg(r20150, r20149, MPFR_RNDN);
        mpfr_mul(r20151, r20149, r20149, MPFR_RNDN);
        mpfr_set_d(r20152, a, MPFR_RNDN);
        mpfr_set_d(r20153, c, MPFR_RNDN);
        mpfr_mul(r20154, r20152, r20153, MPFR_RNDN);
        mpfr_sub(r20155, r20151, r20154, MPFR_RNDN);
        mpfr_sqrt(r20156, r20155, MPFR_RNDN);
        mpfr_sub(r20157, r20150, r20156, MPFR_RNDN);
        mpfr_div(r20158, r20157, r20152, MPFR_RNDN);
        return mpfr_get_d(r20158, MPFR_RNDN);
}

static mpfr_t r20159, r20160, r20161, r20162, r20163, r20164, r20165, r20166, r20167, r20168, r20169, r20170, r20171, r20172, r20173, r20174, r20175, r20176, r20177, r20178, r20179, r20180, r20181, r20182, r20183, r20184, r20185, r20186, r20187, r20188, r20189, r20190;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20159);
        mpfr_init_set_str(r20160, "-1.5109696884710251e+32", 10, MPFR_RNDN);
        mpfr_init(r20161);
        mpfr_init(r20162);
        mpfr_init(r20163);
        mpfr_init_set_str(r20164, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20165);
        mpfr_init_set_str(r20166, "-5.265216833412822e-50", 10, MPFR_RNDN);
        mpfr_init(r20167);
        mpfr_init(r20168);
        mpfr_init(r20169);
        mpfr_init(r20170);
        mpfr_init(r20171);
        mpfr_init(r20172);
        mpfr_init(r20173);
        mpfr_init(r20174);
        mpfr_init(r20175);
        mpfr_init(r20176);
        mpfr_init(r20177);
        mpfr_init_set_str(r20178, "-5.313823226269673e-107", 10, MPFR_RNDN);
        mpfr_init(r20179);
        mpfr_init_set_str(r20180, "1.6622135411792587e+81", 10, MPFR_RNDN);
        mpfr_init(r20181);
        mpfr_init(r20182);
        mpfr_init(r20183);
        mpfr_init_set_str(r20184, "-2", 10, MPFR_RNDN);
        mpfr_init(r20185);
        mpfr_init(r20186);
        mpfr_init(r20187);
        mpfr_init(r20188);
        mpfr_init(r20189);
        mpfr_init(r20190);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r20159, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20161, mpfr_cmp(r20159, r20160) <= 0, MPFR_RNDN);
        mpfr_set_d(r20162, c, MPFR_RNDN);
        mpfr_div(r20163, r20162, r20159, MPFR_RNDN);
        ;
        mpfr_mul(r20165, r20163, r20164, MPFR_RNDN);
        ;
        mpfr_set_si(r20167, mpfr_cmp(r20159, r20166) <= 0, MPFR_RNDN);
        mpfr_set_d(r20168, a, MPFR_RNDN);
        mpfr_mul(r20169, r20162, r20168, MPFR_RNDN);
        mpfr_neg(r20170, r20159, MPFR_RNDN);
        mpfr_mul(r20171, r20159, r20159, MPFR_RNDN);
        mpfr_mul(r20172, r20168, r20162, MPFR_RNDN);
        mpfr_sub(r20173, r20171, r20172, MPFR_RNDN);
        mpfr_sqrt(r20174, r20173, MPFR_RNDN);
        mpfr_add(r20175, r20170, r20174, MPFR_RNDN);
        mpfr_div(r20176, r20169, r20175, MPFR_RNDN);
        mpfr_div(r20177, r20176, r20168, MPFR_RNDN);
        ;
        mpfr_set_si(r20179, mpfr_cmp(r20159, r20178) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r20181, mpfr_cmp(r20159, r20180) <= 0, MPFR_RNDN);
        mpfr_sub(r20182, r20170, r20174, MPFR_RNDN);
        mpfr_div(r20183, r20182, r20168, MPFR_RNDN);
        ;
        mpfr_div(r20185, r20159, r20168, MPFR_RNDN);
        mpfr_mul(r20186, r20184, r20185, MPFR_RNDN);
        if (mpfr_get_si(r20181, MPFR_RNDN)) { mpfr_set(r20187, r20183, MPFR_RNDN); } else { mpfr_set(r20187, r20186, MPFR_RNDN); };
        if (mpfr_get_si(r20179, MPFR_RNDN)) { mpfr_set(r20188, r20165, MPFR_RNDN); } else { mpfr_set(r20188, r20187, MPFR_RNDN); };
        if (mpfr_get_si(r20167, MPFR_RNDN)) { mpfr_set(r20189, r20177, MPFR_RNDN); } else { mpfr_set(r20189, r20188, MPFR_RNDN); };
        if (mpfr_get_si(r20161, MPFR_RNDN)) { mpfr_set(r20190, r20165, MPFR_RNDN); } else { mpfr_set(r20190, r20189, MPFR_RNDN); };
        return mpfr_get_d(r20190, MPFR_RNDN);
}

static mpfr_t r20191, r20192, r20193, r20194, r20195, r20196, r20197, r20198, r20199, r20200, r20201, r20202, r20203, r20204, r20205, r20206, r20207, r20208, r20209, r20210, r20211, r20212, r20213, r20214, r20215, r20216, r20217, r20218, r20219, r20220, r20221, r20222;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20191);
        mpfr_init_set_str(r20192, "-1.5109696884710251e+32", 10, MPFR_RNDN);
        mpfr_init(r20193);
        mpfr_init(r20194);
        mpfr_init(r20195);
        mpfr_init_set_str(r20196, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20197);
        mpfr_init_set_str(r20198, "-5.265216833412822e-50", 10, MPFR_RNDN);
        mpfr_init(r20199);
        mpfr_init(r20200);
        mpfr_init(r20201);
        mpfr_init(r20202);
        mpfr_init(r20203);
        mpfr_init(r20204);
        mpfr_init(r20205);
        mpfr_init(r20206);
        mpfr_init(r20207);
        mpfr_init(r20208);
        mpfr_init(r20209);
        mpfr_init_set_str(r20210, "-5.313823226269673e-107", 10, MPFR_RNDN);
        mpfr_init(r20211);
        mpfr_init_set_str(r20212, "1.6622135411792587e+81", 10, MPFR_RNDN);
        mpfr_init(r20213);
        mpfr_init(r20214);
        mpfr_init(r20215);
        mpfr_init_set_str(r20216, "-2", 10, MPFR_RNDN);
        mpfr_init(r20217);
        mpfr_init(r20218);
        mpfr_init(r20219);
        mpfr_init(r20220);
        mpfr_init(r20221);
        mpfr_init(r20222);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r20191, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20193, mpfr_cmp(r20191, r20192) <= 0, MPFR_RNDN);
        mpfr_set_d(r20194, c, MPFR_RNDN);
        mpfr_div(r20195, r20194, r20191, MPFR_RNDN);
        ;
        mpfr_mul(r20197, r20195, r20196, MPFR_RNDN);
        ;
        mpfr_set_si(r20199, mpfr_cmp(r20191, r20198) <= 0, MPFR_RNDN);
        mpfr_set_d(r20200, a, MPFR_RNDN);
        mpfr_mul(r20201, r20194, r20200, MPFR_RNDN);
        mpfr_neg(r20202, r20191, MPFR_RNDN);
        mpfr_mul(r20203, r20191, r20191, MPFR_RNDN);
        mpfr_mul(r20204, r20200, r20194, MPFR_RNDN);
        mpfr_sub(r20205, r20203, r20204, MPFR_RNDN);
        mpfr_sqrt(r20206, r20205, MPFR_RNDN);
        mpfr_add(r20207, r20202, r20206, MPFR_RNDN);
        mpfr_div(r20208, r20201, r20207, MPFR_RNDN);
        mpfr_div(r20209, r20208, r20200, MPFR_RNDN);
        ;
        mpfr_set_si(r20211, mpfr_cmp(r20191, r20210) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r20213, mpfr_cmp(r20191, r20212) <= 0, MPFR_RNDN);
        mpfr_sub(r20214, r20202, r20206, MPFR_RNDN);
        mpfr_div(r20215, r20214, r20200, MPFR_RNDN);
        ;
        mpfr_div(r20217, r20191, r20200, MPFR_RNDN);
        mpfr_mul(r20218, r20216, r20217, MPFR_RNDN);
        if (mpfr_get_si(r20213, MPFR_RNDN)) { mpfr_set(r20219, r20215, MPFR_RNDN); } else { mpfr_set(r20219, r20218, MPFR_RNDN); };
        if (mpfr_get_si(r20211, MPFR_RNDN)) { mpfr_set(r20220, r20197, MPFR_RNDN); } else { mpfr_set(r20220, r20219, MPFR_RNDN); };
        if (mpfr_get_si(r20199, MPFR_RNDN)) { mpfr_set(r20221, r20209, MPFR_RNDN); } else { mpfr_set(r20221, r20220, MPFR_RNDN); };
        if (mpfr_get_si(r20193, MPFR_RNDN)) { mpfr_set(r20222, r20197, MPFR_RNDN); } else { mpfr_set(r20222, r20221, MPFR_RNDN); };
        return mpfr_get_d(r20222, MPFR_RNDN);
}