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

char *name = "Statistics.Math.RootFinding:ridders from math-functions-0.1.5.2";

double f_if(float x, float y, float z, float t, float a) {
        float r40206 = x;
        float r40207 = y;
        float r40208 = r40206 * r40207;
        float r40209 = z;
        float r40210 = r40208 * r40209;
        float r40211 = r40209 * r40209;
        float r40212 = t;
        float r40213 = a;
        float r40214 = r40212 * r40213;
        float r40215 = r40211 - r40214;
        float r40216 = sqrt(r40215);
        float r40217 = r40210 / r40216;
        return r40217;
}

double f_id(double x, double y, double z, double t, double a) {
        double r40218 = x;
        double r40219 = y;
        double r40220 = r40218 * r40219;
        double r40221 = z;
        double r40222 = r40220 * r40221;
        double r40223 = r40221 * r40221;
        double r40224 = t;
        double r40225 = a;
        double r40226 = r40224 * r40225;
        double r40227 = r40223 - r40226;
        double r40228 = sqrt(r40227);
        double r40229 = r40222 / r40228;
        return r40229;
}


double f_of(float x, float y, float z, float t, float a) {
        float r40230 = z;
        float r40231 = -2.3435713047613177e+111;
        bool r40232 = r40230 <= r40231;
        float r40233 = x;
        float r40234 = y;
        float r40235 = -r40234;
        float r40236 = r40233 * r40235;
        float r40237 = 3.215973189848367e+60;
        bool r40238 = r40230 <= r40237;
        float r40239 = r40234 * r40233;
        float r40240 = r40230 * r40230;
        float r40241 = a;
        float r40242 = t;
        float r40243 = r40241 * r40242;
        float r40244 = r40240 - r40243;
        float r40245 = cbrt(r40244);
        float r40246 = fabs(r40245);
        float r40247 = r40239 / r40246;
        float r40248 = r40242 * r40241;
        float r40249 = r40240 - r40248;
        float r40250 = cbrt(r40249);
        float r40251 = sqrt(r40250);
        float r40252 = r40230 / r40251;
        float r40253 = r40247 * r40252;
        float r40254 = r40238 ? r40253 : r40239;
        float r40255 = r40232 ? r40236 : r40254;
        return r40255;
}

double f_od(double x, double y, double z, double t, double a) {
        double r40256 = z;
        double r40257 = -2.3435713047613177e+111;
        bool r40258 = r40256 <= r40257;
        double r40259 = x;
        double r40260 = y;
        double r40261 = -r40260;
        double r40262 = r40259 * r40261;
        double r40263 = 3.215973189848367e+60;
        bool r40264 = r40256 <= r40263;
        double r40265 = r40260 * r40259;
        double r40266 = r40256 * r40256;
        double r40267 = a;
        double r40268 = t;
        double r40269 = r40267 * r40268;
        double r40270 = r40266 - r40269;
        double r40271 = cbrt(r40270);
        double r40272 = fabs(r40271);
        double r40273 = r40265 / r40272;
        double r40274 = r40268 * r40267;
        double r40275 = r40266 - r40274;
        double r40276 = cbrt(r40275);
        double r40277 = sqrt(r40276);
        double r40278 = r40256 / r40277;
        double r40279 = r40273 * r40278;
        double r40280 = r40264 ? r40279 : r40265;
        double r40281 = r40258 ? r40262 : r40280;
        return r40281;
}

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 r40282, r40283, r40284, r40285, r40286, r40287, r40288, r40289, r40290, r40291, r40292, r40293;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r40282);
        mpfr_init(r40283);
        mpfr_init(r40284);
        mpfr_init(r40285);
        mpfr_init(r40286);
        mpfr_init(r40287);
        mpfr_init(r40288);
        mpfr_init(r40289);
        mpfr_init(r40290);
        mpfr_init(r40291);
        mpfr_init(r40292);
        mpfr_init(r40293);
}

