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

char *name = "expax (section 3.5)";

double f_if(float a, float x) {
        float r20370 = a;
        float r20371 = x;
        float r20372 = r20370 * r20371;
        float r20373 = exp(r20372);
        float r20374 = 1.0f;
        float r20375 = r20373 - r20374;
        return r20375;
}

double f_id(double a, double x) {
        double r20376 = a;
        double r20377 = x;
        double r20378 = r20376 * r20377;
        double r20379 = exp(r20378);
        double r20380 = 1.0;
        double r20381 = r20379 - r20380;
        return r20381;
}


double f_of(float a, float x) {
        float r20382 = a;
        float r20383 = x;
        float r20384 = r20382 * r20383;
        float r20385 = -4.283222210193013e-14f;
        bool r20386 = r20384 <= r20385;
        float r20387 = r20383 + r20383;
        float r20388 = r20382 * r20387;
        float r20389 = exp(r20388);
        float r20390 = 1.0f;
        float r20391 = r20390 * r20390;
        float r20392 = r20389 - r20391;
        float r20393 = exp(r20384);
        float r20394 = r20393 + r20390;
        float r20395 = sqrt(r20394);
        float r20396 = r20395 * r20395;
        float r20397 = r20392 / r20396;
        float r20398 = 0.16666666666666666f;
        float r20399 = 3.0f;
        float r20400 = pow(r20382, r20399);
        float r20401 = pow(r20383, r20399);
        float r20402 = r20400 * r20401;
        float r20403 = r20398 * r20402;
        float r20404 = 0.5f;
        float r20405 = r20382 * r20382;
        float r20406 = r20383 * r20383;
        float r20407 = r20405 * r20406;
        float r20408 = r20404 * r20407;
        float r20409 = r20408 + r20384;
        float r20410 = r20403 + r20409;
        float r20411 = r20386 ? r20397 : r20410;
        return r20411;
}

double f_od(double a, double x) {
        double r20412 = a;
        double r20413 = x;
        double r20414 = r20412 * r20413;
        double r20415 = -4.283222210193013e-14;
        bool r20416 = r20414 <= r20415;
        double r20417 = r20413 + r20413;
        double r20418 = r20412 * r20417;
        double r20419 = exp(r20418);
        double r20420 = 1.0;
        double r20421 = r20420 * r20420;
        double r20422 = r20419 - r20421;
        double r20423 = exp(r20414);
        double r20424 = r20423 + r20420;
        double r20425 = sqrt(r20424);
        double r20426 = r20425 * r20425;
        double r20427 = r20422 / r20426;
        double r20428 = 0.16666666666666666;
        double r20429 = 3.0;
        double r20430 = pow(r20412, r20429);
        double r20431 = pow(r20413, r20429);
        double r20432 = r20430 * r20431;
        double r20433 = r20428 * r20432;
        double r20434 = 0.5;
        double r20435 = r20412 * r20412;
        double r20436 = r20413 * r20413;
        double r20437 = r20435 * r20436;
        double r20438 = r20434 * r20437;
        double r20439 = r20438 + r20414;
        double r20440 = r20433 + r20439;
        double r20441 = r20416 ? r20427 : r20440;
        return r20441;
}

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 r20442, r20443, r20444, r20445, r20446, r20447;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20442);
        mpfr_init(r20443);
        mpfr_init(r20444);
        mpfr_init(r20445);
        mpfr_init_set_str(r20446, "1", 10, MPFR_RNDN);
        mpfr_init(r20447);
}

double f_im(double a, double x) {
        mpfr_set_d(r20442, a, MPFR_RNDN);
        mpfr_set_d(r20443, x, MPFR_RNDN);
        mpfr_mul(r20444, r20442, r20443, MPFR_RNDN);
        mpfr_exp(r20445, r20444, MPFR_RNDN);
        ;
        mpfr_sub(r20447, r20445, r20446, MPFR_RNDN);
        return mpfr_get_d(r20447, MPFR_RNDN);
}

static mpfr_t r20448, r20449, r20450, r20451, r20452, r20453, r20454, r20455, r20456, r20457, r20458, r20459, r20460, r20461, r20462, r20463, r20464, r20465, r20466, r20467, r20468, r20469, r20470, r20471, r20472, r20473, r20474, r20475, r20476, r20477;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20448);
        mpfr_init(r20449);
        mpfr_init(r20450);
        mpfr_init_set_str(r20451, "-4.283222210193013e-14", 10, MPFR_RNDN);
        mpfr_init(r20452);
        mpfr_init(r20453);
        mpfr_init(r20454);
        mpfr_init(r20455);
        mpfr_init_set_str(r20456, "1", 10, MPFR_RNDN);
        mpfr_init(r20457);
        mpfr_init(r20458);
        mpfr_init(r20459);
        mpfr_init(r20460);
        mpfr_init(r20461);
        mpfr_init(r20462);
        mpfr_init(r20463);
        mpfr_init_set_str(r20464, "1/6", 10, MPFR_RNDN);
        mpfr_init_set_str(r20465, "3", 10, MPFR_RNDN);
        mpfr_init(r20466);
        mpfr_init(r20467);
        mpfr_init(r20468);
        mpfr_init(r20469);
        mpfr_init_set_str(r20470, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20471);
        mpfr_init(r20472);
        mpfr_init(r20473);
        mpfr_init(r20474);
        mpfr_init(r20475);
        mpfr_init(r20476);
        mpfr_init(r20477);
}

