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

char *name = "3frac (problem 3.3.3)";

double f_if(float x) {
        float r20440 = 1.0f;
        float r20441 = x;
        float r20442 = r20441 + r20440;
        float r20443 = r20440 / r20442;
        float r20444 = 2.0f;
        float r20445 = r20444 / r20441;
        float r20446 = r20443 - r20445;
        float r20447 = r20441 - r20440;
        float r20448 = r20440 / r20447;
        float r20449 = r20446 + r20448;
        return r20449;
}

double f_id(double x) {
        double r20450 = 1.0;
        double r20451 = x;
        double r20452 = r20451 + r20450;
        double r20453 = r20450 / r20452;
        double r20454 = 2.0;
        double r20455 = r20454 / r20451;
        double r20456 = r20453 - r20455;
        double r20457 = r20451 - r20450;
        double r20458 = r20450 / r20457;
        double r20459 = r20456 + r20458;
        return r20459;
}


double f_of(float x) {
        float r20460 = x;
        float r20461 = -0.0004101029468956529f;
        bool r20462 = r20460 <= r20461;
        float r20463 = 2.0f;
        float r20464 = 7.0f;
        float r20465 = pow(r20460, r20464);
        float r20466 = r20463 / r20465;
        float r20467 = 5.0f;
        float r20468 = pow(r20460, r20467);
        float r20469 = r20463 / r20468;
        float r20470 = r20466 + r20469;
        float r20471 = r20460 * (r20460 * r20460);
        float r20472 = r20463 / r20471;
        float r20473 = r20470 + r20472;
        float r20474 = 26943675.89880948f;
        bool r20475 = r20460 <= r20474;
        float r20476 = 1.0f;
        float r20477 = r20460 + r20476;
        float r20478 = r20476 / r20477;
        float r20479 = r20463 / r20460;
        float r20480 = r20478 - r20479;
        float r20481 = r20460 - r20476;
        float r20482 = r20476 / r20481;
        float r20483 = r20480 + r20482;
        float r20484 = r20460 * r20460;
        float r20485 = r20463 / r20484;
        float r20486 = r20485 / r20460;
        float r20487 = r20470 + r20486;
        float r20488 = r20475 ? r20483 : r20487;
        float r20489 = r20462 ? r20473 : r20488;
        return r20489;
}

double f_od(double x) {
        double r20490 = x;
        double r20491 = -0.0004101029468956529;
        bool r20492 = r20490 <= r20491;
        double r20493 = 2.0;
        double r20494 = 7.0;
        double r20495 = pow(r20490, r20494);
        double r20496 = r20493 / r20495;
        double r20497 = 5.0;
        double r20498 = pow(r20490, r20497);
        double r20499 = r20493 / r20498;
        double r20500 = r20496 + r20499;
        double r20501 = r20490 * (r20490 * r20490);
        double r20502 = r20493 / r20501;
        double r20503 = r20500 + r20502;
        double r20504 = 26943675.89880948;
        bool r20505 = r20490 <= r20504;
        double r20506 = 1.0;
        double r20507 = r20490 + r20506;
        double r20508 = r20506 / r20507;
        double r20509 = r20493 / r20490;
        double r20510 = r20508 - r20509;
        double r20511 = r20490 - r20506;
        double r20512 = r20506 / r20511;
        double r20513 = r20510 + r20512;
        double r20514 = r20490 * r20490;
        double r20515 = r20493 / r20514;
        double r20516 = r20515 / r20490;
        double r20517 = r20500 + r20516;
        double r20518 = r20505 ? r20513 : r20517;
        double r20519 = r20492 ? r20503 : r20518;
        return r20519;
}

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 r20520, r20521, r20522, r20523, r20524, r20525, r20526, r20527, r20528, r20529;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1168);
        mpfr_init_set_str(r20520, "1", 10, MPFR_RNDN);
        mpfr_init(r20521);
        mpfr_init(r20522);
        mpfr_init(r20523);
        mpfr_init_set_str(r20524, "2", 10, MPFR_RNDN);
        mpfr_init(r20525);
        mpfr_init(r20526);
        mpfr_init(r20527);
        mpfr_init(r20528);
        mpfr_init(r20529);
}

