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

char *name = "quadp (p42, positive)";

double f_if(float a, float b, float c) {
        float r20595 = b;
        float r20596 = -r20595;
        float r20597 = r20595 * r20595;
        float r20598 = 4;
        float r20599 = a;
        float r20600 = c;
        float r20601 = r20599 * r20600;
        float r20602 = r20598 * r20601;
        float r20603 = r20597 - r20602;
        float r20604 = sqrt(r20603);
        float r20605 = r20596 + r20604;
        float r20606 = 2;
        float r20607 = r20606 * r20599;
        float r20608 = r20605 / r20607;
        return r20608;
}

double f_id(double a, double b, double c) {
        double r20609 = b;
        double r20610 = -r20609;
        double r20611 = r20609 * r20609;
        double r20612 = 4;
        double r20613 = a;
        double r20614 = c;
        double r20615 = r20613 * r20614;
        double r20616 = r20612 * r20615;
        double r20617 = r20611 - r20616;
        double r20618 = sqrt(r20617);
        double r20619 = r20610 + r20618;
        double r20620 = 2;
        double r20621 = r20620 * r20613;
        double r20622 = r20619 / r20621;
        return r20622;
}


double f_of(float a, float b, float c) {
        float r20623 = b;
        float r20624 = -8.111805193496531e+152;
        bool r20625 = r20623 <= r20624;
        float r20626 = -r20623;
        float r20627 = a;
        float r20628 = r20626 / r20627;
        float r20629 = 7.580412743766101e-138;
        bool r20630 = r20623 <= r20629;
        float r20631 = r20623 * r20623;
        float r20632 = 4;
        float r20633 = c;
        float r20634 = r20632 * r20633;
        float r20635 = r20634 * r20627;
        float r20636 = r20631 - r20635;
        float r20637 = sqrt(r20636);
        float r20638 = -r20637;
        float r20639 = r20623 + r20638;
        float r20640 = 2;
        float r20641 = r20640 * r20627;
        float r20642 = -r20641;
        float r20643 = r20639 / r20642;
        float r20644 = r20633 / r20623;
        float r20645 = -2;
        float r20646 = r20645 / r20640;
        float r20647 = r20644 * r20646;
        float r20648 = r20630 ? r20643 : r20647;
        float r20649 = r20625 ? r20628 : r20648;
        return r20649;
}

double f_od(double a, double b, double c) {
        double r20650 = b;
        double r20651 = -8.111805193496531e+152;
        bool r20652 = r20650 <= r20651;
        double r20653 = -r20650;
        double r20654 = a;
        double r20655 = r20653 / r20654;
        double r20656 = 7.580412743766101e-138;
        bool r20657 = r20650 <= r20656;
        double r20658 = r20650 * r20650;
        double r20659 = 4;
        double r20660 = c;
        double r20661 = r20659 * r20660;
        double r20662 = r20661 * r20654;
        double r20663 = r20658 - r20662;
        double r20664 = sqrt(r20663);
        double r20665 = -r20664;
        double r20666 = r20650 + r20665;
        double r20667 = 2;
        double r20668 = r20667 * r20654;
        double r20669 = -r20668;
        double r20670 = r20666 / r20669;
        double r20671 = r20660 / r20650;
        double r20672 = -2;
        double r20673 = r20672 / r20667;
        double r20674 = r20671 * r20673;
        double r20675 = r20657 ? r20670 : r20674;
        double r20676 = r20652 ? r20655 : r20675;
        return r20676;
}

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 r20677, r20678, r20679, r20680, r20681, r20682, r20683, r20684, r20685, r20686, r20687, r20688, r20689, r20690;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20677);
        mpfr_init(r20678);
        mpfr_init(r20679);
        mpfr_init_set_str(r20680, "4", 10, MPFR_RNDN);
        mpfr_init(r20681);
        mpfr_init(r20682);
        mpfr_init(r20683);
        mpfr_init(r20684);
        mpfr_init(r20685);
        mpfr_init(r20686);
        mpfr_init(r20687);
        mpfr_init_set_str(r20688, "2", 10, MPFR_RNDN);
        mpfr_init(r20689);
        mpfr_init(r20690);
}

