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

char *name = "VandenBroeck and Keller, Equation (23)";

double f_if(float F, float B, float x) {
        float r20169 = x;
        float r20170 = 1.0f;
        float r20171 = B;
        float r20172 = tan(r20171);
        float r20173 = r20170 / r20172;
        float r20174 = r20169 * r20173;
        float r20175 = -r20174;
        float r20176 = F;
        float r20177 = sin(r20171);
        float r20178 = r20176 / r20177;
        float r20179 = r20176 * r20176;
        float r20180 = 2.0f;
        float r20181 = r20179 + r20180;
        float r20182 = r20180 * r20169;
        float r20183 = r20181 + r20182;
        float r20184 = r20170 / r20180;
        float r20185 = -r20184;
        float r20186 = pow(r20183, r20185);
        float r20187 = r20178 * r20186;
        float r20188 = r20175 + r20187;
        return r20188;
}

double f_id(double F, double B, double x) {
        double r20189 = x;
        double r20190 = 1.0;
        double r20191 = B;
        double r20192 = tan(r20191);
        double r20193 = r20190 / r20192;
        double r20194 = r20189 * r20193;
        double r20195 = -r20194;
        double r20196 = F;
        double r20197 = sin(r20191);
        double r20198 = r20196 / r20197;
        double r20199 = r20196 * r20196;
        double r20200 = 2.0;
        double r20201 = r20199 + r20200;
        double r20202 = r20200 * r20189;
        double r20203 = r20201 + r20202;
        double r20204 = r20190 / r20200;
        double r20205 = -r20204;
        double r20206 = pow(r20203, r20205);
        double r20207 = r20198 * r20206;
        double r20208 = r20195 + r20207;
        return r20208;
}


double f_of(float F, float B, float x) {
        float r20209 = x;
        float r20210 = -r20209;
        float r20211 = B;
        float r20212 = tan(r20211);
        float r20213 = r20210 / r20212;
        float r20214 = F;
        float r20215 = r20214 * r20214;
        float r20216 = 2.0f;
        float r20217 = r20216 + r20209;
        float r20218 = r20209 + r20217;
        float r20219 = r20215 + r20218;
        float r20220 = 1.0f;
        float r20221 = r20220 / r20216;
        float r20222 = -r20221;
        float r20223 = pow(r20219, r20222);
        float r20224 = sin(r20211);
        float r20225 = r20223 / r20224;
        float r20226 = r20214 * r20225;
        float r20227 = r20213 + r20226;
        return r20227;
}

double f_od(double F, double B, double x) {
        double r20228 = x;
        double r20229 = -r20228;
        double r20230 = B;
        double r20231 = tan(r20230);
        double r20232 = r20229 / r20231;
        double r20233 = F;
        double r20234 = r20233 * r20233;
        double r20235 = 2.0;
        double r20236 = r20235 + r20228;
        double r20237 = r20228 + r20236;
        double r20238 = r20234 + r20237;
        double r20239 = 1.0;
        double r20240 = r20239 / r20235;
        double r20241 = -r20240;
        double r20242 = pow(r20238, r20241);
        double r20243 = sin(r20230);
        double r20244 = r20242 / r20243;
        double r20245 = r20233 * r20244;
        double r20246 = r20232 + r20245;
        return r20246;
}

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 r20247, r20248, r20249, r20250, r20251, r20252, r20253, r20254, r20255, r20256, r20257, r20258, r20259, r20260, r20261, r20262, r20263, r20264, r20265, r20266;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(144);
        mpfr_init(r20247);
        mpfr_init_set_str(r20248, "1", 10, MPFR_RNDN);
        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_set_str(r20258, "2", 10, MPFR_RNDN);
        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_im(double F, double B, double x) {
        mpfr_set_d(r20247, x, MPFR_RNDN);
        ;
        mpfr_set_d(r20249, B, MPFR_RNDN);
        mpfr_tan(r20250, r20249, MPFR_RNDN);
        mpfr_div(r20251, r20248, r20250, MPFR_RNDN);
        mpfr_mul(r20252, r20247, r20251, MPFR_RNDN);
        mpfr_neg(r20253, r20252, MPFR_RNDN);
        mpfr_set_d(r20254, F, MPFR_RNDN);
        mpfr_sin(r20255, r20249, MPFR_RNDN);
        mpfr_div(r20256, r20254, r20255, MPFR_RNDN);
        mpfr_sqr(r20257, r20254, MPFR_RNDN);
        ;
        mpfr_add(r20259, r20257, r20258, MPFR_RNDN);
        mpfr_mul(r20260, r20258, r20247, MPFR_RNDN);
        mpfr_add(r20261, r20259, r20260, MPFR_RNDN);
        mpfr_div(r20262, r20248, r20258, MPFR_RNDN);
        mpfr_neg(r20263, r20262, MPFR_RNDN);
        mpfr_pow(r20264, r20261, r20263, MPFR_RNDN);
        mpfr_mul(r20265, r20256, r20264, MPFR_RNDN);
        mpfr_add(r20266, r20253, r20265, MPFR_RNDN);
        return mpfr_get_d(r20266, MPFR_RNDN);
}

