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

char *name = "2nthrt (problem 3.4.6)";

double f_if(float x, float n) {
        float r20394 = x;
        float r20395 = 1;
        float r20396 = r20394 + r20395;
        float r20397 = n;
        float r20398 = r20395 / r20397;
        float r20399 = pow(r20396, r20398);
        float r20400 = pow(r20394, r20398);
        float r20401 = r20399 - r20400;
        return r20401;
}

double f_id(double x, double n) {
        double r20402 = x;
        double r20403 = 1;
        double r20404 = r20402 + r20403;
        double r20405 = n;
        double r20406 = r20403 / r20405;
        double r20407 = pow(r20404, r20406);
        double r20408 = pow(r20402, r20406);
        double r20409 = r20407 - r20408;
        return r20409;
}


double f_of(float x, float n) {
        float r20410 = n;
        float r20411 = -96408.94814952476;
        bool r20412 = r20410 <= r20411;
        float r20413 = 1;
        float r20414 = x;
        float r20415 = r20414 * r20410;
        float r20416 = r20413 / r20415;
        float r20417 = 1/2;
        float r20418 = r20417 / r20414;
        float r20419 = r20418 / r20415;
        float r20420 = r20416 - r20419;
        float r20421 = log(r20414);
        float r20422 = r20421 / r20410;
        float r20423 = r20422 / r20415;
        float r20424 = r20420 - r20423;
        float r20425 = 8.1181694271554e+21;
        bool r20426 = r20410 <= r20425;
        float r20427 = r20414 + r20413;
        float r20428 = r20413 / r20410;
        float r20429 = pow(r20427, r20428);
        float r20430 = pow(r20414, r20428);
        float r20431 = r20429 - r20430;
        float r20432 = cbrt(r20431);
        float r20433 = r20432 * r20432;
        float r20434 = r20433 * r20432;
        float r20435 = cbrt(r20434);
        float r20436 = r20432 * r20435;
        float r20437 = r20436 * r20435;
        float r20438 = r20426 ? r20437 : r20424;
        float r20439 = r20412 ? r20424 : r20438;
        return r20439;
}

double f_od(double x, double n) {
        double r20440 = n;
        double r20441 = -96408.94814952476;
        bool r20442 = r20440 <= r20441;
        double r20443 = 1;
        double r20444 = x;
        double r20445 = r20444 * r20440;
        double r20446 = r20443 / r20445;
        double r20447 = 1/2;
        double r20448 = r20447 / r20444;
        double r20449 = r20448 / r20445;
        double r20450 = r20446 - r20449;
        double r20451 = log(r20444);
        double r20452 = r20451 / r20440;
        double r20453 = r20452 / r20445;
        double r20454 = r20450 - r20453;
        double r20455 = 8.1181694271554e+21;
        bool r20456 = r20440 <= r20455;
        double r20457 = r20444 + r20443;
        double r20458 = r20443 / r20440;
        double r20459 = pow(r20457, r20458);
        double r20460 = pow(r20444, r20458);
        double r20461 = r20459 - r20460;
        double r20462 = cbrt(r20461);
        double r20463 = r20462 * r20462;
        double r20464 = r20463 * r20462;
        double r20465 = cbrt(r20464);
        double r20466 = r20462 * r20465;
        double r20467 = r20466 * r20465;
        double r20468 = r20456 ? r20467 : r20454;
        double r20469 = r20442 ? r20454 : r20468;
        return r20469;
}

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 r20470, r20471, r20472, r20473, r20474, r20475, r20476, r20477;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20470);
        mpfr_init_set_str(r20471, "1", 10, MPFR_RNDN);
        mpfr_init(r20472);
        mpfr_init(r20473);
        mpfr_init(r20474);
        mpfr_init(r20475);
        mpfr_init(r20476);
        mpfr_init(r20477);
}

double f_im(double x, double n) {
        mpfr_set_d(r20470, x, MPFR_RNDN);
        ;
        mpfr_add(r20472, r20470, r20471, MPFR_RNDN);
        mpfr_set_d(r20473, n, MPFR_RNDN);
        mpfr_div(r20474, r20471, r20473, MPFR_RNDN);
        mpfr_pow(r20475, r20472, r20474, MPFR_RNDN);
        mpfr_pow(r20476, r20470, r20474, MPFR_RNDN);
        mpfr_sub(r20477, r20475, 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_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20478);
        mpfr_init_set_str(r20479, "-96408.94814952476", 10, MPFR_RNDN);
        mpfr_init(r20480);
        mpfr_init_set_str(r20481, "1", 10, MPFR_RNDN);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init_set_str(r20485, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20486);
        mpfr_init(r20487);
        mpfr_init(r20488);
        mpfr_init(r20489);
        mpfr_init(r20490);
        mpfr_init(r20491);
        mpfr_init(r20492);
        mpfr_init_set_str(r20493, "8.1181694271554e+21", 10, MPFR_RNDN);
        mpfr_init(r20494);
        mpfr_init(r20495);
        mpfr_init(r20496);
        mpfr_init(r20497);
        mpfr_init(r20498);
        mpfr_init(r20499);
        mpfr_init(r20500);
        mpfr_init(r20501);
        mpfr_init(r20502);
        mpfr_init(r20503);
        mpfr_init(r20504);
        mpfr_init(r20505);
        mpfr_init(r20506);
        mpfr_init(r20507);
}

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

