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

char *name = "3.9.1 imaginary part (p56)";

double f_if() {
        float r25578 = -1;
        float r25579 = 1;
        float r25580 = /* ERROR: no complex support in C */;
        float r25581 = r25580 * r25580;
        float r25582 = r25581 * r25580;
        float r25583 = r25582 * r25580;
        float r25584 = r25583 * r25580;
        float r25585 = r25584 * r25580;
        float r25586 = 6;
        float r25587 = 0;
        float r25588 = /* ERROR: no complex support in C */;
        float r25589 = r25588 * r25580;
        float r25590 = r25589 * r25580;
        float r25591 = r25590 * r25580;
        float r25592 = r25591 * r25580;
        float r25593 = r25592 * r25580;
        float r25594 = r25585 + r25593;
        float r25595 = 15;
        float r25596 = /* ERROR: no complex support in C */;
        float r25597 = r25596 * r25580;
        float r25598 = r25597 * r25580;
        float r25599 = r25598 * r25580;
        float r25600 = r25599 * r25580;
        float r25601 = r25594 + r25600;
        float r25602 = 20;
        float r25603 = /* ERROR: no complex support in C */;
        float r25604 = r25603 * r25580;
        float r25605 = r25604 * r25580;
        float r25606 = r25605 * r25580;
        float r25607 = r25601 + r25606;
        float r25608 = r25607 + r25598;
        float r25609 = r25608 + r25589;
        float r25610 = /* ERROR: no complex support in C */;
        float r25611 = r25609 + r25610;
        float r25612 = /* ERROR: no complex support in C */;
        return r25612;
}

double f_id() {
        double r25613 = -1;
        double r25614 = 1;
        double r25615 = /* ERROR: no complex support in C */;
        double r25616 = r25615 * r25615;
        double r25617 = r25616 * r25615;
        double r25618 = r25617 * r25615;
        double r25619 = r25618 * r25615;
        double r25620 = r25619 * r25615;
        double r25621 = 6;
        double r25622 = 0;
        double r25623 = /* ERROR: no complex support in C */;
        double r25624 = r25623 * r25615;
        double r25625 = r25624 * r25615;
        double r25626 = r25625 * r25615;
        double r25627 = r25626 * r25615;
        double r25628 = r25627 * r25615;
        double r25629 = r25620 + r25628;
        double r25630 = 15;
        double r25631 = /* ERROR: no complex support in C */;
        double r25632 = r25631 * r25615;
        double r25633 = r25632 * r25615;
        double r25634 = r25633 * r25615;
        double r25635 = r25634 * r25615;
        double r25636 = r25629 + r25635;
        double r25637 = 20;
        double r25638 = /* ERROR: no complex support in C */;
        double r25639 = r25638 * r25615;
        double r25640 = r25639 * r25615;
        double r25641 = r25640 * r25615;
        double r25642 = r25636 + r25641;
        double r25643 = r25642 + r25633;
        double r25644 = r25643 + r25624;
        double r25645 = /* ERROR: no complex support in C */;
        double r25646 = r25644 + r25645;
        double r25647 = /* ERROR: no complex support in C */;
        return r25647;
}


double f_of() {
        float r25648 = -1;
        float r25649 = 1;
        float r25650 = /* ERROR: no complex support in C */;
        float r25651 = r25650 * r25650;
        float r25652 = r25651 * r25650;
        float r25653 = r25652 * r25650;
        float r25654 = r25653 * r25650;
        float r25655 = r25654 * r25650;
        float r25656 = 6;
        float r25657 = 0;
        float r25658 = /* ERROR: no complex support in C */;
        float r25659 = r25658 * r25650;
        float r25660 = r25659 * r25650;
        float r25661 = r25660 * r25650;
        float r25662 = r25661 * r25650;
        float r25663 = r25662 * r25650;
        float r25664 = r25655 + r25663;
        float r25665 = 15;
        float r25666 = /* ERROR: no complex support in C */;
        float r25667 = r25666 * r25650;
        float r25668 = r25667 * r25650;
        float r25669 = r25668 * r25650;
        float r25670 = r25669 * r25650;
        float r25671 = r25664 + r25670;
        float r25672 = 20;
        float r25673 = /* ERROR: no complex support in C */;
        float r25674 = r25673 * r25650;
        float r25675 = r25674 * r25650;
        float r25676 = r25675 * r25650;
        float r25677 = r25671 + r25676;
        float r25678 = r25677 + r25668;
        float r25679 = r25678 + r25659;
        float r25680 = /* ERROR: no complex support in C */;
        float r25681 = r25679 + r25680;
        float r25682 = /* ERROR: no complex support in C */;
        return r25682;
}

