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

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

double f_if(float f) {
        float r20851 = 1;
        float r20852 = atan2(1.0, 0.0);
        float r20853 = 4;
        float r20854 = r20852 / r20853;
        float r20855 = r20851 / r20854;
        float r20856 = f;
        float r20857 = r20854 * r20856;
        float r20858 = exp(r20857);
        float r20859 = -r20857;
        float r20860 = exp(r20859);
        float r20861 = r20858 + r20860;
        float r20862 = r20858 - r20860;
        float r20863 = r20861 / r20862;
        float r20864 = log(r20863);
        float r20865 = r20855 * r20864;
        float r20866 = -r20865;
        return r20866;
}

double f_id(double f) {
        double r20867 = 1;
        double r20868 = atan2(1.0, 0.0);
        double r20869 = 4;
        double r20870 = r20868 / r20869;
        double r20871 = r20867 / r20870;
        double r20872 = f;
        double r20873 = r20870 * r20872;
        double r20874 = exp(r20873);
        double r20875 = -r20873;
        double r20876 = exp(r20875);
        double r20877 = r20874 + r20876;
        double r20878 = r20874 - r20876;
        double r20879 = r20877 / r20878;
        double r20880 = log(r20879);
        double r20881 = r20871 * r20880;
        double r20882 = -r20881;
        return r20882;
}


double f_of(float f) {
        float r20883 = 4;
        float r20884 = atan2(1.0, 0.0);
        float r20885 = r20883 / r20884;
        float r20886 = sqrt(r20885);
        float r20887 = -r20886;
        float r20888 = f;
        float r20889 = -r20888;
        float r20890 = r20889 / r20885;
        float r20891 = exp(r20890);
        float r20892 = r20884 / r20883;
        float r20893 = r20892 * r20888;
        float r20894 = exp(r20893);
        float r20895 = r20891 + r20894;
        float r20896 = r20888 * r20888;
        float r20897 = 1/192;
        float r20898 = r20888 * r20897;
        float r20899 = r20896 * r20898;
        float r20900 = r20884 * r20884;
        float r20901 = 1/2;
        float r20902 = r20888 * r20901;
        float r20903 = fma(r20899, r20900, r20902);
        float r20904 = 1/61440;
        float r20905 = 5;
        float r20906 = pow(r20884, r20905);
        float r20907 = pow(r20888, r20905);
        float r20908 = r20906 * r20907;
        float r20909 = r20904 * r20908;
        float r20910 = fma(r20884, r20903, r20909);
        float r20911 = r20895 / r20910;
        float r20912 = log(r20911);
        float r20913 = r20886 * r20912;
        float r20914 = r20887 * r20913;
        return r20914;
}

double f_od(double f) {
        double r20915 = 4;
        double r20916 = atan2(1.0, 0.0);
        double r20917 = r20915 / r20916;
        double r20918 = sqrt(r20917);
        double r20919 = -r20918;
        double r20920 = f;
        double r20921 = -r20920;
        double r20922 = r20921 / r20917;
        double r20923 = exp(r20922);
        double r20924 = r20916 / r20915;
        double r20925 = r20924 * r20920;
        double r20926 = exp(r20925);
        double r20927 = r20923 + r20926;
        double r20928 = r20920 * r20920;
        double r20929 = 1/192;
        double r20930 = r20920 * r20929;
        double r20931 = r20928 * r20930;
        double r20932 = r20916 * r20916;
        double r20933 = 1/2;
        double r20934 = r20920 * r20933;
        double r20935 = fma(r20931, r20932, r20934);
        double r20936 = 1/61440;
        double r20937 = 5;
        double r20938 = pow(r20916, r20937);
        double r20939 = pow(r20920, r20937);
        double r20940 = r20938 * r20939;
        double r20941 = r20936 * r20940;
        double r20942 = fma(r20916, r20935, r20941);
        double r20943 = r20927 / r20942;
        double r20944 = log(r20943);
        double r20945 = r20918 * r20944;
        double r20946 = r20919 * r20945;
        return r20946;
}

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 r20947, r20948, r20949, r20950, r20951, r20952, r20953, r20954, r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20947, "1", 10, MPFR_RNDN);
        mpfr_init(r20948);
        mpfr_init_set_str(r20949, "4", 10, MPFR_RNDN);
        mpfr_init(r20950);
        mpfr_init(r20951);
        mpfr_init(r20952);
        mpfr_init(r20953);
        mpfr_init(r20954);
        mpfr_init(r20955);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init(r20958);
        mpfr_init(r20959);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
}