double f_im(double x, double y, double z, double t, double a) {
        mpfr_set_d(r40282, x, MPFR_RNDN);
        mpfr_set_d(r40283, y, MPFR_RNDN);
        mpfr_mul(r40284, r40282, r40283, MPFR_RNDN);
        mpfr_set_d(r40285, z, MPFR_RNDN);
        mpfr_mul(r40286, r40284, r40285, MPFR_RNDN);
        mpfr_mul(r40287, r40285, r40285, MPFR_RNDN);
        mpfr_set_d(r40288, t, MPFR_RNDN);
        mpfr_set_d(r40289, a, MPFR_RNDN);
        mpfr_mul(r40290, r40288, r40289, MPFR_RNDN);
        mpfr_sub(r40291, r40287, r40290, MPFR_RNDN);
        mpfr_sqrt(r40292, r40291, MPFR_RNDN);
        mpfr_div(r40293, r40286, r40292, MPFR_RNDN);
        return mpfr_get_d(r40293, MPFR_RNDN);
}

static mpfr_t r40294, r40295, r40296, r40297, r40298, r40299, r40300, r40301, r40302, r40303, r40304, r40305, r40306, r40307, r40308, r40309, r40310, r40311, r40312, r40313, r40314, r40315, r40316, r40317, r40318, r40319;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r40294);
        mpfr_init_set_str(r40295, "-2.3435713047613177e+111", 10, MPFR_RNDN);
        mpfr_init(r40296);
        mpfr_init(r40297);
        mpfr_init(r40298);
        mpfr_init(r40299);
        mpfr_init(r40300);
        mpfr_init_set_str(r40301, "3.215973189848367e+60", 10, MPFR_RNDN);
        mpfr_init(r40302);
        mpfr_init(r40303);
        mpfr_init(r40304);
        mpfr_init(r40305);
        mpfr_init(r40306);
        mpfr_init(r40307);
        mpfr_init(r40308);
        mpfr_init(r40309);
        mpfr_init(r40310);
        mpfr_init(r40311);
        mpfr_init(r40312);
        mpfr_init(r40313);
        mpfr_init(r40314);
        mpfr_init(r40315);
        mpfr_init(r40316);
        mpfr_init(r40317);
        mpfr_init(r40318);
        mpfr_init(r40319);
}

double f_fm(double x, double y, double z, double t, double a) {
        mpfr_set_d(r40294, z, MPFR_RNDN);
        ;
        mpfr_set_si(r40296, mpfr_cmp(r40294, r40295) <= 0, MPFR_RNDN);
        mpfr_set_d(r40297, x, MPFR_RNDN);
        mpfr_set_d(r40298, y, MPFR_RNDN);
        mpfr_neg(r40299, r40298, MPFR_RNDN);
        mpfr_mul(r40300, r40297, r40299, MPFR_RNDN);
        ;
        mpfr_set_si(r40302, mpfr_cmp(r40294, r40301) <= 0, MPFR_RNDN);
        mpfr_mul(r40303, r40298, r40297, MPFR_RNDN);
        mpfr_mul(r40304, r40294, r40294, MPFR_RNDN);
        mpfr_set_d(r40305, a, MPFR_RNDN);
        mpfr_set_d(r40306, t, MPFR_RNDN);
        mpfr_mul(r40307, r40305, r40306, MPFR_RNDN);
        mpfr_sub(r40308, r40304, r40307, MPFR_RNDN);
        mpfr_cbrt(r40309, r40308, MPFR_RNDN);
        mpfr_abs(r40310, r40309, MPFR_RNDN);
        mpfr_div(r40311, r40303, r40310, MPFR_RNDN);
        mpfr_mul(r40312, r40306, r40305, MPFR_RNDN);
        mpfr_sub(r40313, r40304, r40312, MPFR_RNDN);
        mpfr_cbrt(r40314, r40313, MPFR_RNDN);
        mpfr_sqrt(r40315, r40314, MPFR_RNDN);
        mpfr_div(r40316, r40294, r40315, MPFR_RNDN);
        mpfr_mul(r40317, r40311, r40316, MPFR_RNDN);
        if (mpfr_get_si(r40302, MPFR_RNDN)) { mpfr_set(r40318, r40317, MPFR_RNDN); } else { mpfr_set(r40318, r40303, MPFR_RNDN); };
        if (mpfr_get_si(r40296, MPFR_RNDN)) { mpfr_set(r40319, r40300, MPFR_RNDN); } else { mpfr_set(r40319, r40318, MPFR_RNDN); };
        return mpfr_get_d(r40319, MPFR_RNDN);
}