double f_od() {
        double r25683 = -1;
        double r25684 = 1;
        double r25685 = /* ERROR: no complex support in C */;
        double r25686 = r25685 * r25685;
        double r25687 = r25686 * r25685;
        double r25688 = r25687 * r25685;
        double r25689 = r25688 * r25685;
        double r25690 = r25689 * r25685;
        double r25691 = 6;
        double r25692 = 0;
        double r25693 = /* ERROR: no complex support in C */;
        double r25694 = r25693 * r25685;
        double r25695 = r25694 * r25685;
        double r25696 = r25695 * r25685;
        double r25697 = r25696 * r25685;
        double r25698 = r25697 * r25685;
        double r25699 = r25690 + r25698;
        double r25700 = 15;
        double r25701 = /* ERROR: no complex support in C */;
        double r25702 = r25701 * r25685;
        double r25703 = r25702 * r25685;
        double r25704 = r25703 * r25685;
        double r25705 = r25704 * r25685;
        double r25706 = r25699 + r25705;
        double r25707 = 20;
        double r25708 = /* ERROR: no complex support in C */;
        double r25709 = r25708 * r25685;
        double r25710 = r25709 * r25685;
        double r25711 = r25710 * r25685;
        double r25712 = r25706 + r25711;
        double r25713 = r25712 + r25703;
        double r25714 = r25713 + r25694;
        double r25715 = /* ERROR: no complex support in C */;
        double r25716 = r25714 + r25715;
        double r25717 = /* ERROR: no complex support in C */;
        return r25717;
}

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 r25718, r25719, r25720, r25721, r25722, r25723, r25724, r25725, r25726, r25727, r25728, r25729, r25730, r25731, r25732, r25733, r25734, r25735, r25736, r25737, r25738, r25739, r25740, r25741, r25742, r25743, r25744, r25745, r25746, r25747, r25748, r25749, r25750, r25751, r25752;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r25718, "-1", 10, MPFR_RNDN);
        mpfr_init_set_str(r25719, "1", 10, MPFR_RNDN);
        mpfr_init(r25720);
        mpfr_init(r25721);
        mpfr_init(r25722);
        mpfr_init(r25723);
        mpfr_init(r25724);
        mpfr_init(r25725);
        mpfr_init_set_str(r25726, "6", 10, MPFR_RNDN);
        mpfr_init_set_str(r25727, "0", 10, MPFR_RNDN);
        mpfr_init(r25728);
        mpfr_init(r25729);
        mpfr_init(r25730);
        mpfr_init(r25731);
        mpfr_init(r25732);
        mpfr_init(r25733);
        mpfr_init(r25734);
        mpfr_init_set_str(r25735, "15", 10, MPFR_RNDN);
        mpfr_init(r25736);
        mpfr_init(r25737);
        mpfr_init(r25738);
        mpfr_init(r25739);
        mpfr_init(r25740);
        mpfr_init(r25741);
        mpfr_init_set_str(r25742, "20", 10, MPFR_RNDN);
        mpfr_init(r25743);
        mpfr_init(r25744);
        mpfr_init(r25745);
        mpfr_init(r25746);
        mpfr_init(r25747);
        mpfr_init(r25748);
        mpfr_init(r25749);
        mpfr_init(r25750);
        mpfr_init(r25751);
        mpfr_init(r25752);
}

