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

char *name = "NMSE problem 3.2.1";

double f_if(float a, float b_2F2, float c) {
        float r5808 = b_2F2;
        float r5809 = -r5808;
        float r5810 = r5808 * r5808;
        float r5811 = a;
        float r5812 = c;
        float r5813 = r5811 * r5812;
        float r5814 = r5810 - r5813;
        float r5815 = sqrt(r5814);
        float r5816 = r5809 - r5815;
        float r5817 = r5816 / r5811;
        return r5817;
}

double f_id(double a, double b_2F2, double c) {
        double r5818 = b_2F2;
        double r5819 = -r5818;
        double r5820 = r5818 * r5818;
        double r5821 = a;
        double r5822 = c;
        double r5823 = r5821 * r5822;
        double r5824 = r5820 - r5823;
        double r5825 = sqrt(r5824);
        double r5826 = r5819 - r5825;
        double r5827 = r5826 / r5821;
        return r5827;
}


double f_of(float a, float b_2F2, float c) {
        float r5828 = b_2F2;
        float r5829 = -4.716965670945614e+37;
        bool r5830 = r5828 <= r5829;
        float r5831 = c;
        float r5832 = -r5831;
        float r5833 = r5832 / r5828;
        float r5834 = 1;
        float r5835 = 1/2;
        float r5836 = r5834 / r5835;
        float r5837 = r5833 / r5836;
        float r5838 = -1.6276309842825124e-141;
        bool r5839 = r5828 <= r5838;
        float r5840 = r5828 * r5828;
        float r5841 = a;
        float r5842 = r5831 * r5841;
        float r5843 = r5840 - r5842;
        float r5844 = sqrt(r5843);
        float r5845 = r5844 - r5828;
        float r5846 = r5831 / r5845;
        float r5847 = cbrt(r5846);
        float r5848 = r5847 * r5847;
        float r5849 = r5848 * r5847;
        float r5850 = 1.0989486611216948e+147;
        bool r5851 = r5828 <= r5850;
        float r5852 = -r5828;
        float r5853 = r5841 * r5831;
        float r5854 = r5840 - r5853;
        float r5855 = sqrt(r5854);
        float r5856 = r5852 - r5855;
        float r5857 = r5856 / r5841;
        float r5858 = r5841 / r5828;
        float r5859 = r5835 * r5831;
        float r5860 = r5858 * r5859;
        float r5861 = r5828 + r5828;
        float r5862 = r5860 - r5861;
        float r5863 = r5862 / r5841;
        float r5864 = r5851 ? r5857 : r5863;
        float r5865 = r5839 ? r5849 : r5864;
        float r5866 = r5830 ? r5837 : r5865;
        return r5866;
}