double f_fm(double a, double x) {
        mpfr_set_d(r20448, a, MPFR_RNDN);
        mpfr_set_d(r20449, x, MPFR_RNDN);
        mpfr_mul(r20450, r20448, r20449, MPFR_RNDN);
        ;
        mpfr_set_si(r20452, mpfr_cmp(r20450, r20451) <= 0, MPFR_RNDN);
        mpfr_add(r20453, r20449, r20449, MPFR_RNDN);
        mpfr_mul(r20454, r20448, r20453, MPFR_RNDN);
        mpfr_exp(r20455, r20454, MPFR_RNDN);
        ;
        mpfr_sqr(r20457, r20456, MPFR_RNDN);
        mpfr_sub(r20458, r20455, r20457, MPFR_RNDN);
        mpfr_exp(r20459, r20450, MPFR_RNDN);
        mpfr_add(r20460, r20459, r20456, MPFR_RNDN);
        mpfr_sqrt(r20461, r20460, MPFR_RNDN);
        mpfr_sqr(r20462, r20461, MPFR_RNDN);
        mpfr_div(r20463, r20458, r20462, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20466, r20448, r20465, MPFR_RNDN);
        mpfr_pow(r20467, r20449, r20465, MPFR_RNDN);
        mpfr_mul(r20468, r20466, r20467, MPFR_RNDN);
        mpfr_mul(r20469, r20464, r20468, MPFR_RNDN);
        ;
        mpfr_sqr(r20471, r20448, MPFR_RNDN);
        mpfr_sqr(r20472, r20449, MPFR_RNDN);
        mpfr_mul(r20473, r20471, r20472, MPFR_RNDN);
        mpfr_mul(r20474, r20470, r20473, MPFR_RNDN);
        mpfr_add(r20475, r20474, r20450, MPFR_RNDN);
        mpfr_add(r20476, r20469, r20475, MPFR_RNDN);
        if (mpfr_get_si(r20452, MPFR_RNDN)) { mpfr_set(r20477, r20463, MPFR_RNDN); } else { mpfr_set(r20477, r20476, MPFR_RNDN); };
        return mpfr_get_d(r20477, MPFR_RNDN);
}

static mpfr_t r20478, r20479, r20480, r20481, r20482, r20483, r20484, r20485, r20486, r20487, r20488, r20489, r20490, r20491, r20492, r20493, r20494, r20495, r20496, r20497, r20498, r20499, r20500, r20501, r20502, r20503, r20504, r20505, r20506, r20507;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20478);
        mpfr_init(r20479);
        mpfr_init(r20480);
        mpfr_init_set_str(r20481, "-4.283222210193013e-14", 10, MPFR_RNDN);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init(r20485);
        mpfr_init_set_str(r20486, "1", 10, MPFR_RNDN);
        mpfr_init(r20487);
        mpfr_init(r20488);
        mpfr_init(r20489);
        mpfr_init(r20490);
        mpfr_init(r20491);
        mpfr_init(r20492);
        mpfr_init(r20493);
        mpfr_init_set_str(r20494, "1/6", 10, MPFR_RNDN);
        mpfr_init_set_str(r20495, "3", 10, MPFR_RNDN);
        mpfr_init(r20496);
        mpfr_init(r20497);
        mpfr_init(r20498);
        mpfr_init(r20499);
        mpfr_init_set_str(r20500, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20501);
        mpfr_init(r20502);
        mpfr_init(r20503);
        mpfr_init(r20504);
        mpfr_init(r20505);
        mpfr_init(r20506);
        mpfr_init(r20507);
}

double f_dm(double a, double x) {
        mpfr_set_d(r20478, a, MPFR_RNDN);
        mpfr_set_d(r20479, x, MPFR_RNDN);
        mpfr_mul(r20480, r20478, r20479, MPFR_RNDN);
        ;
        mpfr_set_si(r20482, mpfr_cmp(r20480, r20481) <= 0, MPFR_RNDN);
        mpfr_add(r20483, r20479, r20479, MPFR_RNDN);
        mpfr_mul(r20484, r20478, r20483, MPFR_RNDN);
        mpfr_exp(r20485, r20484, MPFR_RNDN);
        ;
        mpfr_sqr(r20487, r20486, MPFR_RNDN);
        mpfr_sub(r20488, r20485, r20487, MPFR_RNDN);
        mpfr_exp(r20489, r20480, MPFR_RNDN);
        mpfr_add(r20490, r20489, r20486, MPFR_RNDN);
        mpfr_sqrt(r20491, r20490, MPFR_RNDN);
        mpfr_sqr(r20492, r20491, MPFR_RNDN);
        mpfr_div(r20493, r20488, r20492, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20496, r20478, r20495, MPFR_RNDN);
        mpfr_pow(r20497, r20479, r20495, MPFR_RNDN);
        mpfr_mul(r20498, r20496, r20497, MPFR_RNDN);
        mpfr_mul(r20499, r20494, r20498, MPFR_RNDN);
        ;
        mpfr_sqr(r20501, r20478, MPFR_RNDN);
        mpfr_sqr(r20502, r20479, MPFR_RNDN);
        mpfr_mul(r20503, r20501, r20502, MPFR_RNDN);
        mpfr_mul(r20504, r20500, r20503, MPFR_RNDN);
        mpfr_add(r20505, r20504, r20480, MPFR_RNDN);
        mpfr_add(r20506, r20499, r20505, MPFR_RNDN);
        if (mpfr_get_si(r20482, MPFR_RNDN)) { mpfr_set(r20507, r20493, MPFR_RNDN); } else { mpfr_set(r20507, r20506, MPFR_RNDN); };
        return mpfr_get_d(r20507, MPFR_RNDN);
}