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

char *name = "math.log/2 on complex, real part";

double f_if(float re, float im, float base) {
        float r22265 = re;
        float r22266 = r22265 * r22265;
        float r22267 = im;
        float r22268 = r22267 * r22267;
        float r22269 = r22266 + r22268;
        float r22270 = sqrt(r22269);
        float r22271 = log(r22270);
        float r22272 = base;
        float r22273 = log(r22272);
        float r22274 = r22271 * r22273;
        float r22275 = atan2(r22267, r22265);
        float r22276 = 0;
        float r22277 = r22275 * r22276;
        float r22278 = r22274 + r22277;
        float r22279 = r22273 * r22273;
        float r22280 = r22276 * r22276;
        float r22281 = r22279 + r22280;
        float r22282 = r22278 / r22281;
        return r22282;
}

double f_id(double re, double im, double base) {
        double r22283 = re;
        double r22284 = r22283 * r22283;
        double r22285 = im;
        double r22286 = r22285 * r22285;
        double r22287 = r22284 + r22286;
        double r22288 = sqrt(r22287);
        double r22289 = log(r22288);
        double r22290 = base;
        double r22291 = log(r22290);
        double r22292 = r22289 * r22291;
        double r22293 = atan2(r22285, r22283);
        double r22294 = 0;
        double r22295 = r22293 * r22294;
        double r22296 = r22292 + r22295;
        double r22297 = r22291 * r22291;
        double r22298 = r22294 * r22294;
        double r22299 = r22297 + r22298;
        double r22300 = r22296 / r22299;
        return r22300;
}


double f_of(float re, float im, float base) {
        float r22301 = im;
        float r22302 = -2.5648424477148826e+148;
        bool r22303 = r22301 <= r22302;
        float r22304 = -1;
        float r22305 = r22304 / r22301;
        float r22306 = log(r22305);
        float r22307 = base;
        float r22308 = log(r22307);
        float r22309 = r22308 / r22304;
        float r22310 = r22306 / r22309;
        float r22311 = 8.016935727886631e+105;
        bool r22312 = r22301 <= r22311;
        float r22313 = 1;
        float r22314 = r22308 * r22308;
        float r22315 = sqrt(r22314);
        float r22316 = r22313 / r22315;
        float r22317 = r22301 * r22301;
        float r22318 = re;
        float r22319 = r22318 * r22318;
        float r22320 = r22317 + r22319;
        float r22321 = sqrt(r22320);
        float r22322 = log(r22321);
        float r22323 = r22308 * r22322;
        float r22324 = r22323 / r22315;
        float r22325 = r22316 * r22324;
        float r22326 = log(r22301);
        float r22327 = r22326 / r22308;
        float r22328 = r22312 ? r22325 : r22327;
        float r22329 = r22303 ? r22310 : r22328;
        return r22329;
}

double f_od(double re, double im, double base) {
        double r22330 = im;
        double r22331 = -2.5648424477148826e+148;
        bool r22332 = r22330 <= r22331;
        double r22333 = -1;
        double r22334 = r22333 / r22330;
        double r22335 = log(r22334);
        double r22336 = base;
        double r22337 = log(r22336);
        double r22338 = r22337 / r22333;
        double r22339 = r22335 / r22338;
        double r22340 = 8.016935727886631e+105;
        bool r22341 = r22330 <= r22340;
        double r22342 = 1;
        double r22343 = r22337 * r22337;
        double r22344 = sqrt(r22343);
        double r22345 = r22342 / r22344;
        double r22346 = r22330 * r22330;
        double r22347 = re;
        double r22348 = r22347 * r22347;
        double r22349 = r22346 + r22348;
        double r22350 = sqrt(r22349);
        double r22351 = log(r22350);
        double r22352 = r22337 * r22351;
        double r22353 = r22352 / r22344;
        double r22354 = r22345 * r22353;
        double r22355 = log(r22330);
        double r22356 = r22355 / r22337;
        double r22357 = r22341 ? r22354 : r22356;
        double r22358 = r22332 ? r22339 : r22357;
        return r22358;
}

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 r22359, r22360, r22361, r22362, r22363, r22364, r22365, r22366, r22367, r22368, r22369, r22370, r22371, r22372, r22373, r22374, r22375, r22376;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r22359);
        mpfr_init(r22360);
        mpfr_init(r22361);
        mpfr_init(r22362);
        mpfr_init(r22363);
        mpfr_init(r22364);
        mpfr_init(r22365);
        mpfr_init(r22366);
        mpfr_init(r22367);
        mpfr_init(r22368);
        mpfr_init(r22369);
        mpfr_init_set_str(r22370, "0", 10, MPFR_RNDN);
        mpfr_init(r22371);
        mpfr_init(r22372);
        mpfr_init(r22373);
        mpfr_init(r22374);
        mpfr_init(r22375);
        mpfr_init(r22376);
}

