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

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

double f_if() {
        float r24697 = 1;
        float r24698 = -r24697;
        float r24699 = 2;
        float r24700 = r24698 / r24699;
        float r24701 = 3;
        float r24702 = sqrt(r24701);
        float r24703 = r24702 / r24699;
        float r24704 = /* ERROR: no complex support in C */;
        float r24705 = r24704 * r24704;
        float r24706 = r24705 * r24704;
        float r24707 = r24706 * r24704;
        float r24708 = -r24699;
        float r24709 = 0;
        float r24710 = /* ERROR: no complex support in C */;
        float r24711 = r24710 * r24704;
        float r24712 = r24711 * r24704;
        float r24713 = r24712 * r24704;
        float r24714 = r24707 + r24713;
        float r24715 = 5;
        float r24716 = /* ERROR: no complex support in C */;
        float r24717 = r24716 * r24704;
        float r24718 = r24717 * r24704;
        float r24719 = r24714 + r24718;
        float r24720 = 4;
        float r24721 = /* ERROR: no complex support in C */;
        float r24722 = r24721 * r24704;
        float r24723 = r24719 + r24722;
        float r24724 = 7;
        float r24725 = /* ERROR: no complex support in C */;
        float r24726 = r24723 + r24725;
        float r24727 = /* ERROR: no complex support in C */;
        return r24727;
}

double f_id() {
        double r24728 = 1;
        double r24729 = -r24728;
        double r24730 = 2;
        double r24731 = r24729 / r24730;
        double r24732 = 3;
        double r24733 = sqrt(r24732);
        double r24734 = r24733 / r24730;
        double r24735 = /* ERROR: no complex support in C */;
        double r24736 = r24735 * r24735;
        double r24737 = r24736 * r24735;
        double r24738 = r24737 * r24735;
        double r24739 = -r24730;
        double r24740 = 0;
        double r24741 = /* ERROR: no complex support in C */;
        double r24742 = r24741 * r24735;
        double r24743 = r24742 * r24735;
        double r24744 = r24743 * r24735;
        double r24745 = r24738 + r24744;
        double r24746 = 5;
        double r24747 = /* ERROR: no complex support in C */;
        double r24748 = r24747 * r24735;
        double r24749 = r24748 * r24735;
        double r24750 = r24745 + r24749;
        double r24751 = 4;
        double r24752 = /* ERROR: no complex support in C */;
        double r24753 = r24752 * r24735;
        double r24754 = r24750 + r24753;
        double r24755 = 7;
        double r24756 = /* ERROR: no complex support in C */;
        double r24757 = r24754 + r24756;
        double r24758 = /* ERROR: no complex support in C */;
        return r24758;
}


double f_of() {
        float r24759 = 1;
        float r24760 = -r24759;
        float r24761 = 2;
        float r24762 = r24760 / r24761;
        float r24763 = 3;
        float r24764 = sqrt(r24763);
        float r24765 = r24764 / r24761;
        float r24766 = /* ERROR: no complex support in C */;
        float r24767 = r24766 * r24766;
        float r24768 = r24767 * r24766;
        float r24769 = r24768 * r24766;
        float r24770 = -r24761;
        float r24771 = 0;
        float r24772 = /* ERROR: no complex support in C */;
        float r24773 = r24772 * r24766;
        float r24774 = r24773 * r24766;
        float r24775 = r24774 * r24766;
        float r24776 = r24769 + r24775;
        float r24777 = 5;
        float r24778 = /* ERROR: no complex support in C */;
        float r24779 = r24778 * r24766;
        float r24780 = r24779 * r24766;
        float r24781 = r24776 + r24780;
        float r24782 = 4;
        float r24783 = /* ERROR: no complex support in C */;
        float r24784 = r24783 * r24766;
        float r24785 = r24781 + r24784;
        float r24786 = 7;
        float r24787 = /* ERROR: no complex support in C */;
        float r24788 = r24785 + r24787;
        float r24789 = /* ERROR: no complex support in C */;
        return r24789;
}

