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

char *name = "powComplex, imaginary part";

double f_if(float x_re, float x_im, float y_re, float y_im) {
        float r20602 = x_re;
        float r20603 = r20602 * r20602;
        float r20604 = x_im;
        float r20605 = r20604 * r20604;
        float r20606 = r20603 + r20605;
        float r20607 = sqrt(r20606);
        float r20608 = log(r20607);
        float r20609 = y_re;
        float r20610 = r20608 * r20609;
        float r20611 = atan2(r20604, r20602);
        float r20612 = y_im;
        float r20613 = r20611 * r20612;
        float r20614 = r20610 - r20613;
        float r20615 = exp(r20614);
        float r20616 = r20608 * r20612;
        float r20617 = r20611 * r20609;
        float r20618 = r20616 + r20617;
        float r20619 = sin(r20618);
        float r20620 = r20615 * r20619;
        return r20620;
}

double f_id(double x_re, double x_im, double y_re, double y_im) {
        double r20621 = x_re;
        double r20622 = r20621 * r20621;
        double r20623 = x_im;
        double r20624 = r20623 * r20623;
        double r20625 = r20622 + r20624;
        double r20626 = sqrt(r20625);
        double r20627 = log(r20626);
        double r20628 = y_re;
        double r20629 = r20627 * r20628;
        double r20630 = atan2(r20623, r20621);
        double r20631 = y_im;
        double r20632 = r20630 * r20631;
        double r20633 = r20629 - r20632;
        double r20634 = exp(r20633);
        double r20635 = r20627 * r20631;
        double r20636 = r20630 * r20628;
        double r20637 = r20635 + r20636;
        double r20638 = sin(r20637);
        double r20639 = r20634 * r20638;
        return r20639;
}


double f_of(float x_re, float x_im, float y_re, float y_im) {
        float r20640 = x_re;
        float r20641 = -6.747954126779563e-116;
        bool r20642 = r20640 <= r20641;
        float r20643 = x_im;
        float r20644 = atan2(r20643, r20640);
        float r20645 = y_re;
        float r20646 = r20644 * r20645;
        float r20647 = -1;
        float r20648 = r20647 / r20640;
        float r20649 = log(r20648);
        float r20650 = y_im;
        float r20651 = r20649 * r20650;
        float r20652 = r20646 - r20651;
        float r20653 = sin(r20652);
        float r20654 = exp(r20650);
        float r20655 = pow(r20654, r20644);
        float r20656 = r20643 * r20643;
        float r20657 = r20640 * r20640;
        float r20658 = r20656 + r20657;
        float r20659 = sqrt(r20658);
        float r20660 = pow(r20659, r20645);
        float r20661 = r20655 / r20660;
        float r20662 = r20653 / r20661;
        float r20663 = 6.384967306401406e+104;
        bool r20664 = r20640 <= r20663;
        float r20665 = r20657 + r20656;
        float r20666 = sqrt(r20665);
        float r20667 = log(r20666);
        float r20668 = r20667 * r20645;
        float r20669 = r20644 * r20650;
        float r20670 = r20668 - r20669;
        float r20671 = exp(r20670);
        float r20672 = 1/3;
        float r20673 = pow(r20658, r20672);
        float r20674 = fabs(r20673);
        float r20675 = cbrt(r20665);
        float r20676 = sqrt(r20675);
        float r20677 = r20674 * r20676;
        float r20678 = log(r20677);
        float r20679 = r20678 * r20650;
        float r20680 = r20679 + r20646;
        float r20681 = sin(r20680);
        float r20682 = r20671 * r20681;
        float r20683 = log(r20640);
        float r20684 = -r20650;
        float r20685 = r20683 * r20684;
        float r20686 = r20646 - r20685;
        float r20687 = sin(r20686);
        float r20688 = r20687 * r20660;
        float r20689 = r20688 / r20655;
        float r20690 = r20664 ? r20682 : r20689;
        float r20691 = r20642 ? r20662 : r20690;
        return r20691;
}