double f_im(double re, double im, double base) {
        mpfr_set_d(r22359, re, MPFR_RNDN);
        mpfr_mul(r22360, r22359, r22359, MPFR_RNDN);
        mpfr_set_d(r22361, im, MPFR_RNDN);
        mpfr_mul(r22362, r22361, r22361, MPFR_RNDN);
        mpfr_add(r22363, r22360, r22362, MPFR_RNDN);
        mpfr_sqrt(r22364, r22363, MPFR_RNDN);
        mpfr_log(r22365, r22364, MPFR_RNDN);
        mpfr_set_d(r22366, base, MPFR_RNDN);
        mpfr_log(r22367, r22366, MPFR_RNDN);
        mpfr_mul(r22368, r22365, r22367, MPFR_RNDN);
        mpfr_atan2(r22369, r22361, r22359, MPFR_RNDN);
        ;
        mpfr_mul(r22371, r22369, r22370, MPFR_RNDN);
        mpfr_add(r22372, r22368, r22371, MPFR_RNDN);
        mpfr_mul(r22373, r22367, r22367, MPFR_RNDN);
        mpfr_mul(r22374, r22370, r22370, MPFR_RNDN);
        mpfr_add(r22375, r22373, r22374, MPFR_RNDN);
        mpfr_div(r22376, r22372, r22375, MPFR_RNDN);
        return mpfr_get_d(r22376, MPFR_RNDN);
}

static mpfr_t r22377, r22378, r22379, r22380, r22381, r22382, r22383, r22384, r22385, r22386, r22387, r22388, r22389, r22390, r22391, r22392, r22393, r22394, r22395, r22396, r22397, r22398, r22399, r22400, r22401, r22402, r22403, r22404, r22405;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r22377);
        mpfr_init_set_str(r22378, "-2.5648424477148826e+148", 10, MPFR_RNDN);
        mpfr_init(r22379);
        mpfr_init_set_str(r22380, "-1", 10, MPFR_RNDN);
        mpfr_init(r22381);
        mpfr_init(r22382);
        mpfr_init(r22383);
        mpfr_init(r22384);
        mpfr_init(r22385);
        mpfr_init(r22386);
        mpfr_init_set_str(r22387, "8.016935727886631e+105", 10, MPFR_RNDN);
        mpfr_init(r22388);
        mpfr_init_set_str(r22389, "1", 10, MPFR_RNDN);
        mpfr_init(r22390);
        mpfr_init(r22391);
        mpfr_init(r22392);
        mpfr_init(r22393);
        mpfr_init(r22394);
        mpfr_init(r22395);
        mpfr_init(r22396);
        mpfr_init(r22397);
        mpfr_init(r22398);
        mpfr_init(r22399);
        mpfr_init(r22400);
        mpfr_init(r22401);
        mpfr_init(r22402);
        mpfr_init(r22403);
        mpfr_init(r22404);
        mpfr_init(r22405);
}

double f_fm(double re, double im, double base) {
        mpfr_set_d(r22377, im, MPFR_RNDN);
        ;
        mpfr_set_si(r22379, mpfr_cmp(r22377, r22378) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r22381, r22380, r22377, MPFR_RNDN);
        mpfr_log(r22382, r22381, MPFR_RNDN);
        mpfr_set_d(r22383, base, MPFR_RNDN);
        mpfr_log(r22384, r22383, MPFR_RNDN);
        mpfr_div(r22385, r22384, r22380, MPFR_RNDN);
        mpfr_div(r22386, r22382, r22385, MPFR_RNDN);
        ;
        mpfr_set_si(r22388, mpfr_cmp(r22377, r22387) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r22390, r22384, r22384, MPFR_RNDN);
        mpfr_sqrt(r22391, r22390, MPFR_RNDN);
        mpfr_div(r22392, r22389, r22391, MPFR_RNDN);
        mpfr_mul(r22393, r22377, r22377, MPFR_RNDN);
        mpfr_set_d(r22394, re, MPFR_RNDN);
        mpfr_mul(r22395, r22394, r22394, MPFR_RNDN);
        mpfr_add(r22396, r22393, r22395, MPFR_RNDN);
        mpfr_sqrt(r22397, r22396, MPFR_RNDN);
        mpfr_log(r22398, r22397, MPFR_RNDN);
        mpfr_mul(r22399, r22384, r22398, MPFR_RNDN);
        mpfr_div(r22400, r22399, r22391, MPFR_RNDN);
        mpfr_mul(r22401, r22392, r22400, MPFR_RNDN);
        mpfr_log(r22402, r22377, MPFR_RNDN);
        mpfr_div(r22403, r22402, r22384, MPFR_RNDN);
        if (mpfr_get_si(r22388, MPFR_RNDN)) { mpfr_set(r22404, r22401, MPFR_RNDN); } else { mpfr_set(r22404, r22403, MPFR_RNDN); };
        if (mpfr_get_si(r22379, MPFR_RNDN)) { mpfr_set(r22405, r22386, MPFR_RNDN); } else { mpfr_set(r22405, r22404, MPFR_RNDN); };
        return mpfr_get_d(r22405, MPFR_RNDN);
}

