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

char *name = "Octave 3.8, jcobi/1";

double f_if(float alpha, float beta) {
        float r20808 = beta;
        float r20809 = alpha;
        float r20810 = r20808 - r20809;
        float r20811 = r20809 + r20808;
        float r20812 = 2.0f;
        float r20813 = r20811 + r20812;
        float r20814 = r20810 / r20813;
        float r20815 = 1.0f;
        float r20816 = r20814 + r20815;
        float r20817 = r20816 / r20812;
        return r20817;
}

double f_id(double alpha, double beta) {
        double r20818 = beta;
        double r20819 = alpha;
        double r20820 = r20818 - r20819;
        double r20821 = r20819 + r20818;
        double r20822 = 2.0;
        double r20823 = r20821 + r20822;
        double r20824 = r20820 / r20823;
        double r20825 = 1.0;
        double r20826 = r20824 + r20825;
        double r20827 = r20826 / r20822;
        return r20827;
}


double f_of(float alpha, float beta) {
        float r20828 = beta;
        float r20829 = alpha;
        float r20830 = r20828 - r20829;
        float r20831 = r20829 + r20828;
        float r20832 = 2.0f;
        float r20833 = r20831 + r20832;
        float r20834 = r20830 / r20833;
        float r20835 = -0.9905064891050389f;
        bool r20836 = r20834 <= r20835;
        float r20837 = r20828 / r20832;
        float r20838 = r20832 + r20829;
        float r20839 = r20838 + r20828;
        float r20840 = r20837 / r20839;
        float r20841 = 4.0f;
        float r20842 = r20841 / r20829;
        float r20843 = r20842 / r20829;
        float r20844 = r20843 / r20832;
        float r20845 = r20840 - r20844;
        float r20846 = 8.0f;
        float r20847 = r20846 / r20829;
        float r20848 = r20847 / r20829;
        float r20849 = r20832 + r20848;
        float r20850 = r20832 * r20829;
        float r20851 = r20849 / r20850;
        float r20852 = r20845 + r20851;
        float r20853 = r20828 / r20833;
        float r20854 = r20829 / r20833;
        float r20855 = 1.0f;
        float r20856 = r20854 - r20855;
        float r20857 = r20853 - r20856;
        float r20858 = log(r20857);
        float r20859 = exp(r20858);
        float r20860 = r20859 / r20832;
        float r20861 = r20836 ? r20852 : r20860;
        return r20861;
}

double f_od(double alpha, double beta) {
        double r20862 = beta;
        double r20863 = alpha;
        double r20864 = r20862 - r20863;
        double r20865 = r20863 + r20862;
        double r20866 = 2.0;
        double r20867 = r20865 + r20866;
        double r20868 = r20864 / r20867;
        double r20869 = -0.9905064891050389;
        bool r20870 = r20868 <= r20869;
        double r20871 = r20862 / r20866;
        double r20872 = r20866 + r20863;
        double r20873 = r20872 + r20862;
        double r20874 = r20871 / r20873;
        double r20875 = 4.0;
        double r20876 = r20875 / r20863;
        double r20877 = r20876 / r20863;
        double r20878 = r20877 / r20866;
        double r20879 = r20874 - r20878;
        double r20880 = 8.0;
        double r20881 = r20880 / r20863;
        double r20882 = r20881 / r20863;
        double r20883 = r20866 + r20882;
        double r20884 = r20866 * r20863;
        double r20885 = r20883 / r20884;
        double r20886 = r20879 + r20885;
        double r20887 = r20862 / r20867;
        double r20888 = r20863 / r20867;
        double r20889 = 1.0;
        double r20890 = r20888 - r20889;
        double r20891 = r20887 - r20890;
        double r20892 = log(r20891);
        double r20893 = exp(r20892);
        double r20894 = r20893 / r20866;
        double r20895 = r20870 ? r20886 : r20894;
        return r20895;
}

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 r20896, r20897, r20898, r20899, r20900, r20901, r20902, r20903, r20904, r20905;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20896);
        mpfr_init(r20897);
        mpfr_init(r20898);
        mpfr_init(r20899);
        mpfr_init_set_str(r20900, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20901);
        mpfr_init(r20902);
        mpfr_init_set_str(r20903, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20904);
        mpfr_init(r20905);
}

