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

char *name = "powComplex, real part";

double f_if(float x_re, float x_im, float y_re, float y_im) {
        float r20231 = x_re;
        float r20232 = r20231 * r20231;
        float r20233 = x_im;
        float r20234 = r20233 * r20233;
        float r20235 = r20232 + r20234;
        float r20236 = sqrt(r20235);
        float r20237 = log(r20236);
        float r20238 = y_re;
        float r20239 = r20237 * r20238;
        float r20240 = atan2(r20233, r20231);
        float r20241 = y_im;
        float r20242 = r20240 * r20241;
        float r20243 = r20239 - r20242;
        float r20244 = exp(r20243);
        float r20245 = r20237 * r20241;
        float r20246 = r20240 * r20238;
        float r20247 = r20245 + r20246;
        float r20248 = cos(r20247);
        float r20249 = r20244 * r20248;
        return r20249;
}

double f_id(double x_re, double x_im, double y_re, double y_im) {
        double r20250 = x_re;
        double r20251 = r20250 * r20250;
        double r20252 = x_im;
        double r20253 = r20252 * r20252;
        double r20254 = r20251 + r20253;
        double r20255 = sqrt(r20254);
        double r20256 = log(r20255);
        double r20257 = y_re;
        double r20258 = r20256 * r20257;
        double r20259 = atan2(r20252, r20250);
        double r20260 = y_im;
        double r20261 = r20259 * r20260;
        double r20262 = r20258 - r20261;
        double r20263 = exp(r20262);
        double r20264 = r20256 * r20260;
        double r20265 = r20259 * r20257;
        double r20266 = r20264 + r20265;
        double r20267 = cos(r20266);
        double r20268 = r20263 * r20267;
        return r20268;
}


double f_of(float x_re, float x_im, float y_re, float y_im) {
        float r20269 = x_im;
        float r20270 = 3.6519349309068006e-301;
        bool r20271 = r20269 <= r20270;
        float r20272 = y_re;
        float r20273 = x_re;
        float r20274 = atan2(r20269, r20273);
        float r20275 = r20272 * r20274;
        float r20276 = y_im;
        float r20277 = -r20269;
        float r20278 = log(r20277);
        float r20279 = r20276 * r20278;
        float r20280 = r20275 + r20279;
        float r20281 = cos(r20280);
        float r20282 = exp(r20276);
        float r20283 = pow(r20282, r20274);
        float r20284 = r20269 * r20269;
        float r20285 = r20273 * r20273;
        float r20286 = r20284 + r20285;
        float r20287 = sqrt(r20286);
        float r20288 = pow(r20287, r20272);
        float r20289 = r20283 / r20288;
        float r20290 = r20281 / r20289;
        float r20291 = log(r20269);
        float r20292 = r20276 * r20291;
        float r20293 = r20274 * r20272;
        float r20294 = r20292 + r20293;
        float r20295 = cos(r20294);
        float r20296 = r20295 / r20289;
        float r20297 = r20271 ? r20290 : r20296;
        return r20297;
}

double f_od(double x_re, double x_im, double y_re, double y_im) {
        double r20298 = x_im;
        double r20299 = 3.6519349309068006e-301;
        bool r20300 = r20298 <= r20299;
        double r20301 = y_re;
        double r20302 = x_re;
        double r20303 = atan2(r20298, r20302);
        double r20304 = r20301 * r20303;
        double r20305 = y_im;
        double r20306 = -r20298;
        double r20307 = log(r20306);
        double r20308 = r20305 * r20307;
        double r20309 = r20304 + r20308;
        double r20310 = cos(r20309);
        double r20311 = exp(r20305);
        double r20312 = pow(r20311, r20303);
        double r20313 = r20298 * r20298;
        double r20314 = r20302 * r20302;
        double r20315 = r20313 + r20314;
        double r20316 = sqrt(r20315);
        double r20317 = pow(r20316, r20301);
        double r20318 = r20312 / r20317;
        double r20319 = r20310 / r20318;
        double r20320 = log(r20298);
        double r20321 = r20305 * r20320;
        double r20322 = r20303 * r20301;
        double r20323 = r20321 + r20322;
        double r20324 = cos(r20323);
        double r20325 = r20324 / r20318;
        double r20326 = r20300 ? r20319 : r20325;
        return r20326;
}

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 r20327, r20328, r20329, r20330, r20331, r20332, r20333, r20334, r20335, r20336, r20337, r20338, r20339, r20340, r20341, r20342, r20343, r20344, r20345;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20327);
        mpfr_init(r20328);
        mpfr_init(r20329);
        mpfr_init(r20330);
        mpfr_init(r20331);
        mpfr_init(r20332);
        mpfr_init(r20333);
        mpfr_init(r20334);
        mpfr_init(r20335);
        mpfr_init(r20336);
        mpfr_init(r20337);
        mpfr_init(r20338);
        mpfr_init(r20339);
        mpfr_init(r20340);
        mpfr_init(r20341);
        mpfr_init(r20342);
        mpfr_init(r20343);
        mpfr_init(r20344);
        mpfr_init(r20345);
}

