#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 r20616 = x;
        float r20617 = 1;
        float r20618 = B;
        float r20619 = tan(r20618);
        float r20620 = r20617 / r20619;
        float r20621 = r20616 * r20620;
        float r20622 = -r20621;
        float r20623 = F;
        float r20624 = sin(r20618);
        float r20625 = r20623 / r20624;
        float r20626 = r20623 * r20623;
        float r20627 = 2;
        float r20628 = r20626 + r20627;
        float r20629 = r20627 * r20616;
        float r20630 = r20628 + r20629;
        float r20631 = r20617 / r20627;
        float r20632 = -r20631;
        float r20633 = pow(r20630, r20632);
        float r20634 = r20625 * r20633;
        float r20635 = r20622 + r20634;
        return r20635;
}

double f_id(double F, double B, double x) {
        double r20636 = x;
        double r20637 = 1;
        double r20638 = B;
        double r20639 = tan(r20638);
        double r20640 = r20637 / r20639;
        double r20641 = r20636 * r20640;
        double r20642 = -r20641;
        double r20643 = F;
        double r20644 = sin(r20638);
        double r20645 = r20643 / r20644;
        double r20646 = r20643 * r20643;
        double r20647 = 2;
        double r20648 = r20646 + r20647;
        double r20649 = r20647 * r20636;
        double r20650 = r20648 + r20649;
        double r20651 = r20637 / r20647;
        double r20652 = -r20651;
        double r20653 = pow(r20650, r20652);
        double r20654 = r20645 * r20653;
        double r20655 = r20642 + r20654;
        return r20655;
}


double f_of(float F, float B, float x) {
        float r20656 = x;
        float r20657 = -r20656;
        float r20658 = B;
        float r20659 = tan(r20658);
        float r20660 = r20657 / r20659;
        float r20661 = r20656 + r20656;
        float r20662 = 2;
        float r20663 = F;
        float r20664 = r20663 * r20663;
        float r20665 = r20662 + r20664;
        float r20666 = r20661 + r20665;
        float r20667 = 1;
        float r20668 = r20667 / r20662;
        float r20669 = -r20668;
        float r20670 = pow(r20666, r20669);
        float r20671 = r20670 * r20663;
        float r20672 = sin(r20658);
        float r20673 = r20667 / r20672;
        float r20674 = r20671 * r20673;
        float r20675 = r20660 + r20674;
        return r20675;
}

double f_od(double F, double B, double x) {
        double r20676 = x;
        double r20677 = -r20676;
        double r20678 = B;
        double r20679 = tan(r20678);
        double r20680 = r20677 / r20679;
        double r20681 = r20676 + r20676;
        double r20682 = 2;
        double r20683 = F;
        double r20684 = r20683 * r20683;
        double r20685 = r20682 + r20684;
        double r20686 = r20681 + r20685;
        double r20687 = 1;
        double r20688 = r20687 / r20682;
        double r20689 = -r20688;
        double r20690 = pow(r20686, r20689);
        double r20691 = r20690 * r20683;
        double r20692 = sin(r20678);
        double r20693 = r20687 / r20692;
        double r20694 = r20691 * r20693;
        double r20695 = r20680 + r20694;
        return r20695;
}

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 r20696, r20697, r20698, r20699, r20700, r20701, r20702, r20703, r20704, r20705, r20706, r20707, r20708, r20709, r20710, r20711, r20712, r20713, r20714, r20715;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r20696);
        mpfr_init_set_str(r20697, "1", 10, MPFR_RNDN);
        mpfr_init(r20698);
        mpfr_init(r20699);
        mpfr_init(r20700);
        mpfr_init(r20701);
        mpfr_init(r20702);
        mpfr_init(r20703);
        mpfr_init(r20704);
        mpfr_init(r20705);
        mpfr_init(r20706);
        mpfr_init_set_str(r20707, "2", 10, MPFR_RNDN);
        mpfr_init(r20708);
        mpfr_init(r20709);
        mpfr_init(r20710);
        mpfr_init(r20711);
        mpfr_init(r20712);
        mpfr_init(r20713);
        mpfr_init(r20714);
        mpfr_init(r20715);
}

double f_im(double F, double B, double x) {
        mpfr_set_d(r20696, x, MPFR_RNDN);
        ;
        mpfr_set_d(r20698, B, MPFR_RNDN);
        mpfr_tan(r20699, r20698, MPFR_RNDN);
        mpfr_div(r20700, r20697, r20699, MPFR_RNDN);
        mpfr_mul(r20701, r20696, r20700, MPFR_RNDN);
        mpfr_neg(r20702, r20701, MPFR_RNDN);
        mpfr_set_d(r20703, F, MPFR_RNDN);
        mpfr_sin(r20704, r20698, MPFR_RNDN);
        mpfr_div(r20705, r20703, r20704, MPFR_RNDN);
        mpfr_mul(r20706, r20703, r20703, MPFR_RNDN);
        ;
        mpfr_add(r20708, r20706, r20707, MPFR_RNDN);
        mpfr_mul(r20709, r20707, r20696, MPFR_RNDN);
        mpfr_add(r20710, r20708, r20709, MPFR_RNDN);
        mpfr_div(r20711, r20697, r20707, MPFR_RNDN);
        mpfr_neg(r20712, r20711, MPFR_RNDN);
        mpfr_pow(r20713, r20710, r20712, MPFR_RNDN);
        mpfr_mul(r20714, r20705, r20713, MPFR_RNDN);
        mpfr_add(r20715, r20702, r20714, MPFR_RNDN);
        return mpfr_get_d(r20715, MPFR_RNDN);
}