double f_od(double x_re, double x_im, double y_re, double y_im) {
        double r20692 = x_re;
        double r20693 = -6.747954126779563e-116;
        bool r20694 = r20692 <= r20693;
        double r20695 = x_im;
        double r20696 = atan2(r20695, r20692);
        double r20697 = y_re;
        double r20698 = r20696 * r20697;
        double r20699 = -1;
        double r20700 = r20699 / r20692;
        double r20701 = log(r20700);
        double r20702 = y_im;
        double r20703 = r20701 * r20702;
        double r20704 = r20698 - r20703;
        double r20705 = sin(r20704);
        double r20706 = exp(r20702);
        double r20707 = pow(r20706, r20696);
        double r20708 = r20695 * r20695;
        double r20709 = r20692 * r20692;
        double r20710 = r20708 + r20709;
        double r20711 = sqrt(r20710);
        double r20712 = pow(r20711, r20697);
        double r20713 = r20707 / r20712;
        double r20714 = r20705 / r20713;
        double r20715 = 6.384967306401406e+104;
        bool r20716 = r20692 <= r20715;
        double r20717 = r20709 + r20708;
        double r20718 = sqrt(r20717);
        double r20719 = log(r20718);
        double r20720 = r20719 * r20697;
        double r20721 = r20696 * r20702;
        double r20722 = r20720 - r20721;
        double r20723 = exp(r20722);
        double r20724 = 1/3;
        double r20725 = pow(r20710, r20724);
        double r20726 = fabs(r20725);
        double r20727 = cbrt(r20717);
        double r20728 = sqrt(r20727);
        double r20729 = r20726 * r20728;
        double r20730 = log(r20729);
        double r20731 = r20730 * r20702;
        double r20732 = r20731 + r20698;
        double r20733 = sin(r20732);
        double r20734 = r20723 * r20733;
        double r20735 = log(r20692);
        double r20736 = -r20702;
        double r20737 = r20735 * r20736;
        double r20738 = r20698 - r20737;
        double r20739 = sin(r20738);
        double r20740 = r20739 * r20712;
        double r20741 = r20740 / r20707;
        double r20742 = r20716 ? r20734 : r20741;
        double r20743 = r20694 ? r20714 : r20742;
        return r20743;
}

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 r20744, r20745, r20746, r20747, r20748, r20749, r20750, r20751, r20752, r20753, r20754, r20755, r20756, r20757, r20758, r20759, r20760, r20761, r20762;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20744);
        mpfr_init(r20745);
        mpfr_init(r20746);
        mpfr_init(r20747);
        mpfr_init(r20748);
        mpfr_init(r20749);
        mpfr_init(r20750);
        mpfr_init(r20751);
        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);
        mpfr_init(r20762);
}

double f_im(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20744, x_re, MPFR_RNDN);
        mpfr_mul(r20745, r20744, r20744, MPFR_RNDN);
        mpfr_set_d(r20746, x_im, MPFR_RNDN);
        mpfr_mul(r20747, r20746, r20746, MPFR_RNDN);
        mpfr_add(r20748, r20745, r20747, MPFR_RNDN);
        mpfr_sqrt(r20749, r20748, MPFR_RNDN);
        mpfr_log(r20750, r20749, MPFR_RNDN);
        mpfr_set_d(r20751, y_re, MPFR_RNDN);
        mpfr_mul(r20752, r20750, r20751, MPFR_RNDN);
        mpfr_atan2(r20753, r20746, r20744, MPFR_RNDN);
        mpfr_set_d(r20754, y_im, MPFR_RNDN);
        mpfr_mul(r20755, r20753, r20754, MPFR_RNDN);
        mpfr_sub(r20756, r20752, r20755, MPFR_RNDN);
        mpfr_exp(r20757, r20756, MPFR_RNDN);
        mpfr_mul(r20758, r20750, r20754, MPFR_RNDN);
        mpfr_mul(r20759, r20753, r20751, MPFR_RNDN);
        mpfr_add(r20760, r20758, r20759, MPFR_RNDN);
        mpfr_sin(r20761, r20760, MPFR_RNDN);
        mpfr_mul(r20762, r20757, r20761, MPFR_RNDN);
        return mpfr_get_d(r20762, MPFR_RNDN);
}

