#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 r20800 = beta;
        float r20801 = alpha;
        float r20802 = r20800 - r20801;
        float r20803 = r20801 + r20800;
        float r20804 = 2.0f;
        float r20805 = r20803 + r20804;
        float r20806 = r20802 / r20805;
        float r20807 = 1.0f;
        float r20808 = r20806 + r20807;
        float r20809 = r20808 / r20804;
        return r20809;
}

double f_id(double alpha, double beta) {
        double r20810 = beta;
        double r20811 = alpha;
        double r20812 = r20810 - r20811;
        double r20813 = r20811 + r20810;
        double r20814 = 2.0;
        double r20815 = r20813 + r20814;
        double r20816 = r20812 / r20815;
        double r20817 = 1.0;
        double r20818 = r20816 + r20817;
        double r20819 = r20818 / r20814;
        return r20819;
}


double f_of(float alpha, float beta) {
        float r20820 = beta;
        float r20821 = alpha;
        float r20822 = r20820 - r20821;
        float r20823 = r20821 + r20820;
        float r20824 = 2.0f;
        float r20825 = r20823 + r20824;
        float r20826 = r20822 / r20825;
        float r20827 = -0.9905064891050389f;
        bool r20828 = r20826 <= r20827;
        float r20829 = r20820 / r20824;
        float r20830 = r20824 + r20821;
        float r20831 = r20830 + r20820;
        float r20832 = r20829 / r20831;
        float r20833 = 4.0f;
        float r20834 = r20833 / r20821;
        float r20835 = r20834 / r20821;
        float r20836 = r20835 / r20824;
        float r20837 = r20832 - r20836;
        float r20838 = 8.0f;
        float r20839 = r20838 / r20821;
        float r20840 = r20839 / r20821;
        float r20841 = r20824 + r20840;
        float r20842 = r20824 * r20821;
        float r20843 = r20841 / r20842;
        float r20844 = r20837 + r20843;
        float r20845 = r20820 / r20825;
        float r20846 = r20821 / r20825;
        float r20847 = 1.0f;
        float r20848 = r20846 - r20847;
        float r20849 = r20845 - r20848;
        float r20850 = log(r20849);
        float r20851 = exp(r20850);
        float r20852 = r20851 / r20824;
        float r20853 = r20828 ? r20844 : r20852;
        return r20853;
}

double f_od(double alpha, double beta) {
        double r20854 = beta;
        double r20855 = alpha;
        double r20856 = r20854 - r20855;
        double r20857 = r20855 + r20854;
        double r20858 = 2.0;
        double r20859 = r20857 + r20858;
        double r20860 = r20856 / r20859;
        double r20861 = -0.9905064891050389;
        bool r20862 = r20860 <= r20861;
        double r20863 = r20854 / r20858;
        double r20864 = r20858 + r20855;
        double r20865 = r20864 + r20854;
        double r20866 = r20863 / r20865;
        double r20867 = 4.0;
        double r20868 = r20867 / r20855;
        double r20869 = r20868 / r20855;
        double r20870 = r20869 / r20858;
        double r20871 = r20866 - r20870;
        double r20872 = 8.0;
        double r20873 = r20872 / r20855;
        double r20874 = r20873 / r20855;
        double r20875 = r20858 + r20874;
        double r20876 = r20858 * r20855;
        double r20877 = r20875 / r20876;
        double r20878 = r20871 + r20877;
        double r20879 = r20854 / r20859;
        double r20880 = r20855 / r20859;
        double r20881 = 1.0;
        double r20882 = r20880 - r20881;
        double r20883 = r20879 - r20882;
        double r20884 = log(r20883);
        double r20885 = exp(r20884);
        double r20886 = r20885 / r20858;
        double r20887 = r20862 ? r20878 : r20886;
        return r20887;
}

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 r20888, r20889, r20890, r20891, r20892, r20893, r20894, r20895, r20896, r20897;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20888);
        mpfr_init(r20889);
        mpfr_init(r20890);
        mpfr_init(r20891);
        mpfr_init_set_str(r20892, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20893);
        mpfr_init(r20894);
        mpfr_init_set_str(r20895, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20896);
        mpfr_init(r20897);
}