double f_im(double x) {
        ;
        mpfr_set_d(r20521, x, MPFR_RNDN);
        mpfr_add(r20522, r20521, r20520, MPFR_RNDN);
        mpfr_div(r20523, r20520, r20522, MPFR_RNDN);
        ;
        mpfr_div(r20525, r20524, r20521, MPFR_RNDN);
        mpfr_sub(r20526, r20523, r20525, MPFR_RNDN);
        mpfr_sub(r20527, r20521, r20520, MPFR_RNDN);
        mpfr_div(r20528, r20520, r20527, MPFR_RNDN);
        mpfr_add(r20529, r20526, r20528, MPFR_RNDN);
        return mpfr_get_d(r20529, MPFR_RNDN);
}

static mpfr_t r20530, r20531, r20532, r20533, r20534, r20535, r20536, r20537, r20538, r20539, r20540, r20541, r20542, r20543, r20544, r20545, r20546, r20547, r20548, r20549, r20550, r20551, r20552, r20553, r20554, r20555, r20556, r20557, r20558, r20559;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1168);
        mpfr_init(r20530);
        mpfr_init_set_str(r20531, "-0.0004101029468956529", 10, MPFR_RNDN);
        mpfr_init(r20532);
        mpfr_init_set_str(r20533, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20534, "7", 10, MPFR_RNDN);
        mpfr_init(r20535);
        mpfr_init(r20536);
        mpfr_init_set_str(r20537, "5", 10, MPFR_RNDN);
        mpfr_init(r20538);
        mpfr_init(r20539);
        mpfr_init(r20540);
        mpfr_init(r20541);
        mpfr_init(r20542);
        mpfr_init(r20543);
        mpfr_init_set_str(r20544, "26943675.89880948", 10, MPFR_RNDN);
        mpfr_init(r20545);
        mpfr_init_set_str(r20546, "1", 10, MPFR_RNDN);
        mpfr_init(r20547);
        mpfr_init(r20548);
        mpfr_init(r20549);
        mpfr_init(r20550);
        mpfr_init(r20551);
        mpfr_init(r20552);
        mpfr_init(r20553);
        mpfr_init(r20554);
        mpfr_init(r20555);
        mpfr_init(r20556);
        mpfr_init(r20557);
        mpfr_init(r20558);
        mpfr_init(r20559);
}

double f_fm(double x) {
        mpfr_set_d(r20530, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20532, mpfr_cmp(r20530, r20531) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20535, r20530, r20534, MPFR_RNDN);
        mpfr_div(r20536, r20533, r20535, MPFR_RNDN);
        ;
        mpfr_pow(r20538, r20530, r20537, MPFR_RNDN);
        mpfr_div(r20539, r20533, r20538, MPFR_RNDN);
        mpfr_add(r20540, r20536, r20539, MPFR_RNDN);
        mpfr_mul(r20541, r20530, r20530, MPFR_RNDN); mpfr_mul(r20541, r20541, r20530, MPFR_RNDN);
        mpfr_div(r20542, r20533, r20541, MPFR_RNDN);
        mpfr_add(r20543, r20540, r20542, MPFR_RNDN);
        ;
        mpfr_set_si(r20545, mpfr_cmp(r20530, r20544) <= 0, MPFR_RNDN);
        ;
        mpfr_add(r20547, r20530, r20546, MPFR_RNDN);
        mpfr_div(r20548, r20546, r20547, MPFR_RNDN);
        mpfr_div(r20549, r20533, r20530, MPFR_RNDN);
        mpfr_sub(r20550, r20548, r20549, MPFR_RNDN);
        mpfr_sub(r20551, r20530, r20546, MPFR_RNDN);
        mpfr_div(r20552, r20546, r20551, MPFR_RNDN);
        mpfr_add(r20553, r20550, r20552, MPFR_RNDN);
        mpfr_sqr(r20554, r20530, MPFR_RNDN);
        mpfr_div(r20555, r20533, r20554, MPFR_RNDN);
        mpfr_div(r20556, r20555, r20530, MPFR_RNDN);
        mpfr_add(r20557, r20540, r20556, MPFR_RNDN);
        if (mpfr_get_si(r20545, MPFR_RNDN)) { mpfr_set(r20558, r20553, MPFR_RNDN); } else { mpfr_set(r20558, r20557, MPFR_RNDN); };
        if (mpfr_get_si(r20532, MPFR_RNDN)) { mpfr_set(r20559, r20543, MPFR_RNDN); } else { mpfr_set(r20559, r20558, MPFR_RNDN); };
        return mpfr_get_d(r20559, MPFR_RNDN);
}