double f_od() {
        double r24790 = 1;
        double r24791 = -r24790;
        double r24792 = 2;
        double r24793 = r24791 / r24792;
        double r24794 = 3;
        double r24795 = sqrt(r24794);
        double r24796 = r24795 / r24792;
        double r24797 = /* ERROR: no complex support in C */;
        double r24798 = r24797 * r24797;
        double r24799 = r24798 * r24797;
        double r24800 = r24799 * r24797;
        double r24801 = -r24792;
        double r24802 = 0;
        double r24803 = /* ERROR: no complex support in C */;
        double r24804 = r24803 * r24797;
        double r24805 = r24804 * r24797;
        double r24806 = r24805 * r24797;
        double r24807 = r24800 + r24806;
        double r24808 = 5;
        double r24809 = /* ERROR: no complex support in C */;
        double r24810 = r24809 * r24797;
        double r24811 = r24810 * r24797;
        double r24812 = r24807 + r24811;
        double r24813 = 4;
        double r24814 = /* ERROR: no complex support in C */;
        double r24815 = r24814 * r24797;
        double r24816 = r24812 + r24815;
        double r24817 = 7;
        double r24818 = /* ERROR: no complex support in C */;
        double r24819 = r24816 + r24818;
        double r24820 = /* ERROR: no complex support in C */;
        return r24820;
}

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 r24821, r24822, r24823, r24824, r24825, r24826, r24827, r24828, r24829, r24830, r24831, r24832, r24833, r24834, r24835, r24836, r24837, r24838, r24839, r24840, r24841, r24842, r24843, r24844, r24845, r24846, r24847, r24848, r24849, r24850, r24851;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24821, "1", 10, MPFR_RNDN);
        mpfr_init(r24822);
        mpfr_init_set_str(r24823, "2", 10, MPFR_RNDN);
        mpfr_init(r24824);
        mpfr_init_set_str(r24825, "3", 10, MPFR_RNDN);
        mpfr_init(r24826);
        mpfr_init(r24827);
        mpfr_init(r24828);
        mpfr_init(r24829);
        mpfr_init(r24830);
        mpfr_init(r24831);
        mpfr_init(r24832);
        mpfr_init_set_str(r24833, "0", 10, MPFR_RNDN);
        mpfr_init(r24834);
        mpfr_init(r24835);
        mpfr_init(r24836);
        mpfr_init(r24837);
        mpfr_init(r24838);
        mpfr_init_set_str(r24839, "5", 10, MPFR_RNDN);
        mpfr_init(r24840);
        mpfr_init(r24841);
        mpfr_init(r24842);
        mpfr_init(r24843);
        mpfr_init_set_str(r24844, "4", 10, MPFR_RNDN);
        mpfr_init(r24845);
        mpfr_init(r24846);
        mpfr_init(r24847);
        mpfr_init_set_str(r24848, "7", 10, MPFR_RNDN);
        mpfr_init(r24849);
        mpfr_init(r24850);
        mpfr_init(r24851);
}

double f_im() {
        ;
        mpfr_neg(r24822, r24821, MPFR_RNDN);
        ;
        mpfr_div(r24824, r24822, r24823, MPFR_RNDN);
        ;
        mpfr_sqrt(r24826, r24825, MPFR_RNDN);
        mpfr_div(r24827, r24826, r24823, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24829, r24828, r24828, MPFR_RNDN);
        mpfr_mul(r24830, r24829, r24828, MPFR_RNDN);
        mpfr_mul(r24831, r24830, r24828, MPFR_RNDN);
        mpfr_neg(r24832, r24823, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24835, r24834, r24828, MPFR_RNDN);
        mpfr_mul(r24836, r24835, r24828, MPFR_RNDN);
        mpfr_mul(r24837, r24836, r24828, MPFR_RNDN);
        mpfr_add(r24838, r24831, r24837, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24841, r24840, r24828, MPFR_RNDN);
        mpfr_mul(r24842, r24841, r24828, MPFR_RNDN);
        mpfr_add(r24843, r24838, r24842, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24846, r24845, r24828, MPFR_RNDN);
        mpfr_add(r24847, r24843, r24846, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r24850, r24847, r24849, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24851, MPFR_RNDN);
}

static mpfr_t r24852, r24853, r24854, r24855, r24856, r24857, r24858, r24859, r24860, r24861, r24862, r24863, r24864, r24865, r24866, r24867, r24868, r24869, r24870, r24871, r24872, r24873, r24874, r24875, r24876, r24877, r24878, r24879, r24880, r24881, r24882;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24852, "1", 10, MPFR_RNDN);
        mpfr_init(r24853);
        mpfr_init_set_str(r24854, "2", 10, MPFR_RNDN);
        mpfr_init(r24855);
        mpfr_init_set_str(r24856, "3", 10, MPFR_RNDN);
        mpfr_init(r24857);
        mpfr_init(r24858);
        mpfr_init(r24859);
        mpfr_init(r24860);
        mpfr_init(r24861);
        mpfr_init(r24862);
        mpfr_init(r24863);
        mpfr_init_set_str(r24864, "0", 10, MPFR_RNDN);
        mpfr_init(r24865);
        mpfr_init(r24866);
        mpfr_init(r24867);
        mpfr_init(r24868);
        mpfr_init(r24869);
        mpfr_init_set_str(r24870, "5", 10, MPFR_RNDN);
        mpfr_init(r24871);
        mpfr_init(r24872);
        mpfr_init(r24873);
        mpfr_init(r24874);
        mpfr_init_set_str(r24875, "4", 10, MPFR_RNDN);
        mpfr_init(r24876);
        mpfr_init(r24877);
        mpfr_init(r24878);
        mpfr_init_set_str(r24879, "7", 10, MPFR_RNDN);
        mpfr_init(r24880);
        mpfr_init(r24881);
        mpfr_init(r24882);
}

