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

char *name = "NMSE Section 6.1 mentioned, A";

double f_if(float x, float eps) {
        float r20034 = 1;
        float r20035 = eps;
        float r20036 = r20034 / r20035;
        float r20037 = r20034 + r20036;
        float r20038 = r20034 - r20035;
        float r20039 = x;
        float r20040 = r20038 * r20039;
        float r20041 = -r20040;
        float r20042 = exp(r20041);
        float r20043 = r20037 * r20042;
        float r20044 = r20036 - r20034;
        float r20045 = r20034 + r20035;
        float r20046 = r20045 * r20039;
        float r20047 = -r20046;
        float r20048 = exp(r20047);
        float r20049 = r20044 * r20048;
        float r20050 = r20043 - r20049;
        float r20051 = 2;
        float r20052 = r20050 / r20051;
        return r20052;
}

double f_id(double x, double eps) {
        double r20053 = 1;
        double r20054 = eps;
        double r20055 = r20053 / r20054;
        double r20056 = r20053 + r20055;
        double r20057 = r20053 - r20054;
        double r20058 = x;
        double r20059 = r20057 * r20058;
        double r20060 = -r20059;
        double r20061 = exp(r20060);
        double r20062 = r20056 * r20061;
        double r20063 = r20055 - r20053;
        double r20064 = r20053 + r20054;
        double r20065 = r20064 * r20058;
        double r20066 = -r20065;
        double r20067 = exp(r20066);
        double r20068 = r20063 * r20067;
        double r20069 = r20062 - r20068;
        double r20070 = 2;
        double r20071 = r20069 / r20070;
        return r20071;
}


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

double f_od(double x, double eps) {
        double r20107 = x;
        double r20108 = 10.163623375656135;
        bool r20109 = r20107 <= r20108;
        double r20110 = 2;
        double r20111 = 2/3;
        double r20112 = 3;
        double r20113 = pow(r20107, r20112);
        double r20114 = r20111 * r20113;
        double r20115 = exp(r20114);
        double r20116 = log(r20115);
        double r20117 = r20110 + r20116;
        double r20118 = pow(r20107, r20110);
        double r20119 = r20117 - r20118;
        double r20120 = r20119 / r20110;
        double r20121 = 1;
        double r20122 = eps;
        double r20123 = r20121 / r20122;
        double r20124 = r20121 + r20123;
        double r20125 = r20121 - r20122;
        double r20126 = r20125 * r20107;
        double r20127 = -r20126;
        double r20128 = exp(r20127);
        double r20129 = r20124 * r20128;
        double r20130 = r20123 - r20121;
        double r20131 = cbrt(r20130);
        double r20132 = r20131 * r20131;
        double r20133 = r20121 + r20122;
        double r20134 = r20133 * r20107;
        double r20135 = -r20134;
        double r20136 = exp(r20135);
        double r20137 = r20131 * r20136;
        double r20138 = r20132 * r20137;
        double r20139 = r20129 - r20138;
        double r20140 = r20139 / r20110;
        double r20141 = r20109 ? r20120 : r20140;
        return r20141;
}

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 r20142, r20143, r20144, r20145, r20146, r20147, r20148, r20149, r20150, r20151, r20152, r20153, r20154, r20155, r20156, r20157, r20158, r20159, r20160;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20142, "1", 10, MPFR_RNDN);
        mpfr_init(r20143);
        mpfr_init(r20144);
        mpfr_init(r20145);
        mpfr_init(r20146);
        mpfr_init(r20147);
        mpfr_init(r20148);
        mpfr_init(r20149);
        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, "2", 10, MPFR_RNDN);
        mpfr_init(r20160);
}

