#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 r20058 = 1;
        float r20059 = eps;
        float r20060 = r20058 / r20059;
        float r20061 = r20058 + r20060;
        float r20062 = r20058 - r20059;
        float r20063 = x;
        float r20064 = r20062 * r20063;
        float r20065 = -r20064;
        float r20066 = exp(r20065);
        float r20067 = r20061 * r20066;
        float r20068 = r20060 - r20058;
        float r20069 = r20058 + r20059;
        float r20070 = r20069 * r20063;
        float r20071 = -r20070;
        float r20072 = exp(r20071);
        float r20073 = r20068 * r20072;
        float r20074 = r20067 - r20073;
        float r20075 = 2;
        float r20076 = r20074 / r20075;
        return r20076;
}

double f_id(double x, double eps) {
        double r20077 = 1;
        double r20078 = eps;
        double r20079 = r20077 / r20078;
        double r20080 = r20077 + r20079;
        double r20081 = r20077 - r20078;
        double r20082 = x;
        double r20083 = r20081 * r20082;
        double r20084 = -r20083;
        double r20085 = exp(r20084);
        double r20086 = r20080 * r20085;
        double r20087 = r20079 - r20077;
        double r20088 = r20077 + r20078;
        double r20089 = r20088 * r20082;
        double r20090 = -r20089;
        double r20091 = exp(r20090);
        double r20092 = r20087 * r20091;
        double r20093 = r20086 - r20092;
        double r20094 = 2;
        double r20095 = r20093 / r20094;
        return r20095;
}


double f_of(float x, float eps) {
        float r20096 = x;
        float r20097 = 157.57083929077044;
        bool r20098 = r20096 <= r20097;
        float r20099 = 2;
        float r20100 = 2/3;
        float r20101 = 3;
        float r20102 = pow(r20096, r20101);
        float r20103 = r20100 * r20102;
        float r20104 = cbrt(r20103);
        float r20105 = r20104 * r20104;
        float r20106 = log(r20105);
        float r20107 = exp(r20106);
        float r20108 = r20107 * r20104;
        float r20109 = r20099 + r20108;
        float r20110 = pow(r20096, r20099);
        float r20111 = r20109 - r20110;
        float r20112 = r20111 / r20099;
        float r20113 = 1;
        float r20114 = eps;
        float r20115 = r20113 / r20114;
        float r20116 = r20113 + r20115;
        float r20117 = r20113 - r20114;
        float r20118 = r20117 * r20096;
        float r20119 = -r20118;
        float r20120 = exp(r20119);
        float r20121 = r20116 * r20120;
        float r20122 = r20115 - r20113;
        float r20123 = cbrt(r20122);
        float r20124 = r20123 * r20123;
        float r20125 = r20113 + r20114;
        float r20126 = r20125 * r20096;
        float r20127 = -r20126;
        float r20128 = exp(r20127);
        float r20129 = r20123 * r20128;
        float r20130 = r20124 * r20129;
        float r20131 = r20121 - r20130;
        float r20132 = r20131 / r20099;
        float r20133 = r20098 ? r20112 : r20132;
        return r20133;
}

double f_od(double x, double eps) {
        double r20134 = x;
        double r20135 = 157.57083929077044;
        bool r20136 = r20134 <= r20135;
        double r20137 = 2;
        double r20138 = 2/3;
        double r20139 = 3;
        double r20140 = pow(r20134, r20139);
        double r20141 = r20138 * r20140;
        double r20142 = cbrt(r20141);
        double r20143 = r20142 * r20142;
        double r20144 = log(r20143);
        double r20145 = exp(r20144);
        double r20146 = r20145 * r20142;
        double r20147 = r20137 + r20146;
        double r20148 = pow(r20134, r20137);
        double r20149 = r20147 - r20148;
        double r20150 = r20149 / r20137;
        double r20151 = 1;
        double r20152 = eps;
        double r20153 = r20151 / r20152;
        double r20154 = r20151 + r20153;
        double r20155 = r20151 - r20152;
        double r20156 = r20155 * r20134;
        double r20157 = -r20156;
        double r20158 = exp(r20157);
        double r20159 = r20154 * r20158;
        double r20160 = r20153 - r20151;
        double r20161 = cbrt(r20160);
        double r20162 = r20161 * r20161;
        double r20163 = r20151 + r20152;
        double r20164 = r20163 * r20134;
        double r20165 = -r20164;
        double r20166 = exp(r20165);
        double r20167 = r20161 * r20166;
        double r20168 = r20162 * r20167;
        double r20169 = r20159 - r20168;
        double r20170 = r20169 / r20137;
        double r20171 = r20136 ? r20150 : r20170;
        return r20171;
}

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 r20172, r20173, r20174, r20175, r20176, r20177, r20178, r20179, r20180, r20181, r20182, r20183, r20184, r20185, r20186, r20187, r20188, r20189, r20190;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20172, "1", 10, MPFR_RNDN);
        mpfr_init(r20173);
        mpfr_init(r20174);
        mpfr_init(r20175);
        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_set_str(r20189, "2", 10, MPFR_RNDN);
        mpfr_init(r20190);
}

