#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 r20073 = b_2F2;
        float r20074 = -r20073;
        float r20075 = r20073 * r20073;
        float r20076 = a;
        float r20077 = c;
        float r20078 = r20076 * r20077;
        float r20079 = r20075 - r20078;
        float r20080 = sqrt(r20079);
        float r20081 = r20074 - r20080;
        float r20082 = r20081 / r20076;
        return r20082;
}

double f_id(double a, double b_2F2, double c) {
        double r20083 = b_2F2;
        double r20084 = -r20083;
        double r20085 = r20083 * r20083;
        double r20086 = a;
        double r20087 = c;
        double r20088 = r20086 * r20087;
        double r20089 = r20085 - r20088;
        double r20090 = sqrt(r20089);
        double r20091 = r20084 - r20090;
        double r20092 = r20091 / r20086;
        return r20092;
}


double f_of(float a, float b_2F2, float c) {
        float r20093 = b_2F2;
        float r20094 = -5.018034098196628e+28;
        bool r20095 = r20093 <= r20094;
        float r20096 = c;
        float r20097 = r20096 / r20093;
        float r20098 = -1/2;
        float r20099 = r20097 * r20098;
        float r20100 = -1.992853954034314e-66;
        bool r20101 = r20093 <= r20100;
        float r20102 = a;
        float r20103 = r20096 * r20102;
        float r20104 = -r20093;
        float r20105 = r20093 * r20093;
        float r20106 = r20102 * r20096;
        float r20107 = r20105 - r20106;
        float r20108 = sqrt(r20107);
        float r20109 = r20104 + r20108;
        float r20110 = r20103 / r20109;
        float r20111 = r20110 / r20102;
        float r20112 = -5.3589749776329416e-108;
        bool r20113 = r20093 <= r20112;
        float r20114 = 1.7007616628281973e+81;
        bool r20115 = r20093 <= r20114;
        float r20116 = r20104 - r20108;
        float r20117 = r20116 / r20102;
        float r20118 = -2;
        float r20119 = r20093 / r20102;
        float r20120 = r20118 * r20119;
        float r20121 = r20115 ? r20117 : r20120;
        float r20122 = r20113 ? r20099 : r20121;
        float r20123 = r20101 ? r20111 : r20122;
        float r20124 = r20095 ? r20099 : r20123;
        return r20124;
}

double f_od(double a, double b_2F2, double c) {
        double r20125 = b_2F2;
        double r20126 = -5.018034098196628e+28;
        bool r20127 = r20125 <= r20126;
        double r20128 = c;
        double r20129 = r20128 / r20125;
        double r20130 = -1/2;
        double r20131 = r20129 * r20130;
        double r20132 = -1.992853954034314e-66;
        bool r20133 = r20125 <= r20132;
        double r20134 = a;
        double r20135 = r20128 * r20134;
        double r20136 = -r20125;
        double r20137 = r20125 * r20125;
        double r20138 = r20134 * r20128;
        double r20139 = r20137 - r20138;
        double r20140 = sqrt(r20139);
        double r20141 = r20136 + r20140;
        double r20142 = r20135 / r20141;
        double r20143 = r20142 / r20134;
        double r20144 = -5.3589749776329416e-108;
        bool r20145 = r20125 <= r20144;
        double r20146 = 1.7007616628281973e+81;
        bool r20147 = r20125 <= r20146;
        double r20148 = r20136 - r20140;
        double r20149 = r20148 / r20134;
        double r20150 = -2;
        double r20151 = r20125 / r20134;
        double r20152 = r20150 * r20151;
        double r20153 = r20147 ? r20149 : r20152;
        double r20154 = r20145 ? r20131 : r20153;
        double r20155 = r20133 ? r20143 : r20154;
        double r20156 = r20127 ? r20131 : r20155;
        return r20156;
}

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 r20157, r20158, r20159, r20160, r20161, r20162, r20163, r20164, r20165, r20166;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2704);
        mpfr_init(r20157);
        mpfr_init(r20158);
        mpfr_init(r20159);
        mpfr_init(r20160);
        mpfr_init(r20161);
        mpfr_init(r20162);
        mpfr_init(r20163);
        mpfr_init(r20164);
        mpfr_init(r20165);
        mpfr_init(r20166);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20157, b_2F2, MPFR_RNDN);
        mpfr_neg(r20158, r20157, MPFR_RNDN);
        mpfr_mul(r20159, r20157, r20157, MPFR_RNDN);
        mpfr_set_d(r20160, a, MPFR_RNDN);
        mpfr_set_d(r20161, c, MPFR_RNDN);
        mpfr_mul(r20162, r20160, r20161, MPFR_RNDN);
        mpfr_sub(r20163, r20159, r20162, MPFR_RNDN);
        mpfr_sqrt(r20164, r20163, MPFR_RNDN);
        mpfr_sub(r20165, r20158, r20164, MPFR_RNDN);
        mpfr_div(r20166, r20165, r20160, MPFR_RNDN);
        return mpfr_get_d(r20166, MPFR_RNDN);
}