double f_im(double x, double eps) {
        ;
        mpfr_set_d(r20143, eps, MPFR_RNDN);
        mpfr_div(r20144, r20142, r20143, MPFR_RNDN);
        mpfr_add(r20145, r20142, r20144, MPFR_RNDN);
        mpfr_sub(r20146, r20142, r20143, MPFR_RNDN);
        mpfr_set_d(r20147, x, MPFR_RNDN);
        mpfr_mul(r20148, r20146, r20147, MPFR_RNDN);
        mpfr_neg(r20149, r20148, MPFR_RNDN);
        mpfr_exp(r20150, r20149, MPFR_RNDN);
        mpfr_mul(r20151, r20145, r20150, MPFR_RNDN);
        mpfr_sub(r20152, r20144, r20142, MPFR_RNDN);
        mpfr_add(r20153, r20142, r20143, MPFR_RNDN);
        mpfr_mul(r20154, r20153, r20147, MPFR_RNDN);
        mpfr_neg(r20155, r20154, MPFR_RNDN);
        mpfr_exp(r20156, r20155, MPFR_RNDN);
        mpfr_mul(r20157, r20152, r20156, MPFR_RNDN);
        mpfr_sub(r20158, r20151, r20157, MPFR_RNDN);
        ;
        mpfr_div(r20160, r20158, r20159, MPFR_RNDN);
        return mpfr_get_d(r20160, MPFR_RNDN);
}

static mpfr_t r20161, r20162, r20163, r20164, r20165, r20166, r20167, r20168, r20169, r20170, r20171, r20172, r20173, r20174, r20175, r20176, r20177, r20178, r20179, r20180, r20181, r20182, r20183, r20184, r20185, r20186, r20187, r20188, r20189, r20190, r20191, r20192, r20193, r20194, r20195;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20161);
        mpfr_init_set_str(r20162, "10.163623375656135", 10, MPFR_RNDN);
        mpfr_init(r20163);
        mpfr_init_set_str(r20164, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20165, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20166, "3", 10, MPFR_RNDN);
        mpfr_init(r20167);
        mpfr_init(r20168);
        mpfr_init(r20169);
        mpfr_init(r20170);
        mpfr_init(r20171);
        mpfr_init(r20172);
        mpfr_init(r20173);
        mpfr_init(r20174);
        mpfr_init_set_str(r20175, "1", 10, MPFR_RNDN);
        mpfr_init(r20176);
        mpfr_init(r20177);
        mpfr_init(r20178);
        mpfr_init(r20179);
        mpfr_init(r20180);
        mpfr_init(r20181);
        mpfr_init(r20182);
        mpfr_init(r20183);
        mpfr_init(r20184);
        mpfr_init(r20185);
        mpfr_init(r20186);
        mpfr_init(r20187);
        mpfr_init(r20188);
        mpfr_init(r20189);
        mpfr_init(r20190);
        mpfr_init(r20191);
        mpfr_init(r20192);
        mpfr_init(r20193);
        mpfr_init(r20194);
        mpfr_init(r20195);
}

double f_fm(double x, double eps) {
        mpfr_set_d(r20161, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20163, mpfr_cmp(r20161, r20162) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20167, r20161, r20166, MPFR_RNDN);
        mpfr_mul(r20168, r20165, r20167, MPFR_RNDN);
        mpfr_exp(r20169, r20168, MPFR_RNDN);
        mpfr_log(r20170, r20169, MPFR_RNDN);
        mpfr_add(r20171, r20164, r20170, MPFR_RNDN);
        mpfr_pow(r20172, r20161, r20164, MPFR_RNDN);
        mpfr_sub(r20173, r20171, r20172, MPFR_RNDN);
        mpfr_div(r20174, r20173, r20164, MPFR_RNDN);
        ;
        mpfr_set_d(r20176, eps, MPFR_RNDN);
        mpfr_div(r20177, r20175, r20176, MPFR_RNDN);
        mpfr_add(r20178, r20175, r20177, MPFR_RNDN);
        mpfr_sub(r20179, r20175, r20176, MPFR_RNDN);
        mpfr_mul(r20180, r20179, r20161, MPFR_RNDN);
        mpfr_neg(r20181, r20180, MPFR_RNDN);
        mpfr_exp(r20182, r20181, MPFR_RNDN);
        mpfr_mul(r20183, r20178, r20182, MPFR_RNDN);
        mpfr_sub(r20184, r20177, r20175, MPFR_RNDN);
        mpfr_cbrt(r20185, r20184, MPFR_RNDN);
        mpfr_mul(r20186, r20185, r20185, MPFR_RNDN);
        mpfr_add(r20187, r20175, r20176, MPFR_RNDN);
        mpfr_mul(r20188, r20187, r20161, MPFR_RNDN);
        mpfr_neg(r20189, r20188, MPFR_RNDN);
        mpfr_exp(r20190, r20189, MPFR_RNDN);
        mpfr_mul(r20191, r20185, r20190, MPFR_RNDN);
        mpfr_mul(r20192, r20186, r20191, MPFR_RNDN);
        mpfr_sub(r20193, r20183, r20192, MPFR_RNDN);
        mpfr_div(r20194, r20193, r20164, MPFR_RNDN);
        if (mpfr_get_si(r20163, MPFR_RNDN)) { mpfr_set(r20195, r20174, MPFR_RNDN); } else { mpfr_set(r20195, r20194, MPFR_RNDN); };
        return mpfr_get_d(r20195, MPFR_RNDN);
}