static mpfr_t 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, r20794, r20795, r20796, r20797, r20798, r20799, r20800, r20801, r20802, r20803, r20804, r20805, r20806, r20807, r20808, r20809, r20810, r20811, r20812, r20813, r20814;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20763);
        mpfr_init_set_str(r20764, "-6.747954126779563e-116", 10, MPFR_RNDN);
        mpfr_init(r20765);
        mpfr_init(r20766);
        mpfr_init(r20767);
        mpfr_init(r20768);
        mpfr_init(r20769);
        mpfr_init_set_str(r20770, "-1", 10, MPFR_RNDN);
        mpfr_init(r20771);
        mpfr_init(r20772);
        mpfr_init(r20773);
        mpfr_init(r20774);
        mpfr_init(r20775);
        mpfr_init(r20776);
        mpfr_init(r20777);
        mpfr_init(r20778);
        mpfr_init(r20779);
        mpfr_init(r20780);
        mpfr_init(r20781);
        mpfr_init(r20782);
        mpfr_init(r20783);
        mpfr_init(r20784);
        mpfr_init(r20785);
        mpfr_init_set_str(r20786, "6.384967306401406e+104", 10, MPFR_RNDN);
        mpfr_init(r20787);
        mpfr_init(r20788);
        mpfr_init(r20789);
        mpfr_init(r20790);
        mpfr_init(r20791);
        mpfr_init(r20792);
        mpfr_init(r20793);
        mpfr_init(r20794);
        mpfr_init_set_str(r20795, "1/3", 10, MPFR_RNDN);
        mpfr_init(r20796);
        mpfr_init(r20797);
        mpfr_init(r20798);
        mpfr_init(r20799);
        mpfr_init(r20800);
        mpfr_init(r20801);
        mpfr_init(r20802);
        mpfr_init(r20803);
        mpfr_init(r20804);
        mpfr_init(r20805);
        mpfr_init(r20806);
        mpfr_init(r20807);
        mpfr_init(r20808);
        mpfr_init(r20809);
        mpfr_init(r20810);
        mpfr_init(r20811);
        mpfr_init(r20812);
        mpfr_init(r20813);
        mpfr_init(r20814);
}

double f_fm(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20763, x_re, MPFR_RNDN);
        ;
        mpfr_set_si(r20765, mpfr_cmp(r20763, r20764) <= 0, MPFR_RNDN);
        mpfr_set_d(r20766, x_im, MPFR_RNDN);
        mpfr_atan2(r20767, r20766, r20763, MPFR_RNDN);
        mpfr_set_d(r20768, y_re, MPFR_RNDN);
        mpfr_mul(r20769, r20767, r20768, MPFR_RNDN);
        ;
        mpfr_div(r20771, r20770, r20763, MPFR_RNDN);
        mpfr_log(r20772, r20771, MPFR_RNDN);
        mpfr_set_d(r20773, y_im, MPFR_RNDN);
        mpfr_mul(r20774, r20772, r20773, MPFR_RNDN);
        mpfr_sub(r20775, r20769, r20774, MPFR_RNDN);
        mpfr_sin(r20776, r20775, MPFR_RNDN);
        mpfr_exp(r20777, r20773, MPFR_RNDN);
        mpfr_pow(r20778, r20777, r20767, MPFR_RNDN);
        mpfr_mul(r20779, r20766, r20766, MPFR_RNDN);
        mpfr_mul(r20780, r20763, r20763, MPFR_RNDN);
        mpfr_add(r20781, r20779, r20780, MPFR_RNDN);
        mpfr_sqrt(r20782, r20781, MPFR_RNDN);
        mpfr_pow(r20783, r20782, r20768, MPFR_RNDN);
        mpfr_div(r20784, r20778, r20783, MPFR_RNDN);
        mpfr_div(r20785, r20776, r20784, MPFR_RNDN);
        ;
        mpfr_set_si(r20787, mpfr_cmp(r20763, r20786) <= 0, MPFR_RNDN);
        mpfr_add(r20788, r20780, r20779, MPFR_RNDN);
        mpfr_sqrt(r20789, r20788, MPFR_RNDN);
        mpfr_log(r20790, r20789, MPFR_RNDN);
        mpfr_mul(r20791, r20790, r20768, MPFR_RNDN);
        mpfr_mul(r20792, r20767, r20773, MPFR_RNDN);
        mpfr_sub(r20793, r20791, r20792, MPFR_RNDN);
        mpfr_exp(r20794, r20793, MPFR_RNDN);
        ;
        mpfr_pow(r20796, r20781, r20795, MPFR_RNDN);
        mpfr_abs(r20797, r20796, MPFR_RNDN);
        mpfr_cbrt(r20798, r20788, MPFR_RNDN);
        mpfr_sqrt(r20799, r20798, MPFR_RNDN);
        mpfr_mul(r20800, r20797, r20799, MPFR_RNDN);
        mpfr_log(r20801, r20800, MPFR_RNDN);
        mpfr_mul(r20802, r20801, r20773, MPFR_RNDN);
        mpfr_add(r20803, r20802, r20769, MPFR_RNDN);
        mpfr_sin(r20804, r20803, MPFR_RNDN);
        mpfr_mul(r20805, r20794, r20804, MPFR_RNDN);
        mpfr_log(r20806, r20763, MPFR_RNDN);
        mpfr_neg(r20807, r20773, MPFR_RNDN);
        mpfr_mul(r20808, r20806, r20807, MPFR_RNDN);
        mpfr_sub(r20809, r20769, r20808, MPFR_RNDN);
        mpfr_sin(r20810, r20809, MPFR_RNDN);
        mpfr_mul(r20811, r20810, r20783, MPFR_RNDN);
        mpfr_div(r20812, r20811, r20778, MPFR_RNDN);
        if (mpfr_get_si(r20787, MPFR_RNDN)) { mpfr_set(r20813, r20805, MPFR_RNDN); } else { mpfr_set(r20813, r20812, MPFR_RNDN); };
        if (mpfr_get_si(r20765, MPFR_RNDN)) { mpfr_set(r20814, r20785, MPFR_RNDN); } else { mpfr_set(r20814, r20813, MPFR_RNDN); };
        return mpfr_get_d(r20814, MPFR_RNDN);
}