double f_im(double a, double b, double c) {
        mpfr_set_d(r20677, b, MPFR_RNDN);
        mpfr_neg(r20678, r20677, MPFR_RNDN);
        mpfr_mul(r20679, r20677, r20677, MPFR_RNDN);
        ;
        mpfr_set_d(r20681, a, MPFR_RNDN);
        mpfr_set_d(r20682, c, MPFR_RNDN);
        mpfr_mul(r20683, r20681, r20682, MPFR_RNDN);
        mpfr_mul(r20684, r20680, r20683, MPFR_RNDN);
        mpfr_sub(r20685, r20679, r20684, MPFR_RNDN);
        mpfr_sqrt(r20686, r20685, MPFR_RNDN);
        mpfr_add(r20687, r20678, r20686, MPFR_RNDN);
        ;
        mpfr_mul(r20689, r20688, r20681, MPFR_RNDN);
        mpfr_div(r20690, r20687, r20689, MPFR_RNDN);
        return mpfr_get_d(r20690, MPFR_RNDN);
}

static mpfr_t r20691, r20692, r20693, r20694, r20695, r20696, r20697, r20698, r20699, r20700, r20701, r20702, r20703, r20704, r20705, r20706, r20707, r20708, r20709, r20710, r20711, r20712, r20713, r20714, r20715, r20716, r20717;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20691);
        mpfr_init_set_str(r20692, "-8.111805193496531e+152", 10, MPFR_RNDN);
        mpfr_init(r20693);
        mpfr_init(r20694);
        mpfr_init(r20695);
        mpfr_init(r20696);
        mpfr_init_set_str(r20697, "7.580412743766101e-138", 10, MPFR_RNDN);
        mpfr_init(r20698);
        mpfr_init(r20699);
        mpfr_init_set_str(r20700, "4", 10, MPFR_RNDN);
        mpfr_init(r20701);
        mpfr_init(r20702);
        mpfr_init(r20703);
        mpfr_init(r20704);
        mpfr_init(r20705);
        mpfr_init(r20706);
        mpfr_init(r20707);
        mpfr_init_set_str(r20708, "2", 10, MPFR_RNDN);
        mpfr_init(r20709);
        mpfr_init(r20710);
        mpfr_init(r20711);
        mpfr_init(r20712);
        mpfr_init_set_str(r20713, "-2", 10, MPFR_RNDN);
        mpfr_init(r20714);
        mpfr_init(r20715);
        mpfr_init(r20716);
        mpfr_init(r20717);
}

double f_fm(double a, double b, double c) {
        mpfr_set_d(r20691, b, MPFR_RNDN);
        ;
        mpfr_set_si(r20693, mpfr_cmp(r20691, r20692) <= 0, MPFR_RNDN);
        mpfr_neg(r20694, r20691, MPFR_RNDN);
        mpfr_set_d(r20695, a, MPFR_RNDN);
        mpfr_div(r20696, r20694, r20695, MPFR_RNDN);
        ;
        mpfr_set_si(r20698, mpfr_cmp(r20691, r20697) <= 0, MPFR_RNDN);
        mpfr_mul(r20699, r20691, r20691, MPFR_RNDN);
        ;
        mpfr_set_d(r20701, c, MPFR_RNDN);
        mpfr_mul(r20702, r20700, r20701, MPFR_RNDN);
        mpfr_mul(r20703, r20702, r20695, MPFR_RNDN);
        mpfr_sub(r20704, r20699, r20703, MPFR_RNDN);
        mpfr_sqrt(r20705, r20704, MPFR_RNDN);
        mpfr_neg(r20706, r20705, MPFR_RNDN);
        mpfr_add(r20707, r20691, r20706, MPFR_RNDN);
        ;
        mpfr_mul(r20709, r20708, r20695, MPFR_RNDN);
        mpfr_neg(r20710, r20709, MPFR_RNDN);
        mpfr_div(r20711, r20707, r20710, MPFR_RNDN);
        mpfr_div(r20712, r20701, r20691, MPFR_RNDN);
        ;
        mpfr_div(r20714, r20713, r20708, MPFR_RNDN);
        mpfr_mul(r20715, r20712, r20714, MPFR_RNDN);
        if (mpfr_get_si(r20698, MPFR_RNDN)) { mpfr_set(r20716, r20711, MPFR_RNDN); } else { mpfr_set(r20716, r20715, MPFR_RNDN); };
        if (mpfr_get_si(r20693, MPFR_RNDN)) { mpfr_set(r20717, r20696, MPFR_RNDN); } else { mpfr_set(r20717, r20716, MPFR_RNDN); };
        return mpfr_get_d(r20717, MPFR_RNDN);
}