double f_im(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20327, x_re, MPFR_RNDN);
        mpfr_mul(r20328, r20327, r20327, MPFR_RNDN);
        mpfr_set_d(r20329, x_im, MPFR_RNDN);
        mpfr_mul(r20330, r20329, r20329, MPFR_RNDN);
        mpfr_add(r20331, r20328, r20330, MPFR_RNDN);
        mpfr_sqrt(r20332, r20331, MPFR_RNDN);
        mpfr_log(r20333, r20332, MPFR_RNDN);
        mpfr_set_d(r20334, y_re, MPFR_RNDN);
        mpfr_mul(r20335, r20333, r20334, MPFR_RNDN);
        mpfr_atan2(r20336, r20329, r20327, MPFR_RNDN);
        mpfr_set_d(r20337, y_im, MPFR_RNDN);
        mpfr_mul(r20338, r20336, r20337, MPFR_RNDN);
        mpfr_sub(r20339, r20335, r20338, MPFR_RNDN);
        mpfr_exp(r20340, r20339, MPFR_RNDN);
        mpfr_mul(r20341, r20333, r20337, MPFR_RNDN);
        mpfr_mul(r20342, r20336, r20334, MPFR_RNDN);
        mpfr_add(r20343, r20341, r20342, MPFR_RNDN);
        mpfr_cos(r20344, r20343, MPFR_RNDN);
        mpfr_mul(r20345, r20340, r20344, MPFR_RNDN);
        return mpfr_get_d(r20345, MPFR_RNDN);
}

static mpfr_t r20346, r20347, r20348, r20349, r20350, r20351, r20352, r20353, r20354, r20355, r20356, r20357, r20358, r20359, r20360, r20361, r20362, r20363, r20364, r20365, r20366, r20367, r20368, r20369, r20370, r20371, r20372, r20373, r20374;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20346);
        mpfr_init_set_str(r20347, "3.6519349309068006e-301", 10, MPFR_RNDN);
        mpfr_init(r20348);
        mpfr_init(r20349);
        mpfr_init(r20350);
        mpfr_init(r20351);
        mpfr_init(r20352);
        mpfr_init(r20353);
        mpfr_init(r20354);
        mpfr_init(r20355);
        mpfr_init(r20356);
        mpfr_init(r20357);
        mpfr_init(r20358);
        mpfr_init(r20359);
        mpfr_init(r20360);
        mpfr_init(r20361);
        mpfr_init(r20362);
        mpfr_init(r20363);
        mpfr_init(r20364);
        mpfr_init(r20365);
        mpfr_init(r20366);
        mpfr_init(r20367);
        mpfr_init(r20368);
        mpfr_init(r20369);
        mpfr_init(r20370);
        mpfr_init(r20371);
        mpfr_init(r20372);
        mpfr_init(r20373);
        mpfr_init(r20374);
}

double f_fm(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20346, x_im, MPFR_RNDN);
        ;
        mpfr_set_si(r20348, mpfr_cmp(r20346, r20347) <= 0, MPFR_RNDN);
        mpfr_set_d(r20349, y_re, MPFR_RNDN);
        mpfr_set_d(r20350, x_re, MPFR_RNDN);
        mpfr_atan2(r20351, r20346, r20350, MPFR_RNDN);
        mpfr_mul(r20352, r20349, r20351, MPFR_RNDN);
        mpfr_set_d(r20353, y_im, MPFR_RNDN);
        mpfr_neg(r20354, r20346, MPFR_RNDN);
        mpfr_log(r20355, r20354, MPFR_RNDN);
        mpfr_mul(r20356, r20353, r20355, MPFR_RNDN);
        mpfr_add(r20357, r20352, r20356, MPFR_RNDN);
        mpfr_cos(r20358, r20357, MPFR_RNDN);
        mpfr_exp(r20359, r20353, MPFR_RNDN);
        mpfr_pow(r20360, r20359, r20351, MPFR_RNDN);
        mpfr_mul(r20361, r20346, r20346, MPFR_RNDN);
        mpfr_mul(r20362, r20350, r20350, MPFR_RNDN);
        mpfr_add(r20363, r20361, r20362, MPFR_RNDN);
        mpfr_sqrt(r20364, r20363, MPFR_RNDN);
        mpfr_pow(r20365, r20364, r20349, MPFR_RNDN);
        mpfr_div(r20366, r20360, r20365, MPFR_RNDN);
        mpfr_div(r20367, r20358, r20366, MPFR_RNDN);
        mpfr_log(r20368, r20346, MPFR_RNDN);
        mpfr_mul(r20369, r20353, r20368, MPFR_RNDN);
        mpfr_mul(r20370, r20351, r20349, MPFR_RNDN);
        mpfr_add(r20371, r20369, r20370, MPFR_RNDN);
        mpfr_cos(r20372, r20371, MPFR_RNDN);
        mpfr_div(r20373, r20372, r20366, MPFR_RNDN);
        if (mpfr_get_si(r20348, MPFR_RNDN)) { mpfr_set(r20374, r20367, MPFR_RNDN); } else { mpfr_set(r20374, r20373, MPFR_RNDN); };
        return mpfr_get_d(r20374, MPFR_RNDN);
}