double f_fm() {
        ;
        mpfr_neg(r24853, r24852, MPFR_RNDN);
        ;
        mpfr_div(r24855, r24853, r24854, MPFR_RNDN);
        ;
        mpfr_sqrt(r24857, r24856, MPFR_RNDN);
        mpfr_div(r24858, r24857, r24854, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24860, r24859, r24859, MPFR_RNDN);
        mpfr_mul(r24861, r24860, r24859, MPFR_RNDN);
        mpfr_mul(r24862, r24861, r24859, MPFR_RNDN);
        mpfr_neg(r24863, r24854, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24866, r24865, r24859, MPFR_RNDN);
        mpfr_mul(r24867, r24866, r24859, MPFR_RNDN);
        mpfr_mul(r24868, r24867, r24859, MPFR_RNDN);
        mpfr_add(r24869, r24862, r24868, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24872, r24871, r24859, MPFR_RNDN);
        mpfr_mul(r24873, r24872, r24859, MPFR_RNDN);
        mpfr_add(r24874, r24869, r24873, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24877, r24876, r24859, MPFR_RNDN);
        mpfr_add(r24878, r24874, r24877, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r24881, r24878, r24880, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24882, MPFR_RNDN);
}

static mpfr_t r24883, r24884, r24885, r24886, r24887, r24888, r24889, r24890, r24891, r24892, r24893, r24894, r24895, r24896, r24897, r24898, r24899, r24900, r24901, r24902, r24903, r24904, r24905, r24906, r24907, r24908, r24909, r24910, r24911, r24912, r24913;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24883, "1", 10, MPFR_RNDN);
        mpfr_init(r24884);
        mpfr_init_set_str(r24885, "2", 10, MPFR_RNDN);
        mpfr_init(r24886);
        mpfr_init_set_str(r24887, "3", 10, MPFR_RNDN);
        mpfr_init(r24888);
        mpfr_init(r24889);
        mpfr_init(r24890);
        mpfr_init(r24891);
        mpfr_init(r24892);
        mpfr_init(r24893);
        mpfr_init(r24894);
        mpfr_init_set_str(r24895, "0", 10, MPFR_RNDN);
        mpfr_init(r24896);
        mpfr_init(r24897);
        mpfr_init(r24898);
        mpfr_init(r24899);
        mpfr_init(r24900);
        mpfr_init_set_str(r24901, "5", 10, MPFR_RNDN);
        mpfr_init(r24902);
        mpfr_init(r24903);
        mpfr_init(r24904);
        mpfr_init(r24905);
        mpfr_init_set_str(r24906, "4", 10, MPFR_RNDN);
        mpfr_init(r24907);
        mpfr_init(r24908);
        mpfr_init(r24909);
        mpfr_init_set_str(r24910, "7", 10, MPFR_RNDN);
        mpfr_init(r24911);
        mpfr_init(r24912);
        mpfr_init(r24913);
}

double f_dm() {
        ;
        mpfr_neg(r24884, r24883, MPFR_RNDN);
        ;
        mpfr_div(r24886, r24884, r24885, MPFR_RNDN);
        ;
        mpfr_sqrt(r24888, r24887, MPFR_RNDN);
        mpfr_div(r24889, r24888, r24885, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24891, r24890, r24890, MPFR_RNDN);
        mpfr_mul(r24892, r24891, r24890, MPFR_RNDN);
        mpfr_mul(r24893, r24892, r24890, MPFR_RNDN);
        mpfr_neg(r24894, r24885, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24897, r24896, r24890, MPFR_RNDN);
        mpfr_mul(r24898, r24897, r24890, MPFR_RNDN);
        mpfr_mul(r24899, r24898, r24890, MPFR_RNDN);
        mpfr_add(r24900, r24893, r24899, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24903, r24902, r24890, MPFR_RNDN);
        mpfr_mul(r24904, r24903, r24890, MPFR_RNDN);
        mpfr_add(r24905, r24900, r24904, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24908, r24907, r24890, MPFR_RNDN);
        mpfr_add(r24909, r24905, r24908, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r24912, r24909, r24911, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24913, MPFR_RNDN);
}