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

char *name = "Jmat.Real.erfi, branch x less than or equal to 0.5";

double f_if(float x) {
        float r24591 = 1;
        float r24592 = atan2(1.0, 0.0);
        float r24593 = sqrt(r24592);
        float r24594 = r24591 / r24593;
        float r24595 = 2;
        float r24596 = x;
        float r24597 = fabs(r24596);
        float r24598 = r24595 * r24597;
        float r24599 = 3;
        float r24600 = r24595 / r24599;
        float r24601 = r24597 * r24597;
        float r24602 = r24601 * r24597;
        float r24603 = r24600 * r24602;
        float r24604 = r24598 + r24603;
        float r24605 = 5;
        float r24606 = r24591 / r24605;
        float r24607 = r24602 * r24597;
        float r24608 = r24607 * r24597;
        float r24609 = r24606 * r24608;
        float r24610 = r24604 + r24609;
        float r24611 = 21;
        float r24612 = r24591 / r24611;
        float r24613 = r24608 * r24597;
        float r24614 = r24613 * r24597;
        float r24615 = r24612 * r24614;
        float r24616 = r24610 + r24615;
        float r24617 = r24594 * r24616;
        float r24618 = fabs(r24617);
        return r24618;
}

double f_id(double x) {
        double r24619 = 1;
        double r24620 = atan2(1.0, 0.0);
        double r24621 = sqrt(r24620);
        double r24622 = r24619 / r24621;
        double r24623 = 2;
        double r24624 = x;
        double r24625 = fabs(r24624);
        double r24626 = r24623 * r24625;
        double r24627 = 3;
        double r24628 = r24623 / r24627;
        double r24629 = r24625 * r24625;
        double r24630 = r24629 * r24625;
        double r24631 = r24628 * r24630;
        double r24632 = r24626 + r24631;
        double r24633 = 5;
        double r24634 = r24619 / r24633;
        double r24635 = r24630 * r24625;
        double r24636 = r24635 * r24625;
        double r24637 = r24634 * r24636;
        double r24638 = r24632 + r24637;
        double r24639 = 21;
        double r24640 = r24619 / r24639;
        double r24641 = r24636 * r24625;
        double r24642 = r24641 * r24625;
        double r24643 = r24640 * r24642;
        double r24644 = r24638 + r24643;
        double r24645 = r24622 * r24644;
        double r24646 = fabs(r24645);
        return r24646;
}


double f_of(float x) {
        float r24647 = 1;
        float r24648 = atan2(1.0, 0.0);
        float r24649 = sqrt(r24648);
        float r24650 = r24647 / r24649;
        float r24651 = 2;
        float r24652 = x;
        float r24653 = fabs(r24652);
        float r24654 = r24651 * r24653;
        float r24655 = 3;
        float r24656 = r24651 / r24655;
        float r24657 = r24653 * r24653;
        float r24658 = r24657 * r24653;
        float r24659 = r24656 * r24658;
        float r24660 = r24654 + r24659;
        float r24661 = 5;
        float r24662 = r24647 / r24661;
        float r24663 = r24658 * r24653;
        float r24664 = r24663 * r24653;
        float r24665 = r24662 * r24664;
        float r24666 = r24660 + r24665;
        float r24667 = r24650 * r24666;
        float r24668 = r24653 / r24649;
        float r24669 = 21;
        float r24670 = r24668 / r24669;
        float r24671 = pow(r24653, r24655);
        float r24672 = r24671 * r24671;
        float r24673 = r24670 * r24672;
        float r24674 = r24667 + r24673;
        float r24675 = fabs(r24674);
        return r24675;
}

double f_od(double x) {
        double r24676 = 1;
        double r24677 = atan2(1.0, 0.0);
        double r24678 = sqrt(r24677);
        double r24679 = r24676 / r24678;
        double r24680 = 2;
        double r24681 = x;
        double r24682 = fabs(r24681);
        double r24683 = r24680 * r24682;
        double r24684 = 3;
        double r24685 = r24680 / r24684;
        double r24686 = r24682 * r24682;
        double r24687 = r24686 * r24682;
        double r24688 = r24685 * r24687;
        double r24689 = r24683 + r24688;
        double r24690 = 5;
        double r24691 = r24676 / r24690;
        double r24692 = r24687 * r24682;
        double r24693 = r24692 * r24682;
        double r24694 = r24691 * r24693;
        double r24695 = r24689 + r24694;
        double r24696 = r24679 * r24695;
        double r24697 = r24682 / r24678;
        double r24698 = 21;
        double r24699 = r24697 / r24698;
        double r24700 = pow(r24682, r24684);
        double r24701 = r24700 * r24700;
        double r24702 = r24699 * r24701;
        double r24703 = r24696 + r24702;
        double r24704 = fabs(r24703);
        return r24704;
}

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 r24705, r24706, r24707, r24708, r24709, r24710, r24711, r24712, r24713, r24714, r24715, r24716, r24717, r24718, r24719, r24720, r24721, r24722, r24723, r24724, r24725, r24726, r24727, r24728, r24729, r24730, r24731, r24732;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(592);
        mpfr_init_set_str(r24705, "1", 10, MPFR_RNDN);
        mpfr_init(r24706);
        mpfr_init(r24707);
        mpfr_init(r24708);
        mpfr_init_set_str(r24709, "2", 10, MPFR_RNDN);
        mpfr_init(r24710);
        mpfr_init(r24711);
        mpfr_init(r24712);
        mpfr_init_set_str(r24713, "3", 10, MPFR_RNDN);
        mpfr_init(r24714);
        mpfr_init(r24715);
        mpfr_init(r24716);
        mpfr_init(r24717);
        mpfr_init(r24718);
        mpfr_init_set_str(r24719, "5", 10, MPFR_RNDN);
        mpfr_init(r24720);
        mpfr_init(r24721);
        mpfr_init(r24722);
        mpfr_init(r24723);
        mpfr_init(r24724);
        mpfr_init_set_str(r24725, "21", 10, MPFR_RNDN);
        mpfr_init(r24726);
        mpfr_init(r24727);
        mpfr_init(r24728);
        mpfr_init(r24729);
        mpfr_init(r24730);
        mpfr_init(r24731);
        mpfr_init(r24732);
}