static mpfr_t r20560, r20561, r20562, r20563, r20564, r20565, r20566, r20567, r20568, r20569, r20570, r20571, r20572, r20573, r20574, r20575, r20576, r20577, r20578, r20579, r20580, r20581, r20582, r20583, r20584, r20585, r20586, r20587, r20588, r20589;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1168);
        mpfr_init(r20560);
        mpfr_init_set_str(r20561, "-0.0004101029468956529", 10, MPFR_RNDN);
        mpfr_init(r20562);
        mpfr_init_set_str(r20563, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20564, "7", 10, MPFR_RNDN);
        mpfr_init(r20565);
        mpfr_init(r20566);
        mpfr_init_set_str(r20567, "5", 10, MPFR_RNDN);
        mpfr_init(r20568);
        mpfr_init(r20569);
        mpfr_init(r20570);
        mpfr_init(r20571);
        mpfr_init(r20572);
        mpfr_init(r20573);
        mpfr_init_set_str(r20574, "26943675.89880948", 10, MPFR_RNDN);
        mpfr_init(r20575);
        mpfr_init_set_str(r20576, "1", 10, MPFR_RNDN);
        mpfr_init(r20577);
        mpfr_init(r20578);
        mpfr_init(r20579);
        mpfr_init(r20580);
        mpfr_init(r20581);
        mpfr_init(r20582);
        mpfr_init(r20583);
        mpfr_init(r20584);
        mpfr_init(r20585);
        mpfr_init(r20586);
        mpfr_init(r20587);
        mpfr_init(r20588);
        mpfr_init(r20589);
}

double f_dm(double x) {
        mpfr_set_d(r20560, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20562, mpfr_cmp(r20560, r20561) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20565, r20560, r20564, MPFR_RNDN);
        mpfr_div(r20566, r20563, r20565, MPFR_RNDN);
        ;
        mpfr_pow(r20568, r20560, r20567, MPFR_RNDN);
        mpfr_div(r20569, r20563, r20568, MPFR_RNDN);
        mpfr_add(r20570, r20566, r20569, MPFR_RNDN);
        mpfr_mul(r20571, r20560, r20560, MPFR_RNDN); mpfr_mul(r20571, r20571, r20560, MPFR_RNDN);
        mpfr_div(r20572, r20563, r20571, MPFR_RNDN);
        mpfr_add(r20573, r20570, r20572, MPFR_RNDN);
        ;
        mpfr_set_si(r20575, mpfr_cmp(r20560, r20574) <= 0, MPFR_RNDN);
        ;
        mpfr_add(r20577, r20560, r20576, MPFR_RNDN);
        mpfr_div(r20578, r20576, r20577, MPFR_RNDN);
        mpfr_div(r20579, r20563, r20560, MPFR_RNDN);
        mpfr_sub(r20580, r20578, r20579, MPFR_RNDN);
        mpfr_sub(r20581, r20560, r20576, MPFR_RNDN);
        mpfr_div(r20582, r20576, r20581, MPFR_RNDN);
        mpfr_add(r20583, r20580, r20582, MPFR_RNDN);
        mpfr_sqr(r20584, r20560, MPFR_RNDN);
        mpfr_div(r20585, r20563, r20584, MPFR_RNDN);
        mpfr_div(r20586, r20585, r20560, MPFR_RNDN);
        mpfr_add(r20587, r20570, r20586, MPFR_RNDN);
        if (mpfr_get_si(r20575, MPFR_RNDN)) { mpfr_set(r20588, r20583, MPFR_RNDN); } else { mpfr_set(r20588, r20587, MPFR_RNDN); };
        if (mpfr_get_si(r20562, MPFR_RNDN)) { mpfr_set(r20589, r20573, MPFR_RNDN); } else { mpfr_set(r20589, r20588, MPFR_RNDN); };
        return mpfr_get_d(r20589, MPFR_RNDN);
}