double f_im(double alpha, double beta) {
        mpfr_set_d(r20888, beta, MPFR_RNDN);
        mpfr_set_d(r20889, alpha, MPFR_RNDN);
        mpfr_sub(r20890, r20888, r20889, MPFR_RNDN);
        mpfr_add(r20891, r20889, r20888, MPFR_RNDN);
        ;
        mpfr_add(r20893, r20891, r20892, MPFR_RNDN);
        mpfr_div(r20894, r20890, r20893, MPFR_RNDN);
        ;
        mpfr_add(r20896, r20894, r20895, MPFR_RNDN);
        mpfr_div(r20897, r20896, r20892, MPFR_RNDN);
        return mpfr_get_d(r20897, MPFR_RNDN);
}

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

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20898);
        mpfr_init(r20899);
        mpfr_init(r20900);
        mpfr_init(r20901);
        mpfr_init_set_str(r20902, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20903);
        mpfr_init(r20904);
        mpfr_init_set_str(r20905, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20906);
        mpfr_init(r20907);
        mpfr_init(r20908);
        mpfr_init(r20909);
        mpfr_init(r20910);
        mpfr_init_set_str(r20911, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20912);
        mpfr_init(r20913);
        mpfr_init(r20914);
        mpfr_init(r20915);
        mpfr_init_set_str(r20916, "8.0", 10, MPFR_RNDN);
        mpfr_init(r20917);
        mpfr_init(r20918);
        mpfr_init(r20919);
        mpfr_init(r20920);
        mpfr_init(r20921);
        mpfr_init(r20922);
        mpfr_init(r20923);
        mpfr_init(r20924);
        mpfr_init_set_str(r20925, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20926);
        mpfr_init(r20927);
        mpfr_init(r20928);
        mpfr_init(r20929);
        mpfr_init(r20930);
        mpfr_init(r20931);
}

double f_fm(double alpha, double beta) {
        mpfr_set_d(r20898, beta, MPFR_RNDN);
        mpfr_set_d(r20899, alpha, MPFR_RNDN);
        mpfr_sub(r20900, r20898, r20899, MPFR_RNDN);
        mpfr_add(r20901, r20899, r20898, MPFR_RNDN);
        ;
        mpfr_add(r20903, r20901, r20902, MPFR_RNDN);
        mpfr_div(r20904, r20900, r20903, MPFR_RNDN);
        ;
        mpfr_set_si(r20906, mpfr_cmp(r20904, r20905) <= 0, MPFR_RNDN);
        mpfr_div(r20907, r20898, r20902, MPFR_RNDN);
        mpfr_add(r20908, r20902, r20899, MPFR_RNDN);
        mpfr_add(r20909, r20908, r20898, MPFR_RNDN);
        mpfr_div(r20910, r20907, r20909, MPFR_RNDN);
        ;
        mpfr_div(r20912, r20911, r20899, MPFR_RNDN);
        mpfr_div(r20913, r20912, r20899, MPFR_RNDN);
        mpfr_div(r20914, r20913, r20902, MPFR_RNDN);
        mpfr_sub(r20915, r20910, r20914, MPFR_RNDN);
        ;
        mpfr_div(r20917, r20916, r20899, MPFR_RNDN);
        mpfr_div(r20918, r20917, r20899, MPFR_RNDN);
        mpfr_add(r20919, r20902, r20918, MPFR_RNDN);
        mpfr_mul(r20920, r20902, r20899, MPFR_RNDN);
        mpfr_div(r20921, r20919, r20920, MPFR_RNDN);
        mpfr_add(r20922, r20915, r20921, MPFR_RNDN);
        mpfr_div(r20923, r20898, r20903, MPFR_RNDN);
        mpfr_div(r20924, r20899, r20903, MPFR_RNDN);
        ;
        mpfr_sub(r20926, r20924, r20925, MPFR_RNDN);
        mpfr_sub(r20927, r20923, r20926, MPFR_RNDN);
        mpfr_log(r20928, r20927, MPFR_RNDN);
        mpfr_exp(r20929, r20928, MPFR_RNDN);
        mpfr_div(r20930, r20929, r20902, MPFR_RNDN);
        if (mpfr_get_si(r20906, MPFR_RNDN)) { mpfr_set(r20931, r20922, MPFR_RNDN); } else { mpfr_set(r20931, r20930, MPFR_RNDN); };
        return mpfr_get_d(r20931, MPFR_RNDN);
}