double f_im(double x) {
        ;
        mpfr_const_pi(r24706, MPFR_RNDN);
        mpfr_sqrt(r24707, r24706, MPFR_RNDN);
        mpfr_div(r24708, r24705, r24707, MPFR_RNDN);
        ;
        mpfr_set_d(r24710, x, MPFR_RNDN);
        mpfr_abs(r24711, r24710, MPFR_RNDN);
        mpfr_mul(r24712, r24709, r24711, MPFR_RNDN);
        ;
        mpfr_div(r24714, r24709, r24713, MPFR_RNDN);
        mpfr_mul(r24715, r24711, r24711, MPFR_RNDN);
        mpfr_mul(r24716, r24715, r24711, MPFR_RNDN);
        mpfr_mul(r24717, r24714, r24716, MPFR_RNDN);
        mpfr_add(r24718, r24712, r24717, MPFR_RNDN);
        ;
        mpfr_div(r24720, r24705, r24719, MPFR_RNDN);
        mpfr_mul(r24721, r24716, r24711, MPFR_RNDN);
        mpfr_mul(r24722, r24721, r24711, MPFR_RNDN);
        mpfr_mul(r24723, r24720, r24722, MPFR_RNDN);
        mpfr_add(r24724, r24718, r24723, MPFR_RNDN);
        ;
        mpfr_div(r24726, r24705, r24725, MPFR_RNDN);
        mpfr_mul(r24727, r24722, r24711, MPFR_RNDN);
        mpfr_mul(r24728, r24727, r24711, MPFR_RNDN);
        mpfr_mul(r24729, r24726, r24728, MPFR_RNDN);
        mpfr_add(r24730, r24724, r24729, MPFR_RNDN);
        mpfr_mul(r24731, r24708, r24730, MPFR_RNDN);
        mpfr_abs(r24732, r24731, MPFR_RNDN);
        return mpfr_get_d(r24732, MPFR_RNDN);
}

static mpfr_t r24733, r24734, r24735, r24736, r24737, r24738, r24739, r24740, r24741, r24742, r24743, r24744, r24745, r24746, r24747, r24748, r24749, r24750, r24751, r24752, r24753, r24754, r24755, r24756, r24757, r24758, r24759, r24760, r24761;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(592);
        mpfr_init_set_str(r24733, "1", 10, MPFR_RNDN);
        mpfr_init(r24734);
        mpfr_init(r24735);
        mpfr_init(r24736);
        mpfr_init_set_str(r24737, "2", 10, MPFR_RNDN);
        mpfr_init(r24738);
        mpfr_init(r24739);
        mpfr_init(r24740);
        mpfr_init_set_str(r24741, "3", 10, MPFR_RNDN);
        mpfr_init(r24742);
        mpfr_init(r24743);
        mpfr_init(r24744);
        mpfr_init(r24745);
        mpfr_init(r24746);
        mpfr_init_set_str(r24747, "5", 10, MPFR_RNDN);
        mpfr_init(r24748);
        mpfr_init(r24749);
        mpfr_init(r24750);
        mpfr_init(r24751);
        mpfr_init(r24752);
        mpfr_init(r24753);
        mpfr_init(r24754);
        mpfr_init_set_str(r24755, "21", 10, MPFR_RNDN);
        mpfr_init(r24756);
        mpfr_init(r24757);
        mpfr_init(r24758);
        mpfr_init(r24759);
        mpfr_init(r24760);
        mpfr_init(r24761);
}

