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

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

double f_if(float F, float l) {
        float r20392 = atan2(1.0, 0.0);
        float r20393 = l;
        float r20394 = r20392 * r20393;
        float r20395 = 1;
        float r20396 = F;
        float r20397 = r20396 * r20396;
        float r20398 = r20395 / r20397;
        float r20399 = tan(r20394);
        float r20400 = r20398 * r20399;
        float r20401 = r20394 - r20400;
        return r20401;
}

double f_id(double F, double l) {
        double r20402 = atan2(1.0, 0.0);
        double r20403 = l;
        double r20404 = r20402 * r20403;
        double r20405 = 1;
        double r20406 = F;
        double r20407 = r20406 * r20406;
        double r20408 = r20405 / r20407;
        double r20409 = tan(r20404);
        double r20410 = r20408 * r20409;
        double r20411 = r20404 - r20410;
        return r20411;
}


double f_of(float F, float l) {
        float r20412 = atan2(1.0, 0.0);
        float r20413 = l;
        float r20414 = r20412 * r20413;
        float r20415 = -1.2391563621069606e+121;
        bool r20416 = r20414 <= r20415;
        float r20417 = F;
        float r20418 = r20412 / r20413;
        float r20419 = sin(r20418);
        float r20420 = cos(r20418);
        float r20421 = r20419 / r20420;
        float r20422 = r20417 * r20421;
        float r20423 = cbrt(r20422);
        float r20424 = cbrt(r20423);
        float r20425 = tan(r20414);
        float r20426 = r20425 / r20417;
        float r20427 = cbrt(r20426);
        float r20428 = r20427 * r20427;
        float r20429 = r20424 * r20428;
        float r20430 = cbrt(r20428);
        float r20431 = r20417 / r20430;
        float r20432 = r20429 / r20431;
        float r20433 = r20414 - r20432;
        float r20434 = 2.8029951490048387e+50;
        bool r20435 = r20414 <= r20434;
        float r20436 = r20413 * r20412;
        float r20437 = 1;
        float r20438 = r20437 / r20417;
        float r20439 = tan(r20436);
        float r20440 = r20439 / r20417;
        float r20441 = r20438 * r20440;
        float r20442 = r20436 - r20441;
        float r20443 = r20435 ? r20442 : r20433;
        float r20444 = r20416 ? r20433 : r20443;
        return r20444;
}

double f_od(double F, double l) {
        double r20445 = atan2(1.0, 0.0);
        double r20446 = l;
        double r20447 = r20445 * r20446;
        double r20448 = -1.2391563621069606e+121;
        bool r20449 = r20447 <= r20448;
        double r20450 = F;
        double r20451 = r20445 / r20446;
        double r20452 = sin(r20451);
        double r20453 = cos(r20451);
        double r20454 = r20452 / r20453;
        double r20455 = r20450 * r20454;
        double r20456 = cbrt(r20455);
        double r20457 = cbrt(r20456);
        double r20458 = tan(r20447);
        double r20459 = r20458 / r20450;
        double r20460 = cbrt(r20459);
        double r20461 = r20460 * r20460;
        double r20462 = r20457 * r20461;
        double r20463 = cbrt(r20461);
        double r20464 = r20450 / r20463;
        double r20465 = r20462 / r20464;
        double r20466 = r20447 - r20465;
        double r20467 = 2.8029951490048387e+50;
        bool r20468 = r20447 <= r20467;
        double r20469 = r20446 * r20445;
        double r20470 = 1;
        double r20471 = r20470 / r20450;
        double r20472 = tan(r20469);
        double r20473 = r20472 / r20450;
        double r20474 = r20471 * r20473;
        double r20475 = r20469 - r20474;
        double r20476 = r20468 ? r20475 : r20466;
        double r20477 = r20449 ? r20466 : r20476;
        return r20477;
}

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 r20478, r20479, r20480, r20481, r20482, r20483, r20484, r20485, r20486, r20487;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(4752);
        mpfr_init(r20478);
        mpfr_init(r20479);
        mpfr_init(r20480);
        mpfr_init_set_str(r20481, "1", 10, MPFR_RNDN);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init(r20485);
        mpfr_init(r20486);
        mpfr_init(r20487);
}

double f_im(double F, double l) {
        mpfr_const_pi(r20478, MPFR_RNDN);
        mpfr_set_d(r20479, l, MPFR_RNDN);
        mpfr_mul(r20480, r20478, r20479, MPFR_RNDN);
        ;
        mpfr_set_d(r20482, F, MPFR_RNDN);
        mpfr_mul(r20483, r20482, r20482, MPFR_RNDN);
        mpfr_div(r20484, r20481, r20483, MPFR_RNDN);
        mpfr_tan(r20485, r20480, MPFR_RNDN);
        mpfr_mul(r20486, r20484, r20485, MPFR_RNDN);
        mpfr_sub(r20487, r20480, r20486, MPFR_RNDN);
        return mpfr_get_d(r20487, MPFR_RNDN);
}

