#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 r20816 = beta;
        float r20817 = alpha;
        float r20818 = r20816 - r20817;
        float r20819 = r20817 + r20816;
        float r20820 = 2.0f;
        float r20821 = r20819 + r20820;
        float r20822 = r20818 / r20821;
        float r20823 = 1.0f;
        float r20824 = r20822 + r20823;
        float r20825 = r20824 / r20820;
        return r20825;
}

double f_id(double alpha, double beta) {
        double r20826 = beta;
        double r20827 = alpha;
        double r20828 = r20826 - r20827;
        double r20829 = r20827 + r20826;
        double r20830 = 2.0;
        double r20831 = r20829 + r20830;
        double r20832 = r20828 / r20831;
        double r20833 = 1.0;
        double r20834 = r20832 + r20833;
        double r20835 = r20834 / r20830;
        return r20835;
}


double f_of(float alpha, float beta) {
        float r20836 = beta;
        float r20837 = alpha;
        float r20838 = r20836 - r20837;
        float r20839 = r20837 + r20836;
        float r20840 = 2.0f;
        float r20841 = r20839 + r20840;
        float r20842 = r20838 / r20841;
        float r20843 = -0.9905064891050389f;
        bool r20844 = r20842 <= r20843;
        float r20845 = r20836 / r20840;
        float r20846 = r20840 + r20837;
        float r20847 = r20846 + r20836;
        float r20848 = r20845 / r20847;
        float r20849 = 4.0f;
        float r20850 = r20849 / r20837;
        float r20851 = r20850 / r20837;
        float r20852 = r20851 / r20840;
        float r20853 = r20848 - r20852;
        float r20854 = 8.0f;
        float r20855 = r20854 / r20837;
        float r20856 = r20855 / r20837;
        float r20857 = r20840 + r20856;
        float r20858 = r20840 * r20837;
        float r20859 = r20857 / r20858;
        float r20860 = r20853 + r20859;
        float r20861 = r20836 / r20841;
        float r20862 = r20837 / r20841;
        float r20863 = 1.0f;
        float r20864 = r20862 - r20863;
        float r20865 = r20861 - r20864;
        float r20866 = log(r20865);
        float r20867 = exp(r20866);
        float r20868 = r20867 / r20840;
        float r20869 = r20844 ? r20860 : r20868;
        return r20869;
}

double f_od(double alpha, double beta) {
        double r20870 = beta;
        double r20871 = alpha;
        double r20872 = r20870 - r20871;
        double r20873 = r20871 + r20870;
        double r20874 = 2.0;
        double r20875 = r20873 + r20874;
        double r20876 = r20872 / r20875;
        double r20877 = -0.9905064891050389;
        bool r20878 = r20876 <= r20877;
        double r20879 = r20870 / r20874;
        double r20880 = r20874 + r20871;
        double r20881 = r20880 + r20870;
        double r20882 = r20879 / r20881;
        double r20883 = 4.0;
        double r20884 = r20883 / r20871;
        double r20885 = r20884 / r20871;
        double r20886 = r20885 / r20874;
        double r20887 = r20882 - r20886;
        double r20888 = 8.0;
        double r20889 = r20888 / r20871;
        double r20890 = r20889 / r20871;
        double r20891 = r20874 + r20890;
        double r20892 = r20874 * r20871;
        double r20893 = r20891 / r20892;
        double r20894 = r20887 + r20893;
        double r20895 = r20870 / r20875;
        double r20896 = r20871 / r20875;
        double r20897 = 1.0;
        double r20898 = r20896 - r20897;
        double r20899 = r20895 - r20898;
        double r20900 = log(r20899);
        double r20901 = exp(r20900);
        double r20902 = r20901 / r20874;
        double r20903 = r20878 ? r20894 : r20902;
        return r20903;
}

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 r20904, r20905, r20906, r20907, r20908, r20909, r20910, r20911, r20912, r20913;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20904);
        mpfr_init(r20905);
        mpfr_init(r20906);
        mpfr_init(r20907);
        mpfr_init_set_str(r20908, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20909);
        mpfr_init(r20910);
        mpfr_init_set_str(r20911, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20912);
        mpfr_init(r20913);
}