double f_od(double a, double b_2F2, double c) {
        double r5867 = b_2F2;
        double r5868 = -4.716965670945614e+37;
        bool r5869 = r5867 <= r5868;
        double r5870 = c;
        double r5871 = -r5870;
        double r5872 = r5871 / r5867;
        double r5873 = 1;
        double r5874 = 1/2;
        double r5875 = r5873 / r5874;
        double r5876 = r5872 / r5875;
        double r5877 = -1.6276309842825124e-141;
        bool r5878 = r5867 <= r5877;
        double r5879 = r5867 * r5867;
        double r5880 = a;
        double r5881 = r5870 * r5880;
        double r5882 = r5879 - r5881;
        double r5883 = sqrt(r5882);
        double r5884 = r5883 - r5867;
        double r5885 = r5870 / r5884;
        double r5886 = cbrt(r5885);
        double r5887 = r5886 * r5886;
        double r5888 = r5887 * r5886;
        double r5889 = 1.0989486611216948e+147;
        bool r5890 = r5867 <= r5889;
        double r5891 = -r5867;
        double r5892 = r5880 * r5870;
        double r5893 = r5879 - r5892;
        double r5894 = sqrt(r5893);
        double r5895 = r5891 - r5894;
        double r5896 = r5895 / r5880;
        double r5897 = r5880 / r5867;
        double r5898 = r5874 * r5870;
        double r5899 = r5897 * r5898;
        double r5900 = r5867 + r5867;
        double r5901 = r5899 - r5900;
        double r5902 = r5901 / r5880;
        double r5903 = r5890 ? r5896 : r5902;
        double r5904 = r5878 ? r5888 : r5903;
        double r5905 = r5869 ? r5876 : r5904;
        return r5905;
}

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 r5906, r5907, r5908, r5909, r5910, r5911, r5912, r5913, r5914, r5915;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3408);
        mpfr_init(r5906);
        mpfr_init(r5907);
        mpfr_init(r5908);
        mpfr_init(r5909);
        mpfr_init(r5910);
        mpfr_init(r5911);
        mpfr_init(r5912);
        mpfr_init(r5913);
        mpfr_init(r5914);
        mpfr_init(r5915);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r5906, b_2F2, MPFR_RNDN);
        mpfr_neg(r5907, r5906, MPFR_RNDN);
        mpfr_mul(r5908, r5906, r5906, MPFR_RNDN);
        mpfr_set_d(r5909, a, MPFR_RNDN);
        mpfr_set_d(r5910, c, MPFR_RNDN);
        mpfr_mul(r5911, r5909, r5910, MPFR_RNDN);
        mpfr_sub(r5912, r5908, r5911, MPFR_RNDN);
        mpfr_sqrt(r5913, r5912, MPFR_RNDN);
        mpfr_sub(r5914, r5907, r5913, MPFR_RNDN);
        mpfr_div(r5915, r5914, r5909, MPFR_RNDN);
        return mpfr_get_d(r5915, MPFR_RNDN);
}

