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

char *name = "quadm (p42, negative)";

double f_if(float a, float b, float c) {
        float r38056 = b;
        float r38057 = -r38056;
        float r38058 = r38056 * r38056;
        float r38059 = 4;
        float r38060 = a;
        float r38061 = c;
        float r38062 = r38060 * r38061;
        float r38063 = r38059 * r38062;
        float r38064 = r38058 - r38063;
        float r38065 = sqrt(r38064);
        float r38066 = r38057 - r38065;
        float r38067 = 2;
        float r38068 = r38067 * r38060;
        float r38069 = r38066 / r38068;
        return r38069;
}

double f_id(double a, double b, double c) {
        double r38070 = b;
        double r38071 = -r38070;
        double r38072 = r38070 * r38070;
        double r38073 = 4;
        double r38074 = a;
        double r38075 = c;
        double r38076 = r38074 * r38075;
        double r38077 = r38073 * r38076;
        double r38078 = r38072 - r38077;
        double r38079 = sqrt(r38078);
        double r38080 = r38071 - r38079;
        double r38081 = 2;
        double r38082 = r38081 * r38074;
        double r38083 = r38080 / r38082;
        return r38083;
}


double f_of(float a, float b, float c) {
        float r38084 = b;
        float r38085 = -1.0524347947917307e+32;
        bool r38086 = r38084 <= r38085;
        float r38087 = -r38084;
        float r38088 = r38087 + r38084;
        float r38089 = a;
        float r38090 = r38089 + r38089;
        float r38091 = r38088 / r38090;
        float r38092 = c;
        float r38093 = r38092 / r38084;
        float r38094 = r38091 - r38093;
        float r38095 = -8.424346933460515e-49;
        bool r38096 = r38084 <= r38095;
        float r38097 = r38092 * r38089;
        float r38098 = 4;
        float r38099 = r38097 * r38098;
        float r38100 = r38084 * r38084;
        float r38101 = r38089 * r38092;
        float r38102 = r38098 * r38101;
        float r38103 = r38100 - r38102;
        float r38104 = sqrt(r38103);
        float r38105 = r38087 + r38104;
        float r38106 = r38099 / r38105;
        float r38107 = 2;
        float r38108 = r38107 * r38089;
        float r38109 = r38106 / r38108;
        float r38110 = -2.725780123328718e-107;
        bool r38111 = r38084 <= r38110;
        float r38112 = 1.6902485387421231e+81;
        bool r38113 = r38084 <= r38112;
        float r38114 = r38098 * r38089;
        float r38115 = r38114 * r38092;
        float r38116 = r38100 - r38115;
        float r38117 = sqrt(r38116);
        float r38118 = r38087 - r38117;
        float r38119 = r38118 / r38108;
        float r38120 = r38087 / r38089;
        float r38121 = r38113 ? r38119 : r38120;
        float r38122 = r38111 ? r38094 : r38121;
        float r38123 = r38096 ? r38109 : r38122;
        float r38124 = r38086 ? r38094 : r38123;
        return r38124;
}

