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

char *name = "quadp (p42, positive)";

double f_if(float a, float b, float c) {
        float r19080 = b;
        float r19081 = -r19080;
        float r19082 = r19080 * r19080;
        float r19083 = 4.0f;
        float r19084 = a;
        float r19085 = c;
        float r19086 = r19084 * r19085;
        float r19087 = r19083 * r19086;
        float r19088 = r19082 - r19087;
        float r19089 = sqrt(r19088);
        float r19090 = r19081 + r19089;
        float r19091 = 2.0f;
        float r19092 = r19091 * r19084;
        float r19093 = r19090 / r19092;
        return r19093;
}

double f_id(double a, double b, double c) {
        double r19094 = b;
        double r19095 = -r19094;
        double r19096 = r19094 * r19094;
        double r19097 = 4.0;
        double r19098 = a;
        double r19099 = c;
        double r19100 = r19098 * r19099;
        double r19101 = r19097 * r19100;
        double r19102 = r19096 - r19101;
        double r19103 = sqrt(r19102);
        double r19104 = r19095 + r19103;
        double r19105 = 2.0;
        double r19106 = r19105 * r19098;
        double r19107 = r19104 / r19106;
        return r19107;
}


double f_of(float a, float b, float c) {
        float r19108 = b;
        float r19109 = -4.072401843866691e+122f;
        bool r19110 = r19108 <= r19109;
        float r19111 = c;
        float r19112 = r19111 / r19108;
        float r19113 = a;
        float r19114 = r19108 / r19113;
        float r19115 = r19112 - r19114;
        float r19116 = 7.905426201889951e-159f;
        bool r19117 = r19108 <= r19116;
        float r19118 = -r19108;
        float r19119 = r19108 * r19108;
        float r19120 = 4.0f;
        float r19121 = r19113 * r19111;
        float r19122 = r19120 * r19121;
        float r19123 = r19119 - r19122;
        float r19124 = sqrt(r19123);
        float r19125 = r19118 + r19124;
        float r19126 = 2.0f;
        float r19127 = r19126 * r19113;
        float r19128 = r19125 / r19127;
        float r19129 = 9.141549925217606e+73f;
        bool r19130 = r19108 <= r19129;
        float r19131 = r19120 * r19111;
        float r19132 = r19113 * r19131;
        float r19133 = r19118 - r19124;
        float r19134 = r19132 / r19133;
        float r19135 = r19134 / r19127;
        float r19136 = -2.0f;
        float r19137 = r19136 / r19126;
        float r19138 = r19112 * r19137;
        float r19139 = r19130 ? r19135 : r19138;
        float r19140 = r19117 ? r19128 : r19139;
        float r19141 = r19110 ? r19115 : r19140;
        return r19141;
}

double f_od(double a, double b, double c) {
        double r19142 = b;
        double r19143 = -4.072401843866691e+122;
        bool r19144 = r19142 <= r19143;
        double r19145 = c;
        double r19146 = r19145 / r19142;
        double r19147 = a;
        double r19148 = r19142 / r19147;
        double r19149 = r19146 - r19148;
        double r19150 = 7.905426201889951e-159;
        bool r19151 = r19142 <= r19150;
        double r19152 = -r19142;
        double r19153 = r19142 * r19142;
        double r19154 = 4.0;
        double r19155 = r19147 * r19145;
        double r19156 = r19154 * r19155;
        double r19157 = r19153 - r19156;
        double r19158 = sqrt(r19157);
        double r19159 = r19152 + r19158;
        double r19160 = 2.0;
        double r19161 = r19160 * r19147;
        double r19162 = r19159 / r19161;
        double r19163 = 9.141549925217606e+73;
        bool r19164 = r19142 <= r19163;
        double r19165 = r19154 * r19145;
        double r19166 = r19147 * r19165;
        double r19167 = r19152 - r19158;
        double r19168 = r19166 / r19167;
        double r19169 = r19168 / r19161;
        double r19170 = -2.0;
        double r19171 = r19170 / r19160;
        double r19172 = r19146 * r19171;
        double r19173 = r19164 ? r19169 : r19172;
        double r19174 = r19151 ? r19162 : r19173;
        double r19175 = r19144 ? r19149 : r19174;
        return r19175;
}

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 r19176, r19177, r19178, r19179, r19180, r19181, r19182, r19183, r19184, r19185, r19186, r19187, r19188, r19189;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2960);
        mpfr_init(r19176);
        mpfr_init(r19177);
        mpfr_init(r19178);
        mpfr_init_set_str(r19179, "4", 10, MPFR_RNDN);
        mpfr_init(r19180);
        mpfr_init(r19181);
        mpfr_init(r19182);
        mpfr_init(r19183);
        mpfr_init(r19184);
        mpfr_init(r19185);
        mpfr_init(r19186);
        mpfr_init_set_str(r19187, "2", 10, MPFR_RNDN);
        mpfr_init(r19188);
        mpfr_init(r19189);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r19176, b, MPFR_RNDN);
        mpfr_neg(r19177, r19176, MPFR_RNDN);
        mpfr_sqr(r19178, r19176, MPFR_RNDN);
        ;
        mpfr_set_d(r19180, a, MPFR_RNDN);
        mpfr_set_d(r19181, c, MPFR_RNDN);
        mpfr_mul(r19182, r19180, r19181, MPFR_RNDN);
        mpfr_mul(r19183, r19179, r19182, MPFR_RNDN);
        mpfr_sub(r19184, r19178, r19183, MPFR_RNDN);
        mpfr_sqrt(r19185, r19184, MPFR_RNDN);
        mpfr_add(r19186, r19177, r19185, MPFR_RNDN);
        ;
        mpfr_mul(r19188, r19187, r19180, MPFR_RNDN);
        mpfr_div(r19189, r19186, r19188, MPFR_RNDN);
        return mpfr_get_d(r19189, MPFR_RNDN);
}

