#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 r20095 = 1;
        float r20096 = eps;
        float r20097 = r20095 / r20096;
        float r20098 = r20095 + r20097;
        float r20099 = r20095 - r20096;
        float r20100 = x;
        float r20101 = r20099 * r20100;
        float r20102 = -r20101;
        float r20103 = exp(r20102);
        float r20104 = r20098 * r20103;
        float r20105 = r20097 - r20095;
        float r20106 = r20095 + r20096;
        float r20107 = r20106 * r20100;
        float r20108 = -r20107;
        float r20109 = exp(r20108);
        float r20110 = r20105 * r20109;
        float r20111 = r20104 - r20110;
        float r20112 = 2;
        float r20113 = r20111 / r20112;
        return r20113;
}

double f_id(double x, double eps) {
        double r20114 = 1;
        double r20115 = eps;
        double r20116 = r20114 / r20115;
        double r20117 = r20114 + r20116;
        double r20118 = r20114 - r20115;
        double r20119 = x;
        double r20120 = r20118 * r20119;
        double r20121 = -r20120;
        double r20122 = exp(r20121);
        double r20123 = r20117 * r20122;
        double r20124 = r20116 - r20114;
        double r20125 = r20114 + r20115;
        double r20126 = r20125 * r20119;
        double r20127 = -r20126;
        double r20128 = exp(r20127);
        double r20129 = r20124 * r20128;
        double r20130 = r20123 - r20129;
        double r20131 = 2;
        double r20132 = r20130 / r20131;
        return r20132;
}


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

double f_od(double x, double eps) {
        double r20173 = x;
        double r20174 = 74.29071833149575;
        bool r20175 = r20173 <= r20174;
        double r20176 = 2;
        double r20177 = 2/3;
        double r20178 = 3;
        double r20179 = pow(r20173, r20178);
        double r20180 = r20177 * r20179;
        double r20181 = cbrt(r20180);
        double r20182 = r20181 * r20181;
        double r20183 = cbrt(r20182);
        double r20184 = r20183 * r20183;
        double r20185 = r20184 * r20183;
        double r20186 = cbrt(r20181);
        double r20187 = r20186 * r20186;
        double r20188 = r20187 * r20186;
        double r20189 = r20185 * r20188;
        double r20190 = r20176 + r20189;
        double r20191 = pow(r20173, r20176);
        double r20192 = r20190 - r20191;
        double r20193 = r20192 / r20176;
        double r20194 = 1;
        double r20195 = eps;
        double r20196 = r20194 / r20195;
        double r20197 = r20194 + r20196;
        double r20198 = exp(1.0);
        double r20199 = r20194 - r20195;
        double r20200 = r20199 * r20173;
        double r20201 = -r20200;
        double r20202 = pow(r20198, r20201);
        double r20203 = r20197 * r20202;
        double r20204 = r20196 - r20194;
        double r20205 = r20194 + r20195;
        double r20206 = r20205 * r20173;
        double r20207 = -r20206;
        double r20208 = exp(r20207);
        double r20209 = r20204 * r20208;
        double r20210 = r20203 - r20209;
        double r20211 = r20210 / r20176;
        double r20212 = r20175 ? r20193 : r20211;
        return r20212;
}

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 r20213, r20214, r20215, r20216, r20217, r20218, r20219, r20220, r20221, r20222, r20223, r20224, r20225, r20226, r20227, r20228, r20229, r20230, r20231;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20213, "1", 10, MPFR_RNDN);
        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_set_str(r20230, "2", 10, MPFR_RNDN);
        mpfr_init(r20231);
}

double f_im(double x, double eps) {
        ;
        mpfr_set_d(r20214, eps, MPFR_RNDN);
        mpfr_div(r20215, r20213, r20214, MPFR_RNDN);
        mpfr_add(r20216, r20213, r20215, MPFR_RNDN);
        mpfr_sub(r20217, r20213, r20214, MPFR_RNDN);
        mpfr_set_d(r20218, x, MPFR_RNDN);
        mpfr_mul(r20219, r20217, r20218, MPFR_RNDN);
        mpfr_neg(r20220, r20219, MPFR_RNDN);
        mpfr_exp(r20221, r20220, MPFR_RNDN);
        mpfr_mul(r20222, r20216, r20221, MPFR_RNDN);
        mpfr_sub(r20223, r20215, r20213, MPFR_RNDN);
        mpfr_add(r20224, r20213, r20214, MPFR_RNDN);
        mpfr_mul(r20225, r20224, r20218, MPFR_RNDN);
        mpfr_neg(r20226, r20225, MPFR_RNDN);
        mpfr_exp(r20227, r20226, MPFR_RNDN);
        mpfr_mul(r20228, r20223, r20227, MPFR_RNDN);
        mpfr_sub(r20229, r20222, r20228, MPFR_RNDN);
        ;
        mpfr_div(r20231, r20229, r20230, MPFR_RNDN);
        return mpfr_get_d(r20231, MPFR_RNDN);
}