double f_od(double a, double b, double c) {
        double r38125 = b;
        double r38126 = -1.0524347947917307e+32;
        bool r38127 = r38125 <= r38126;
        double r38128 = -r38125;
        double r38129 = r38128 + r38125;
        double r38130 = a;
        double r38131 = r38130 + r38130;
        double r38132 = r38129 / r38131;
        double r38133 = c;
        double r38134 = r38133 / r38125;
        double r38135 = r38132 - r38134;
        double r38136 = -8.424346933460515e-49;
        bool r38137 = r38125 <= r38136;
        double r38138 = r38133 * r38130;
        double r38139 = 4;
        double r38140 = r38138 * r38139;
        double r38141 = r38125 * r38125;
        double r38142 = r38130 * r38133;
        double r38143 = r38139 * r38142;
        double r38144 = r38141 - r38143;
        double r38145 = sqrt(r38144);
        double r38146 = r38128 + r38145;
        double r38147 = r38140 / r38146;
        double r38148 = 2;
        double r38149 = r38148 * r38130;
        double r38150 = r38147 / r38149;
        double r38151 = -2.725780123328718e-107;
        bool r38152 = r38125 <= r38151;
        double r38153 = 1.6902485387421231e+81;
        bool r38154 = r38125 <= r38153;
        double r38155 = r38139 * r38130;
        double r38156 = r38155 * r38133;
        double r38157 = r38141 - r38156;
        double r38158 = sqrt(r38157);
        double r38159 = r38128 - r38158;
        double r38160 = r38159 / r38149;
        double r38161 = r38128 / r38130;
        double r38162 = r38154 ? r38160 : r38161;
        double r38163 = r38152 ? r38135 : r38162;
        double r38164 = r38137 ? r38150 : r38163;
        double r38165 = r38127 ? r38135 : r38164;
        return r38165;
}

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 r38166, r38167, r38168, r38169, r38170, r38171, r38172, r38173, r38174, r38175, r38176, r38177, r38178, r38179;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r38166);
        mpfr_init(r38167);
        mpfr_init(r38168);
        mpfr_init_set_str(r38169, "4", 10, MPFR_RNDN);
        mpfr_init(r38170);
        mpfr_init(r38171);
        mpfr_init(r38172);
        mpfr_init(r38173);
        mpfr_init(r38174);
        mpfr_init(r38175);
        mpfr_init(r38176);
        mpfr_init_set_str(r38177, "2", 10, MPFR_RNDN);
        mpfr_init(r38178);
        mpfr_init(r38179);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r38166, b, MPFR_RNDN);
        mpfr_neg(r38167, r38166, MPFR_RNDN);
        mpfr_mul(r38168, r38166, r38166, MPFR_RNDN);
        ;
        mpfr_set_d(r38170, a, MPFR_RNDN);
        mpfr_set_d(r38171, c, MPFR_RNDN);
        mpfr_mul(r38172, r38170, r38171, MPFR_RNDN);
        mpfr_mul(r38173, r38169, r38172, MPFR_RNDN);
        mpfr_sub(r38174, r38168, r38173, MPFR_RNDN);
        mpfr_sqrt(r38175, r38174, MPFR_RNDN);
        mpfr_sub(r38176, r38167, r38175, MPFR_RNDN);
        ;
        mpfr_mul(r38178, r38177, r38170, MPFR_RNDN);
        mpfr_div(r38179, r38176, r38178, MPFR_RNDN);
        return mpfr_get_d(r38179, MPFR_RNDN);
}

