#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 r20097 = x;
        float r20098 = 1;
        float r20099 = r20097 + r20098;
        float r20100 = n;
        float r20101 = r20098 / r20100;
        float r20102 = pow(r20099, r20101);
        float r20103 = pow(r20097, r20101);
        float r20104 = r20102 - r20103;
        return r20104;
}

double f_id(double x, double n) {
        double r20105 = x;
        double r20106 = 1;
        double r20107 = r20105 + r20106;
        double r20108 = n;
        double r20109 = r20106 / r20108;
        double r20110 = pow(r20107, r20109);
        double r20111 = pow(r20105, r20109);
        double r20112 = r20110 - r20111;
        return r20112;
}


double f_of(float x, float n) {
        float r20113 = n;
        float r20114 = -2.5632332976918115e+20;
        bool r20115 = r20113 <= r20114;
        float r20116 = 1;
        float r20117 = x;
        float r20118 = r20116 / r20117;
        float r20119 = r20118 / r20113;
        float r20120 = 1/2;
        float r20121 = r20120 / r20113;
        float r20122 = r20117 * r20117;
        float r20123 = r20121 / r20122;
        float r20124 = r20119 - r20123;
        float r20125 = log(r20117);
        float r20126 = r20117 * r20113;
        float r20127 = r20125 / r20126;
        float r20128 = r20127 / r20113;
        float r20129 = r20124 - r20128;
        float r20130 = 3833790775.8826175;
        bool r20131 = r20113 <= r20130;
        float r20132 = r20116 + r20117;
        float r20133 = r20116 / r20113;
        float r20134 = pow(r20132, r20133);
        float r20135 = pow(r20117, r20133);
        float r20136 = r20134 - r20135;
        float r20137 = exp(r20136);
        float r20138 = sqrt(r20137);
        float r20139 = log(r20138);
        float r20140 = r20117 + r20116;
        float r20141 = pow(r20140, r20133);
        float r20142 = r20141 - r20135;
        float r20143 = r20120 * r20142;
        float r20144 = r20139 + r20143;
        float r20145 = r20131 ? r20144 : r20129;
        float r20146 = r20115 ? r20129 : r20145;
        return r20146;
}

double f_od(double x, double n) {
        double r20147 = n;
        double r20148 = -2.5632332976918115e+20;
        bool r20149 = r20147 <= r20148;
        double r20150 = 1;
        double r20151 = x;
        double r20152 = r20150 / r20151;
        double r20153 = r20152 / r20147;
        double r20154 = 1/2;
        double r20155 = r20154 / r20147;
        double r20156 = r20151 * r20151;
        double r20157 = r20155 / r20156;
        double r20158 = r20153 - r20157;
        double r20159 = log(r20151);
        double r20160 = r20151 * r20147;
        double r20161 = r20159 / r20160;
        double r20162 = r20161 / r20147;
        double r20163 = r20158 - r20162;
        double r20164 = 3833790775.8826175;
        bool r20165 = r20147 <= r20164;
        double r20166 = r20150 + r20151;
        double r20167 = r20150 / r20147;
        double r20168 = pow(r20166, r20167);
        double r20169 = pow(r20151, r20167);
        double r20170 = r20168 - r20169;
        double r20171 = exp(r20170);
        double r20172 = sqrt(r20171);
        double r20173 = log(r20172);
        double r20174 = r20151 + r20150;
        double r20175 = pow(r20174, r20167);
        double r20176 = r20175 - r20169;
        double r20177 = r20154 * r20176;
        double r20178 = r20173 + r20177;
        double r20179 = r20165 ? r20178 : r20163;
        double r20180 = r20149 ? r20163 : r20179;
        return r20180;
}

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 r20181, r20182, r20183, r20184, r20185, r20186, r20187, r20188;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20181);
        mpfr_init_set_str(r20182, "1", 10, MPFR_RNDN);
        mpfr_init(r20183);
        mpfr_init(r20184);
        mpfr_init(r20185);
        mpfr_init(r20186);
        mpfr_init(r20187);
        mpfr_init(r20188);
}

double f_im(double x, double n) {
        mpfr_set_d(r20181, x, MPFR_RNDN);
        ;
        mpfr_add(r20183, r20181, r20182, MPFR_RNDN);
        mpfr_set_d(r20184, n, MPFR_RNDN);
        mpfr_div(r20185, r20182, r20184, MPFR_RNDN);
        mpfr_pow(r20186, r20183, r20185, MPFR_RNDN);
        mpfr_pow(r20187, r20181, r20185, MPFR_RNDN);
        mpfr_sub(r20188, r20186, r20187, MPFR_RNDN);
        return mpfr_get_d(r20188, MPFR_RNDN);
}

