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

char *name = "quad2p (problem 3.2.1, positive)";

double f_if(float a, float b_2F2, float c) {
        float r20668 = b_2F2;
        float r20669 = -r20668;
        float r20670 = r20668 * r20668;
        float r20671 = a;
        float r20672 = c;
        float r20673 = r20671 * r20672;
        float r20674 = r20670 - r20673;
        float r20675 = sqrt(r20674);
        float r20676 = r20669 + r20675;
        float r20677 = r20676 / r20671;
        return r20677;
}

double f_id(double a, double b_2F2, double c) {
        double r20678 = b_2F2;
        double r20679 = -r20678;
        double r20680 = r20678 * r20678;
        double r20681 = a;
        double r20682 = c;
        double r20683 = r20681 * r20682;
        double r20684 = r20680 - r20683;
        double r20685 = sqrt(r20684);
        double r20686 = r20679 + r20685;
        double r20687 = r20686 / r20681;
        return r20687;
}


double f_of(float a, float b_2F2, float c) {
        float r20688 = b_2F2;
        float r20689 = -3.9996729660226635e+88;
        bool r20690 = r20688 <= r20689;
        float r20691 = 1/2;
        float r20692 = c;
        float r20693 = r20692 / r20688;
        float r20694 = r20691 * r20693;
        float r20695 = 2;
        float r20696 = a;
        float r20697 = r20688 / r20696;
        float r20698 = r20695 * r20697;
        float r20699 = r20694 - r20698;
        float r20700 = -9.051221972079937e-232;
        bool r20701 = r20688 <= r20700;
        float r20702 = -r20688;
        float r20703 = r20688 * r20688;
        float r20704 = r20696 * r20692;
        float r20705 = r20703 - r20704;
        float r20706 = sqrt(r20705);
        float r20707 = r20702 + r20706;
        float r20708 = 1;
        float r20709 = r20708 / r20696;
        float r20710 = r20707 * r20709;
        float r20711 = 5.445054255281422e+99;
        bool r20712 = r20688 <= r20711;
        float r20713 = r20702 - r20706;
        float r20714 = r20692 / r20713;
        float r20715 = -1/2;
        float r20716 = r20693 * r20715;
        float r20717 = r20712 ? r20714 : r20716;
        float r20718 = r20701 ? r20710 : r20717;
        float r20719 = r20690 ? r20699 : r20718;
        return r20719;
}

double f_od(double a, double b_2F2, double c) {
        double r20720 = b_2F2;
        double r20721 = -3.9996729660226635e+88;
        bool r20722 = r20720 <= r20721;
        double r20723 = 1/2;
        double r20724 = c;
        double r20725 = r20724 / r20720;
        double r20726 = r20723 * r20725;
        double r20727 = 2;
        double r20728 = a;
        double r20729 = r20720 / r20728;
        double r20730 = r20727 * r20729;
        double r20731 = r20726 - r20730;
        double r20732 = -9.051221972079937e-232;
        bool r20733 = r20720 <= r20732;
        double r20734 = -r20720;
        double r20735 = r20720 * r20720;
        double r20736 = r20728 * r20724;
        double r20737 = r20735 - r20736;
        double r20738 = sqrt(r20737);
        double r20739 = r20734 + r20738;
        double r20740 = 1;
        double r20741 = r20740 / r20728;
        double r20742 = r20739 * r20741;
        double r20743 = 5.445054255281422e+99;
        bool r20744 = r20720 <= r20743;
        double r20745 = r20734 - r20738;
        double r20746 = r20724 / r20745;
        double r20747 = -1/2;
        double r20748 = r20725 * r20747;
        double r20749 = r20744 ? r20746 : r20748;
        double r20750 = r20733 ? r20742 : r20749;
        double r20751 = r20722 ? r20731 : r20750;
        return r20751;
}

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 r20752, r20753, r20754, r20755, r20756, r20757, r20758, r20759, r20760, r20761;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20752);
        mpfr_init(r20753);
        mpfr_init(r20754);
        mpfr_init(r20755);
        mpfr_init(r20756);
        mpfr_init(r20757);
        mpfr_init(r20758);
        mpfr_init(r20759);
        mpfr_init(r20760);
        mpfr_init(r20761);
}

