#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 r20025 = x;
        float r20026 = 1;
        float r20027 = r20025 + r20026;
        float r20028 = n;
        float r20029 = r20026 / r20028;
        float r20030 = pow(r20027, r20029);
        float r20031 = pow(r20025, r20029);
        float r20032 = r20030 - r20031;
        return r20032;
}

double f_id(double x, double n) {
        double r20033 = x;
        double r20034 = 1;
        double r20035 = r20033 + r20034;
        double r20036 = n;
        double r20037 = r20034 / r20036;
        double r20038 = pow(r20035, r20037);
        double r20039 = pow(r20033, r20037);
        double r20040 = r20038 - r20039;
        return r20040;
}


double f_of(float x, float n) {
        float r20041 = n;
        float r20042 = -16217293.129781114;
        bool r20043 = r20041 <= r20042;
        float r20044 = 1;
        float r20045 = x;
        float r20046 = r20044 / r20045;
        float r20047 = r20046 / r20041;
        float r20048 = 1/2;
        float r20049 = r20048 / r20041;
        float r20050 = r20045 * r20045;
        float r20051 = r20049 / r20050;
        float r20052 = r20047 - r20051;
        float r20053 = log(r20045);
        float r20054 = r20041 * r20041;
        float r20055 = r20053 / r20054;
        float r20056 = r20055 / r20045;
        float r20057 = r20052 - r20056;
        float r20058 = 698268857478.727;
        bool r20059 = r20041 <= r20058;
        float r20060 = r20045 + r20044;
        float r20061 = r20044 / r20041;
        float r20062 = pow(r20060, r20061);
        float r20063 = pow(r20045, r20061);
        float r20064 = r20062 - r20063;
        float r20065 = exp(r20064);
        float r20066 = log(r20065);
        float r20067 = 3;
        float r20068 = pow(r20066, r20067);
        float r20069 = cbrt(r20068);
        float r20070 = r20059 ? r20069 : r20057;
        float r20071 = r20043 ? r20057 : r20070;
        return r20071;
}

double f_od(double x, double n) {
        double r20072 = n;
        double r20073 = -16217293.129781114;
        bool r20074 = r20072 <= r20073;
        double r20075 = 1;
        double r20076 = x;
        double r20077 = r20075 / r20076;
        double r20078 = r20077 / r20072;
        double r20079 = 1/2;
        double r20080 = r20079 / r20072;
        double r20081 = r20076 * r20076;
        double r20082 = r20080 / r20081;
        double r20083 = r20078 - r20082;
        double r20084 = log(r20076);
        double r20085 = r20072 * r20072;
        double r20086 = r20084 / r20085;
        double r20087 = r20086 / r20076;
        double r20088 = r20083 - r20087;
        double r20089 = 698268857478.727;
        bool r20090 = r20072 <= r20089;
        double r20091 = r20076 + r20075;
        double r20092 = r20075 / r20072;
        double r20093 = pow(r20091, r20092);
        double r20094 = pow(r20076, r20092);
        double r20095 = r20093 - r20094;
        double r20096 = exp(r20095);
        double r20097 = log(r20096);
        double r20098 = 3;
        double r20099 = pow(r20097, r20098);
        double r20100 = cbrt(r20099);
        double r20101 = r20090 ? r20100 : r20088;
        double r20102 = r20074 ? r20088 : r20101;
        return r20102;
}

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 r20103, r20104, r20105, r20106, r20107, r20108, r20109, r20110;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20103);
        mpfr_init_set_str(r20104, "1", 10, MPFR_RNDN);
        mpfr_init(r20105);
        mpfr_init(r20106);
        mpfr_init(r20107);
        mpfr_init(r20108);
        mpfr_init(r20109);
        mpfr_init(r20110);
}

double f_im(double x, double n) {
        mpfr_set_d(r20103, x, MPFR_RNDN);
        ;
        mpfr_add(r20105, r20103, r20104, MPFR_RNDN);
        mpfr_set_d(r20106, n, MPFR_RNDN);
        mpfr_div(r20107, r20104, r20106, MPFR_RNDN);
        mpfr_pow(r20108, r20105, r20107, MPFR_RNDN);
        mpfr_pow(r20109, r20103, r20107, MPFR_RNDN);
        mpfr_sub(r20110, r20108, r20109, MPFR_RNDN);
        return mpfr_get_d(r20110, MPFR_RNDN);
}