double f_im(double alpha, double beta) {
        mpfr_set_d(r20904, beta, MPFR_RNDN);
        mpfr_set_d(r20905, alpha, MPFR_RNDN);
        mpfr_sub(r20906, r20904, r20905, MPFR_RNDN);
        mpfr_add(r20907, r20905, r20904, MPFR_RNDN);
        ;
        mpfr_add(r20909, r20907, r20908, MPFR_RNDN);
        mpfr_div(r20910, r20906, r20909, MPFR_RNDN);
        ;
        mpfr_add(r20912, r20910, r20911, MPFR_RNDN);
        mpfr_div(r20913, r20912, r20908, MPFR_RNDN);
        return mpfr_get_d(r20913, MPFR_RNDN);
}

static mpfr_t 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, r20940, r20941, r20942, r20943, r20944, r20945, r20946, r20947;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20914);
        mpfr_init(r20915);
        mpfr_init(r20916);
        mpfr_init(r20917);
        mpfr_init_set_str(r20918, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20919);
        mpfr_init(r20920);
        mpfr_init_set_str(r20921, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20922);
        mpfr_init(r20923);
        mpfr_init(r20924);
        mpfr_init(r20925);
        mpfr_init(r20926);
        mpfr_init_set_str(r20927, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20928);
        mpfr_init(r20929);
        mpfr_init(r20930);
        mpfr_init(r20931);
        mpfr_init_set_str(r20932, "8.0", 10, MPFR_RNDN);
        mpfr_init(r20933);
        mpfr_init(r20934);
        mpfr_init(r20935);
        mpfr_init(r20936);
        mpfr_init(r20937);
        mpfr_init(r20938);
        mpfr_init(r20939);
        mpfr_init(r20940);
        mpfr_init_set_str(r20941, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20942);
        mpfr_init(r20943);
        mpfr_init(r20944);
        mpfr_init(r20945);
        mpfr_init(r20946);
        mpfr_init(r20947);
}

double f_fm(double alpha, double beta) {
        mpfr_set_d(r20914, beta, MPFR_RNDN);
        mpfr_set_d(r20915, alpha, MPFR_RNDN);
        mpfr_sub(r20916, r20914, r20915, MPFR_RNDN);
        mpfr_add(r20917, r20915, r20914, MPFR_RNDN);
        ;
        mpfr_add(r20919, r20917, r20918, MPFR_RNDN);
        mpfr_div(r20920, r20916, r20919, MPFR_RNDN);
        ;
        mpfr_set_si(r20922, mpfr_cmp(r20920, r20921) <= 0, MPFR_RNDN);
        mpfr_div(r20923, r20914, r20918, MPFR_RNDN);
        mpfr_add(r20924, r20918, r20915, MPFR_RNDN);
        mpfr_add(r20925, r20924, r20914, MPFR_RNDN);
        mpfr_div(r20926, r20923, r20925, MPFR_RNDN);
        ;
        mpfr_div(r20928, r20927, r20915, MPFR_RNDN);
        mpfr_div(r20929, r20928, r20915, MPFR_RNDN);
        mpfr_div(r20930, r20929, r20918, MPFR_RNDN);
        mpfr_sub(r20931, r20926, r20930, MPFR_RNDN);
        ;
        mpfr_div(r20933, r20932, r20915, MPFR_RNDN);
        mpfr_div(r20934, r20933, r20915, MPFR_RNDN);
        mpfr_add(r20935, r20918, r20934, MPFR_RNDN);
        mpfr_mul(r20936, r20918, r20915, MPFR_RNDN);
        mpfr_div(r20937, r20935, r20936, MPFR_RNDN);
        mpfr_add(r20938, r20931, r20937, MPFR_RNDN);
        mpfr_div(r20939, r20914, r20919, MPFR_RNDN);
        mpfr_div(r20940, r20915, r20919, MPFR_RNDN);
        ;
        mpfr_sub(r20942, r20940, r20941, MPFR_RNDN);
        mpfr_sub(r20943, r20939, r20942, MPFR_RNDN);
        mpfr_log(r20944, r20943, MPFR_RNDN);
        mpfr_exp(r20945, r20944, MPFR_RNDN);
        mpfr_div(r20946, r20945, r20918, MPFR_RNDN);
        if (mpfr_get_si(r20922, MPFR_RNDN)) { mpfr_set(r20947, r20938, MPFR_RNDN); } else { mpfr_set(r20947, r20946, MPFR_RNDN); };
        return mpfr_get_d(r20947, MPFR_RNDN);
}