static mpfr_t r20267, r20268, r20269, r20270, r20271, r20272, r20273, r20274, r20275, r20276, r20277, r20278, r20279, r20280, r20281, r20282, r20283, r20284, r20285;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(144);
        mpfr_init(r20267);
        mpfr_init(r20268);
        mpfr_init(r20269);
        mpfr_init(r20270);
        mpfr_init(r20271);
        mpfr_init(r20272);
        mpfr_init(r20273);
        mpfr_init_set_str(r20274, "2", 10, MPFR_RNDN);
        mpfr_init(r20275);
        mpfr_init(r20276);
        mpfr_init(r20277);
        mpfr_init_set_str(r20278, "1", 10, MPFR_RNDN);
        mpfr_init(r20279);
        mpfr_init(r20280);
        mpfr_init(r20281);
        mpfr_init(r20282);
        mpfr_init(r20283);
        mpfr_init(r20284);
        mpfr_init(r20285);
}

double f_fm(double F, double B, double x) {
        mpfr_set_d(r20267, x, MPFR_RNDN);
        mpfr_neg(r20268, r20267, MPFR_RNDN);
        mpfr_set_d(r20269, B, MPFR_RNDN);
        mpfr_tan(r20270, r20269, MPFR_RNDN);
        mpfr_div(r20271, r20268, r20270, MPFR_RNDN);
        mpfr_set_d(r20272, F, MPFR_RNDN);
        mpfr_sqr(r20273, r20272, MPFR_RNDN);
        ;
        mpfr_add(r20275, r20274, r20267, MPFR_RNDN);
        mpfr_add(r20276, r20267, r20275, MPFR_RNDN);
        mpfr_add(r20277, r20273, r20276, MPFR_RNDN);
        ;
        mpfr_div(r20279, r20278, r20274, MPFR_RNDN);
        mpfr_neg(r20280, r20279, MPFR_RNDN);
        mpfr_pow(r20281, r20277, r20280, MPFR_RNDN);
        mpfr_sin(r20282, r20269, MPFR_RNDN);
        mpfr_div(r20283, r20281, r20282, MPFR_RNDN);
        mpfr_mul(r20284, r20272, r20283, MPFR_RNDN);
        mpfr_add(r20285, r20271, r20284, MPFR_RNDN);
        return mpfr_get_d(r20285, MPFR_RNDN);
}

static mpfr_t r20286, r20287, r20288, r20289, r20290, r20291, r20292, r20293, r20294, r20295, r20296, r20297, r20298, r20299, r20300, r20301, r20302, r20303, r20304;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(144);
        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, "2", 10, MPFR_RNDN);
        mpfr_init(r20294);
        mpfr_init(r20295);
        mpfr_init(r20296);
        mpfr_init_set_str(r20297, "1", 10, MPFR_RNDN);
        mpfr_init(r20298);
        mpfr_init(r20299);
        mpfr_init(r20300);
        mpfr_init(r20301);
        mpfr_init(r20302);
        mpfr_init(r20303);
        mpfr_init(r20304);
}

double f_dm(double F, double B, double x) {
        mpfr_set_d(r20286, x, MPFR_RNDN);
        mpfr_neg(r20287, r20286, MPFR_RNDN);
        mpfr_set_d(r20288, B, MPFR_RNDN);
        mpfr_tan(r20289, r20288, MPFR_RNDN);
        mpfr_div(r20290, r20287, r20289, MPFR_RNDN);
        mpfr_set_d(r20291, F, MPFR_RNDN);
        mpfr_sqr(r20292, r20291, MPFR_RNDN);
        ;
        mpfr_add(r20294, r20293, r20286, MPFR_RNDN);
        mpfr_add(r20295, r20286, r20294, MPFR_RNDN);
        mpfr_add(r20296, r20292, r20295, MPFR_RNDN);
        ;
        mpfr_div(r20298, r20297, r20293, MPFR_RNDN);
        mpfr_neg(r20299, r20298, MPFR_RNDN);
        mpfr_pow(r20300, r20296, r20299, MPFR_RNDN);
        mpfr_sin(r20301, r20288, MPFR_RNDN);
        mpfr_div(r20302, r20300, r20301, MPFR_RNDN);
        mpfr_mul(r20303, r20291, r20302, MPFR_RNDN);
        mpfr_add(r20304, r20290, r20303, MPFR_RNDN);
        return mpfr_get_d(r20304, MPFR_RNDN);
}