double f_im(double a, double b_2F2, double c) {
        mpfr_set_d(r20752, b_2F2, MPFR_RNDN);
        mpfr_neg(r20753, r20752, MPFR_RNDN);
        mpfr_mul(r20754, r20752, r20752, MPFR_RNDN);
        mpfr_set_d(r20755, a, MPFR_RNDN);
        mpfr_set_d(r20756, c, MPFR_RNDN);
        mpfr_mul(r20757, r20755, r20756, MPFR_RNDN);
        mpfr_sub(r20758, r20754, r20757, MPFR_RNDN);
        mpfr_sqrt(r20759, r20758, MPFR_RNDN);
        mpfr_add(r20760, r20753, r20759, MPFR_RNDN);
        mpfr_div(r20761, r20760, r20755, MPFR_RNDN);
        return mpfr_get_d(r20761, MPFR_RNDN);
}

static mpfr_t r20762, r20763, r20764, r20765, r20766, r20767, r20768, r20769, r20770, r20771, r20772, r20773, r20774, r20775, r20776, r20777, r20778, r20779, r20780, r20781, r20782, r20783, r20784, r20785, r20786, r20787, r20788, r20789, r20790, r20791, r20792, r20793;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20762);
        mpfr_init_set_str(r20763, "-3.9996729660226635e+88", 10, MPFR_RNDN);
        mpfr_init(r20764);
        mpfr_init_set_str(r20765, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20766);
        mpfr_init(r20767);
        mpfr_init(r20768);
        mpfr_init_set_str(r20769, "2", 10, MPFR_RNDN);
        mpfr_init(r20770);
        mpfr_init(r20771);
        mpfr_init(r20772);
        mpfr_init(r20773);
        mpfr_init_set_str(r20774, "-9.051221972079937e-232", 10, MPFR_RNDN);
        mpfr_init(r20775);
        mpfr_init(r20776);
        mpfr_init(r20777);
        mpfr_init(r20778);
        mpfr_init(r20779);
        mpfr_init(r20780);
        mpfr_init(r20781);
        mpfr_init_set_str(r20782, "1", 10, MPFR_RNDN);
        mpfr_init(r20783);
        mpfr_init(r20784);
        mpfr_init_set_str(r20785, "5.445054255281422e+99", 10, MPFR_RNDN);
        mpfr_init(r20786);
        mpfr_init(r20787);
        mpfr_init(r20788);
        mpfr_init_set_str(r20789, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20790);
        mpfr_init(r20791);
        mpfr_init(r20792);
        mpfr_init(r20793);
}

double f_fm(double a, double b_2F2, double c) {
        mpfr_set_d(r20762, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20764, mpfr_cmp(r20762, r20763) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20766, c, MPFR_RNDN);
        mpfr_div(r20767, r20766, r20762, MPFR_RNDN);
        mpfr_mul(r20768, r20765, r20767, MPFR_RNDN);
        ;
        mpfr_set_d(r20770, a, MPFR_RNDN);
        mpfr_div(r20771, r20762, r20770, MPFR_RNDN);
        mpfr_mul(r20772, r20769, r20771, MPFR_RNDN);
        mpfr_sub(r20773, r20768, r20772, MPFR_RNDN);
        ;
        mpfr_set_si(r20775, mpfr_cmp(r20762, r20774) <= 0, MPFR_RNDN);
        mpfr_neg(r20776, r20762, MPFR_RNDN);
        mpfr_mul(r20777, r20762, r20762, MPFR_RNDN);
        mpfr_mul(r20778, r20770, r20766, MPFR_RNDN);
        mpfr_sub(r20779, r20777, r20778, MPFR_RNDN);
        mpfr_sqrt(r20780, r20779, MPFR_RNDN);
        mpfr_add(r20781, r20776, r20780, MPFR_RNDN);
        ;
        mpfr_div(r20783, r20782, r20770, MPFR_RNDN);
        mpfr_mul(r20784, r20781, r20783, MPFR_RNDN);
        ;
        mpfr_set_si(r20786, mpfr_cmp(r20762, r20785) <= 0, MPFR_RNDN);
        mpfr_sub(r20787, r20776, r20780, MPFR_RNDN);
        mpfr_div(r20788, r20766, r20787, MPFR_RNDN);
        ;
        mpfr_mul(r20790, r20767, r20789, MPFR_RNDN);
        if (mpfr_get_si(r20786, MPFR_RNDN)) { mpfr_set(r20791, r20788, MPFR_RNDN); } else { mpfr_set(r20791, r20790, MPFR_RNDN); };
        if (mpfr_get_si(r20775, MPFR_RNDN)) { mpfr_set(r20792, r20784, MPFR_RNDN); } else { mpfr_set(r20792, r20791, MPFR_RNDN); };
        if (mpfr_get_si(r20764, MPFR_RNDN)) { mpfr_set(r20793, r20773, MPFR_RNDN); } else { mpfr_set(r20793, r20792, MPFR_RNDN); };
        return mpfr_get_d(r20793, MPFR_RNDN);
}