double f_im(double alpha, double beta) {
        mpfr_set_d(r20896, beta, MPFR_RNDN);
        mpfr_set_d(r20897, alpha, MPFR_RNDN);
        mpfr_sub(r20898, r20896, r20897, MPFR_RNDN);
        mpfr_add(r20899, r20897, r20896, MPFR_RNDN);
        ;
        mpfr_add(r20901, r20899, r20900, MPFR_RNDN);
        mpfr_div(r20902, r20898, r20901, MPFR_RNDN);
        ;
        mpfr_add(r20904, r20902, r20903, MPFR_RNDN);
        mpfr_div(r20905, r20904, r20900, MPFR_RNDN);
        return mpfr_get_d(r20905, MPFR_RNDN);
}

static mpfr_t r20906, r20907, r20908, r20909, r20910, r20911, r20912, r20913, r20914, r20915, r20916, r20917, r20918, r20919, r20920, r20921, r20922, r20923, r20924, r20925, r20926, r20927, r20928, r20929, r20930, r20931, r20932, r20933, r20934, r20935, r20936, r20937, r20938, r20939;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20906);
        mpfr_init(r20907);
        mpfr_init(r20908);
        mpfr_init(r20909);
        mpfr_init_set_str(r20910, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20911);
        mpfr_init(r20912);
        mpfr_init_set_str(r20913, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20914);
        mpfr_init(r20915);
        mpfr_init(r20916);
        mpfr_init(r20917);
        mpfr_init(r20918);
        mpfr_init_set_str(r20919, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20920);
        mpfr_init(r20921);
        mpfr_init(r20922);
        mpfr_init(r20923);
        mpfr_init_set_str(r20924, "8.0", 10, MPFR_RNDN);
        mpfr_init(r20925);
        mpfr_init(r20926);
        mpfr_init(r20927);
        mpfr_init(r20928);
        mpfr_init(r20929);
        mpfr_init(r20930);
        mpfr_init(r20931);
        mpfr_init(r20932);
        mpfr_init_set_str(r20933, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20934);
        mpfr_init(r20935);
        mpfr_init(r20936);
        mpfr_init(r20937);
        mpfr_init(r20938);
        mpfr_init(r20939);
}

double f_fm(double alpha, double beta) {
        mpfr_set_d(r20906, beta, MPFR_RNDN);
        mpfr_set_d(r20907, alpha, MPFR_RNDN);
        mpfr_sub(r20908, r20906, r20907, MPFR_RNDN);
        mpfr_add(r20909, r20907, r20906, MPFR_RNDN);
        ;
        mpfr_add(r20911, r20909, r20910, MPFR_RNDN);
        mpfr_div(r20912, r20908, r20911, MPFR_RNDN);
        ;
        mpfr_set_si(r20914, mpfr_cmp(r20912, r20913) <= 0, MPFR_RNDN);
        mpfr_div(r20915, r20906, r20910, MPFR_RNDN);
        mpfr_add(r20916, r20910, r20907, MPFR_RNDN);
        mpfr_add(r20917, r20916, r20906, MPFR_RNDN);
        mpfr_div(r20918, r20915, r20917, MPFR_RNDN);
        ;
        mpfr_div(r20920, r20919, r20907, MPFR_RNDN);
        mpfr_div(r20921, r20920, r20907, MPFR_RNDN);
        mpfr_div(r20922, r20921, r20910, MPFR_RNDN);
        mpfr_sub(r20923, r20918, r20922, MPFR_RNDN);
        ;
        mpfr_div(r20925, r20924, r20907, MPFR_RNDN);
        mpfr_div(r20926, r20925, r20907, MPFR_RNDN);
        mpfr_add(r20927, r20910, r20926, MPFR_RNDN);
        mpfr_mul(r20928, r20910, r20907, MPFR_RNDN);
        mpfr_div(r20929, r20927, r20928, MPFR_RNDN);
        mpfr_add(r20930, r20923, r20929, MPFR_RNDN);
        mpfr_div(r20931, r20906, r20911, MPFR_RNDN);
        mpfr_div(r20932, r20907, r20911, MPFR_RNDN);
        ;
        mpfr_sub(r20934, r20932, r20933, MPFR_RNDN);
        mpfr_sub(r20935, r20931, r20934, MPFR_RNDN);
        mpfr_log(r20936, r20935, MPFR_RNDN);
        mpfr_exp(r20937, r20936, MPFR_RNDN);
        mpfr_div(r20938, r20937, r20910, MPFR_RNDN);
        if (mpfr_get_si(r20914, MPFR_RNDN)) { mpfr_set(r20939, r20930, MPFR_RNDN); } else { mpfr_set(r20939, r20938, MPFR_RNDN); };
        return mpfr_get_d(r20939, MPFR_RNDN);
}