static mpfr_t r20167, r20168, r20169, r20170, r20171, r20172, r20173, r20174, r20175, r20176, r20177, r20178, r20179, r20180, r20181, r20182, r20183, r20184, r20185, r20186, r20187, r20188, r20189, r20190, r20191, r20192, r20193, r20194, r20195, r20196, r20197, r20198;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2704);
        mpfr_init(r20167);
        mpfr_init_set_str(r20168, "-5.018034098196628e+28", 10, MPFR_RNDN);
        mpfr_init(r20169);
        mpfr_init(r20170);
        mpfr_init(r20171);
        mpfr_init_set_str(r20172, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20173);
        mpfr_init_set_str(r20174, "-1.992853954034314e-66", 10, MPFR_RNDN);
        mpfr_init(r20175);
        mpfr_init(r20176);
        mpfr_init(r20177);
        mpfr_init(r20178);
        mpfr_init(r20179);
        mpfr_init(r20180);
        mpfr_init(r20181);
        mpfr_init(r20182);
        mpfr_init(r20183);
        mpfr_init(r20184);
        mpfr_init(r20185);
        mpfr_init_set_str(r20186, "-5.3589749776329416e-108", 10, MPFR_RNDN);
        mpfr_init(r20187);
        mpfr_init_set_str(r20188, "1.7007616628281973e+81", 10, MPFR_RNDN);
        mpfr_init(r20189);
        mpfr_init(r20190);
        mpfr_init(r20191);
        mpfr_init_set_str(r20192, "-2", 10, MPFR_RNDN);
        mpfr_init(r20193);
        mpfr_init(r20194);
        mpfr_init(r20195);
        mpfr_init(r20196);
        mpfr_init(r20197);
        mpfr_init(r20198);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r20167, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20169, mpfr_cmp(r20167, r20168) <= 0, MPFR_RNDN);
        mpfr_set_d(r20170, c, MPFR_RNDN);
        mpfr_div(r20171, r20170, r20167, MPFR_RNDN);
        ;
        mpfr_mul(r20173, r20171, r20172, MPFR_RNDN);
        ;
        mpfr_set_si(r20175, mpfr_cmp(r20167, r20174) <= 0, MPFR_RNDN);
        mpfr_set_d(r20176, a, MPFR_RNDN);
        mpfr_mul(r20177, r20170, r20176, MPFR_RNDN);
        mpfr_neg(r20178, r20167, MPFR_RNDN);
        mpfr_mul(r20179, r20167, r20167, MPFR_RNDN);
        mpfr_mul(r20180, r20176, r20170, MPFR_RNDN);
        mpfr_sub(r20181, r20179, r20180, MPFR_RNDN);
        mpfr_sqrt(r20182, r20181, MPFR_RNDN);
        mpfr_add(r20183, r20178, r20182, MPFR_RNDN);
        mpfr_div(r20184, r20177, r20183, MPFR_RNDN);
        mpfr_div(r20185, r20184, r20176, MPFR_RNDN);
        ;
        mpfr_set_si(r20187, mpfr_cmp(r20167, r20186) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r20189, mpfr_cmp(r20167, r20188) <= 0, MPFR_RNDN);
        mpfr_sub(r20190, r20178, r20182, MPFR_RNDN);
        mpfr_div(r20191, r20190, r20176, MPFR_RNDN);
        ;
        mpfr_div(r20193, r20167, r20176, MPFR_RNDN);
        mpfr_mul(r20194, r20192, r20193, MPFR_RNDN);
        if (mpfr_get_si(r20189, MPFR_RNDN)) { mpfr_set(r20195, r20191, MPFR_RNDN); } else { mpfr_set(r20195, r20194, MPFR_RNDN); };
        if (mpfr_get_si(r20187, MPFR_RNDN)) { mpfr_set(r20196, r20173, MPFR_RNDN); } else { mpfr_set(r20196, r20195, MPFR_RNDN); };
        if (mpfr_get_si(r20175, MPFR_RNDN)) { mpfr_set(r20197, r20185, MPFR_RNDN); } else { mpfr_set(r20197, r20196, MPFR_RNDN); };
        if (mpfr_get_si(r20169, MPFR_RNDN)) { mpfr_set(r20198, r20173, MPFR_RNDN); } else { mpfr_set(r20198, r20197, MPFR_RNDN); };
        return mpfr_get_d(r20198, MPFR_RNDN);
}