double f_im() {
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25721, r25720, r25720, MPFR_RNDN);
        mpfr_mul(r25722, r25721, r25720, MPFR_RNDN);
        mpfr_mul(r25723, r25722, r25720, MPFR_RNDN);
        mpfr_mul(r25724, r25723, r25720, MPFR_RNDN);
        mpfr_mul(r25725, r25724, r25720, MPFR_RNDN);
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25729, r25728, r25720, MPFR_RNDN);
        mpfr_mul(r25730, r25729, r25720, MPFR_RNDN);
        mpfr_mul(r25731, r25730, r25720, MPFR_RNDN);
        mpfr_mul(r25732, r25731, r25720, MPFR_RNDN);
        mpfr_mul(r25733, r25732, r25720, MPFR_RNDN);
        mpfr_add(r25734, r25725, r25733, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25737, r25736, r25720, MPFR_RNDN);
        mpfr_mul(r25738, r25737, r25720, MPFR_RNDN);
        mpfr_mul(r25739, r25738, r25720, MPFR_RNDN);
        mpfr_mul(r25740, r25739, r25720, MPFR_RNDN);
        mpfr_add(r25741, r25734, r25740, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25744, r25743, r25720, MPFR_RNDN);
        mpfr_mul(r25745, r25744, r25720, MPFR_RNDN);
        mpfr_mul(r25746, r25745, r25720, MPFR_RNDN);
        mpfr_add(r25747, r25741, r25746, MPFR_RNDN);
        mpfr_add(r25748, r25747, r25738, MPFR_RNDN);
        mpfr_add(r25749, r25748, r25729, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_add(r25751, r25749, r25750, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r25752, MPFR_RNDN);
}

static mpfr_t r25753, r25754, r25755, r25756, r25757, r25758, r25759, r25760, r25761, r25762, r25763, r25764, r25765, r25766, r25767, r25768, r25769, r25770, r25771, r25772, r25773, r25774, r25775, r25776, r25777, r25778, r25779, r25780, r25781, r25782, r25783, r25784, r25785, r25786, r25787;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r25753, "-1", 10, MPFR_RNDN);
        mpfr_init_set_str(r25754, "1", 10, MPFR_RNDN);
        mpfr_init(r25755);
        mpfr_init(r25756);
        mpfr_init(r25757);
        mpfr_init(r25758);
        mpfr_init(r25759);
        mpfr_init(r25760);
        mpfr_init_set_str(r25761, "6", 10, MPFR_RNDN);
        mpfr_init_set_str(r25762, "0", 10, MPFR_RNDN);
        mpfr_init(r25763);
        mpfr_init(r25764);
        mpfr_init(r25765);
        mpfr_init(r25766);
        mpfr_init(r25767);
        mpfr_init(r25768);
        mpfr_init(r25769);
        mpfr_init_set_str(r25770, "15", 10, MPFR_RNDN);
        mpfr_init(r25771);
        mpfr_init(r25772);
        mpfr_init(r25773);
        mpfr_init(r25774);
        mpfr_init(r25775);
        mpfr_init(r25776);
        mpfr_init_set_str(r25777, "20", 10, MPFR_RNDN);
        mpfr_init(r25778);
        mpfr_init(r25779);
        mpfr_init(r25780);
        mpfr_init(r25781);
        mpfr_init(r25782);
        mpfr_init(r25783);
        mpfr_init(r25784);
        mpfr_init(r25785);
        mpfr_init(r25786);
        mpfr_init(r25787);
}

double f_fm() {
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25756, r25755, r25755, MPFR_RNDN);
        mpfr_mul(r25757, r25756, r25755, MPFR_RNDN);
        mpfr_mul(r25758, r25757, r25755, MPFR_RNDN);
        mpfr_mul(r25759, r25758, r25755, MPFR_RNDN);
        mpfr_mul(r25760, r25759, r25755, MPFR_RNDN);
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25764, r25763, r25755, MPFR_RNDN);
        mpfr_mul(r25765, r25764, r25755, MPFR_RNDN);
        mpfr_mul(r25766, r25765, r25755, MPFR_RNDN);
        mpfr_mul(r25767, r25766, r25755, MPFR_RNDN);
        mpfr_mul(r25768, r25767, r25755, MPFR_RNDN);
        mpfr_add(r25769, r25760, r25768, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25772, r25771, r25755, MPFR_RNDN);
        mpfr_mul(r25773, r25772, r25755, MPFR_RNDN);
        mpfr_mul(r25774, r25773, r25755, MPFR_RNDN);
        mpfr_mul(r25775, r25774, r25755, MPFR_RNDN);
        mpfr_add(r25776, r25769, r25775, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25779, r25778, r25755, MPFR_RNDN);
        mpfr_mul(r25780, r25779, r25755, MPFR_RNDN);
        mpfr_mul(r25781, r25780, r25755, MPFR_RNDN);
        mpfr_add(r25782, r25776, r25781, MPFR_RNDN);
        mpfr_add(r25783, r25782, r25773, MPFR_RNDN);
        mpfr_add(r25784, r25783, r25764, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_add(r25786, r25784, r25785, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r25787, MPFR_RNDN);
}