double f_im(double f) {
        ;
        mpfr_const_pi(r20948, MPFR_RNDN);
        ;
        mpfr_div(r20950, r20948, r20949, MPFR_RNDN);
        mpfr_div(r20951, r20947, r20950, MPFR_RNDN);
        mpfr_set_d(r20952, f, MPFR_RNDN);
        mpfr_mul(r20953, r20950, r20952, MPFR_RNDN);
        mpfr_exp(r20954, r20953, MPFR_RNDN);
        mpfr_neg(r20955, r20953, MPFR_RNDN);
        mpfr_exp(r20956, r20955, MPFR_RNDN);
        mpfr_add(r20957, r20954, r20956, MPFR_RNDN);
        mpfr_sub(r20958, r20954, r20956, MPFR_RNDN);
        mpfr_div(r20959, r20957, r20958, MPFR_RNDN);
        mpfr_log(r20960, r20959, MPFR_RNDN);
        mpfr_mul(r20961, r20951, r20960, MPFR_RNDN);
        mpfr_neg(r20962, r20961, MPFR_RNDN);
        return mpfr_get_d(r20962, MPFR_RNDN);
}

static mpfr_t r20963, r20964, r20965, r20966, r20967, r20968, r20969, r20970, r20971, r20972, r20973, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981, r20982, r20983, r20984, r20985, r20986, r20987, r20988, r20989, r20990, r20991, r20992, r20993, r20994;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20963, "4", 10, MPFR_RNDN);
        mpfr_init(r20964);
        mpfr_init(r20965);
        mpfr_init(r20966);
        mpfr_init(r20967);
        mpfr_init(r20968);
        mpfr_init(r20969);
        mpfr_init(r20970);
        mpfr_init(r20971);
        mpfr_init(r20972);
        mpfr_init(r20973);
        mpfr_init(r20974);
        mpfr_init(r20975);
        mpfr_init(r20976);
        mpfr_init_set_str(r20977, "1/192", 10, MPFR_RNDN);
        mpfr_init(r20978);
        mpfr_init(r20979);
        mpfr_init(r20980);
        mpfr_init_set_str(r20981, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20982);
        mpfr_init(r20983);
        mpfr_init_set_str(r20984, "1/61440", 10, MPFR_RNDN);
        mpfr_init_set_str(r20985, "5", 10, MPFR_RNDN);
        mpfr_init(r20986);
        mpfr_init(r20987);
        mpfr_init(r20988);
        mpfr_init(r20989);
        mpfr_init(r20990);
        mpfr_init(r20991);
        mpfr_init(r20992);
        mpfr_init(r20993);
        mpfr_init(r20994);
}

double f_fm(double f) {
        ;
        mpfr_const_pi(r20964, MPFR_RNDN);
        mpfr_div(r20965, r20963, r20964, MPFR_RNDN);
        mpfr_sqrt(r20966, r20965, MPFR_RNDN);
        mpfr_neg(r20967, r20966, MPFR_RNDN);
        mpfr_set_d(r20968, f, MPFR_RNDN);
        mpfr_neg(r20969, r20968, MPFR_RNDN);
        mpfr_div(r20970, r20969, r20965, MPFR_RNDN);
        mpfr_exp(r20971, r20970, MPFR_RNDN);
        mpfr_div(r20972, r20964, r20963, MPFR_RNDN);
        mpfr_mul(r20973, r20972, r20968, MPFR_RNDN);
        mpfr_exp(r20974, r20973, MPFR_RNDN);
        mpfr_add(r20975, r20971, r20974, MPFR_RNDN);
        mpfr_mul(r20976, r20968, r20968, MPFR_RNDN);
        ;
        mpfr_mul(r20978, r20968, r20977, MPFR_RNDN);
        mpfr_mul(r20979, r20976, r20978, MPFR_RNDN);
        mpfr_mul(r20980, r20964, r20964, MPFR_RNDN);
        ;
        mpfr_mul(r20982, r20968, r20981, MPFR_RNDN);
        mpfr_fma(r20983, r20979, r20980, r20982, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20986, r20964, r20985, MPFR_RNDN);
        mpfr_pow(r20987, r20968, r20985, MPFR_RNDN);
        mpfr_mul(r20988, r20986, r20987, MPFR_RNDN);
        mpfr_mul(r20989, r20984, r20988, MPFR_RNDN);
        mpfr_fma(r20990, r20964, r20983, r20989, MPFR_RNDN);
        mpfr_div(r20991, r20975, r20990, MPFR_RNDN);
        mpfr_log(r20992, r20991, MPFR_RNDN);
        mpfr_mul(r20993, r20966, r20992, MPFR_RNDN);
        mpfr_mul(r20994, r20967, r20993, MPFR_RNDN);
        return mpfr_get_d(r20994, MPFR_RNDN);
}

