#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 r20115 = 1;
        float r20116 = eps;
        float r20117 = r20115 / r20116;
        float r20118 = r20115 + r20117;
        float r20119 = r20115 - r20116;
        float r20120 = x;
        float r20121 = r20119 * r20120;
        float r20122 = -r20121;
        float r20123 = exp(r20122);
        float r20124 = r20118 * r20123;
        float r20125 = r20117 - r20115;
        float r20126 = r20115 + r20116;
        float r20127 = r20126 * r20120;
        float r20128 = -r20127;
        float r20129 = exp(r20128);
        float r20130 = r20125 * r20129;
        float r20131 = r20124 - r20130;
        float r20132 = 2;
        float r20133 = r20131 / r20132;
        return r20133;
}

double f_id(double x, double eps) {
        double r20134 = 1;
        double r20135 = eps;
        double r20136 = r20134 / r20135;
        double r20137 = r20134 + r20136;
        double r20138 = r20134 - r20135;
        double r20139 = x;
        double r20140 = r20138 * r20139;
        double r20141 = -r20140;
        double r20142 = exp(r20141);
        double r20143 = r20137 * r20142;
        double r20144 = r20136 - r20134;
        double r20145 = r20134 + r20135;
        double r20146 = r20145 * r20139;
        double r20147 = -r20146;
        double r20148 = exp(r20147);
        double r20149 = r20144 * r20148;
        double r20150 = r20143 - r20149;
        double r20151 = 2;
        double r20152 = r20150 / r20151;
        return r20152;
}


double f_of(float x, float eps) {
        float r20153 = x;
        float r20154 = 2859.9798077968026;
        bool r20155 = r20153 <= r20154;
        float r20156 = 2;
        float r20157 = 2/3;
        float r20158 = 3;
        float r20159 = pow(r20153, r20158);
        float r20160 = r20157 * r20159;
        float r20161 = cbrt(r20160);
        float r20162 = r20161 * r20161;
        float r20163 = cbrt(r20162);
        float r20164 = r20163 * r20163;
        float r20165 = r20164 * r20163;
        float r20166 = r20165 * r20161;
        float r20167 = r20156 + r20166;
        float r20168 = pow(r20153, r20156);
        float r20169 = r20167 - r20168;
        float r20170 = r20169 / r20156;
        float r20171 = 1;
        float r20172 = eps;
        float r20173 = r20171 / r20172;
        float r20174 = r20171 + r20173;
        float r20175 = exp(1.0);
        float r20176 = r20171 - r20172;
        float r20177 = r20176 * r20153;
        float r20178 = -r20177;
        float r20179 = pow(r20175, r20178);
        float r20180 = r20174 * r20179;
        float r20181 = r20173 - r20171;
        float r20182 = r20171 + r20172;
        float r20183 = r20182 * r20153;
        float r20184 = -r20183;
        float r20185 = exp(r20184);
        float r20186 = r20181 * r20185;
        float r20187 = r20180 - r20186;
        float r20188 = r20187 / r20156;
        float r20189 = r20155 ? r20170 : r20188;
        return r20189;
}

double f_od(double x, double eps) {
        double r20190 = x;
        double r20191 = 2859.9798077968026;
        bool r20192 = r20190 <= r20191;
        double r20193 = 2;
        double r20194 = 2/3;
        double r20195 = 3;
        double r20196 = pow(r20190, r20195);
        double r20197 = r20194 * r20196;
        double r20198 = cbrt(r20197);
        double r20199 = r20198 * r20198;
        double r20200 = cbrt(r20199);
        double r20201 = r20200 * r20200;
        double r20202 = r20201 * r20200;
        double r20203 = r20202 * r20198;
        double r20204 = r20193 + r20203;
        double r20205 = pow(r20190, r20193);
        double r20206 = r20204 - r20205;
        double r20207 = r20206 / r20193;
        double r20208 = 1;
        double r20209 = eps;
        double r20210 = r20208 / r20209;
        double r20211 = r20208 + r20210;
        double r20212 = exp(1.0);
        double r20213 = r20208 - r20209;
        double r20214 = r20213 * r20190;
        double r20215 = -r20214;
        double r20216 = pow(r20212, r20215);
        double r20217 = r20211 * r20216;
        double r20218 = r20210 - r20208;
        double r20219 = r20208 + r20209;
        double r20220 = r20219 * r20190;
        double r20221 = -r20220;
        double r20222 = exp(r20221);
        double r20223 = r20218 * r20222;
        double r20224 = r20217 - r20223;
        double r20225 = r20224 / r20193;
        double r20226 = r20192 ? r20207 : r20225;
        return r20226;
}

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 r20227, r20228, r20229, r20230, r20231, r20232, r20233, r20234, r20235, r20236, r20237, r20238, r20239, r20240, r20241, r20242, r20243, r20244, r20245;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20227, "1", 10, MPFR_RNDN);
        mpfr_init(r20228);
        mpfr_init(r20229);
        mpfr_init(r20230);
        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(r20240);
        mpfr_init(r20241);
        mpfr_init(r20242);
        mpfr_init(r20243);
        mpfr_init_set_str(r20244, "2", 10, MPFR_RNDN);
        mpfr_init(r20245);
}