static mpfr_t r20488, r20489, r20490, r20491, r20492, r20493, r20494, r20495, r20496, r20497, r20498, r20499, r20500, r20501, r20502, r20503, r20504, r20505, r20506, r20507, r20508, r20509, r20510, r20511, r20512, r20513, r20514, r20515, r20516, r20517, r20518, r20519, r20520;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(4752);
        mpfr_init(r20488);
        mpfr_init(r20489);
        mpfr_init(r20490);
        mpfr_init_set_str(r20491, "-1.2391563621069606e+121", 10, MPFR_RNDN);
        mpfr_init(r20492);
        mpfr_init(r20493);
        mpfr_init(r20494);
        mpfr_init(r20495);
        mpfr_init(r20496);
        mpfr_init(r20497);
        mpfr_init(r20498);
        mpfr_init(r20499);
        mpfr_init(r20500);
        mpfr_init(r20501);
        mpfr_init(r20502);
        mpfr_init(r20503);
        mpfr_init(r20504);
        mpfr_init(r20505);
        mpfr_init(r20506);
        mpfr_init(r20507);
        mpfr_init(r20508);
        mpfr_init(r20509);
        mpfr_init_set_str(r20510, "2.8029951490048387e+50", 10, MPFR_RNDN);
        mpfr_init(r20511);
        mpfr_init(r20512);
        mpfr_init_set_str(r20513, "1", 10, MPFR_RNDN);
        mpfr_init(r20514);
        mpfr_init(r20515);
        mpfr_init(r20516);
        mpfr_init(r20517);
        mpfr_init(r20518);
        mpfr_init(r20519);
        mpfr_init(r20520);
}

double f_fm(double F, double l) {
        mpfr_const_pi(r20488, MPFR_RNDN);
        mpfr_set_d(r20489, l, MPFR_RNDN);
        mpfr_mul(r20490, r20488, r20489, MPFR_RNDN);
        ;
        mpfr_set_si(r20492, mpfr_cmp(r20490, r20491) <= 0, MPFR_RNDN);
        mpfr_set_d(r20493, F, MPFR_RNDN);
        mpfr_div(r20494, r20488, r20489, MPFR_RNDN);
        mpfr_sin(r20495, r20494, MPFR_RNDN);
        mpfr_cos(r20496, r20494, MPFR_RNDN);
        mpfr_div(r20497, r20495, r20496, MPFR_RNDN);
        mpfr_mul(r20498, r20493, r20497, MPFR_RNDN);
        mpfr_cbrt(r20499, r20498, MPFR_RNDN);
        mpfr_cbrt(r20500, r20499, MPFR_RNDN);
        mpfr_tan(r20501, r20490, MPFR_RNDN);
        mpfr_div(r20502, r20501, r20493, MPFR_RNDN);
        mpfr_cbrt(r20503, r20502, MPFR_RNDN);
        mpfr_mul(r20504, r20503, r20503, MPFR_RNDN);
        mpfr_mul(r20505, r20500, r20504, MPFR_RNDN);
        mpfr_cbrt(r20506, r20504, MPFR_RNDN);
        mpfr_div(r20507, r20493, r20506, MPFR_RNDN);
        mpfr_div(r20508, r20505, r20507, MPFR_RNDN);
        mpfr_sub(r20509, r20490, r20508, MPFR_RNDN);
        ;
        mpfr_set_si(r20511, mpfr_cmp(r20490, r20510) <= 0, MPFR_RNDN);
        mpfr_mul(r20512, r20489, r20488, MPFR_RNDN);
        ;
        mpfr_div(r20514, r20513, r20493, MPFR_RNDN);
        mpfr_tan(r20515, r20512, MPFR_RNDN);
        mpfr_div(r20516, r20515, r20493, MPFR_RNDN);
        mpfr_mul(r20517, r20514, r20516, MPFR_RNDN);
        mpfr_sub(r20518, r20512, r20517, MPFR_RNDN);
        if (mpfr_get_si(r20511, MPFR_RNDN)) { mpfr_set(r20519, r20518, MPFR_RNDN); } else { mpfr_set(r20519, r20509, MPFR_RNDN); };
        if (mpfr_get_si(r20492, MPFR_RNDN)) { mpfr_set(r20520, r20509, MPFR_RNDN); } else { mpfr_set(r20520, r20519, MPFR_RNDN); };
        return mpfr_get_d(r20520, MPFR_RNDN);
}