static mpfr_t r20508, r20509, r20510, r20511, r20512, r20513, r20514, r20515, r20516, r20517, r20518, r20519, r20520, r20521, r20522, r20523, r20524, r20525, r20526, r20527, r20528, r20529, r20530, r20531, r20532, r20533, r20534, r20535, r20536, r20537;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20508);
        mpfr_init_set_str(r20509, "-96408.94814952476", 10, MPFR_RNDN);
        mpfr_init(r20510);
        mpfr_init_set_str(r20511, "1", 10, MPFR_RNDN);
        mpfr_init(r20512);
        mpfr_init(r20513);
        mpfr_init(r20514);
        mpfr_init_set_str(r20515, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20516);
        mpfr_init(r20517);
        mpfr_init(r20518);
        mpfr_init(r20519);
        mpfr_init(r20520);
        mpfr_init(r20521);
        mpfr_init(r20522);
        mpfr_init_set_str(r20523, "8.1181694271554e+21", 10, MPFR_RNDN);
        mpfr_init(r20524);
        mpfr_init(r20525);
        mpfr_init(r20526);
        mpfr_init(r20527);
        mpfr_init(r20528);
        mpfr_init(r20529);
        mpfr_init(r20530);
        mpfr_init(r20531);
        mpfr_init(r20532);
        mpfr_init(r20533);
        mpfr_init(r20534);
        mpfr_init(r20535);
        mpfr_init(r20536);
        mpfr_init(r20537);
}

double f_dm(double x, double n) {
        mpfr_set_d(r20508, n, MPFR_RNDN);
        ;
        mpfr_set_si(r20510, mpfr_cmp(r20508, r20509) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20512, x, MPFR_RNDN);
        mpfr_mul(r20513, r20512, r20508, MPFR_RNDN);
        mpfr_div(r20514, r20511, r20513, MPFR_RNDN);
        ;
        mpfr_div(r20516, r20515, r20512, MPFR_RNDN);
        mpfr_div(r20517, r20516, r20513, MPFR_RNDN);
        mpfr_sub(r20518, r20514, r20517, MPFR_RNDN);
        mpfr_log(r20519, r20512, MPFR_RNDN);
        mpfr_div(r20520, r20519, r20508, MPFR_RNDN);
        mpfr_div(r20521, r20520, r20513, MPFR_RNDN);
        mpfr_sub(r20522, r20518, r20521, MPFR_RNDN);
        ;
        mpfr_set_si(r20524, mpfr_cmp(r20508, r20523) <= 0, MPFR_RNDN);
        mpfr_add(r20525, r20512, r20511, MPFR_RNDN);
        mpfr_div(r20526, r20511, r20508, MPFR_RNDN);
        mpfr_pow(r20527, r20525, r20526, MPFR_RNDN);
        mpfr_pow(r20528, r20512, r20526, MPFR_RNDN);
        mpfr_sub(r20529, r20527, r20528, MPFR_RNDN);
        mpfr_cbrt(r20530, r20529, MPFR_RNDN);
        mpfr_mul(r20531, r20530, r20530, MPFR_RNDN);
        mpfr_mul(r20532, r20531, r20530, MPFR_RNDN);
        mpfr_cbrt(r20533, r20532, MPFR_RNDN);
        mpfr_mul(r20534, r20530, r20533, MPFR_RNDN);
        mpfr_mul(r20535, r20534, r20533, MPFR_RNDN);
        if (mpfr_get_si(r20524, MPFR_RNDN)) { mpfr_set(r20536, r20535, MPFR_RNDN); } else { mpfr_set(r20536, r20522, MPFR_RNDN); };
        if (mpfr_get_si(r20510, MPFR_RNDN)) { mpfr_set(r20537, r20522, MPFR_RNDN); } else { mpfr_set(r20537, r20536, MPFR_RNDN); };
        return mpfr_get_d(r20537, MPFR_RNDN);
}