static mpfr_t r25788, r25789, r25790, r25791, r25792, r25793, r25794, r25795, r25796, r25797, r25798, r25799, r25800, r25801, r25802, r25803, r25804, r25805, r25806, r25807, r25808, r25809, r25810, r25811, r25812, r25813, r25814, r25815, r25816, r25817, r25818, r25819, r25820, r25821, r25822;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r25788, "-1", 10, MPFR_RNDN);
        mpfr_init_set_str(r25789, "1", 10, MPFR_RNDN);
        mpfr_init(r25790);
        mpfr_init(r25791);
        mpfr_init(r25792);
        mpfr_init(r25793);
        mpfr_init(r25794);
        mpfr_init(r25795);
        mpfr_init_set_str(r25796, "6", 10, MPFR_RNDN);
        mpfr_init_set_str(r25797, "0", 10, MPFR_RNDN);
        mpfr_init(r25798);
        mpfr_init(r25799);
        mpfr_init(r25800);
        mpfr_init(r25801);
        mpfr_init(r25802);
        mpfr_init(r25803);
        mpfr_init(r25804);
        mpfr_init_set_str(r25805, "15", 10, MPFR_RNDN);
        mpfr_init(r25806);
        mpfr_init(r25807);
        mpfr_init(r25808);
        mpfr_init(r25809);
        mpfr_init(r25810);
        mpfr_init(r25811);
        mpfr_init_set_str(r25812, "20", 10, MPFR_RNDN);
        mpfr_init(r25813);
        mpfr_init(r25814);
        mpfr_init(r25815);
        mpfr_init(r25816);
        mpfr_init(r25817);
        mpfr_init(r25818);
        mpfr_init(r25819);
        mpfr_init(r25820);
        mpfr_init(r25821);
        mpfr_init(r25822);
}

double f_dm() {
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25791, r25790, r25790, MPFR_RNDN);
        mpfr_mul(r25792, r25791, r25790, MPFR_RNDN);
        mpfr_mul(r25793, r25792, r25790, MPFR_RNDN);
        mpfr_mul(r25794, r25793, r25790, MPFR_RNDN);
        mpfr_mul(r25795, r25794, r25790, MPFR_RNDN);
        ;
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25799, r25798, r25790, MPFR_RNDN);
        mpfr_mul(r25800, r25799, r25790, MPFR_RNDN);
        mpfr_mul(r25801, r25800, r25790, MPFR_RNDN);
        mpfr_mul(r25802, r25801, r25790, MPFR_RNDN);
        mpfr_mul(r25803, r25802, r25790, MPFR_RNDN);
        mpfr_add(r25804, r25795, r25803, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25807, r25806, r25790, MPFR_RNDN);
        mpfr_mul(r25808, r25807, r25790, MPFR_RNDN);
        mpfr_mul(r25809, r25808, r25790, MPFR_RNDN);
        mpfr_mul(r25810, r25809, r25790, MPFR_RNDN);
        mpfr_add(r25811, r25804, r25810, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r25814, r25813, r25790, MPFR_RNDN);
        mpfr_mul(r25815, r25814, r25790, MPFR_RNDN);
        mpfr_mul(r25816, r25815, r25790, MPFR_RNDN);
        mpfr_add(r25817, r25811, r25816, MPFR_RNDN);
        mpfr_add(r25818, r25817, r25808, MPFR_RNDN);
        mpfr_add(r25819, r25818, r25799, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_add(r25821, r25819, r25820, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r25822, MPFR_RNDN);
}