static mpfr_t r5916, r5917, r5918, r5919, r5920, r5921, r5922, r5923, r5924, r5925, r5926, r5927, r5928, r5929, r5930, r5931, r5932, r5933, r5934, r5935, r5936, r5937, r5938, r5939, r5940, r5941, r5942, r5943, r5944, r5945, r5946, r5947, r5948, r5949, r5950, r5951, r5952, r5953, r5954;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r5916);
        mpfr_init_set_str(r5917, "-4.716965670945614e+37", 10, MPFR_RNDN);
        mpfr_init(r5918);
        mpfr_init(r5919);
        mpfr_init(r5920);
        mpfr_init(r5921);
        mpfr_init_set_str(r5922, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r5923, "1/2", 10, MPFR_RNDN);
        mpfr_init(r5924);
        mpfr_init(r5925);
        mpfr_init_set_str(r5926, "-1.6276309842825124e-141", 10, MPFR_RNDN);
        mpfr_init(r5927);
        mpfr_init(r5928);
        mpfr_init(r5929);
        mpfr_init(r5930);
        mpfr_init(r5931);
        mpfr_init(r5932);
        mpfr_init(r5933);
        mpfr_init(r5934);
        mpfr_init(r5935);
        mpfr_init(r5936);
        mpfr_init(r5937);
        mpfr_init_set_str(r5938, "1.0989486611216948e+147", 10, MPFR_RNDN);
        mpfr_init(r5939);
        mpfr_init(r5940);
        mpfr_init(r5941);
        mpfr_init(r5942);
        mpfr_init(r5943);
        mpfr_init(r5944);
        mpfr_init(r5945);
        mpfr_init(r5946);
        mpfr_init(r5947);
        mpfr_init(r5948);
        mpfr_init(r5949);
        mpfr_init(r5950);
        mpfr_init(r5951);
        mpfr_init(r5952);
        mpfr_init(r5953);
        mpfr_init(r5954);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r5916, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r5918, mpfr_cmp(r5916, r5917) <= 0, MPFR_RNDN);
        mpfr_set_d(r5919, c, MPFR_RNDN);
        mpfr_neg(r5920, r5919, MPFR_RNDN);
        mpfr_div(r5921, r5920, r5916, MPFR_RNDN);
        ;
        ;
        mpfr_div(r5924, r5922, r5923, MPFR_RNDN);
        mpfr_div(r5925, r5921, r5924, MPFR_RNDN);
        ;
        mpfr_set_si(r5927, mpfr_cmp(r5916, r5926) <= 0, MPFR_RNDN);
        mpfr_mul(r5928, r5916, r5916, MPFR_RNDN);
        mpfr_set_d(r5929, a, MPFR_RNDN);
        mpfr_mul(r5930, r5919, r5929, MPFR_RNDN);
        mpfr_sub(r5931, r5928, r5930, MPFR_RNDN);
        mpfr_sqrt(r5932, r5931, MPFR_RNDN);
        mpfr_sub(r5933, r5932, r5916, MPFR_RNDN);
        mpfr_div(r5934, r5919, r5933, MPFR_RNDN);
        mpfr_cbrt(r5935, r5934, MPFR_RNDN);
        mpfr_mul(r5936, r5935, r5935, MPFR_RNDN);
        mpfr_mul(r5937, r5936, r5935, MPFR_RNDN);
        ;
        mpfr_set_si(r5939, mpfr_cmp(r5916, r5938) <= 0, MPFR_RNDN);
        mpfr_neg(r5940, r5916, MPFR_RNDN);
        mpfr_mul(r5941, r5929, r5919, MPFR_RNDN);
        mpfr_sub(r5942, r5928, r5941, MPFR_RNDN);
        mpfr_sqrt(r5943, r5942, MPFR_RNDN);
        mpfr_sub(r5944, r5940, r5943, MPFR_RNDN);
        mpfr_div(r5945, r5944, r5929, MPFR_RNDN);
        mpfr_div(r5946, r5929, r5916, MPFR_RNDN);
        mpfr_mul(r5947, r5923, r5919, MPFR_RNDN);
        mpfr_mul(r5948, r5946, r5947, MPFR_RNDN);
        mpfr_add(r5949, r5916, r5916, MPFR_RNDN);
        mpfr_sub(r5950, r5948, r5949, MPFR_RNDN);
        mpfr_div(r5951, r5950, r5929, MPFR_RNDN);
        if (mpfr_get_si(r5939, MPFR_RNDN)) { mpfr_set(r5952, r5945, MPFR_RNDN); } else { mpfr_set(r5952, r5951, MPFR_RNDN); };
        if (mpfr_get_si(r5927, MPFR_RNDN)) { mpfr_set(r5953, r5937, MPFR_RNDN); } else { mpfr_set(r5953, r5952, MPFR_RNDN); };
        if (mpfr_get_si(r5918, MPFR_RNDN)) { mpfr_set(r5954, r5925, MPFR_RNDN); } else { mpfr_set(r5954, r5953, MPFR_RNDN); };
        return mpfr_get_d(r5954, MPFR_RNDN);
}