static mpfr_t r20815, r20816, r20817, r20818, r20819, r20820, r20821, r20822, r20823, r20824, r20825, r20826, r20827, r20828, r20829, r20830, r20831, r20832, r20833, r20834, r20835, r20836, r20837, r20838, r20839, r20840, r20841, r20842, r20843, r20844, r20845, r20846, r20847, r20848, r20849, r20850, r20851, r20852, r20853, r20854, r20855, r20856, r20857, r20858, r20859, r20860, r20861, r20862, r20863, r20864, r20865, r20866;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20815);
        mpfr_init_set_str(r20816, "-6.747954126779563e-116", 10, MPFR_RNDN);
        mpfr_init(r20817);
        mpfr_init(r20818);
        mpfr_init(r20819);
        mpfr_init(r20820);
        mpfr_init(r20821);
        mpfr_init_set_str(r20822, "-1", 10, MPFR_RNDN);
        mpfr_init(r20823);
        mpfr_init(r20824);
        mpfr_init(r20825);
        mpfr_init(r20826);
        mpfr_init(r20827);
        mpfr_init(r20828);
        mpfr_init(r20829);
        mpfr_init(r20830);
        mpfr_init(r20831);
        mpfr_init(r20832);
        mpfr_init(r20833);
        mpfr_init(r20834);
        mpfr_init(r20835);
        mpfr_init(r20836);
        mpfr_init(r20837);
        mpfr_init_set_str(r20838, "6.384967306401406e+104", 10, MPFR_RNDN);
        mpfr_init(r20839);
        mpfr_init(r20840);
        mpfr_init(r20841);
        mpfr_init(r20842);
        mpfr_init(r20843);
        mpfr_init(r20844);
        mpfr_init(r20845);
        mpfr_init(r20846);
        mpfr_init_set_str(r20847, "1/3", 10, MPFR_RNDN);
        mpfr_init(r20848);
        mpfr_init(r20849);
        mpfr_init(r20850);
        mpfr_init(r20851);
        mpfr_init(r20852);
        mpfr_init(r20853);
        mpfr_init(r20854);
        mpfr_init(r20855);
        mpfr_init(r20856);
        mpfr_init(r20857);
        mpfr_init(r20858);
        mpfr_init(r20859);
        mpfr_init(r20860);
        mpfr_init(r20861);
        mpfr_init(r20862);
        mpfr_init(r20863);
        mpfr_init(r20864);
        mpfr_init(r20865);
        mpfr_init(r20866);
}