double f_im(double x, double eps) {
        ;
        mpfr_set_d(r20228, eps, MPFR_RNDN);
        mpfr_div(r20229, r20227, r20228, MPFR_RNDN);
        mpfr_add(r20230, r20227, r20229, MPFR_RNDN);
        mpfr_sub(r20231, r20227, r20228, MPFR_RNDN);
        mpfr_set_d(r20232, x, MPFR_RNDN);
        mpfr_mul(r20233, r20231, r20232, MPFR_RNDN);
        mpfr_neg(r20234, r20233, MPFR_RNDN);
        mpfr_exp(r20235, r20234, MPFR_RNDN);
        mpfr_mul(r20236, r20230, r20235, MPFR_RNDN);
        mpfr_sub(r20237, r20229, r20227, MPFR_RNDN);
        mpfr_add(r20238, r20227, r20228, MPFR_RNDN);
        mpfr_mul(r20239, r20238, r20232, MPFR_RNDN);
        mpfr_neg(r20240, r20239, MPFR_RNDN);
        mpfr_exp(r20241, r20240, MPFR_RNDN);
        mpfr_mul(r20242, r20237, r20241, MPFR_RNDN);
        mpfr_sub(r20243, r20236, r20242, MPFR_RNDN);
        ;
        mpfr_div(r20245, r20243, r20244, MPFR_RNDN);
        return mpfr_get_d(r20245, MPFR_RNDN);
}

static mpfr_t r20246, r20247, r20248, r20249, r20250, r20251, r20252, r20253, r20254, r20255, r20256, r20257, r20258, r20259, r20260, r20261, r20262, r20263, r20264, r20265, r20266, r20267, r20268, r20269, r20270, r20271, r20272, r20273, r20274, r20275, r20276, r20277, r20278, r20279, r20280, r20281, r20282;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20246);
        mpfr_init_set_str(r20247, "2859.9798077968026", 10, MPFR_RNDN);
        mpfr_init(r20248);
        mpfr_init_set_str(r20249, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20250, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20251, "3", 10, MPFR_RNDN);
        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_set_str(r20264, "1", 10, MPFR_RNDN);
        mpfr_init(r20265);
        mpfr_init(r20266);
        mpfr_init(r20267);
        mpfr_init(r20268);
        mpfr_init(r20269);
        mpfr_init(r20270);
        mpfr_init(r20271);
        mpfr_init(r20272);
        mpfr_init(r20273);
        mpfr_init(r20274);
        mpfr_init(r20275);
        mpfr_init(r20276);
        mpfr_init(r20277);
        mpfr_init(r20278);
        mpfr_init(r20279);
        mpfr_init(r20280);
        mpfr_init(r20281);
        mpfr_init(r20282);
}

double f_fm(double x, double eps) {
        mpfr_set_d(r20246, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20248, mpfr_cmp(r20246, r20247) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20252, r20246, r20251, MPFR_RNDN);
        mpfr_mul(r20253, r20250, r20252, MPFR_RNDN);
        mpfr_cbrt(r20254, r20253, MPFR_RNDN);
        mpfr_mul(r20255, r20254, r20254, MPFR_RNDN);
        mpfr_cbrt(r20256, r20255, MPFR_RNDN);
        mpfr_mul(r20257, r20256, r20256, MPFR_RNDN);
        mpfr_mul(r20258, r20257, r20256, MPFR_RNDN);
        mpfr_mul(r20259, r20258, r20254, MPFR_RNDN);
        mpfr_add(r20260, r20249, r20259, MPFR_RNDN);
        mpfr_pow(r20261, r20246, r20249, MPFR_RNDN);
        mpfr_sub(r20262, r20260, r20261, MPFR_RNDN);
        mpfr_div(r20263, r20262, r20249, MPFR_RNDN);
        ;
        mpfr_set_d(r20265, eps, MPFR_RNDN);
        mpfr_div(r20266, r20264, r20265, MPFR_RNDN);
        mpfr_add(r20267, r20264, r20266, MPFR_RNDN);
        mpfr_set_si(r20268, 1, MPFR_RNDN), mpfr_const_exp(r20268, r20268, MPFR_RNDN);
        mpfr_sub(r20269, r20264, r20265, MPFR_RNDN);
        mpfr_mul(r20270, r20269, r20246, MPFR_RNDN);
        mpfr_neg(r20271, r20270, MPFR_RNDN);
        mpfr_pow(r20272, r20268, r20271, MPFR_RNDN);
        mpfr_mul(r20273, r20267, r20272, MPFR_RNDN);
        mpfr_sub(r20274, r20266, r20264, MPFR_RNDN);
        mpfr_add(r20275, r20264, r20265, MPFR_RNDN);
        mpfr_mul(r20276, r20275, r20246, MPFR_RNDN);
        mpfr_neg(r20277, r20276, MPFR_RNDN);
        mpfr_exp(r20278, r20277, MPFR_RNDN);
        mpfr_mul(r20279, r20274, r20278, MPFR_RNDN);
        mpfr_sub(r20280, r20273, r20279, MPFR_RNDN);
        mpfr_div(r20281, r20280, r20249, MPFR_RNDN);
        if (mpfr_get_si(r20248, MPFR_RNDN)) { mpfr_set(r20282, r20263, MPFR_RNDN); } else { mpfr_set(r20282, r20281, MPFR_RNDN); };
        return mpfr_get_d(r20282, MPFR_RNDN);
}