static mpfr_t r20375, r20376, r20377, r20378, r20379, r20380, r20381, r20382, r20383, r20384, r20385, r20386, r20387, r20388, r20389, r20390, r20391, r20392, r20393, r20394, r20395, r20396, r20397, r20398, r20399, r20400, r20401, r20402, r20403;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20375);
        mpfr_init_set_str(r20376, "3.6519349309068006e-301", 10, MPFR_RNDN);
        mpfr_init(r20377);
        mpfr_init(r20378);
        mpfr_init(r20379);
        mpfr_init(r20380);
        mpfr_init(r20381);
        mpfr_init(r20382);
        mpfr_init(r20383);
        mpfr_init(r20384);
        mpfr_init(r20385);
        mpfr_init(r20386);
        mpfr_init(r20387);
        mpfr_init(r20388);
        mpfr_init(r20389);
        mpfr_init(r20390);
        mpfr_init(r20391);
        mpfr_init(r20392);
        mpfr_init(r20393);
        mpfr_init(r20394);
        mpfr_init(r20395);
        mpfr_init(r20396);
        mpfr_init(r20397);
        mpfr_init(r20398);
        mpfr_init(r20399);
        mpfr_init(r20400);
        mpfr_init(r20401);
        mpfr_init(r20402);
        mpfr_init(r20403);
}

double f_dm(double x_re, double x_im, double y_re, double y_im) {
        mpfr_set_d(r20375, x_im, MPFR_RNDN);
        ;
        mpfr_set_si(r20377, mpfr_cmp(r20375, r20376) <= 0, MPFR_RNDN);
        mpfr_set_d(r20378, y_re, MPFR_RNDN);
        mpfr_set_d(r20379, x_re, MPFR_RNDN);
        mpfr_atan2(r20380, r20375, r20379, MPFR_RNDN);
        mpfr_mul(r20381, r20378, r20380, MPFR_RNDN);
        mpfr_set_d(r20382, y_im, MPFR_RNDN);
        mpfr_neg(r20383, r20375, MPFR_RNDN);
        mpfr_log(r20384, r20383, MPFR_RNDN);
        mpfr_mul(r20385, r20382, r20384, MPFR_RNDN);
        mpfr_add(r20386, r20381, r20385, MPFR_RNDN);
        mpfr_cos(r20387, r20386, MPFR_RNDN);
        mpfr_exp(r20388, r20382, MPFR_RNDN);
        mpfr_pow(r20389, r20388, r20380, MPFR_RNDN);
        mpfr_mul(r20390, r20375, r20375, MPFR_RNDN);
        mpfr_mul(r20391, r20379, r20379, MPFR_RNDN);
        mpfr_add(r20392, r20390, r20391, MPFR_RNDN);
        mpfr_sqrt(r20393, r20392, MPFR_RNDN);
        mpfr_pow(r20394, r20393, r20378, MPFR_RNDN);
        mpfr_div(r20395, r20389, r20394, MPFR_RNDN);
        mpfr_div(r20396, r20387, r20395, MPFR_RNDN);
        mpfr_log(r20397, r20375, MPFR_RNDN);
        mpfr_mul(r20398, r20382, r20397, MPFR_RNDN);
        mpfr_mul(r20399, r20380, r20378, MPFR_RNDN);
        mpfr_add(r20400, r20398, r20399, MPFR_RNDN);
        mpfr_cos(r20401, r20400, MPFR_RNDN);
        mpfr_div(r20402, r20401, r20395, MPFR_RNDN);
        if (mpfr_get_si(r20377, MPFR_RNDN)) { mpfr_set(r20403, r20396, MPFR_RNDN); } else { mpfr_set(r20403, r20402, MPFR_RNDN); };
        return mpfr_get_d(r20403, MPFR_RNDN);
}