static mpfr_t r20521, r20522, r20523, r20524, r20525, r20526, r20527, r20528, r20529, r20530, r20531, r20532, r20533, r20534, r20535, r20536, r20537, r20538, r20539, r20540, r20541, r20542, r20543, r20544, r20545, r20546, r20547, r20548, r20549, r20550, r20551, r20552, r20553;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(4752);
        mpfr_init(r20521);
        mpfr_init(r20522);
        mpfr_init(r20523);
        mpfr_init_set_str(r20524, "-1.2391563621069606e+121", 10, MPFR_RNDN);
        mpfr_init(r20525);
        mpfr_init(r20526);
        mpfr_init(r20527);
        mpfr_init(r20528);
        mpfr_init(r20529);
        mpfr_init(r20530);
        mpfr_init(r20531);
        mpfr_init(r20532);
        mpfr_init(r20533);
        mpfr_init(r20534);
        mpfr_init(r20535);
        mpfr_init(r20536);
        mpfr_init(r20537);
        mpfr_init(r20538);
        mpfr_init(r20539);
        mpfr_init(r20540);
        mpfr_init(r20541);
        mpfr_init(r20542);
        mpfr_init_set_str(r20543, "2.8029951490048387e+50", 10, MPFR_RNDN);
        mpfr_init(r20544);
        mpfr_init(r20545);
        mpfr_init_set_str(r20546, "1", 10, MPFR_RNDN);
        mpfr_init(r20547);
        mpfr_init(r20548);
        mpfr_init(r20549);
        mpfr_init(r20550);
        mpfr_init(r20551);
        mpfr_init(r20552);
        mpfr_init(r20553);
}

double f_dm(double F, double l) {
        mpfr_const_pi(r20521, MPFR_RNDN);
        mpfr_set_d(r20522, l, MPFR_RNDN);
        mpfr_mul(r20523, r20521, r20522, MPFR_RNDN);
        ;
        mpfr_set_si(r20525, mpfr_cmp(r20523, r20524) <= 0, MPFR_RNDN);
        mpfr_set_d(r20526, F, MPFR_RNDN);
        mpfr_div(r20527, r20521, r20522, MPFR_RNDN);
        mpfr_sin(r20528, r20527, MPFR_RNDN);
        mpfr_cos(r20529, r20527, MPFR_RNDN);
        mpfr_div(r20530, r20528, r20529, MPFR_RNDN);
        mpfr_mul(r20531, r20526, r20530, MPFR_RNDN);
        mpfr_cbrt(r20532, r20531, MPFR_RNDN);
        mpfr_cbrt(r20533, r20532, MPFR_RNDN);
        mpfr_tan(r20534, r20523, MPFR_RNDN);
        mpfr_div(r20535, r20534, r20526, MPFR_RNDN);
        mpfr_cbrt(r20536, r20535, MPFR_RNDN);
        mpfr_mul(r20537, r20536, r20536, MPFR_RNDN);
        mpfr_mul(r20538, r20533, r20537, MPFR_RNDN);
        mpfr_cbrt(r20539, r20537, MPFR_RNDN);
        mpfr_div(r20540, r20526, r20539, MPFR_RNDN);
        mpfr_div(r20541, r20538, r20540, MPFR_RNDN);
        mpfr_sub(r20542, r20523, r20541, MPFR_RNDN);
        ;
        mpfr_set_si(r20544, mpfr_cmp(r20523, r20543) <= 0, MPFR_RNDN);
        mpfr_mul(r20545, r20522, r20521, MPFR_RNDN);
        ;
        mpfr_div(r20547, r20546, r20526, MPFR_RNDN);
        mpfr_tan(r20548, r20545, MPFR_RNDN);
        mpfr_div(r20549, r20548, r20526, MPFR_RNDN);
        mpfr_mul(r20550, r20547, r20549, MPFR_RNDN);
        mpfr_sub(r20551, r20545, r20550, MPFR_RNDN);
        if (mpfr_get_si(r20544, MPFR_RNDN)) { mpfr_set(r20552, r20551, MPFR_RNDN); } else { mpfr_set(r20552, r20542, MPFR_RNDN); };
        if (mpfr_get_si(r20525, MPFR_RNDN)) { mpfr_set(r20553, r20542, MPFR_RNDN); } else { mpfr_set(r20553, r20552, MPFR_RNDN); };
        return mpfr_get_d(r20553, MPFR_RNDN);
}