static mpfr_t r20111, r20112, r20113, r20114, r20115, r20116, r20117, r20118, r20119, r20120, r20121, r20122, r20123, r20124, r20125, r20126, r20127, r20128, r20129, r20130, r20131, r20132, r20133, r20134, r20135, r20136, r20137, r20138, r20139, r20140, r20141;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20111);
        mpfr_init_set_str(r20112, "-16217293.129781114", 10, MPFR_RNDN);
        mpfr_init(r20113);
        mpfr_init_set_str(r20114, "1", 10, MPFR_RNDN);
        mpfr_init(r20115);
        mpfr_init(r20116);
        mpfr_init(r20117);
        mpfr_init_set_str(r20118, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20119);
        mpfr_init(r20120);
        mpfr_init(r20121);
        mpfr_init(r20122);
        mpfr_init(r20123);
        mpfr_init(r20124);
        mpfr_init(r20125);
        mpfr_init(r20126);
        mpfr_init(r20127);
        mpfr_init_set_str(r20128, "698268857478.727", 10, MPFR_RNDN);
        mpfr_init(r20129);
        mpfr_init(r20130);
        mpfr_init(r20131);
        mpfr_init(r20132);
        mpfr_init(r20133);
        mpfr_init(r20134);
        mpfr_init(r20135);
        mpfr_init(r20136);
        mpfr_init_set_str(r20137, "3", 10, MPFR_RNDN);
        mpfr_init(r20138);
        mpfr_init(r20139);
        mpfr_init(r20140);
        mpfr_init(r20141);
}

double f_fm(double x, double n) {
        mpfr_set_d(r20111, n, MPFR_RNDN);
        ;
        mpfr_set_si(r20113, mpfr_cmp(r20111, r20112) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20115, x, MPFR_RNDN);
        mpfr_div(r20116, r20114, r20115, MPFR_RNDN);
        mpfr_div(r20117, r20116, r20111, MPFR_RNDN);
        ;
        mpfr_div(r20119, r20118, r20111, MPFR_RNDN);
        mpfr_mul(r20120, r20115, r20115, MPFR_RNDN);
        mpfr_div(r20121, r20119, r20120, MPFR_RNDN);
        mpfr_sub(r20122, r20117, r20121, MPFR_RNDN);
        mpfr_log(r20123, r20115, MPFR_RNDN);
        mpfr_mul(r20124, r20111, r20111, MPFR_RNDN);
        mpfr_div(r20125, r20123, r20124, MPFR_RNDN);
        mpfr_div(r20126, r20125, r20115, MPFR_RNDN);
        mpfr_sub(r20127, r20122, r20126, MPFR_RNDN);
        ;
        mpfr_set_si(r20129, mpfr_cmp(r20111, r20128) <= 0, MPFR_RNDN);
        mpfr_add(r20130, r20115, r20114, MPFR_RNDN);
        mpfr_div(r20131, r20114, r20111, MPFR_RNDN);
        mpfr_pow(r20132, r20130, r20131, MPFR_RNDN);
        mpfr_pow(r20133, r20115, r20131, MPFR_RNDN);
        mpfr_sub(r20134, r20132, r20133, MPFR_RNDN);
        mpfr_exp(r20135, r20134, MPFR_RNDN);
        mpfr_log(r20136, r20135, MPFR_RNDN);
        ;
        mpfr_pow(r20138, r20136, r20137, MPFR_RNDN);
        mpfr_cbrt(r20139, r20138, MPFR_RNDN);
        if (mpfr_get_si(r20129, MPFR_RNDN)) { mpfr_set(r20140, r20139, MPFR_RNDN); } else { mpfr_set(r20140, r20127, MPFR_RNDN); };
        if (mpfr_get_si(r20113, MPFR_RNDN)) { mpfr_set(r20141, r20127, MPFR_RNDN); } else { mpfr_set(r20141, r20140, MPFR_RNDN); };
        return mpfr_get_d(r20141, MPFR_RNDN);
}