static mpfr_t r20718, r20719, r20720, r20721, r20722, r20723, r20724, r20725, r20726, r20727, r20728, r20729, r20730, r20731, r20732, r20733, r20734, r20735, r20736, r20737, r20738, r20739, r20740, r20741, r20742, r20743, r20744;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(3472);
        mpfr_init(r20718);
        mpfr_init_set_str(r20719, "-8.111805193496531e+152", 10, MPFR_RNDN);
        mpfr_init(r20720);
        mpfr_init(r20721);
        mpfr_init(r20722);
        mpfr_init(r20723);
        mpfr_init_set_str(r20724, "7.580412743766101e-138", 10, MPFR_RNDN);
        mpfr_init(r20725);
        mpfr_init(r20726);
        mpfr_init_set_str(r20727, "4", 10, MPFR_RNDN);
        mpfr_init(r20728);
        mpfr_init(r20729);
        mpfr_init(r20730);
        mpfr_init(r20731);
        mpfr_init(r20732);
        mpfr_init(r20733);
        mpfr_init(r20734);
        mpfr_init_set_str(r20735, "2", 10, MPFR_RNDN);
        mpfr_init(r20736);
        mpfr_init(r20737);
        mpfr_init(r20738);
        mpfr_init(r20739);
        mpfr_init_set_str(r20740, "-2", 10, MPFR_RNDN);
        mpfr_init(r20741);
        mpfr_init(r20742);
        mpfr_init(r20743);
        mpfr_init(r20744);
}

double f_dm(double a, double b, double c) {
        mpfr_set_d(r20718, b, MPFR_RNDN);
        ;
        mpfr_set_si(r20720, mpfr_cmp(r20718, r20719) <= 0, MPFR_RNDN);
        mpfr_neg(r20721, r20718, MPFR_RNDN);
        mpfr_set_d(r20722, a, MPFR_RNDN);
        mpfr_div(r20723, r20721, r20722, MPFR_RNDN);
        ;
        mpfr_set_si(r20725, mpfr_cmp(r20718, r20724) <= 0, MPFR_RNDN);
        mpfr_mul(r20726, r20718, r20718, MPFR_RNDN);
        ;
        mpfr_set_d(r20728, c, MPFR_RNDN);
        mpfr_mul(r20729, r20727, r20728, MPFR_RNDN);
        mpfr_mul(r20730, r20729, r20722, MPFR_RNDN);
        mpfr_sub(r20731, r20726, r20730, MPFR_RNDN);
        mpfr_sqrt(r20732, r20731, MPFR_RNDN);
        mpfr_neg(r20733, r20732, MPFR_RNDN);
        mpfr_add(r20734, r20718, r20733, MPFR_RNDN);
        ;
        mpfr_mul(r20736, r20735, r20722, MPFR_RNDN);
        mpfr_neg(r20737, r20736, MPFR_RNDN);
        mpfr_div(r20738, r20734, r20737, MPFR_RNDN);
        mpfr_div(r20739, r20728, r20718, MPFR_RNDN);
        ;
        mpfr_div(r20741, r20740, r20735, MPFR_RNDN);
        mpfr_mul(r20742, r20739, r20741, MPFR_RNDN);
        if (mpfr_get_si(r20725, MPFR_RNDN)) { mpfr_set(r20743, r20738, MPFR_RNDN); } else { mpfr_set(r20743, r20742, MPFR_RNDN); };
        if (mpfr_get_si(r20720, MPFR_RNDN)) { mpfr_set(r20744, r20723, MPFR_RNDN); } else { mpfr_set(r20744, r20743, MPFR_RNDN); };
        return mpfr_get_d(r20744, MPFR_RNDN);
}