static mpfr_t r40320, r40321, r40322, r40323, r40324, r40325, r40326, r40327, r40328, r40329, r40330, r40331, r40332, r40333, r40334, r40335, r40336, r40337, r40338, r40339, r40340, r40341, r40342, r40343, r40344, r40345;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r40320);
        mpfr_init_set_str(r40321, "-2.3435713047613177e+111", 10, MPFR_RNDN);
        mpfr_init(r40322);
        mpfr_init(r40323);
        mpfr_init(r40324);
        mpfr_init(r40325);
        mpfr_init(r40326);
        mpfr_init_set_str(r40327, "3.215973189848367e+60", 10, MPFR_RNDN);
        mpfr_init(r40328);
        mpfr_init(r40329);
        mpfr_init(r40330);
        mpfr_init(r40331);
        mpfr_init(r40332);
        mpfr_init(r40333);
        mpfr_init(r40334);
        mpfr_init(r40335);
        mpfr_init(r40336);
        mpfr_init(r40337);
        mpfr_init(r40338);
        mpfr_init(r40339);
        mpfr_init(r40340);
        mpfr_init(r40341);
        mpfr_init(r40342);
        mpfr_init(r40343);
        mpfr_init(r40344);
        mpfr_init(r40345);
}

double f_dm(double x, double y, double z, double t, double a) {
        mpfr_set_d(r40320, z, MPFR_RNDN);
        ;
        mpfr_set_si(r40322, mpfr_cmp(r40320, r40321) <= 0, MPFR_RNDN);
        mpfr_set_d(r40323, x, MPFR_RNDN);
        mpfr_set_d(r40324, y, MPFR_RNDN);
        mpfr_neg(r40325, r40324, MPFR_RNDN);
        mpfr_mul(r40326, r40323, r40325, MPFR_RNDN);
        ;
        mpfr_set_si(r40328, mpfr_cmp(r40320, r40327) <= 0, MPFR_RNDN);
        mpfr_mul(r40329, r40324, r40323, MPFR_RNDN);
        mpfr_mul(r40330, r40320, r40320, MPFR_RNDN);
        mpfr_set_d(r40331, a, MPFR_RNDN);
        mpfr_set_d(r40332, t, MPFR_RNDN);
        mpfr_mul(r40333, r40331, r40332, MPFR_RNDN);
        mpfr_sub(r40334, r40330, r40333, MPFR_RNDN);
        mpfr_cbrt(r40335, r40334, MPFR_RNDN);
        mpfr_abs(r40336, r40335, MPFR_RNDN);
        mpfr_div(r40337, r40329, r40336, MPFR_RNDN);
        mpfr_mul(r40338, r40332, r40331, MPFR_RNDN);
        mpfr_sub(r40339, r40330, r40338, MPFR_RNDN);
        mpfr_cbrt(r40340, r40339, MPFR_RNDN);
        mpfr_sqrt(r40341, r40340, MPFR_RNDN);
        mpfr_div(r40342, r40320, r40341, MPFR_RNDN);
        mpfr_mul(r40343, r40337, r40342, MPFR_RNDN);
        if (mpfr_get_si(r40328, MPFR_RNDN)) { mpfr_set(r40344, r40343, MPFR_RNDN); } else { mpfr_set(r40344, r40329, MPFR_RNDN); };
        if (mpfr_get_si(r40322, MPFR_RNDN)) { mpfr_set(r40345, r40326, MPFR_RNDN); } else { mpfr_set(r40345, r40344, MPFR_RNDN); };
        return mpfr_get_d(r40345, MPFR_RNDN);
}

