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

char *name = "Cubic critical";

double f_if(float a, float b, float c, float __attribute__((unused)) d) {
        float r25843 = b;
        float r25844 = -r25843;
        float r25845 = r25843 * r25843;
        float r25846 = 3;
        float r25847 = a;
        float r25848 = r25846 * r25847;
        float r25849 = c;
        float r25850 = r25848 * r25849;
        float r25851 = r25845 - r25850;
        float r25852 = sqrt(r25851);
        float r25853 = r25844 + r25852;
        float r25854 = r25853 / r25848;
        return r25854;
}

double f_id(double a, double b, double c, double __attribute__((unused)) d) {
        double r25855 = b;
        double r25856 = -r25855;
        double r25857 = r25855 * r25855;
        double r25858 = 3;
        double r25859 = a;
        double r25860 = r25858 * r25859;
        double r25861 = c;
        double r25862 = r25860 * r25861;
        double r25863 = r25857 - r25862;
        double r25864 = sqrt(r25863);
        double r25865 = r25856 + r25864;
        double r25866 = r25865 / r25860;
        return r25866;
}


double f_of(float a, float b, float c, float __attribute__((unused)) d) {
        float r25867 = b;
        float r25868 = -2/3;
        float r25869 = r25867 * r25868;
        float r25870 = -2.327767601627927e+87;
        bool r25871 = r25869 <= r25870;
        float r25872 = -3/2;
        float r25873 = 3;
        float r25874 = r25872 / r25873;
        float r25875 = c;
        float r25876 = r25875 / r25867;
        float r25877 = r25874 * r25876;
        float r25878 = -1.6038021471621018e-298;
        bool r25879 = r25869 <= r25878;
        float r25880 = -r25867;
        float r25881 = r25867 * r25867;
        float r25882 = a;
        float r25883 = r25882 * r25873;
        float r25884 = r25875 * r25883;
        float r25885 = r25881 - r25884;
        float r25886 = sqrt(r25885);
        float r25887 = r25880 - r25886;
        float r25888 = r25873 / r25887;
        float r25889 = r25875 / r25873;
        float r25890 = r25888 * r25889;
        float r25891 = 4.234302703938596e+144;
        bool r25892 = r25869 <= r25891;
        float r25893 = 1;
        float r25894 = r25886 - r25867;
        float r25895 = r25883 / r25894;
        float r25896 = r25893 / r25895;
        float r25897 = r25869 / r25882;
        float r25898 = r25892 ? r25896 : r25897;
        float r25899 = r25879 ? r25890 : r25898;
        float r25900 = r25871 ? r25877 : r25899;
        return r25900;
}

double f_od(double a, double b, double c, double __attribute__((unused)) d) {
        double r25901 = b;
        double r25902 = -2/3;
        double r25903 = r25901 * r25902;
        double r25904 = -2.327767601627927e+87;
        bool r25905 = r25903 <= r25904;
        double r25906 = -3/2;
        double r25907 = 3;
        double r25908 = r25906 / r25907;
        double r25909 = c;
        double r25910 = r25909 / r25901;
        double r25911 = r25908 * r25910;
        double r25912 = -1.6038021471621018e-298;
        bool r25913 = r25903 <= r25912;
        double r25914 = -r25901;
        double r25915 = r25901 * r25901;
        double r25916 = a;
        double r25917 = r25916 * r25907;
        double r25918 = r25909 * r25917;
        double r25919 = r25915 - r25918;
        double r25920 = sqrt(r25919);
        double r25921 = r25914 - r25920;
        double r25922 = r25907 / r25921;
        double r25923 = r25909 / r25907;
        double r25924 = r25922 * r25923;
        double r25925 = 4.234302703938596e+144;
        bool r25926 = r25903 <= r25925;
        double r25927 = 1;
        double r25928 = r25920 - r25901;
        double r25929 = r25917 / r25928;
        double r25930 = r25927 / r25929;
        double r25931 = r25903 / r25916;
        double r25932 = r25926 ? r25930 : r25931;
        double r25933 = r25913 ? r25924 : r25932;
        double r25934 = r25905 ? r25911 : r25933;
        return r25934;
}

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 r25935, r25936, r25937, r25938, r25939, r25940, r25941, r25942, r25943, r25944, r25945, r25946;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3408);
        mpfr_init(r25935);
        mpfr_init(r25936);
        mpfr_init(r25937);
        mpfr_init_set_str(r25938, "3", 10, MPFR_RNDN);
        mpfr_init(r25939);
        mpfr_init(r25940);
        mpfr_init(r25941);
        mpfr_init(r25942);
        mpfr_init(r25943);
        mpfr_init(r25944);
        mpfr_init(r25945);
        mpfr_init(r25946);
}