double f_dm(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20815, x_re, MPFR_RNDN);
        ;
        mpfr_set_si(r20817, mpfr_cmp(r20815, r20816) <= 0, MPFR_RNDN);
        mpfr_set_d(r20818, x_im, MPFR_RNDN);
        mpfr_atan2(r20819, r20818, r20815, MPFR_RNDN);
        mpfr_set_d(r20820, y_re, MPFR_RNDN);
        mpfr_mul(r20821, r20819, r20820, MPFR_RNDN);
        ;
        mpfr_div(r20823, r20822, r20815, MPFR_RNDN);
        mpfr_log(r20824, r20823, MPFR_RNDN);
        mpfr_set_d(r20825, y_im, MPFR_RNDN);
        mpfr_mul(r20826, r20824, r20825, MPFR_RNDN);
        mpfr_sub(r20827, r20821, r20826, MPFR_RNDN);
        mpfr_sin(r20828, r20827, MPFR_RNDN);
        mpfr_exp(r20829, r20825, MPFR_RNDN);
        mpfr_pow(r20830, r20829, r20819, MPFR_RNDN);
        mpfr_mul(r20831, r20818, r20818, MPFR_RNDN);
        mpfr_mul(r20832, r20815, r20815, MPFR_RNDN);
        mpfr_add(r20833, r20831, r20832, MPFR_RNDN);
        mpfr_sqrt(r20834, r20833, MPFR_RNDN);
        mpfr_pow(r20835, r20834, r20820, MPFR_RNDN);
        mpfr_div(r20836, r20830, r20835, MPFR_RNDN);
        mpfr_div(r20837, r20828, r20836, MPFR_RNDN);
        ;
        mpfr_set_si(r20839, mpfr_cmp(r20815, r20838) <= 0, MPFR_RNDN);
        mpfr_add(r20840, r20832, r20831, MPFR_RNDN);
        mpfr_sqrt(r20841, r20840, MPFR_RNDN);
        mpfr_log(r20842, r20841, MPFR_RNDN);
        mpfr_mul(r20843, r20842, r20820, MPFR_RNDN);
        mpfr_mul(r20844, r20819, r20825, MPFR_RNDN);
        mpfr_sub(r20845, r20843, r20844, MPFR_RNDN);
        mpfr_exp(r20846, r20845, MPFR_RNDN);
        ;
        mpfr_pow(r20848, r20833, r20847, MPFR_RNDN);
        mpfr_abs(r20849, r20848, MPFR_RNDN);
        mpfr_cbrt(r20850, r20840, MPFR_RNDN);
        mpfr_sqrt(r20851, r20850, MPFR_RNDN);
        mpfr_mul(r20852, r20849, r20851, MPFR_RNDN);
        mpfr_log(r20853, r20852, MPFR_RNDN);
        mpfr_mul(r20854, r20853, r20825, MPFR_RNDN);
        mpfr_add(r20855, r20854, r20821, MPFR_RNDN);
        mpfr_sin(r20856, r20855, MPFR_RNDN);
        mpfr_mul(r20857, r20846, r20856, MPFR_RNDN);
        mpfr_log(r20858, r20815, MPFR_RNDN);
        mpfr_neg(r20859, r20825, MPFR_RNDN);
        mpfr_mul(r20860, r20858, r20859, MPFR_RNDN);
        mpfr_sub(r20861, r20821, r20860, MPFR_RNDN);
        mpfr_sin(r20862, r20861, MPFR_RNDN);
        mpfr_mul(r20863, r20862, r20835, MPFR_RNDN);
        mpfr_div(r20864, r20863, r20830, MPFR_RNDN);
        if (mpfr_get_si(r20839, MPFR_RNDN)) { mpfr_set(r20865, r20857, MPFR_RNDN); } else { mpfr_set(r20865, r20864, MPFR_RNDN); };
        if (mpfr_get_si(r20817, MPFR_RNDN)) { mpfr_set(r20866, r20837, MPFR_RNDN); } else { mpfr_set(r20866, r20865, MPFR_RNDN); };
        return mpfr_get_d(r20866, MPFR_RNDN);
}