double f_fm(double x) {
        ;
        mpfr_const_pi(r24734, MPFR_RNDN);
        mpfr_sqrt(r24735, r24734, MPFR_RNDN);
        mpfr_div(r24736, r24733, r24735, MPFR_RNDN);
        ;
        mpfr_set_d(r24738, x, MPFR_RNDN);
        mpfr_abs(r24739, r24738, MPFR_RNDN);
        mpfr_mul(r24740, r24737, r24739, MPFR_RNDN);
        ;
        mpfr_div(r24742, r24737, r24741, MPFR_RNDN);
        mpfr_mul(r24743, r24739, r24739, MPFR_RNDN);
        mpfr_mul(r24744, r24743, r24739, MPFR_RNDN);
        mpfr_mul(r24745, r24742, r24744, MPFR_RNDN);
        mpfr_add(r24746, r24740, r24745, MPFR_RNDN);
        ;
        mpfr_div(r24748, r24733, r24747, MPFR_RNDN);
        mpfr_mul(r24749, r24744, r24739, MPFR_RNDN);
        mpfr_mul(r24750, r24749, r24739, MPFR_RNDN);
        mpfr_mul(r24751, r24748, r24750, MPFR_RNDN);
        mpfr_add(r24752, r24746, r24751, MPFR_RNDN);
        mpfr_mul(r24753, r24736, r24752, MPFR_RNDN);
        mpfr_div(r24754, r24739, r24735, MPFR_RNDN);
        ;
        mpfr_div(r24756, r24754, r24755, MPFR_RNDN);
        mpfr_pow(r24757, r24739, r24741, MPFR_RNDN);
        mpfr_mul(r24758, r24757, r24757, MPFR_RNDN);
        mpfr_mul(r24759, r24756, r24758, MPFR_RNDN);
        mpfr_add(r24760, r24753, r24759, MPFR_RNDN);
        mpfr_abs(r24761, r24760, MPFR_RNDN);
        return mpfr_get_d(r24761, MPFR_RNDN);
}

static mpfr_t r24762, r24763, r24764, r24765, r24766, r24767, r24768, r24769, r24770, r24771, r24772, r24773, r24774, r24775, r24776, r24777, r24778, r24779, r24780, r24781, r24782, r24783, r24784, r24785, r24786, r24787, r24788, r24789, r24790;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(592);
        mpfr_init_set_str(r24762, "1", 10, MPFR_RNDN);
        mpfr_init(r24763);
        mpfr_init(r24764);
        mpfr_init(r24765);
        mpfr_init_set_str(r24766, "2", 10, MPFR_RNDN);
        mpfr_init(r24767);
        mpfr_init(r24768);
        mpfr_init(r24769);
        mpfr_init_set_str(r24770, "3", 10, MPFR_RNDN);
        mpfr_init(r24771);
        mpfr_init(r24772);
        mpfr_init(r24773);
        mpfr_init(r24774);
        mpfr_init(r24775);
        mpfr_init_set_str(r24776, "5", 10, MPFR_RNDN);
        mpfr_init(r24777);
        mpfr_init(r24778);
        mpfr_init(r24779);
        mpfr_init(r24780);
        mpfr_init(r24781);
        mpfr_init(r24782);
        mpfr_init(r24783);
        mpfr_init_set_str(r24784, "21", 10, MPFR_RNDN);
        mpfr_init(r24785);
        mpfr_init(r24786);
        mpfr_init(r24787);
        mpfr_init(r24788);
        mpfr_init(r24789);
        mpfr_init(r24790);
}

double f_dm(double x) {
        ;
        mpfr_const_pi(r24763, MPFR_RNDN);
        mpfr_sqrt(r24764, r24763, MPFR_RNDN);
        mpfr_div(r24765, r24762, r24764, MPFR_RNDN);
        ;
        mpfr_set_d(r24767, x, MPFR_RNDN);
        mpfr_abs(r24768, r24767, MPFR_RNDN);
        mpfr_mul(r24769, r24766, r24768, MPFR_RNDN);
        ;
        mpfr_div(r24771, r24766, r24770, MPFR_RNDN);
        mpfr_mul(r24772, r24768, r24768, MPFR_RNDN);
        mpfr_mul(r24773, r24772, r24768, MPFR_RNDN);
        mpfr_mul(r24774, r24771, r24773, MPFR_RNDN);
        mpfr_add(r24775, r24769, r24774, MPFR_RNDN);
        ;
        mpfr_div(r24777, r24762, r24776, MPFR_RNDN);
        mpfr_mul(r24778, r24773, r24768, MPFR_RNDN);
        mpfr_mul(r24779, r24778, r24768, MPFR_RNDN);
        mpfr_mul(r24780, r24777, r24779, MPFR_RNDN);
        mpfr_add(r24781, r24775, r24780, MPFR_RNDN);
        mpfr_mul(r24782, r24765, r24781, MPFR_RNDN);
        mpfr_div(r24783, r24768, r24764, MPFR_RNDN);
        ;
        mpfr_div(r24785, r24783, r24784, MPFR_RNDN);
        mpfr_pow(r24786, r24768, r24770, MPFR_RNDN);
        mpfr_mul(r24787, r24786, r24786, MPFR_RNDN);
        mpfr_mul(r24788, r24785, r24787, MPFR_RNDN);
        mpfr_add(r24789, r24782, r24788, MPFR_RNDN);
        mpfr_abs(r24790, r24789, MPFR_RNDN);
        return mpfr_get_d(r24790, MPFR_RNDN);
}