double f_im(double x, double eps) {
        ;
        mpfr_set_d(r20173, eps, MPFR_RNDN);
        mpfr_div(r20174, r20172, r20173, MPFR_RNDN);
        mpfr_add(r20175, r20172, r20174, MPFR_RNDN);
        mpfr_sub(r20176, r20172, r20173, MPFR_RNDN);
        mpfr_set_d(r20177, x, MPFR_RNDN);
        mpfr_mul(r20178, r20176, r20177, MPFR_RNDN);
        mpfr_neg(r20179, r20178, MPFR_RNDN);
        mpfr_exp(r20180, r20179, MPFR_RNDN);
        mpfr_mul(r20181, r20175, r20180, MPFR_RNDN);
        mpfr_sub(r20182, r20174, r20172, MPFR_RNDN);
        mpfr_add(r20183, r20172, r20173, MPFR_RNDN);
        mpfr_mul(r20184, r20183, r20177, MPFR_RNDN);
        mpfr_neg(r20185, r20184, MPFR_RNDN);
        mpfr_exp(r20186, r20185, MPFR_RNDN);
        mpfr_mul(r20187, r20182, r20186, MPFR_RNDN);
        mpfr_sub(r20188, r20181, r20187, MPFR_RNDN);
        ;
        mpfr_div(r20190, r20188, r20189, MPFR_RNDN);
        return mpfr_get_d(r20190, MPFR_RNDN);
}

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

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20191);
        mpfr_init_set_str(r20192, "157.57083929077044", 10, MPFR_RNDN);
        mpfr_init(r20193);
        mpfr_init_set_str(r20194, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20195, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20196, "3", 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(r20206);
        mpfr_init(r20207);
        mpfr_init_set_str(r20208, "1", 10, MPFR_RNDN);
        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);
        mpfr_init(r20223);
        mpfr_init(r20224);
        mpfr_init(r20225);
        mpfr_init(r20226);
        mpfr_init(r20227);
        mpfr_init(r20228);
}

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

static mpfr_t 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, r20257, r20258, r20259, r20260, r20261, r20262, r20263, r20264, r20265, r20266;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20229);
        mpfr_init_set_str(r20230, "157.57083929077044", 10, MPFR_RNDN);
        mpfr_init(r20231);
        mpfr_init_set_str(r20232, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20233, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20234, "3", 10, MPFR_RNDN);
        mpfr_init(r20235);
        mpfr_init(r20236);
        mpfr_init(r20237);
        mpfr_init(r20238);
        mpfr_init(r20239);
        mpfr_init(r20240);
        mpfr_init(r20241);
        mpfr_init(r20242);
        mpfr_init(r20243);
        mpfr_init(r20244);
        mpfr_init(r20245);
        mpfr_init_set_str(r20246, "1", 10, MPFR_RNDN);
        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);
        mpfr_init(r20257);
        mpfr_init(r20258);
        mpfr_init(r20259);
        mpfr_init(r20260);
        mpfr_init(r20261);
        mpfr_init(r20262);
        mpfr_init(r20263);
        mpfr_init(r20264);
        mpfr_init(r20265);
        mpfr_init(r20266);
}

double f_dm(double x, double eps) {
        mpfr_set_d(r20229, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20231, mpfr_cmp(r20229, r20230) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20235, r20229, r20234, MPFR_RNDN);
        mpfr_mul(r20236, r20233, r20235, MPFR_RNDN);
        mpfr_cbrt(r20237, r20236, MPFR_RNDN);
        mpfr_mul(r20238, r20237, r20237, MPFR_RNDN);
        mpfr_log(r20239, r20238, MPFR_RNDN);
        mpfr_exp(r20240, r20239, MPFR_RNDN);
        mpfr_mul(r20241, r20240, r20237, MPFR_RNDN);
        mpfr_add(r20242, r20232, r20241, MPFR_RNDN);
        mpfr_pow(r20243, r20229, r20232, MPFR_RNDN);
        mpfr_sub(r20244, r20242, r20243, MPFR_RNDN);
        mpfr_div(r20245, r20244, r20232, MPFR_RNDN);
        ;
        mpfr_set_d(r20247, eps, MPFR_RNDN);
        mpfr_div(r20248, r20246, r20247, MPFR_RNDN);
        mpfr_add(r20249, r20246, r20248, MPFR_RNDN);
        mpfr_sub(r20250, r20246, r20247, MPFR_RNDN);
        mpfr_mul(r20251, r20250, r20229, MPFR_RNDN);
        mpfr_neg(r20252, r20251, MPFR_RNDN);
        mpfr_exp(r20253, r20252, MPFR_RNDN);
        mpfr_mul(r20254, r20249, r20253, MPFR_RNDN);
        mpfr_sub(r20255, r20248, r20246, MPFR_RNDN);
        mpfr_cbrt(r20256, r20255, MPFR_RNDN);
        mpfr_mul(r20257, r20256, r20256, MPFR_RNDN);
        mpfr_add(r20258, r20246, r20247, MPFR_RNDN);
        mpfr_mul(r20259, r20258, r20229, MPFR_RNDN);
        mpfr_neg(r20260, r20259, MPFR_RNDN);
        mpfr_exp(r20261, r20260, MPFR_RNDN);
        mpfr_mul(r20262, r20256, r20261, MPFR_RNDN);
        mpfr_mul(r20263, r20257, r20262, MPFR_RNDN);
        mpfr_sub(r20264, r20254, r20263, MPFR_RNDN);
        mpfr_div(r20265, r20264, r20232, MPFR_RNDN);
        if (mpfr_get_si(r20231, MPFR_RNDN)) { mpfr_set(r20266, r20245, MPFR_RNDN); } else { mpfr_set(r20266, r20265, MPFR_RNDN); };
        return mpfr_get_d(r20266, MPFR_RNDN);
}