double f_im(double a, double b, double c, double __attribute__((unused)) d) {
        mpfr_set_d(r25935, b, MPFR_RNDN);
        mpfr_neg(r25936, r25935, MPFR_RNDN);
        mpfr_mul(r25937, r25935, r25935, MPFR_RNDN);
        ;
        mpfr_set_d(r25939, a, MPFR_RNDN);
        mpfr_mul(r25940, r25938, r25939, MPFR_RNDN);
        mpfr_set_d(r25941, c, MPFR_RNDN);
        mpfr_mul(r25942, r25940, r25941, MPFR_RNDN);
        mpfr_sub(r25943, r25937, r25942, MPFR_RNDN);
        mpfr_sqrt(r25944, r25943, MPFR_RNDN);
        mpfr_add(r25945, r25936, r25944, MPFR_RNDN);
        mpfr_div(r25946, r25945, r25940, MPFR_RNDN);
        return mpfr_get_d(r25946, MPFR_RNDN);
}

static mpfr_t r25947, r25948, r25949, r25950, r25951, r25952, r25953, r25954, r25955, r25956, r25957, r25958, r25959, r25960, r25961, r25962, r25963, r25964, r25965, r25966, r25967, r25968, r25969, r25970, r25971, r25972, r25973, r25974, r25975, r25976, r25977, r25978, r25979, r25980;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r25947);
        mpfr_init_set_str(r25948, "-2/3", 10, MPFR_RNDN);
        mpfr_init(r25949);
        mpfr_init_set_str(r25950, "-2.327767601627927e+87", 10, MPFR_RNDN);
        mpfr_init(r25951);
        mpfr_init_set_str(r25952, "-3/2", 10, MPFR_RNDN);
        mpfr_init_set_str(r25953, "3", 10, MPFR_RNDN);
        mpfr_init(r25954);
        mpfr_init(r25955);
        mpfr_init(r25956);
        mpfr_init(r25957);
        mpfr_init_set_str(r25958, "-1.6038021471621018e-298", 10, MPFR_RNDN);
        mpfr_init(r25959);
        mpfr_init(r25960);
        mpfr_init(r25961);
        mpfr_init(r25962);
        mpfr_init(r25963);
        mpfr_init(r25964);
        mpfr_init(r25965);
        mpfr_init(r25966);
        mpfr_init(r25967);
        mpfr_init(r25968);
        mpfr_init(r25969);
        mpfr_init(r25970);
        mpfr_init_set_str(r25971, "4.234302703938596e+144", 10, MPFR_RNDN);
        mpfr_init(r25972);
        mpfr_init_set_str(r25973, "1", 10, MPFR_RNDN);
        mpfr_init(r25974);
        mpfr_init(r25975);
        mpfr_init(r25976);
        mpfr_init(r25977);
        mpfr_init(r25978);
        mpfr_init(r25979);
        mpfr_init(r25980);
}

double f_fm(double a, double b, double c, double __attribute__((unused)) d) {
        mpfr_set_d(r25947, b, MPFR_RNDN);
        ;
        mpfr_mul(r25949, r25947, r25948, MPFR_RNDN);
        ;
        mpfr_set_si(r25951, mpfr_cmp(r25949, r25950) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_div(r25954, r25952, r25953, MPFR_RNDN);
        mpfr_set_d(r25955, c, MPFR_RNDN);
        mpfr_div(r25956, r25955, r25947, MPFR_RNDN);
        mpfr_mul(r25957, r25954, r25956, MPFR_RNDN);
        ;
        mpfr_set_si(r25959, mpfr_cmp(r25949, r25958) <= 0, MPFR_RNDN);
        mpfr_neg(r25960, r25947, MPFR_RNDN);
        mpfr_mul(r25961, r25947, r25947, MPFR_RNDN);
        mpfr_set_d(r25962, a, MPFR_RNDN);
        mpfr_mul(r25963, r25962, r25953, MPFR_RNDN);
        mpfr_mul(r25964, r25955, r25963, MPFR_RNDN);
        mpfr_sub(r25965, r25961, r25964, MPFR_RNDN);
        mpfr_sqrt(r25966, r25965, MPFR_RNDN);
        mpfr_sub(r25967, r25960, r25966, MPFR_RNDN);
        mpfr_div(r25968, r25953, r25967, MPFR_RNDN);
        mpfr_div(r25969, r25955, r25953, MPFR_RNDN);
        mpfr_mul(r25970, r25968, r25969, MPFR_RNDN);
        ;
        mpfr_set_si(r25972, mpfr_cmp(r25949, r25971) <= 0, MPFR_RNDN);
        ;
        mpfr_sub(r25974, r25966, r25947, MPFR_RNDN);
        mpfr_div(r25975, r25963, r25974, MPFR_RNDN);
        mpfr_div(r25976, r25973, r25975, MPFR_RNDN);
        mpfr_div(r25977, r25949, r25962, MPFR_RNDN);
        if (mpfr_get_si(r25972, MPFR_RNDN)) { mpfr_set(r25978, r25976, MPFR_RNDN); } else { mpfr_set(r25978, r25977, MPFR_RNDN); };
        if (mpfr_get_si(r25959, MPFR_RNDN)) { mpfr_set(r25979, r25970, MPFR_RNDN); } else { mpfr_set(r25979, r25978, MPFR_RNDN); };
        if (mpfr_get_si(r25951, MPFR_RNDN)) { mpfr_set(r25980, r25957, MPFR_RNDN); } else { mpfr_set(r25980, r25979, MPFR_RNDN); };
        return mpfr_get_d(r25980, MPFR_RNDN);
}

static mpfr_t r25981, r25982, r25983, r25984, r25985, r25986, r25987, r25988, r25989, r25990, r25991, r25992, r25993, r25994, r25995, r25996, r25997, r25998, r25999, r26000, r26001, r26002, r26003, r26004, r26005, r26006, r26007, r26008, r26009, r26010, r26011, r26012, r26013, r26014;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r25981);
        mpfr_init_set_str(r25982, "-2/3", 10, MPFR_RNDN);
        mpfr_init(r25983);
        mpfr_init_set_str(r25984, "-2.327767601627927e+87", 10, MPFR_RNDN);
        mpfr_init(r25985);
        mpfr_init_set_str(r25986, "-3/2", 10, MPFR_RNDN);
        mpfr_init_set_str(r25987, "3", 10, MPFR_RNDN);
        mpfr_init(r25988);
        mpfr_init(r25989);
        mpfr_init(r25990);
        mpfr_init(r25991);
        mpfr_init_set_str(r25992, "-1.6038021471621018e-298", 10, MPFR_RNDN);
        mpfr_init(r25993);
        mpfr_init(r25994);
        mpfr_init(r25995);
        mpfr_init(r25996);
        mpfr_init(r25997);
        mpfr_init(r25998);
        mpfr_init(r25999);
        mpfr_init(r26000);
        mpfr_init(r26001);
        mpfr_init(r26002);
        mpfr_init(r26003);
        mpfr_init(r26004);
        mpfr_init_set_str(r26005, "4.234302703938596e+144", 10, MPFR_RNDN);
        mpfr_init(r26006);
        mpfr_init_set_str(r26007, "1", 10, MPFR_RNDN);
        mpfr_init(r26008);
        mpfr_init(r26009);
        mpfr_init(r26010);
        mpfr_init(r26011);
        mpfr_init(r26012);
        mpfr_init(r26013);
        mpfr_init(r26014);
}

