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

char *name = "Octave 3.8, jcobi/4, as called";

double f_if(float i) {
        float r20158 = i;
        float r20159 = r20158 * r20158;
        float r20160 = r20159 * r20159;
        float r20161 = 2.0f;
        float r20162 = r20161 * r20158;
        float r20163 = r20162 * r20162;
        float r20164 = r20160 / r20163;
        float r20165 = 1.0f;
        float r20166 = r20163 - r20165;
        float r20167 = r20164 / r20166;
        return r20167;
}

double f_id(double i) {
        double r20168 = i;
        double r20169 = r20168 * r20168;
        double r20170 = r20169 * r20169;
        double r20171 = 2.0;
        double r20172 = r20171 * r20168;
        double r20173 = r20172 * r20172;
        double r20174 = r20170 / r20173;
        double r20175 = 1.0;
        double r20176 = r20173 - r20175;
        double r20177 = r20174 / r20176;
        return r20177;
}


double f_of(float i) {
        float r20178 = i;
        float r20179 = 14343.200142683158f;
        bool r20180 = r20178 <= r20179;
        float r20181 = 2.0f;
        float r20182 = r20178 / r20181;
        float r20183 = r20182 * r20182;
        float r20184 = r20178 + r20178;
        float r20185 = r20184 * r20184;
        float r20186 = 1.0f;
        float r20187 = r20185 - r20186;
        float r20188 = r20183 / r20187;
        float r20189 = 0.015625f;
        float r20190 = r20178 * r20178;
        float r20191 = r20189 / r20190;
        float r20192 = 0.0625f;
        float r20193 = 0.00390625f;
        float r20194 = 4.0f;
        float r20195 = pow(r20178, r20194);
        float r20196 = r20193 / r20195;
        float r20197 = r20192 + r20196;
        float r20198 = r20191 + r20197;
        float r20199 = r20180 ? r20188 : r20198;
        return r20199;
}

double f_od(double i) {
        double r20200 = i;
        double r20201 = 14343.200142683158;
        bool r20202 = r20200 <= r20201;
        double r20203 = 2.0;
        double r20204 = r20200 / r20203;
        double r20205 = r20204 * r20204;
        double r20206 = r20200 + r20200;
        double r20207 = r20206 * r20206;
        double r20208 = 1.0;
        double r20209 = r20207 - r20208;
        double r20210 = r20205 / r20209;
        double r20211 = 0.015625;
        double r20212 = r20200 * r20200;
        double r20213 = r20211 / r20212;
        double r20214 = 0.0625;
        double r20215 = 0.00390625;
        double r20216 = 4.0;
        double r20217 = pow(r20200, r20216);
        double r20218 = r20215 / r20217;
        double r20219 = r20214 + r20218;
        double r20220 = r20213 + r20219;
        double r20221 = r20202 ? r20210 : r20220;
        return r20221;
}

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 r20222, r20223, r20224, r20225, r20226, r20227, r20228, r20229, r20230, r20231;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r20222);
        mpfr_init(r20223);
        mpfr_init(r20224);
        mpfr_init_set_str(r20225, "2", 10, MPFR_RNDN);
        mpfr_init(r20226);
        mpfr_init(r20227);
        mpfr_init(r20228);
        mpfr_init_set_str(r20229, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20230);
        mpfr_init(r20231);
}

double f_im(double i) {
        mpfr_set_d(r20222, i, MPFR_RNDN);
        mpfr_mul(r20223, r20222, r20222, MPFR_RNDN);
        mpfr_mul(r20224, r20223, r20223, MPFR_RNDN);
        ;
        mpfr_mul(r20226, r20225, r20222, MPFR_RNDN);
        mpfr_mul(r20227, r20226, r20226, MPFR_RNDN);
        mpfr_div(r20228, r20224, r20227, MPFR_RNDN);
        ;
        mpfr_sub(r20230, r20227, r20229, MPFR_RNDN);
        mpfr_div(r20231, r20228, r20230, MPFR_RNDN);
        return mpfr_get_d(r20231, MPFR_RNDN);
}

static mpfr_t r20232, r20233, r20234, r20235, r20236, r20237, r20238, r20239, r20240, r20241, r20242, r20243, r20244, r20245, r20246, r20247, r20248, r20249, r20250, r20251, r20252, r20253;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20232);
        mpfr_init_set_str(r20233, "14343.200142683158", 10, MPFR_RNDN);
        mpfr_init(r20234);
        mpfr_init_set_str(r20235, "2", 10, MPFR_RNDN);
        mpfr_init(r20236);
        mpfr_init(r20237);
        mpfr_init(r20238);
        mpfr_init(r20239);
        mpfr_init_set_str(r20240, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20241);
        mpfr_init(r20242);
        mpfr_init_set_str(r20243, "0.015625", 10, MPFR_RNDN);
        mpfr_init(r20244);
        mpfr_init(r20245);
        mpfr_init_set_str(r20246, "1/16", 10, MPFR_RNDN);
        mpfr_init_set_str(r20247, "0.00390625", 10, MPFR_RNDN);
        mpfr_init_set_str(r20248, "4", 10, MPFR_RNDN);
        mpfr_init(r20249);
        mpfr_init(r20250);
        mpfr_init(r20251);
        mpfr_init(r20252);
        mpfr_init(r20253);
}