static mpfr_t r19190, r19191, r19192, r19193, r19194, r19195, r19196, r19197, r19198, r19199, r19200, r19201, r19202, r19203, r19204, r19205, r19206, r19207, r19208, r19209, r19210, r19211, r19212, r19213, r19214, r19215, r19216, r19217, r19218, r19219, r19220, r19221, r19222, r19223;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2960);
        mpfr_init(r19190);
        mpfr_init_set_str(r19191, "-4.072401843866691e+122", 10, MPFR_RNDN);
        mpfr_init(r19192);
        mpfr_init(r19193);
        mpfr_init(r19194);
        mpfr_init(r19195);
        mpfr_init(r19196);
        mpfr_init(r19197);
        mpfr_init_set_str(r19198, "7.905426201889951e-159", 10, MPFR_RNDN);
        mpfr_init(r19199);
        mpfr_init(r19200);
        mpfr_init(r19201);
        mpfr_init_set_str(r19202, "4", 10, MPFR_RNDN);
        mpfr_init(r19203);
        mpfr_init(r19204);
        mpfr_init(r19205);
        mpfr_init(r19206);
        mpfr_init(r19207);
        mpfr_init_set_str(r19208, "2", 10, MPFR_RNDN);
        mpfr_init(r19209);
        mpfr_init(r19210);
        mpfr_init_set_str(r19211, "9.141549925217606e+73", 10, MPFR_RNDN);
        mpfr_init(r19212);
        mpfr_init(r19213);
        mpfr_init(r19214);
        mpfr_init(r19215);
        mpfr_init(r19216);
        mpfr_init(r19217);
        mpfr_init_set_str(r19218, "-2", 10, MPFR_RNDN);
        mpfr_init(r19219);
        mpfr_init(r19220);
        mpfr_init(r19221);
        mpfr_init(r19222);
        mpfr_init(r19223);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r19190, b, MPFR_RNDN);
        ;
        mpfr_set_si(r19192, mpfr_cmp(r19190, r19191) <= 0, MPFR_RNDN);
        mpfr_set_d(r19193, c, MPFR_RNDN);
        mpfr_div(r19194, r19193, r19190, MPFR_RNDN);
        mpfr_set_d(r19195, a, MPFR_RNDN);
        mpfr_div(r19196, r19190, r19195, MPFR_RNDN);
        mpfr_sub(r19197, r19194, r19196, MPFR_RNDN);
        ;
        mpfr_set_si(r19199, mpfr_cmp(r19190, r19198) <= 0, MPFR_RNDN);
        mpfr_neg(r19200, r19190, MPFR_RNDN);
        mpfr_sqr(r19201, r19190, MPFR_RNDN);
        ;
        mpfr_mul(r19203, r19195, r19193, MPFR_RNDN);
        mpfr_mul(r19204, r19202, r19203, MPFR_RNDN);
        mpfr_sub(r19205, r19201, r19204, MPFR_RNDN);
        mpfr_sqrt(r19206, r19205, MPFR_RNDN);
        mpfr_add(r19207, r19200, r19206, MPFR_RNDN);
        ;
        mpfr_mul(r19209, r19208, r19195, MPFR_RNDN);
        mpfr_div(r19210, r19207, r19209, MPFR_RNDN);
        ;
        mpfr_set_si(r19212, mpfr_cmp(r19190, r19211) <= 0, MPFR_RNDN);
        mpfr_mul(r19213, r19202, r19193, MPFR_RNDN);
        mpfr_mul(r19214, r19195, r19213, MPFR_RNDN);
        mpfr_sub(r19215, r19200, r19206, MPFR_RNDN);
        mpfr_div(r19216, r19214, r19215, MPFR_RNDN);
        mpfr_div(r19217, r19216, r19209, MPFR_RNDN);
        ;
        mpfr_div(r19219, r19218, r19208, MPFR_RNDN);
        mpfr_mul(r19220, r19194, r19219, MPFR_RNDN);
        if (mpfr_get_si(r19212, MPFR_RNDN)) { mpfr_set(r19221, r19217, MPFR_RNDN); } else { mpfr_set(r19221, r19220, MPFR_RNDN); };
        if (mpfr_get_si(r19199, MPFR_RNDN)) { mpfr_set(r19222, r19210, MPFR_RNDN); } else { mpfr_set(r19222, r19221, MPFR_RNDN); };
        if (mpfr_get_si(r19192, MPFR_RNDN)) { mpfr_set(r19223, r19197, MPFR_RNDN); } else { mpfr_set(r19223, r19222, MPFR_RNDN); };
        return mpfr_get_d(r19223, MPFR_RNDN);
}