double f_dm(double a, double b, double c, double __attribute__((unused)) d) {
        mpfr_set_d(r25981, b, MPFR_RNDN);
        ;
        mpfr_mul(r25983, r25981, r25982, MPFR_RNDN);
        ;
        mpfr_set_si(r25985, mpfr_cmp(r25983, r25984) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_div(r25988, r25986, r25987, MPFR_RNDN);
        mpfr_set_d(r25989, c, MPFR_RNDN);
        mpfr_div(r25990, r25989, r25981, MPFR_RNDN);
        mpfr_mul(r25991, r25988, r25990, MPFR_RNDN);
        ;
        mpfr_set_si(r25993, mpfr_cmp(r25983, r25992) <= 0, MPFR_RNDN);
        mpfr_neg(r25994, r25981, MPFR_RNDN);
        mpfr_mul(r25995, r25981, r25981, MPFR_RNDN);
        mpfr_set_d(r25996, a, MPFR_RNDN);
        mpfr_mul(r25997, r25996, r25987, MPFR_RNDN);
        mpfr_mul(r25998, r25989, r25997, MPFR_RNDN);
        mpfr_sub(r25999, r25995, r25998, MPFR_RNDN);
        mpfr_sqrt(r26000, r25999, MPFR_RNDN);
        mpfr_sub(r26001, r25994, r26000, MPFR_RNDN);
        mpfr_div(r26002, r25987, r26001, MPFR_RNDN);
        mpfr_div(r26003, r25989, r25987, MPFR_RNDN);
        mpfr_mul(r26004, r26002, r26003, MPFR_RNDN);
        ;
        mpfr_set_si(r26006, mpfr_cmp(r25983, r26005) <= 0, MPFR_RNDN);
        ;
        mpfr_sub(r26008, r26000, r25981, MPFR_RNDN);
        mpfr_div(r26009, r25997, r26008, MPFR_RNDN);
        mpfr_div(r26010, r26007, r26009, MPFR_RNDN);
        mpfr_div(r26011, r25983, r25996, MPFR_RNDN);
        if (mpfr_get_si(r26006, MPFR_RNDN)) { mpfr_set(r26012, r26010, MPFR_RNDN); } else { mpfr_set(r26012, r26011, MPFR_RNDN); };
        if (mpfr_get_si(r25993, MPFR_RNDN)) { mpfr_set(r26013, r26004, MPFR_RNDN); } else { mpfr_set(r26013, r26012, MPFR_RNDN); };
        if (mpfr_get_si(r25985, MPFR_RNDN)) { mpfr_set(r26014, r25991, MPFR_RNDN); } else { mpfr_set(r26014, r26013, MPFR_RNDN); };
        return mpfr_get_d(r26014, MPFR_RNDN);
}