static mpfr_t r38180, r38181, r38182, r38183, r38184, r38185, r38186, r38187, r38188, r38189, r38190, r38191, r38192, r38193, r38194, r38195, r38196, r38197, r38198, r38199, r38200, r38201, r38202, r38203, r38204, r38205, r38206, r38207, r38208, r38209, r38210, r38211, r38212, r38213, r38214, r38215, r38216, r38217, r38218, r38219, r38220;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r38180);
        mpfr_init_set_str(r38181, "-1.0524347947917307e+32", 10, MPFR_RNDN);
        mpfr_init(r38182);
        mpfr_init(r38183);
        mpfr_init(r38184);
        mpfr_init(r38185);
        mpfr_init(r38186);
        mpfr_init(r38187);
        mpfr_init(r38188);
        mpfr_init(r38189);
        mpfr_init(r38190);
        mpfr_init_set_str(r38191, "-8.424346933460515e-49", 10, MPFR_RNDN);
        mpfr_init(r38192);
        mpfr_init(r38193);
        mpfr_init_set_str(r38194, "4", 10, MPFR_RNDN);
        mpfr_init(r38195);
        mpfr_init(r38196);
        mpfr_init(r38197);
        mpfr_init(r38198);
        mpfr_init(r38199);
        mpfr_init(r38200);
        mpfr_init(r38201);
        mpfr_init(r38202);
        mpfr_init_set_str(r38203, "2", 10, MPFR_RNDN);
        mpfr_init(r38204);
        mpfr_init(r38205);
        mpfr_init_set_str(r38206, "-2.725780123328718e-107", 10, MPFR_RNDN);
        mpfr_init(r38207);
        mpfr_init_set_str(r38208, "1.6902485387421231e+81", 10, MPFR_RNDN);
        mpfr_init(r38209);
        mpfr_init(r38210);
        mpfr_init(r38211);
        mpfr_init(r38212);
        mpfr_init(r38213);
        mpfr_init(r38214);
        mpfr_init(r38215);
        mpfr_init(r38216);
        mpfr_init(r38217);
        mpfr_init(r38218);
        mpfr_init(r38219);
        mpfr_init(r38220);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r38180, b, MPFR_RNDN);
        ;
        mpfr_set_si(r38182, mpfr_cmp(r38180, r38181) <= 0, MPFR_RNDN);
        mpfr_neg(r38183, r38180, MPFR_RNDN);
        mpfr_add(r38184, r38183, r38180, MPFR_RNDN);
        mpfr_set_d(r38185, a, MPFR_RNDN);
        mpfr_add(r38186, r38185, r38185, MPFR_RNDN);
        mpfr_div(r38187, r38184, r38186, MPFR_RNDN);
        mpfr_set_d(r38188, c, MPFR_RNDN);
        mpfr_div(r38189, r38188, r38180, MPFR_RNDN);
        mpfr_sub(r38190, r38187, r38189, MPFR_RNDN);
        ;
        mpfr_set_si(r38192, mpfr_cmp(r38180, r38191) <= 0, MPFR_RNDN);
        mpfr_mul(r38193, r38188, r38185, MPFR_RNDN);
        ;
        mpfr_mul(r38195, r38193, r38194, MPFR_RNDN);
        mpfr_mul(r38196, r38180, r38180, MPFR_RNDN);
        mpfr_mul(r38197, r38185, r38188, MPFR_RNDN);
        mpfr_mul(r38198, r38194, r38197, MPFR_RNDN);
        mpfr_sub(r38199, r38196, r38198, MPFR_RNDN);
        mpfr_sqrt(r38200, r38199, MPFR_RNDN);
        mpfr_add(r38201, r38183, r38200, MPFR_RNDN);
        mpfr_div(r38202, r38195, r38201, MPFR_RNDN);
        ;
        mpfr_mul(r38204, r38203, r38185, MPFR_RNDN);
        mpfr_div(r38205, r38202, r38204, MPFR_RNDN);
        ;
        mpfr_set_si(r38207, mpfr_cmp(r38180, r38206) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r38209, mpfr_cmp(r38180, r38208) <= 0, MPFR_RNDN);
        mpfr_mul(r38210, r38194, r38185, MPFR_RNDN);
        mpfr_mul(r38211, r38210, r38188, MPFR_RNDN);
        mpfr_sub(r38212, r38196, r38211, MPFR_RNDN);
        mpfr_sqrt(r38213, r38212, MPFR_RNDN);
        mpfr_sub(r38214, r38183, r38213, MPFR_RNDN);
        mpfr_div(r38215, r38214, r38204, MPFR_RNDN);
        mpfr_div(r38216, r38183, r38185, MPFR_RNDN);
        if (mpfr_get_si(r38209, MPFR_RNDN)) { mpfr_set(r38217, r38215, MPFR_RNDN); } else { mpfr_set(r38217, r38216, MPFR_RNDN); };
        if (mpfr_get_si(r38207, MPFR_RNDN)) { mpfr_set(r38218, r38190, MPFR_RNDN); } else { mpfr_set(r38218, r38217, MPFR_RNDN); };
        if (mpfr_get_si(r38192, MPFR_RNDN)) { mpfr_set(r38219, r38205, MPFR_RNDN); } else { mpfr_set(r38219, r38218, MPFR_RNDN); };
        if (mpfr_get_si(r38182, MPFR_RNDN)) { mpfr_set(r38220, r38190, MPFR_RNDN); } else { mpfr_set(r38220, r38219, MPFR_RNDN); };
        return mpfr_get_d(r38220, MPFR_RNDN);
}