static mpfr_t r20716, r20717, r20718, r20719, r20720, r20721, r20722, r20723, r20724, r20725, r20726, r20727, r20728, r20729, r20730, r20731, r20732, r20733, r20734, r20735;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20716);
        mpfr_init(r20717);
        mpfr_init(r20718);
        mpfr_init(r20719);
        mpfr_init(r20720);
        mpfr_init(r20721);
        mpfr_init_set_str(r20722, "2", 10, MPFR_RNDN);
        mpfr_init(r20723);
        mpfr_init(r20724);
        mpfr_init(r20725);
        mpfr_init(r20726);
        mpfr_init_set_str(r20727, "1", 10, MPFR_RNDN);
        mpfr_init(r20728);
        mpfr_init(r20729);
        mpfr_init(r20730);
        mpfr_init(r20731);
        mpfr_init(r20732);
        mpfr_init(r20733);
        mpfr_init(r20734);
        mpfr_init(r20735);
}

double f_fm(double F, double B, double x) {
        mpfr_set_d(r20716, x, MPFR_RNDN);
        mpfr_neg(r20717, r20716, MPFR_RNDN);
        mpfr_set_d(r20718, B, MPFR_RNDN);
        mpfr_tan(r20719, r20718, MPFR_RNDN);
        mpfr_div(r20720, r20717, r20719, MPFR_RNDN);
        mpfr_add(r20721, r20716, r20716, MPFR_RNDN);
        ;
        mpfr_set_d(r20723, F, MPFR_RNDN);
        mpfr_mul(r20724, r20723, r20723, MPFR_RNDN);
        mpfr_add(r20725, r20722, r20724, MPFR_RNDN);
        mpfr_add(r20726, r20721, r20725, MPFR_RNDN);
        ;
        mpfr_div(r20728, r20727, r20722, MPFR_RNDN);
        mpfr_neg(r20729, r20728, MPFR_RNDN);
        mpfr_pow(r20730, r20726, r20729, MPFR_RNDN);
        mpfr_mul(r20731, r20730, r20723, MPFR_RNDN);
        mpfr_sin(r20732, r20718, MPFR_RNDN);
        mpfr_div(r20733, r20727, r20732, MPFR_RNDN);
        mpfr_mul(r20734, r20731, r20733, MPFR_RNDN);
        mpfr_add(r20735, r20720, r20734, MPFR_RNDN);
        return mpfr_get_d(r20735, MPFR_RNDN);
}

static mpfr_t r20736, r20737, r20738, r20739, r20740, r20741, r20742, r20743, r20744, r20745, r20746, r20747, r20748, r20749, r20750, r20751, r20752, r20753, r20754, r20755;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20736);
        mpfr_init(r20737);
        mpfr_init(r20738);
        mpfr_init(r20739);
        mpfr_init(r20740);
        mpfr_init(r20741);
        mpfr_init_set_str(r20742, "2", 10, MPFR_RNDN);
        mpfr_init(r20743);
        mpfr_init(r20744);
        mpfr_init(r20745);
        mpfr_init(r20746);
        mpfr_init_set_str(r20747, "1", 10, MPFR_RNDN);
        mpfr_init(r20748);
        mpfr_init(r20749);
        mpfr_init(r20750);
        mpfr_init(r20751);
        mpfr_init(r20752);
        mpfr_init(r20753);
        mpfr_init(r20754);
        mpfr_init(r20755);
}

double f_dm(double F, double B, double x) {
        mpfr_set_d(r20736, x, MPFR_RNDN);
        mpfr_neg(r20737, r20736, MPFR_RNDN);
        mpfr_set_d(r20738, B, MPFR_RNDN);
        mpfr_tan(r20739, r20738, MPFR_RNDN);
        mpfr_div(r20740, r20737, r20739, MPFR_RNDN);
        mpfr_add(r20741, r20736, r20736, MPFR_RNDN);
        ;
        mpfr_set_d(r20743, F, MPFR_RNDN);
        mpfr_mul(r20744, r20743, r20743, MPFR_RNDN);
        mpfr_add(r20745, r20742, r20744, MPFR_RNDN);
        mpfr_add(r20746, r20741, r20745, MPFR_RNDN);
        ;
        mpfr_div(r20748, r20747, r20742, MPFR_RNDN);
        mpfr_neg(r20749, r20748, MPFR_RNDN);
        mpfr_pow(r20750, r20746, r20749, MPFR_RNDN);
        mpfr_mul(r20751, r20750, r20743, MPFR_RNDN);
        mpfr_sin(r20752, r20738, MPFR_RNDN);
        mpfr_div(r20753, r20747, r20752, MPFR_RNDN);
        mpfr_mul(r20754, r20751, r20753, MPFR_RNDN);
        mpfr_add(r20755, r20740, r20754, MPFR_RNDN);
        return mpfr_get_d(r20755, MPFR_RNDN);
}