double f_fm(double i) {
        mpfr_set_d(r20232, i, MPFR_RNDN);
        ;
        mpfr_set_si(r20234, mpfr_cmp(r20232, r20233) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20236, r20232, r20235, MPFR_RNDN);
        mpfr_mul(r20237, r20236, r20236, MPFR_RNDN);
        mpfr_add(r20238, r20232, r20232, MPFR_RNDN);
        mpfr_sqr(r20239, r20238, MPFR_RNDN);
        ;
        mpfr_sub(r20241, r20239, r20240, MPFR_RNDN);
        mpfr_div(r20242, r20237, r20241, MPFR_RNDN);
        ;
        mpfr_sqr(r20244, r20232, MPFR_RNDN);
        mpfr_div(r20245, r20243, r20244, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20249, r20232, r20248, MPFR_RNDN);
        mpfr_div(r20250, r20247, r20249, MPFR_RNDN);
        mpfr_add(r20251, r20246, r20250, MPFR_RNDN);
        mpfr_add(r20252, r20245, r20251, MPFR_RNDN);
        if (mpfr_get_si(r20234, MPFR_RNDN)) { mpfr_set(r20253, r20242, MPFR_RNDN); } else { mpfr_set(r20253, r20252, MPFR_RNDN); };
        return mpfr_get_d(r20253, MPFR_RNDN);
}

static mpfr_t r20254, r20255, r20256, r20257, r20258, r20259, r20260, r20261, r20262, r20263, r20264, r20265, r20266, r20267, r20268, r20269, r20270, r20271, r20272, r20273, r20274, r20275;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20254);
        mpfr_init_set_str(r20255, "14343.200142683158", 10, MPFR_RNDN);
        mpfr_init(r20256);
        mpfr_init_set_str(r20257, "2", 10, MPFR_RNDN);
        mpfr_init(r20258);
        mpfr_init(r20259);
        mpfr_init(r20260);
        mpfr_init(r20261);
        mpfr_init_set_str(r20262, "1.0", 10, MPFR_RNDN);
        mpfr_init(r20263);
        mpfr_init(r20264);
        mpfr_init_set_str(r20265, "0.015625", 10, MPFR_RNDN);
        mpfr_init(r20266);
        mpfr_init(r20267);
        mpfr_init_set_str(r20268, "1/16", 10, MPFR_RNDN);
        mpfr_init_set_str(r20269, "0.00390625", 10, MPFR_RNDN);
        mpfr_init_set_str(r20270, "4", 10, MPFR_RNDN);
        mpfr_init(r20271);
        mpfr_init(r20272);
        mpfr_init(r20273);
        mpfr_init(r20274);
        mpfr_init(r20275);
}

double f_dm(double i) {
        mpfr_set_d(r20254, i, MPFR_RNDN);
        ;
        mpfr_set_si(r20256, mpfr_cmp(r20254, r20255) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20258, r20254, r20257, MPFR_RNDN);
        mpfr_mul(r20259, r20258, r20258, MPFR_RNDN);
        mpfr_add(r20260, r20254, r20254, MPFR_RNDN);
        mpfr_sqr(r20261, r20260, MPFR_RNDN);
        ;
        mpfr_sub(r20263, r20261, r20262, MPFR_RNDN);
        mpfr_div(r20264, r20259, r20263, MPFR_RNDN);
        ;
        mpfr_sqr(r20266, r20254, MPFR_RNDN);
        mpfr_div(r20267, r20265, r20266, MPFR_RNDN);
        ;
        ;
        ;
        mpfr_pow(r20271, r20254, r20270, MPFR_RNDN);
        mpfr_div(r20272, r20269, r20271, MPFR_RNDN);
        mpfr_add(r20273, r20268, r20272, MPFR_RNDN);
        mpfr_add(r20274, r20267, r20273, MPFR_RNDN);
        if (mpfr_get_si(r20256, MPFR_RNDN)) { mpfr_set(r20275, r20264, MPFR_RNDN); } else { mpfr_set(r20275, r20274, MPFR_RNDN); };
        return mpfr_get_d(r20275, MPFR_RNDN);
}