static mpfr_t r38221, r38222, r38223, r38224, r38225, r38226, r38227, r38228, r38229, r38230, r38231, r38232, r38233, r38234, r38235, r38236, r38237, r38238, r38239, r38240, r38241, r38242, r38243, r38244, r38245, r38246, r38247, r38248, r38249, r38250, r38251, r38252, r38253, r38254, r38255, r38256, r38257, r38258, r38259, r38260, r38261;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r38221);
        mpfr_init_set_str(r38222, "-1.0524347947917307e+32", 10, MPFR_RNDN);
        mpfr_init(r38223);
        mpfr_init(r38224);
        mpfr_init(r38225);
        mpfr_init(r38226);
        mpfr_init(r38227);
        mpfr_init(r38228);
        mpfr_init(r38229);
        mpfr_init(r38230);
        mpfr_init(r38231);
        mpfr_init_set_str(r38232, "-8.424346933460515e-49", 10, MPFR_RNDN);
        mpfr_init(r38233);
        mpfr_init(r38234);
        mpfr_init_set_str(r38235, "4", 10, MPFR_RNDN);
        mpfr_init(r38236);
        mpfr_init(r38237);
        mpfr_init(r38238);
        mpfr_init(r38239);
        mpfr_init(r38240);
        mpfr_init(r38241);
        mpfr_init(r38242);
        mpfr_init(r38243);
        mpfr_init_set_str(r38244, "2", 10, MPFR_RNDN);
        mpfr_init(r38245);
        mpfr_init(r38246);
        mpfr_init_set_str(r38247, "-2.725780123328718e-107", 10, MPFR_RNDN);
        mpfr_init(r38248);
        mpfr_init_set_str(r38249, "1.6902485387421231e+81", 10, MPFR_RNDN);
        mpfr_init(r38250);
        mpfr_init(r38251);
        mpfr_init(r38252);
        mpfr_init(r38253);
        mpfr_init(r38254);
        mpfr_init(r38255);
        mpfr_init(r38256);
        mpfr_init(r38257);
        mpfr_init(r38258);
        mpfr_init(r38259);
        mpfr_init(r38260);
        mpfr_init(r38261);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r38221, b, MPFR_RNDN);
        ;
        mpfr_set_si(r38223, mpfr_cmp(r38221, r38222) <= 0, MPFR_RNDN);
        mpfr_neg(r38224, r38221, MPFR_RNDN);
        mpfr_add(r38225, r38224, r38221, MPFR_RNDN);
        mpfr_set_d(r38226, a, MPFR_RNDN);
        mpfr_add(r38227, r38226, r38226, MPFR_RNDN);
        mpfr_div(r38228, r38225, r38227, MPFR_RNDN);
        mpfr_set_d(r38229, c, MPFR_RNDN);
        mpfr_div(r38230, r38229, r38221, MPFR_RNDN);
        mpfr_sub(r38231, r38228, r38230, MPFR_RNDN);
        ;
        mpfr_set_si(r38233, mpfr_cmp(r38221, r38232) <= 0, MPFR_RNDN);
        mpfr_mul(r38234, r38229, r38226, MPFR_RNDN);
        ;
        mpfr_mul(r38236, r38234, r38235, MPFR_RNDN);
        mpfr_mul(r38237, r38221, r38221, MPFR_RNDN);
        mpfr_mul(r38238, r38226, r38229, MPFR_RNDN);
        mpfr_mul(r38239, r38235, r38238, MPFR_RNDN);
        mpfr_sub(r38240, r38237, r38239, MPFR_RNDN);
        mpfr_sqrt(r38241, r38240, MPFR_RNDN);
        mpfr_add(r38242, r38224, r38241, MPFR_RNDN);
        mpfr_div(r38243, r38236, r38242, MPFR_RNDN);
        ;
        mpfr_mul(r38245, r38244, r38226, MPFR_RNDN);
        mpfr_div(r38246, r38243, r38245, MPFR_RNDN);
        ;
        mpfr_set_si(r38248, mpfr_cmp(r38221, r38247) <= 0, MPFR_RNDN);
        ;
        mpfr_set_si(r38250, mpfr_cmp(r38221, r38249) <= 0, MPFR_RNDN);
        mpfr_mul(r38251, r38235, r38226, MPFR_RNDN);
        mpfr_mul(r38252, r38251, r38229, MPFR_RNDN);
        mpfr_sub(r38253, r38237, r38252, MPFR_RNDN);
        mpfr_sqrt(r38254, r38253, MPFR_RNDN);
        mpfr_sub(r38255, r38224, r38254, MPFR_RNDN);
        mpfr_div(r38256, r38255, r38245, MPFR_RNDN);
        mpfr_div(r38257, r38224, r38226, MPFR_RNDN);
        if (mpfr_get_si(r38250, MPFR_RNDN)) { mpfr_set(r38258, r38256, MPFR_RNDN); } else { mpfr_set(r38258, r38257, MPFR_RNDN); };
        if (mpfr_get_si(r38248, MPFR_RNDN)) { mpfr_set(r38259, r38231, MPFR_RNDN); } else { mpfr_set(r38259, r38258, MPFR_RNDN); };
        if (mpfr_get_si(r38233, MPFR_RNDN)) { mpfr_set(r38260, r38246, MPFR_RNDN); } else { mpfr_set(r38260, r38259, MPFR_RNDN); };
        if (mpfr_get_si(r38223, MPFR_RNDN)) { mpfr_set(r38261, r38231, MPFR_RNDN); } else { mpfr_set(r38261, r38260, MPFR_RNDN); };
        return mpfr_get_d(r38261, MPFR_RNDN);
}