static mpfr_t r20189, r20190, r20191, r20192, r20193, r20194, r20195, r20196, r20197, r20198, r20199, r20200, r20201, r20202, r20203, r20204, r20205, r20206, r20207, r20208, r20209, r20210, r20211, r20212, r20213, r20214, r20215, r20216, r20217, r20218, r20219, r20220, r20221, r20222;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20189);
        mpfr_init_set_str(r20190, "-2.5632332976918115e+20", 10, MPFR_RNDN);
        mpfr_init(r20191);
        mpfr_init_set_str(r20192, "1", 10, MPFR_RNDN);
        mpfr_init(r20193);
        mpfr_init(r20194);
        mpfr_init(r20195);
        mpfr_init_set_str(r20196, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20197);
        mpfr_init(r20198);
        mpfr_init(r20199);
        mpfr_init(r20200);
        mpfr_init(r20201);
        mpfr_init(r20202);
        mpfr_init(r20203);
        mpfr_init(r20204);
        mpfr_init(r20205);
        mpfr_init_set_str(r20206, "3833790775.8826175", 10, MPFR_RNDN);
        mpfr_init(r20207);
        mpfr_init(r20208);
        mpfr_init(r20209);
        mpfr_init(r20210);
        mpfr_init(r20211);
        mpfr_init(r20212);
        mpfr_init(r20213);
        mpfr_init(r20214);
        mpfr_init(r20215);
        mpfr_init(r20216);
        mpfr_init(r20217);
        mpfr_init(r20218);
        mpfr_init(r20219);
        mpfr_init(r20220);
        mpfr_init(r20221);
        mpfr_init(r20222);
}

double f_fm(double x, double n) {
        mpfr_set_d(r20189, n, MPFR_RNDN);
        ;
        mpfr_set_si(r20191, mpfr_cmp(r20189, r20190) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20193, x, MPFR_RNDN);
        mpfr_div(r20194, r20192, r20193, MPFR_RNDN);
        mpfr_div(r20195, r20194, r20189, MPFR_RNDN);
        ;
        mpfr_div(r20197, r20196, r20189, MPFR_RNDN);
        mpfr_mul(r20198, r20193, r20193, MPFR_RNDN);
        mpfr_div(r20199, r20197, r20198, MPFR_RNDN);
        mpfr_sub(r20200, r20195, r20199, MPFR_RNDN);
        mpfr_log(r20201, r20193, MPFR_RNDN);
        mpfr_mul(r20202, r20193, r20189, MPFR_RNDN);
        mpfr_div(r20203, r20201, r20202, MPFR_RNDN);
        mpfr_div(r20204, r20203, r20189, MPFR_RNDN);
        mpfr_sub(r20205, r20200, r20204, MPFR_RNDN);
        ;
        mpfr_set_si(r20207, mpfr_cmp(r20189, r20206) <= 0, MPFR_RNDN);
        mpfr_add(r20208, r20192, r20193, MPFR_RNDN);
        mpfr_div(r20209, r20192, r20189, MPFR_RNDN);
        mpfr_pow(r20210, r20208, r20209, MPFR_RNDN);
        mpfr_pow(r20211, r20193, r20209, MPFR_RNDN);
        mpfr_sub(r20212, r20210, r20211, MPFR_RNDN);
        mpfr_exp(r20213, r20212, MPFR_RNDN);
        mpfr_sqrt(r20214, r20213, MPFR_RNDN);
        mpfr_log(r20215, r20214, MPFR_RNDN);
        mpfr_add(r20216, r20193, r20192, MPFR_RNDN);
        mpfr_pow(r20217, r20216, r20209, MPFR_RNDN);
        mpfr_sub(r20218, r20217, r20211, MPFR_RNDN);
        mpfr_mul(r20219, r20196, r20218, MPFR_RNDN);
        mpfr_add(r20220, r20215, r20219, MPFR_RNDN);
        if (mpfr_get_si(r20207, MPFR_RNDN)) { mpfr_set(r20221, r20220, MPFR_RNDN); } else { mpfr_set(r20221, r20205, MPFR_RNDN); };
        if (mpfr_get_si(r20191, MPFR_RNDN)) { mpfr_set(r20222, r20205, MPFR_RNDN); } else { mpfr_set(r20222, r20221, MPFR_RNDN); };
        return mpfr_get_d(r20222, MPFR_RNDN);
}