static mpfr_t r20995, r20996, r20997, r20998, r20999, r21000, r21001, r21002, r21003, r21004, r21005, r21006, r21007, r21008, r21009, r21010, r21011, r21012, r21013, r21014, r21015, r21016, r21017, r21018, r21019, r21020, r21021, r21022, r21023, r21024, r21025, r21026;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init_set_str(r20995, "4", 10, MPFR_RNDN);
        mpfr_init(r20996);
        mpfr_init(r20997);
        mpfr_init(r20998);
        mpfr_init(r20999);
        mpfr_init(r21000);
        mpfr_init(r21001);
        mpfr_init(r21002);
        mpfr_init(r21003);
        mpfr_init(r21004);
        mpfr_init(r21005);
        mpfr_init(r21006);
        mpfr_init(r21007);
        mpfr_init(r21008);
        mpfr_init_set_str(r21009, "1/192", 10, MPFR_RNDN);
        mpfr_init(r21010);
        mpfr_init(r21011);
        mpfr_init(r21012);
        mpfr_init_set_str(r21013, "1/2", 10, MPFR_RNDN);
        mpfr_init(r21014);
        mpfr_init(r21015);
        mpfr_init_set_str(r21016, "1/61440", 10, MPFR_RNDN);
        mpfr_init_set_str(r21017, "5", 10, MPFR_RNDN);
        mpfr_init(r21018);
        mpfr_init(r21019);
        mpfr_init(r21020);
        mpfr_init(r21021);
        mpfr_init(r21022);
        mpfr_init(r21023);
        mpfr_init(r21024);
        mpfr_init(r21025);
        mpfr_init(r21026);
}

double f_dm(double f) {
        ;
        mpfr_const_pi(r20996, MPFR_RNDN);
        mpfr_div(r20997, r20995, r20996, MPFR_RNDN);
        mpfr_sqrt(r20998, r20997, MPFR_RNDN);
        mpfr_neg(r20999, r20998, MPFR_RNDN);
        mpfr_set_d(r21000, f, MPFR_RNDN);
        mpfr_neg(r21001, r21000, MPFR_RNDN);
        mpfr_div(r21002, r21001, r20997, MPFR_RNDN);
        mpfr_exp(r21003, r21002, MPFR_RNDN);
        mpfr_div(r21004, r20996, r20995, MPFR_RNDN);
        mpfr_mul(r21005, r21004, r21000, MPFR_RNDN);
        mpfr_exp(r21006, r21005, MPFR_RNDN);
        mpfr_add(r21007, r21003, r21006, MPFR_RNDN);
        mpfr_mul(r21008, r21000, r21000, MPFR_RNDN);
        ;
        mpfr_mul(r21010, r21000, r21009, MPFR_RNDN);
        mpfr_mul(r21011, r21008, r21010, MPFR_RNDN);
        mpfr_mul(r21012, r20996, r20996, MPFR_RNDN);
        ;
        mpfr_mul(r21014, r21000, r21013, MPFR_RNDN);
        mpfr_fma(r21015, r21011, r21012, r21014, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r21018, r20996, r21017, MPFR_RNDN);
        mpfr_pow(r21019, r21000, r21017, MPFR_RNDN);
        mpfr_mul(r21020, r21018, r21019, MPFR_RNDN);
        mpfr_mul(r21021, r21016, r21020, MPFR_RNDN);
        mpfr_fma(r21022, r20996, r21015, r21021, MPFR_RNDN);
        mpfr_div(r21023, r21007, r21022, MPFR_RNDN);
        mpfr_log(r21024, r21023, MPFR_RNDN);
        mpfr_mul(r21025, r20998, r21024, MPFR_RNDN);
        mpfr_mul(r21026, r20999, r21025, MPFR_RNDN);
        return mpfr_get_d(r21026, MPFR_RNDN);
}