static mpfr_t 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, r20223, r20224, r20225, r20226, r20227, r20228, r20229, r20230;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20196);
        mpfr_init_set_str(r20197, "10.163623375656135", 10, MPFR_RNDN);
        mpfr_init(r20198);
        mpfr_init_set_str(r20199, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20200, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20201, "3", 10, MPFR_RNDN);
        mpfr_init(r20202);
        mpfr_init(r20203);
        mpfr_init(r20204);
        mpfr_init(r20205);
        mpfr_init(r20206);
        mpfr_init(r20207);
        mpfr_init(r20208);
        mpfr_init(r20209);
        mpfr_init_set_str(r20210, "1", 10, MPFR_RNDN);
        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);
        mpfr_init(r20223);
        mpfr_init(r20224);
        mpfr_init(r20225);
        mpfr_init(r20226);
        mpfr_init(r20227);
        mpfr_init(r20228);
        mpfr_init(r20229);
        mpfr_init(r20230);
}

double f_dm(double x, double eps) {
        mpfr_set_d(r20196, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20198, mpfr_cmp(r20196, r20197) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20202, r20196, r20201, MPFR_RNDN);
        mpfr_mul(r20203, r20200, r20202, MPFR_RNDN);
        mpfr_exp(r20204, r20203, MPFR_RNDN);
        mpfr_log(r20205, r20204, MPFR_RNDN);
        mpfr_add(r20206, r20199, r20205, MPFR_RNDN);
        mpfr_pow(r20207, r20196, r20199, MPFR_RNDN);
        mpfr_sub(r20208, r20206, r20207, MPFR_RNDN);
        mpfr_div(r20209, r20208, r20199, MPFR_RNDN);
        ;
        mpfr_set_d(r20211, eps, MPFR_RNDN);
        mpfr_div(r20212, r20210, r20211, MPFR_RNDN);
        mpfr_add(r20213, r20210, r20212, MPFR_RNDN);
        mpfr_sub(r20214, r20210, r20211, MPFR_RNDN);
        mpfr_mul(r20215, r20214, r20196, MPFR_RNDN);
        mpfr_neg(r20216, r20215, MPFR_RNDN);
        mpfr_exp(r20217, r20216, MPFR_RNDN);
        mpfr_mul(r20218, r20213, r20217, MPFR_RNDN);
        mpfr_sub(r20219, r20212, r20210, MPFR_RNDN);
        mpfr_cbrt(r20220, r20219, MPFR_RNDN);
        mpfr_mul(r20221, r20220, r20220, MPFR_RNDN);
        mpfr_add(r20222, r20210, r20211, MPFR_RNDN);
        mpfr_mul(r20223, r20222, r20196, MPFR_RNDN);
        mpfr_neg(r20224, r20223, MPFR_RNDN);
        mpfr_exp(r20225, r20224, MPFR_RNDN);
        mpfr_mul(r20226, r20220, r20225, MPFR_RNDN);
        mpfr_mul(r20227, r20221, r20226, MPFR_RNDN);
        mpfr_sub(r20228, r20218, r20227, MPFR_RNDN);
        mpfr_div(r20229, r20228, r20199, MPFR_RNDN);
        if (mpfr_get_si(r20198, MPFR_RNDN)) { mpfr_set(r20230, r20209, MPFR_RNDN); } else { mpfr_set(r20230, r20229, MPFR_RNDN); };
        return mpfr_get_d(r20230, MPFR_RNDN);
}