static mpfr_t 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, r20267, r20268, r20269, r20270, r20271;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20232);
        mpfr_init_set_str(r20233, "74.29071833149575", 10, MPFR_RNDN);
        mpfr_init(r20234);
        mpfr_init_set_str(r20235, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20236, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20237, "3", 10, MPFR_RNDN);
        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(r20246);
        mpfr_init(r20247);
        mpfr_init(r20248);
        mpfr_init(r20249);
        mpfr_init(r20250);
        mpfr_init(r20251);
        mpfr_init(r20252);
        mpfr_init_set_str(r20253, "1", 10, MPFR_RNDN);
        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);
        mpfr_init(r20267);
        mpfr_init(r20268);
        mpfr_init(r20269);
        mpfr_init(r20270);
        mpfr_init(r20271);
}

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

static mpfr_t r20272, r20273, r20274, r20275, r20276, r20277, r20278, r20279, r20280, r20281, r20282, 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;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20272);
        mpfr_init_set_str(r20273, "74.29071833149575", 10, MPFR_RNDN);
        mpfr_init(r20274);
        mpfr_init_set_str(r20275, "2", 10, MPFR_RNDN);
        mpfr_init_set_str(r20276, "2/3", 10, MPFR_RNDN);
        mpfr_init_set_str(r20277, "3", 10, MPFR_RNDN);
        mpfr_init(r20278);
        mpfr_init(r20279);
        mpfr_init(r20280);
        mpfr_init(r20281);
        mpfr_init(r20282);
        mpfr_init(r20283);
        mpfr_init(r20284);
        mpfr_init(r20285);
        mpfr_init(r20286);
        mpfr_init(r20287);
        mpfr_init(r20288);
        mpfr_init(r20289);
        mpfr_init(r20290);
        mpfr_init(r20291);
        mpfr_init(r20292);
        mpfr_init_set_str(r20293, "1", 10, MPFR_RNDN);
        mpfr_init(r20294);
        mpfr_init(r20295);
        mpfr_init(r20296);
        mpfr_init(r20297);
        mpfr_init(r20298);
        mpfr_init(r20299);
        mpfr_init(r20300);
        mpfr_init(r20301);
        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);
}

double f_dm(double x, double eps) {
        mpfr_set_d(r20272, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20274, mpfr_cmp(r20272, r20273) <= 0, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20278, r20272, r20277, MPFR_RNDN);
        mpfr_mul(r20279, r20276, r20278, MPFR_RNDN);
        mpfr_cbrt(r20280, r20279, MPFR_RNDN);
        mpfr_mul(r20281, r20280, r20280, MPFR_RNDN);
        mpfr_cbrt(r20282, r20281, MPFR_RNDN);
        mpfr_mul(r20283, r20282, r20282, MPFR_RNDN);
        mpfr_mul(r20284, r20283, r20282, MPFR_RNDN);
        mpfr_cbrt(r20285, r20280, MPFR_RNDN);
        mpfr_mul(r20286, r20285, r20285, MPFR_RNDN);
        mpfr_mul(r20287, r20286, r20285, MPFR_RNDN);
        mpfr_mul(r20288, r20284, r20287, MPFR_RNDN);
        mpfr_add(r20289, r20275, r20288, MPFR_RNDN);
        mpfr_pow(r20290, r20272, r20275, MPFR_RNDN);
        mpfr_sub(r20291, r20289, r20290, MPFR_RNDN);
        mpfr_div(r20292, r20291, r20275, MPFR_RNDN);
        ;
        mpfr_set_d(r20294, eps, MPFR_RNDN);
        mpfr_div(r20295, r20293, r20294, MPFR_RNDN);
        mpfr_add(r20296, r20293, r20295, MPFR_RNDN);
        mpfr_set_si(r20297, 1, MPFR_RNDN), mpfr_const_exp(r20297, r20297, MPFR_RNDN);
        mpfr_sub(r20298, r20293, r20294, MPFR_RNDN);
        mpfr_mul(r20299, r20298, r20272, MPFR_RNDN);
        mpfr_neg(r20300, r20299, MPFR_RNDN);
        mpfr_pow(r20301, r20297, r20300, MPFR_RNDN);
        mpfr_mul(r20302, r20296, r20301, MPFR_RNDN);
        mpfr_sub(r20303, r20295, r20293, MPFR_RNDN);
        mpfr_add(r20304, r20293, r20294, MPFR_RNDN);
        mpfr_mul(r20305, r20304, r20272, MPFR_RNDN);
        mpfr_neg(r20306, r20305, MPFR_RNDN);
        mpfr_exp(r20307, r20306, MPFR_RNDN);
        mpfr_mul(r20308, r20303, r20307, MPFR_RNDN);
        mpfr_sub(r20309, r20302, r20308, MPFR_RNDN);
        mpfr_div(r20310, r20309, r20275, MPFR_RNDN);
        if (mpfr_get_si(r20274, MPFR_RNDN)) { mpfr_set(r20311, r20292, MPFR_RNDN); } else { mpfr_set(r20311, r20310, MPFR_RNDN); };
        return mpfr_get_d(r20311, MPFR_RNDN);
}