static mpfr_t r20794, r20795, r20796, r20797, r20798, r20799, r20800, r20801, r20802, r20803, r20804, r20805, r20806, r20807, r20808, r20809, r20810, r20811, r20812, r20813, r20814, r20815, r20816, r20817, r20818, r20819, r20820, r20821, r20822, r20823, r20824, r20825;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3216);
        mpfr_init(r20794);
        mpfr_init_set_str(r20795, "-3.9996729660226635e+88", 10, MPFR_RNDN);
        mpfr_init(r20796);
        mpfr_init_set_str(r20797, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20798);
        mpfr_init(r20799);
        mpfr_init(r20800);
        mpfr_init_set_str(r20801, "2", 10, MPFR_RNDN);
        mpfr_init(r20802);
        mpfr_init(r20803);
        mpfr_init(r20804);
        mpfr_init(r20805);
        mpfr_init_set_str(r20806, "-9.051221972079937e-232", 10, MPFR_RNDN);
        mpfr_init(r20807);
        mpfr_init(r20808);
        mpfr_init(r20809);
        mpfr_init(r20810);
        mpfr_init(r20811);
        mpfr_init(r20812);
        mpfr_init(r20813);
        mpfr_init_set_str(r20814, "1", 10, MPFR_RNDN);
        mpfr_init(r20815);
        mpfr_init(r20816);
        mpfr_init_set_str(r20817, "5.445054255281422e+99", 10, MPFR_RNDN);
        mpfr_init(r20818);
        mpfr_init(r20819);
        mpfr_init(r20820);
        mpfr_init_set_str(r20821, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20822);
        mpfr_init(r20823);
        mpfr_init(r20824);
        mpfr_init(r20825);
}

double f_dm(double a, double b_2F2, double c) {
        mpfr_set_d(r20794, b_2F2, MPFR_RNDN);
        ;
        mpfr_set_si(r20796, mpfr_cmp(r20794, r20795) <= 0, MPFR_RNDN);
        ;
        mpfr_set_d(r20798, c, MPFR_RNDN);
        mpfr_div(r20799, r20798, r20794, MPFR_RNDN);
        mpfr_mul(r20800, r20797, r20799, MPFR_RNDN);
        ;
        mpfr_set_d(r20802, a, MPFR_RNDN);
        mpfr_div(r20803, r20794, r20802, MPFR_RNDN);
        mpfr_mul(r20804, r20801, r20803, MPFR_RNDN);
        mpfr_sub(r20805, r20800, r20804, MPFR_RNDN);
        ;
        mpfr_set_si(r20807, mpfr_cmp(r20794, r20806) <= 0, MPFR_RNDN);
        mpfr_neg(r20808, r20794, MPFR_RNDN);
        mpfr_mul(r20809, r20794, r20794, MPFR_RNDN);
        mpfr_mul(r20810, r20802, r20798, MPFR_RNDN);
        mpfr_sub(r20811, r20809, r20810, MPFR_RNDN);
        mpfr_sqrt(r20812, r20811, MPFR_RNDN);
        mpfr_add(r20813, r20808, r20812, MPFR_RNDN);
        ;
        mpfr_div(r20815, r20814, r20802, MPFR_RNDN);
        mpfr_mul(r20816, r20813, r20815, MPFR_RNDN);
        ;
        mpfr_set_si(r20818, mpfr_cmp(r20794, r20817) <= 0, MPFR_RNDN);
        mpfr_sub(r20819, r20808, r20812, MPFR_RNDN);
        mpfr_div(r20820, r20798, r20819, MPFR_RNDN);
        ;
        mpfr_mul(r20822, r20799, r20821, MPFR_RNDN);
        if (mpfr_get_si(r20818, MPFR_RNDN)) { mpfr_set(r20823, r20820, MPFR_RNDN); } else { mpfr_set(r20823, r20822, MPFR_RNDN); };
        if (mpfr_get_si(r20807, MPFR_RNDN)) { mpfr_set(r20824, r20816, MPFR_RNDN); } else { mpfr_set(r20824, r20823, MPFR_RNDN); };
        if (mpfr_get_si(r20796, MPFR_RNDN)) { mpfr_set(r20825, r20805, MPFR_RNDN); } else { mpfr_set(r20825, r20824, MPFR_RNDN); };
        return mpfr_get_d(r20825, MPFR_RNDN);
}