static mpfr_t r5955, r5956, r5957, r5958, r5959, r5960, r5961, r5962, r5963, r5964, r5965, r5966, r5967, r5968, r5969, r5970, r5971, r5972, r5973, r5974, r5975, r5976, r5977, r5978, r5979, r5980, r5981, r5982, r5983, r5984, r5985, r5986, r5987, r5988, r5989, r5990, r5991, r5992, r5993;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3408);
        mpfr_init(r5955);
        mpfr_init_set_str(r5956, "-4.716965670945614e+37", 10, MPFR_RNDN);
        mpfr_init(r5957);
        mpfr_init(r5958);
        mpfr_init(r5959);
        mpfr_init(r5960);
        mpfr_init_set_str(r5961, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r5962, "1/2", 10, MPFR_RNDN);
        mpfr_init(r5963);
        mpfr_init(r5964);
        mpfr_init_set_str(r5965, "-1.6276309842825124e-141", 10, MPFR_RNDN);
        mpfr_init(r5966);
        mpfr_init(r5967);
        mpfr_init(r5968);
        mpfr_init(r5969);
        mpfr_init(r5970);
        mpfr_init(r5971);
        mpfr_init(r5972);
        mpfr_init(r5973);
        mpfr_init(r5974);
        mpfr_init(r5975);
        mpfr_init(r5976);
        mpfr_init_set_str(r5977, "1.0989486611216948e+147", 10, MPFR_RNDN);
        mpfr_init(r5978);
        mpfr_init(r5979);
        mpfr_init(r5980);
        mpfr_init(r5981);
        mpfr_init(r5982);
        mpfr_init(r5983);
        mpfr_init(r5984);
        mpfr_init(r5985);
        mpfr_init(r5986);
        mpfr_init(r5987);
        mpfr_init(r5988);
        mpfr_init(r5989);
        mpfr_init(r5990);
        mpfr_init(r5991);
        mpfr_init(r5992);
        mpfr_init(r5993);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r5955, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r5957, mpfr_cmp(r5955, r5956) <= 0, MPFR_RNDN);
        mpfr_set_d(r5958, c, MPFR_RNDN);
        mpfr_neg(r5959, r5958, MPFR_RNDN);
        mpfr_div(r5960, r5959, r5955, MPFR_RNDN);
        ;
        ;
        mpfr_div(r5963, r5961, r5962, MPFR_RNDN);
        mpfr_div(r5964, r5960, r5963, MPFR_RNDN);
        ;
        mpfr_set_si(r5966, mpfr_cmp(r5955, r5965) <= 0, MPFR_RNDN);
        mpfr_mul(r5967, r5955, r5955, MPFR_RNDN);
        mpfr_set_d(r5968, a, MPFR_RNDN);
        mpfr_mul(r5969, r5958, r5968, MPFR_RNDN);
        mpfr_sub(r5970, r5967, r5969, MPFR_RNDN);
        mpfr_sqrt(r5971, r5970, MPFR_RNDN);
        mpfr_sub(r5972, r5971, r5955, MPFR_RNDN);
        mpfr_div(r5973, r5958, r5972, MPFR_RNDN);
        mpfr_cbrt(r5974, r5973, MPFR_RNDN);
        mpfr_mul(r5975, r5974, r5974, MPFR_RNDN);
        mpfr_mul(r5976, r5975, r5974, MPFR_RNDN);
        ;
        mpfr_set_si(r5978, mpfr_cmp(r5955, r5977) <= 0, MPFR_RNDN);
        mpfr_neg(r5979, r5955, MPFR_RNDN);
        mpfr_mul(r5980, r5968, r5958, MPFR_RNDN);
        mpfr_sub(r5981, r5967, r5980, MPFR_RNDN);
        mpfr_sqrt(r5982, r5981, MPFR_RNDN);
        mpfr_sub(r5983, r5979, r5982, MPFR_RNDN);
        mpfr_div(r5984, r5983, r5968, MPFR_RNDN);
        mpfr_div(r5985, r5968, r5955, MPFR_RNDN);
        mpfr_mul(r5986, r5962, r5958, MPFR_RNDN);
        mpfr_mul(r5987, r5985, r5986, MPFR_RNDN);
        mpfr_add(r5988, r5955, r5955, MPFR_RNDN);
        mpfr_sub(r5989, r5987, r5988, MPFR_RNDN);
        mpfr_div(r5990, r5989, r5968, MPFR_RNDN);
        if (mpfr_get_si(r5978, MPFR_RNDN)) { mpfr_set(r5991, r5984, MPFR_RNDN); } else { mpfr_set(r5991, r5990, MPFR_RNDN); };
        if (mpfr_get_si(r5966, MPFR_RNDN)) { mpfr_set(r5992, r5976, MPFR_RNDN); } else { mpfr_set(r5992, r5991, MPFR_RNDN); };
        if (mpfr_get_si(r5957, MPFR_RNDN)) { mpfr_set(r5993, r5964, MPFR_RNDN); } else { mpfr_set(r5993, r5992, MPFR_RNDN); };
        return mpfr_get_d(r5993, MPFR_RNDN);
}