static mpfr_t r19224, r19225, r19226, r19227, r19228, r19229, r19230, r19231, r19232, r19233, r19234, r19235, r19236, r19237, r19238, r19239, r19240, r19241, r19242, r19243, r19244, r19245, r19246, r19247, r19248, r19249, r19250, r19251, r19252, r19253, r19254, r19255, r19256, r19257;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2960);
        mpfr_init(r19224);
        mpfr_init_set_str(r19225, "-4.072401843866691e+122", 10, MPFR_RNDN);
        mpfr_init(r19226);
        mpfr_init(r19227);
        mpfr_init(r19228);
        mpfr_init(r19229);
        mpfr_init(r19230);
        mpfr_init(r19231);
        mpfr_init_set_str(r19232, "7.905426201889951e-159", 10, MPFR_RNDN);
        mpfr_init(r19233);
        mpfr_init(r19234);
        mpfr_init(r19235);
        mpfr_init_set_str(r19236, "4", 10, MPFR_RNDN);
        mpfr_init(r19237);
        mpfr_init(r19238);
        mpfr_init(r19239);
        mpfr_init(r19240);
        mpfr_init(r19241);
        mpfr_init_set_str(r19242, "2", 10, MPFR_RNDN);
        mpfr_init(r19243);
        mpfr_init(r19244);
        mpfr_init_set_str(r19245, "9.141549925217606e+73", 10, MPFR_RNDN);
        mpfr_init(r19246);
        mpfr_init(r19247);
        mpfr_init(r19248);
        mpfr_init(r19249);
        mpfr_init(r19250);
        mpfr_init(r19251);
        mpfr_init_set_str(r19252, "-2", 10, MPFR_RNDN);
        mpfr_init(r19253);
        mpfr_init(r19254);
        mpfr_init(r19255);
        mpfr_init(r19256);
        mpfr_init(r19257);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r19224, b, MPFR_RNDN);
        ;
        mpfr_set_si(r19226, mpfr_cmp(r19224, r19225) <= 0, MPFR_RNDN);
        mpfr_set_d(r19227, c, MPFR_RNDN);
        mpfr_div(r19228, r19227, r19224, MPFR_RNDN);
        mpfr_set_d(r19229, a, MPFR_RNDN);
        mpfr_div(r19230, r19224, r19229, MPFR_RNDN);
        mpfr_sub(r19231, r19228, r19230, MPFR_RNDN);
        ;
        mpfr_set_si(r19233, mpfr_cmp(r19224, r19232) <= 0, MPFR_RNDN);
        mpfr_neg(r19234, r19224, MPFR_RNDN);
        mpfr_sqr(r19235, r19224, MPFR_RNDN);
        ;
        mpfr_mul(r19237, r19229, r19227, MPFR_RNDN);
        mpfr_mul(r19238, r19236, r19237, MPFR_RNDN);
        mpfr_sub(r19239, r19235, r19238, MPFR_RNDN);
        mpfr_sqrt(r19240, r19239, MPFR_RNDN);
        mpfr_add(r19241, r19234, r19240, MPFR_RNDN);
        ;
        mpfr_mul(r19243, r19242, r19229, MPFR_RNDN);
        mpfr_div(r19244, r19241, r19243, MPFR_RNDN);
        ;
        mpfr_set_si(r19246, mpfr_cmp(r19224, r19245) <= 0, MPFR_RNDN);
        mpfr_mul(r19247, r19236, r19227, MPFR_RNDN);
        mpfr_mul(r19248, r19229, r19247, MPFR_RNDN);
        mpfr_sub(r19249, r19234, r19240, MPFR_RNDN);
        mpfr_div(r19250, r19248, r19249, MPFR_RNDN);
        mpfr_div(r19251, r19250, r19243, MPFR_RNDN);
        ;
        mpfr_div(r19253, r19252, r19242, MPFR_RNDN);
        mpfr_mul(r19254, r19228, r19253, MPFR_RNDN);
        if (mpfr_get_si(r19246, MPFR_RNDN)) { mpfr_set(r19255, r19251, MPFR_RNDN); } else { mpfr_set(r19255, r19254, MPFR_RNDN); };
        if (mpfr_get_si(r19233, MPFR_RNDN)) { mpfr_set(r19256, r19244, MPFR_RNDN); } else { mpfr_set(r19256, r19255, MPFR_RNDN); };
        if (mpfr_get_si(r19226, MPFR_RNDN)) { mpfr_set(r19257, r19231, MPFR_RNDN); } else { mpfr_set(r19257, r19256, MPFR_RNDN); };
        return mpfr_get_d(r19257, MPFR_RNDN);
}