static mpfr_t r20142, r20143, r20144, r20145, r20146, r20147, r20148, r20149, r20150, r20151, r20152, r20153, r20154, r20155, r20156, r20157, r20158, r20159, r20160, r20161, r20162, r20163, r20164, r20165, r20166, r20167, r20168, r20169, r20170, r20171, r20172;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20142);
        mpfr_init_set_str(r20143, "-16217293.129781114", 10, MPFR_RNDN);
        mpfr_init(r20144);
        mpfr_init_set_str(r20145, "1", 10, MPFR_RNDN);
        mpfr_init(r20146);
        mpfr_init(r20147);
        mpfr_init(r20148);
        mpfr_init_set_str(r20149, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20150);
        mpfr_init(r20151);
        mpfr_init(r20152);
        mpfr_init(r20153);
        mpfr_init(r20154);
        mpfr_init(r20155);
        mpfr_init(r20156);
        mpfr_init(r20157);
        mpfr_init(r20158);
        mpfr_init_set_str(r20159, "698268857478.727", 10, MPFR_RNDN);
        mpfr_init(r20160);
        mpfr_init(r20161);
        mpfr_init(r20162);
        mpfr_init(r20163);
        mpfr_init(r20164);
        mpfr_init(r20165);
        mpfr_init(r20166);
        mpfr_init(r20167);
        mpfr_init_set_str(r20168, "3", 10, MPFR_RNDN);
        mpfr_init(r20169);
        mpfr_init(r20170);
        mpfr_init(r20171);
        mpfr_init(r20172);
}

double f_dm(double x, double n) {
        mpfr_set_d(r20142, n, MPFR_RNDN);
        ;
        mpfr_set_si(r20144, mpfr_cmp(r20142, r20143) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20146, x, MPFR_RNDN);
        mpfr_div(r20147, r20145, r20146, MPFR_RNDN);
        mpfr_div(r20148, r20147, r20142, MPFR_RNDN);
        ;
        mpfr_div(r20150, r20149, r20142, MPFR_RNDN);
        mpfr_mul(r20151, r20146, r20146, MPFR_RNDN);
        mpfr_div(r20152, r20150, r20151, MPFR_RNDN);
        mpfr_sub(r20153, r20148, r20152, MPFR_RNDN);
        mpfr_log(r20154, r20146, MPFR_RNDN);
        mpfr_mul(r20155, r20142, r20142, MPFR_RNDN);
        mpfr_div(r20156, r20154, r20155, MPFR_RNDN);
        mpfr_div(r20157, r20156, r20146, MPFR_RNDN);
        mpfr_sub(r20158, r20153, r20157, MPFR_RNDN);
        ;
        mpfr_set_si(r20160, mpfr_cmp(r20142, r20159) <= 0, MPFR_RNDN);
        mpfr_add(r20161, r20146, r20145, MPFR_RNDN);
        mpfr_div(r20162, r20145, r20142, MPFR_RNDN);
        mpfr_pow(r20163, r20161, r20162, MPFR_RNDN);
        mpfr_pow(r20164, r20146, r20162, MPFR_RNDN);
        mpfr_sub(r20165, r20163, r20164, MPFR_RNDN);
        mpfr_exp(r20166, r20165, MPFR_RNDN);
        mpfr_log(r20167, r20166, MPFR_RNDN);
        ;
        mpfr_pow(r20169, r20167, r20168, MPFR_RNDN);
        mpfr_cbrt(r20170, r20169, MPFR_RNDN);
        if (mpfr_get_si(r20160, MPFR_RNDN)) { mpfr_set(r20171, r20170, MPFR_RNDN); } else { mpfr_set(r20171, r20158, MPFR_RNDN); };
        if (mpfr_get_si(r20144, MPFR_RNDN)) { mpfr_set(r20172, r20158, MPFR_RNDN); } else { mpfr_set(r20172, r20171, MPFR_RNDN); };
        return mpfr_get_d(r20172, MPFR_RNDN);
}