static mpfr_t r20199, r20200, r20201, r20202, r20203, r20204, r20205, r20206, r20207, r20208, r20209, r20210, r20211, r20212, r20213, r20214, r20215, r20216, r20217, r20218, r20219, r20220, r20221, r20222, r20223, r20224, r20225, r20226, r20227, r20228, r20229, r20230;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2704);
        mpfr_init(r20199);
        mpfr_init_set_str(r20200, "-5.018034098196628e+28", 10, MPFR_RNDN);
        mpfr_init(r20201);
        mpfr_init(r20202);
        mpfr_init(r20203);
        mpfr_init_set_str(r20204, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20205);
        mpfr_init_set_str(r20206, "-1.992853954034314e-66", 10, MPFR_RNDN);
        mpfr_init(r20207);
        mpfr_init(r20208);
        mpfr_init(r20209);
        mpfr_init(r20210);
        mpfr_init(r20211);
        mpfr_init(r20212);
        mpfr_init(r20213);
        mpfr_init(r20214);
        mpfr_init(r20215);
        mpfr_init(r20216);
        mpfr_init(r20217);
        mpfr_init_set_str(r20218, "-5.3589749776329416e-108", 10, MPFR_RNDN);
        mpfr_init(r20219);
        mpfr_init_set_str(r20220, "1.7007616628281973e+81", 10, MPFR_RNDN);
        mpfr_init(r20221);
        mpfr_init(r20222);
        mpfr_init(r20223);
        mpfr_init_set_str(r20224, "-2", 10, MPFR_RNDN);
        mpfr_init(r20225);
        mpfr_init(r20226);
        mpfr_init(r20227);
        mpfr_init(r20228);
        mpfr_init(r20229);
        mpfr_init(r20230);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r20199, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20201, mpfr_cmp(r20199, r20200) <= 0, MPFR_RNDN);
        mpfr_set_d(r20202, c, MPFR_RNDN);
        mpfr_div(r20203, r20202, r20199, MPFR_RNDN);
        ;
        mpfr_mul(r20205, r20203, r20204, MPFR_RNDN);
        ;
        mpfr_set_si(r20207, mpfr_cmp(r20199, r20206) <= 0, MPFR_RNDN);
        mpfr_set_d(r20208, a, MPFR_RNDN);
        mpfr_mul(r20209, r20202, r20208, MPFR_RNDN);
        mpfr_neg(r20210, r20199, MPFR_RNDN);
        mpfr_mul(r20211, r20199, r20199, MPFR_RNDN);
        mpfr_mul(r20212, r20208, r20202, MPFR_RNDN);
        mpfr_sub(r20213, r20211, r20212, MPFR_RNDN);
        mpfr_sqrt(r20214, r20213, MPFR_RNDN);
        mpfr_add(r20215, r20210, r20214, MPFR_RNDN);
        mpfr_div(r20216, r20209, r20215, MPFR_RNDN);
        mpfr_div(r20217, r20216, r20208, MPFR_RNDN);
        ;
        mpfr_set_si(r20219, mpfr_cmp(r20199, r20218) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r20221, mpfr_cmp(r20199, r20220) <= 0, MPFR_RNDN);
        mpfr_sub(r20222, r20210, r20214, MPFR_RNDN);
        mpfr_div(r20223, r20222, r20208, MPFR_RNDN);
        ;
        mpfr_div(r20225, r20199, r20208, MPFR_RNDN);
        mpfr_mul(r20226, r20224, r20225, MPFR_RNDN);
        if (mpfr_get_si(r20221, MPFR_RNDN)) { mpfr_set(r20227, r20223, MPFR_RNDN); } else { mpfr_set(r20227, r20226, MPFR_RNDN); };
        if (mpfr_get_si(r20219, MPFR_RNDN)) { mpfr_set(r20228, r20205, MPFR_RNDN); } else { mpfr_set(r20228, r20227, MPFR_RNDN); };
        if (mpfr_get_si(r20207, MPFR_RNDN)) { mpfr_set(r20229, r20217, MPFR_RNDN); } else { mpfr_set(r20229, r20228, MPFR_RNDN); };
        if (mpfr_get_si(r20201, MPFR_RNDN)) { mpfr_set(r20230, r20205, MPFR_RNDN); } else { mpfr_set(r20230, r20229, MPFR_RNDN); };
        return mpfr_get_d(r20230, MPFR_RNDN);
}