static mpfr_t r20932, r20933, r20934, r20935, r20936, r20937, r20938, r20939, 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;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20932);
        mpfr_init(r20933);
        mpfr_init(r20934);
        mpfr_init(r20935);
        mpfr_init_set_str(r20936, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20937);
        mpfr_init(r20938);
        mpfr_init_set_str(r20939, "-0.9905064891050389", 10, MPFR_RNDN);
        mpfr_init(r20940);
        mpfr_init(r20941);
        mpfr_init(r20942);
        mpfr_init(r20943);
        mpfr_init(r20944);
        mpfr_init_set_str(r20945, "4.0", 10, MPFR_RNDN);
        mpfr_init(r20946);
        mpfr_init(r20947);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init_set_str(r20950, "8.0", 10, MPFR_RNDN);
        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_set_str(r20959, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20960);
        mpfr_init(r20961);
        mpfr_init(r20962);
        mpfr_init(r20963);
        mpfr_init(r20964);
        mpfr_init(r20965);
}

double f_dm(double alpha, double beta) {
        mpfr_set_d(r20932, beta, MPFR_RNDN);
        mpfr_set_d(r20933, alpha, MPFR_RNDN);
        mpfr_sub(r20934, r20932, r20933, MPFR_RNDN);
        mpfr_add(r20935, r20933, r20932, MPFR_RNDN);
        ;
        mpfr_add(r20937, r20935, r20936, MPFR_RNDN);
        mpfr_div(r20938, r20934, r20937, MPFR_RNDN);
        ;
        mpfr_set_si(r20940, mpfr_cmp(r20938, r20939) <= 0, MPFR_RNDN);
        mpfr_div(r20941, r20932, r20936, MPFR_RNDN);
        mpfr_add(r20942, r20936, r20933, MPFR_RNDN);
        mpfr_add(r20943, r20942, r20932, MPFR_RNDN);
        mpfr_div(r20944, r20941, r20943, MPFR_RNDN);
        ;
        mpfr_div(r20946, r20945, r20933, MPFR_RNDN);
        mpfr_div(r20947, r20946, r20933, MPFR_RNDN);
        mpfr_div(r20948, r20947, r20936, MPFR_RNDN);
        mpfr_sub(r20949, r20944, r20948, MPFR_RNDN);
        ;
        mpfr_div(r20951, r20950, r20933, MPFR_RNDN);
        mpfr_div(r20952, r20951, r20933, MPFR_RNDN);
        mpfr_add(r20953, r20936, r20952, MPFR_RNDN);
        mpfr_mul(r20954, r20936, r20933, MPFR_RNDN);
        mpfr_div(r20955, r20953, r20954, MPFR_RNDN);
        mpfr_add(r20956, r20949, r20955, MPFR_RNDN);
        mpfr_div(r20957, r20932, r20937, MPFR_RNDN);
        mpfr_div(r20958, r20933, r20937, MPFR_RNDN);
        ;
        mpfr_sub(r20960, r20958, r20959, MPFR_RNDN);
        mpfr_sub(r20961, r20957, r20960, MPFR_RNDN);
        mpfr_log(r20962, r20961, MPFR_RNDN);
        mpfr_exp(r20963, r20962, MPFR_RNDN);
        mpfr_div(r20964, r20963, r20936, MPFR_RNDN);
        if (mpfr_get_si(r20940, MPFR_RNDN)) { mpfr_set(r20965, r20956, MPFR_RNDN); } else { mpfr_set(r20965, r20964, MPFR_RNDN); };
        return mpfr_get_d(r20965, MPFR_RNDN);
}