static mpfr_t 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, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init(r20950);
        mpfr_init(r20951);
        mpfr_init_set_str(r20952, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20953);
        mpfr_init(r20954);
        mpfr_init_set_str(r20955, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init(r20958);
        mpfr_init(r20959);
        mpfr_init(r20960);
        mpfr_init_set_str(r20961, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20962);
        mpfr_init(r20963);
        mpfr_init(r20964);
        mpfr_init(r20965);
        mpfr_init_set_str(r20966, "8.0", 10, MPFR_RNDN);
        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_set_str(r20975, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20976);
        mpfr_init(r20977);
        mpfr_init(r20978);
        mpfr_init(r20979);
        mpfr_init(r20980);
        mpfr_init(r20981);
}

double f_dm(double alpha, double beta) {
        mpfr_set_d(r20948, beta, MPFR_RNDN);
        mpfr_set_d(r20949, alpha, MPFR_RNDN);
        mpfr_sub(r20950, r20948, r20949, MPFR_RNDN);
        mpfr_add(r20951, r20949, r20948, MPFR_RNDN);
        ;
        mpfr_add(r20953, r20951, r20952, MPFR_RNDN);
        mpfr_div(r20954, r20950, r20953, MPFR_RNDN);
        ;
        mpfr_set_si(r20956, mpfr_cmp(r20954, r20955) <= 0, MPFR_RNDN);
        mpfr_div(r20957, r20948, r20952, MPFR_RNDN);
        mpfr_add(r20958, r20952, r20949, MPFR_RNDN);
        mpfr_add(r20959, r20958, r20948, MPFR_RNDN);
        mpfr_div(r20960, r20957, r20959, MPFR_RNDN);
        ;
        mpfr_div(r20962, r20961, r20949, MPFR_RNDN);
        mpfr_div(r20963, r20962, r20949, MPFR_RNDN);
        mpfr_div(r20964, r20963, r20952, MPFR_RNDN);
        mpfr_sub(r20965, r20960, r20964, MPFR_RNDN);
        ;
        mpfr_div(r20967, r20966, r20949, MPFR_RNDN);
        mpfr_div(r20968, r20967, r20949, MPFR_RNDN);
        mpfr_add(r20969, r20952, r20968, MPFR_RNDN);
        mpfr_mul(r20970, r20952, r20949, MPFR_RNDN);
        mpfr_div(r20971, r20969, r20970, MPFR_RNDN);
        mpfr_add(r20972, r20965, r20971, MPFR_RNDN);
        mpfr_div(r20973, r20948, r20953, MPFR_RNDN);
        mpfr_div(r20974, r20949, r20953, MPFR_RNDN);
        ;
        mpfr_sub(r20976, r20974, r20975, MPFR_RNDN);
        mpfr_sub(r20977, r20973, r20976, MPFR_RNDN);
        mpfr_log(r20978, r20977, MPFR_RNDN);
        mpfr_exp(r20979, r20978, MPFR_RNDN);
        mpfr_div(r20980, r20979, r20952, MPFR_RNDN);
        if (mpfr_get_si(r20956, MPFR_RNDN)) { mpfr_set(r20981, r20972, MPFR_RNDN); } else { mpfr_set(r20981, r20980, MPFR_RNDN); };
        return mpfr_get_d(r20981, MPFR_RNDN);
}