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

char *name = "Rosa's DopplerBench";

double f_if(float u, float v, float t1) {
        float r20903 = t1;
        float r20904 = -r20903;
        float r20905 = v;
        float r20906 = r20904 * r20905;
        float r20907 = u;
        float r20908 = r20903 + r20907;
        float r20909 = r20908 * r20908;
        float r20910 = r20906 / r20909;
        return r20910;
}

double f_id(double u, double v, double t1) {
        double r20911 = t1;
        double r20912 = -r20911;
        double r20913 = v;
        double r20914 = r20912 * r20913;
        double r20915 = u;
        double r20916 = r20911 + r20915;
        double r20917 = r20916 * r20916;
        double r20918 = r20914 / r20917;
        return r20918;
}


double f_of(float u, float v, float t1) {
        float r20919 = t1;
        float r20920 = -r20919;
        float r20921 = cbrt(r20920);
        float r20922 = r20921 * r20921;
        float r20923 = u;
        float r20924 = r20919 + r20923;
        float r20925 = cbrt(r20924);
        float r20926 = r20925 * r20925;
        float r20927 = r20922 / r20926;
        float r20928 = r20921 / r20925;
        float r20929 = v;
        float r20930 = r20929 / r20924;
        float r20931 = r20928 * r20930;
        float r20932 = r20927 * r20931;
        return r20932;
}

double f_od(double u, double v, double t1) {
        double r20933 = t1;
        double r20934 = -r20933;
        double r20935 = cbrt(r20934);
        double r20936 = r20935 * r20935;
        double r20937 = u;
        double r20938 = r20933 + r20937;
        double r20939 = cbrt(r20938);
        double r20940 = r20939 * r20939;
        double r20941 = r20936 / r20940;
        double r20942 = r20935 / r20939;
        double r20943 = v;
        double r20944 = r20943 / r20938;
        double r20945 = r20942 * r20944;
        double r20946 = r20941 * r20945;
        return r20946;
}

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 r20947, r20948, r20949, r20950, r20951, r20952, r20953, r20954;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r20947);
        mpfr_init(r20948);
        mpfr_init(r20949);
        mpfr_init(r20950);
        mpfr_init(r20951);
        mpfr_init(r20952);
        mpfr_init(r20953);
        mpfr_init(r20954);
}

double f_im(double u, double v, double t1) {
        mpfr_set_d(r20947, t1, MPFR_RNDN);
        mpfr_neg(r20948, r20947, MPFR_RNDN);
        mpfr_set_d(r20949, v, MPFR_RNDN);
        mpfr_mul(r20950, r20948, r20949, MPFR_RNDN);
        mpfr_set_d(r20951, u, MPFR_RNDN);
        mpfr_add(r20952, r20947, r20951, MPFR_RNDN);
        mpfr_mul(r20953, r20952, r20952, MPFR_RNDN);
        mpfr_div(r20954, r20950, r20953, MPFR_RNDN);
        return mpfr_get_d(r20954, MPFR_RNDN);
}

static mpfr_t r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962, r20963, r20964, r20965, r20966, r20967, r20968;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20955);
        mpfr_init(r20956);
        mpfr_init(r20957);
        mpfr_init(r20958);
        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(r20967);
        mpfr_init(r20968);
}

double f_fm(double u, double v, double t1) {
        mpfr_set_d(r20955, t1, MPFR_RNDN);
        mpfr_neg(r20956, r20955, MPFR_RNDN);
        mpfr_cbrt(r20957, r20956, MPFR_RNDN);
        mpfr_mul(r20958, r20957, r20957, MPFR_RNDN);
        mpfr_set_d(r20959, u, MPFR_RNDN);
        mpfr_add(r20960, r20955, r20959, MPFR_RNDN);
        mpfr_cbrt(r20961, r20960, MPFR_RNDN);
        mpfr_mul(r20962, r20961, r20961, MPFR_RNDN);
        mpfr_div(r20963, r20958, r20962, MPFR_RNDN);
        mpfr_div(r20964, r20957, r20961, MPFR_RNDN);
        mpfr_set_d(r20965, v, MPFR_RNDN);
        mpfr_div(r20966, r20965, r20960, MPFR_RNDN);
        mpfr_mul(r20967, r20964, r20966, MPFR_RNDN);
        mpfr_mul(r20968, r20963, r20967, MPFR_RNDN);
        return mpfr_get_d(r20968, MPFR_RNDN);
}

static mpfr_t r20969, r20970, r20971, r20972, r20973, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981, r20982;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r20969);
        mpfr_init(r20970);
        mpfr_init(r20971);
        mpfr_init(r20972);
        mpfr_init(r20973);
        mpfr_init(r20974);
        mpfr_init(r20975);
        mpfr_init(r20976);
        mpfr_init(r20977);
        mpfr_init(r20978);
        mpfr_init(r20979);
        mpfr_init(r20980);
        mpfr_init(r20981);
        mpfr_init(r20982);
}

double f_dm(double u, double v, double t1) {
        mpfr_set_d(r20969, t1, MPFR_RNDN);
        mpfr_neg(r20970, r20969, MPFR_RNDN);
        mpfr_cbrt(r20971, r20970, MPFR_RNDN);
        mpfr_mul(r20972, r20971, r20971, MPFR_RNDN);
        mpfr_set_d(r20973, u, MPFR_RNDN);
        mpfr_add(r20974, r20969, r20973, MPFR_RNDN);
        mpfr_cbrt(r20975, r20974, MPFR_RNDN);
        mpfr_mul(r20976, r20975, r20975, MPFR_RNDN);
        mpfr_div(r20977, r20972, r20976, MPFR_RNDN);
        mpfr_div(r20978, r20971, r20975, MPFR_RNDN);
        mpfr_set_d(r20979, v, MPFR_RNDN);
        mpfr_div(r20980, r20979, r20974, MPFR_RNDN);
        mpfr_mul(r20981, r20978, r20980, MPFR_RNDN);
        mpfr_mul(r20982, r20977, r20981, MPFR_RNDN);
        return mpfr_get_d(r20982, MPFR_RNDN);
}