static mpfr_t r20283, r20284, r20285, r20286, r20287, r20288, r20289, r20290, r20291, r20292, r20293, r20294, r20295, r20296, r20297, r20298, r20299, r20300, r20301, r20302, r20303, r20304, r20305, r20306, r20307, r20308, r20309, r20310, r20311, r20312, r20313, r20314, r20315, r20316, r20317, r20318, r20319;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20283);
        mpfr_init_set_str(r20284, "2859.9798077968026", 10, MPFR_RNDN);
        mpfr_init(r20285);
        mpfr_init_set_str(r20286, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20287, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20288, "3", 10, MPFR_RNDN);
        mpfr_init(r20289);
        mpfr_init(r20290);
        mpfr_init(r20291);
        mpfr_init(r20292);
        mpfr_init(r20293);
        mpfr_init(r20294);
        mpfr_init(r20295);
        mpfr_init(r20296);
        mpfr_init(r20297);
        mpfr_init(r20298);
        mpfr_init(r20299);
        mpfr_init(r20300);
        mpfr_init_set_str(r20301, "1", 10, MPFR_RNDN);
        mpfr_init(r20302);
        mpfr_init(r20303);
        mpfr_init(r20304);
        mpfr_init(r20305);
        mpfr_init(r20306);
        mpfr_init(r20307);
        mpfr_init(r20308);
        mpfr_init(r20309);
        mpfr_init(r20310);
        mpfr_init(r20311);
        mpfr_init(r20312);
        mpfr_init(r20313);
        mpfr_init(r20314);
        mpfr_init(r20315);
        mpfr_init(r20316);
        mpfr_init(r20317);
        mpfr_init(r20318);
        mpfr_init(r20319);
}

double f_dm(double x, double eps) {
        mpfr_set_d(r20283, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20285, mpfr_cmp(r20283, r20284) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20289, r20283, r20288, MPFR_RNDN);
        mpfr_mul(r20290, r20287, r20289, MPFR_RNDN);
        mpfr_cbrt(r20291, r20290, MPFR_RNDN);
        mpfr_mul(r20292, r20291, r20291, MPFR_RNDN);
        mpfr_cbrt(r20293, r20292, MPFR_RNDN);
        mpfr_mul(r20294, r20293, r20293, MPFR_RNDN);
        mpfr_mul(r20295, r20294, r20293, MPFR_RNDN);
        mpfr_mul(r20296, r20295, r20291, MPFR_RNDN);
        mpfr_add(r20297, r20286, r20296, MPFR_RNDN);
        mpfr_pow(r20298, r20283, r20286, MPFR_RNDN);
        mpfr_sub(r20299, r20297, r20298, MPFR_RNDN);
        mpfr_div(r20300, r20299, r20286, MPFR_RNDN);
        ;
        mpfr_set_d(r20302, eps, MPFR_RNDN);
        mpfr_div(r20303, r20301, r20302, MPFR_RNDN);
        mpfr_add(r20304, r20301, r20303, MPFR_RNDN);
        mpfr_set_si(r20305, 1, MPFR_RNDN), mpfr_const_exp(r20305, r20305, MPFR_RNDN);
        mpfr_sub(r20306, r20301, r20302, MPFR_RNDN);
        mpfr_mul(r20307, r20306, r20283, MPFR_RNDN);
        mpfr_neg(r20308, r20307, MPFR_RNDN);
        mpfr_pow(r20309, r20305, r20308, MPFR_RNDN);
        mpfr_mul(r20310, r20304, r20309, MPFR_RNDN);
        mpfr_sub(r20311, r20303, r20301, MPFR_RNDN);
        mpfr_add(r20312, r20301, r20302, MPFR_RNDN);
        mpfr_mul(r20313, r20312, r20283, MPFR_RNDN);
        mpfr_neg(r20314, r20313, MPFR_RNDN);
        mpfr_exp(r20315, r20314, MPFR_RNDN);
        mpfr_mul(r20316, r20311, r20315, MPFR_RNDN);
        mpfr_sub(r20317, r20310, r20316, MPFR_RNDN);
        mpfr_div(r20318, r20317, r20286, MPFR_RNDN);
        if (mpfr_get_si(r20285, MPFR_RNDN)) { mpfr_set(r20319, r20300, MPFR_RNDN); } else { mpfr_set(r20319, r20318, MPFR_RNDN); };
        return mpfr_get_d(r20319, MPFR_RNDN);
}