static mpfr_t r20940, r20941, r20942, r20943, r20944, r20945, r20946, r20947, r20948, r20949, r20950, r20951, r20952, r20953, r20954, r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962, r20963, r20964, r20965, r20966, r20967, r20968, r20969, r20970, r20971, r20972, r20973;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20940);
        mpfr_init(r20941);
        mpfr_init(r20942);
        mpfr_init(r20943);
        mpfr_init_set_str(r20944, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20945);
        mpfr_init(r20946);
        mpfr_init_set_str(r20947, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init(r20950);
        mpfr_init(r20951);
        mpfr_init(r20952);
        mpfr_init_set_str(r20953, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20954);
        mpfr_init(r20955);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init_set_str(r20958, "8.0", 10, MPFR_RNDN);
        mpfr_init(r20959);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
        mpfr_init(r20963);
        mpfr_init(r20964);
        mpfr_init(r20965);
        mpfr_init(r20966);
        mpfr_init_set_str(r20967, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20968);
        mpfr_init(r20969);
        mpfr_init(r20970);
        mpfr_init(r20971);
        mpfr_init(r20972);
        mpfr_init(r20973);
}

double f_dm(double alpha, double beta) {
        mpfr_set_d(r20940, beta, MPFR_RNDN);
        mpfr_set_d(r20941, alpha, MPFR_RNDN);
        mpfr_sub(r20942, r20940, r20941, MPFR_RNDN);
        mpfr_add(r20943, r20941, r20940, MPFR_RNDN);
        ;
        mpfr_add(r20945, r20943, r20944, MPFR_RNDN);
        mpfr_div(r20946, r20942, r20945, MPFR_RNDN);
        ;
        mpfr_set_si(r20948, mpfr_cmp(r20946, r20947) <= 0, MPFR_RNDN);
        mpfr_div(r20949, r20940, r20944, MPFR_RNDN);
        mpfr_add(r20950, r20944, r20941, MPFR_RNDN);
        mpfr_add(r20951, r20950, r20940, MPFR_RNDN);
        mpfr_div(r20952, r20949, r20951, MPFR_RNDN);
        ;
        mpfr_div(r20954, r20953, r20941, MPFR_RNDN);
        mpfr_div(r20955, r20954, r20941, MPFR_RNDN);
        mpfr_div(r20956, r20955, r20944, MPFR_RNDN);
        mpfr_sub(r20957, r20952, r20956, MPFR_RNDN);
        ;
        mpfr_div(r20959, r20958, r20941, MPFR_RNDN);
        mpfr_div(r20960, r20959, r20941, MPFR_RNDN);
        mpfr_add(r20961, r20944, r20960, MPFR_RNDN);
        mpfr_mul(r20962, r20944, r20941, MPFR_RNDN);
        mpfr_div(r20963, r20961, r20962, MPFR_RNDN);
        mpfr_add(r20964, r20957, r20963, MPFR_RNDN);
        mpfr_div(r20965, r20940, r20945, MPFR_RNDN);
        mpfr_div(r20966, r20941, r20945, MPFR_RNDN);
        ;
        mpfr_sub(r20968, r20966, r20967, MPFR_RNDN);
        mpfr_sub(r20969, r20965, r20968, MPFR_RNDN);
        mpfr_log(r20970, r20969, MPFR_RNDN);
        mpfr_exp(r20971, r20970, MPFR_RNDN);
        mpfr_div(r20972, r20971, r20944, MPFR_RNDN);
        if (mpfr_get_si(r20948, MPFR_RNDN)) { mpfr_set(r20973, r20964, MPFR_RNDN); } else { mpfr_set(r20973, r20972, MPFR_RNDN); };
        return mpfr_get_d(r20973, MPFR_RNDN);
}