static mpfr_t r22406, r22407, r22408, r22409, r22410, r22411, r22412, r22413, r22414, r22415, r22416, r22417, r22418, r22419, r22420, r22421, r22422, r22423, r22424, r22425, r22426, r22427, r22428, r22429, r22430, r22431, r22432, r22433, r22434;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r22406);
        mpfr_init_set_str(r22407, "-2.5648424477148826e+148", 10, MPFR_RNDN);
        mpfr_init(r22408);
        mpfr_init_set_str(r22409, "-1", 10, MPFR_RNDN);
        mpfr_init(r22410);
        mpfr_init(r22411);
        mpfr_init(r22412);
        mpfr_init(r22413);
        mpfr_init(r22414);
        mpfr_init(r22415);
        mpfr_init_set_str(r22416, "8.016935727886631e+105", 10, MPFR_RNDN);
        mpfr_init(r22417);
        mpfr_init_set_str(r22418, "1", 10, MPFR_RNDN);
        mpfr_init(r22419);
        mpfr_init(r22420);
        mpfr_init(r22421);
        mpfr_init(r22422);
        mpfr_init(r22423);
        mpfr_init(r22424);
        mpfr_init(r22425);
        mpfr_init(r22426);
        mpfr_init(r22427);
        mpfr_init(r22428);
        mpfr_init(r22429);
        mpfr_init(r22430);
        mpfr_init(r22431);
        mpfr_init(r22432);
        mpfr_init(r22433);
        mpfr_init(r22434);
}

double f_dm(double re, double im, double base) {
        mpfr_set_d(r22406, im, MPFR_RNDN);
        ;
        mpfr_set_si(r22408, mpfr_cmp(r22406, r22407) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r22410, r22409, r22406, MPFR_RNDN);
        mpfr_log(r22411, r22410, MPFR_RNDN);
        mpfr_set_d(r22412, base, MPFR_RNDN);
        mpfr_log(r22413, r22412, MPFR_RNDN);
        mpfr_div(r22414, r22413, r22409, MPFR_RNDN);
        mpfr_div(r22415, r22411, r22414, MPFR_RNDN);
        ;
        mpfr_set_si(r22417, mpfr_cmp(r22406, r22416) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r22419, r22413, r22413, MPFR_RNDN);
        mpfr_sqrt(r22420, r22419, MPFR_RNDN);
        mpfr_div(r22421, r22418, r22420, MPFR_RNDN);
        mpfr_mul(r22422, r22406, r22406, MPFR_RNDN);
        mpfr_set_d(r22423, re, MPFR_RNDN);
        mpfr_mul(r22424, r22423, r22423, MPFR_RNDN);
        mpfr_add(r22425, r22422, r22424, MPFR_RNDN);
        mpfr_sqrt(r22426, r22425, MPFR_RNDN);
        mpfr_log(r22427, r22426, MPFR_RNDN);
        mpfr_mul(r22428, r22413, r22427, MPFR_RNDN);
        mpfr_div(r22429, r22428, r22420, MPFR_RNDN);
        mpfr_mul(r22430, r22421, r22429, MPFR_RNDN);
        mpfr_log(r22431, r22406, MPFR_RNDN);
        mpfr_div(r22432, r22431, r22413, MPFR_RNDN);
        if (mpfr_get_si(r22417, MPFR_RNDN)) { mpfr_set(r22433, r22430, MPFR_RNDN); } else { mpfr_set(r22433, r22432, MPFR_RNDN); };
        if (mpfr_get_si(r22408, MPFR_RNDN)) { mpfr_set(r22434, r22415, MPFR_RNDN); } else { mpfr_set(r22434, r22433, MPFR_RNDN); };
        return mpfr_get_d(r22434, MPFR_RNDN);
}