static mpfr_t r20223, r20224, r20225, r20226, r20227, r20228, r20229, r20230, r20231, r20232, r20233, r20234, r20235, r20236, r20237, r20238, r20239, r20240, r20241, r20242, r20243, r20244, r20245, r20246, r20247, r20248, r20249, r20250, r20251, r20252, r20253, r20254, r20255, r20256;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20223);
        mpfr_init_set_str(r20224, "-2.5632332976918115e+20", 10, MPFR_RNDN);
        mpfr_init(r20225);
        mpfr_init_set_str(r20226, "1", 10, MPFR_RNDN);
        mpfr_init(r20227);
        mpfr_init(r20228);
        mpfr_init(r20229);
        mpfr_init_set_str(r20230, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20231);
        mpfr_init(r20232);
        mpfr_init(r20233);
        mpfr_init(r20234);
        mpfr_init(r20235);
        mpfr_init(r20236);
        mpfr_init(r20237);
        mpfr_init(r20238);
        mpfr_init(r20239);
        mpfr_init_set_str(r20240, "3833790775.8826175", 10, MPFR_RNDN);
        mpfr_init(r20241);
        mpfr_init(r20242);
        mpfr_init(r20243);
        mpfr_init(r20244);
        mpfr_init(r20245);
        mpfr_init(r20246);
        mpfr_init(r20247);
        mpfr_init(r20248);
        mpfr_init(r20249);
        mpfr_init(r20250);
        mpfr_init(r20251);
        mpfr_init(r20252);
        mpfr_init(r20253);
        mpfr_init(r20254);
        mpfr_init(r20255);
        mpfr_init(r20256);
}

double f_dm(double x, double n) {
        mpfr_set_d(r20223, n, MPFR_RNDN);
        ;
        mpfr_set_si(r20225, mpfr_cmp(r20223, r20224) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20227, x, MPFR_RNDN);
        mpfr_div(r20228, r20226, r20227, MPFR_RNDN);
        mpfr_div(r20229, r20228, r20223, MPFR_RNDN);
        ;
        mpfr_div(r20231, r20230, r20223, MPFR_RNDN);
        mpfr_mul(r20232, r20227, r20227, MPFR_RNDN);
        mpfr_div(r20233, r20231, r20232, MPFR_RNDN);
        mpfr_sub(r20234, r20229, r20233, MPFR_RNDN);
        mpfr_log(r20235, r20227, MPFR_RNDN);
        mpfr_mul(r20236, r20227, r20223, MPFR_RNDN);
        mpfr_div(r20237, r20235, r20236, MPFR_RNDN);
        mpfr_div(r20238, r20237, r20223, MPFR_RNDN);
        mpfr_sub(r20239, r20234, r20238, MPFR_RNDN);
        ;
        mpfr_set_si(r20241, mpfr_cmp(r20223, r20240) <= 0, MPFR_RNDN);
        mpfr_add(r20242, r20226, r20227, MPFR_RNDN);
        mpfr_div(r20243, r20226, r20223, MPFR_RNDN);
        mpfr_pow(r20244, r20242, r20243, MPFR_RNDN);
        mpfr_pow(r20245, r20227, r20243, MPFR_RNDN);
        mpfr_sub(r20246, r20244, r20245, MPFR_RNDN);
        mpfr_exp(r20247, r20246, MPFR_RNDN);
        mpfr_sqrt(r20248, r20247, MPFR_RNDN);
        mpfr_log(r20249, r20248, MPFR_RNDN);
        mpfr_add(r20250, r20227, r20226, MPFR_RNDN);
        mpfr_pow(r20251, r20250, r20243, MPFR_RNDN);
        mpfr_sub(r20252, r20251, r20245, MPFR_RNDN);
        mpfr_mul(r20253, r20230, r20252, MPFR_RNDN);
        mpfr_add(r20254, r20249, r20253, MPFR_RNDN);
        if (mpfr_get_si(r20241, MPFR_RNDN)) { mpfr_set(r20255, r20254, MPFR_RNDN); } else { mpfr_set(r20255, r20239, MPFR_RNDN); };
        if (mpfr_get_si(r20225, MPFR_RNDN)) { mpfr_set(r20256, r20239, MPFR_RNDN); } else { mpfr_set(r20256, r20255, MPFR_RNDN); };
        return mpfr_get_d(r20256, MPFR_RNDN);
}