#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 r18993 = re;
        float r18994 = r18993 * r18993;
        float r18995 = im;
        float r18996 = r18995 * r18995;
        float r18997 = r18994 + r18996;
        float r18998 = sqrt(r18997);
        float r18999 = log(r18998);
        float r19000 = base;
        float r19001 = log(r19000);
        float r19002 = r18999 * r19001;
        float r19003 = atan2(r18995, r18993);
        float r19004 = 0.0f;
        float r19005 = r19003 * r19004;
        float r19006 = r19002 + r19005;
        float r19007 = r19001 * r19001;
        float r19008 = r19004 * r19004;
        float r19009 = r19007 + r19008;
        float r19010 = r19006 / r19009;
        return r19010;
}

double f_id(double re, double im, double base) {
        double r19011 = re;
        double r19012 = r19011 * r19011;
        double r19013 = im;
        double r19014 = r19013 * r19013;
        double r19015 = r19012 + r19014;
        double r19016 = sqrt(r19015);
        double r19017 = log(r19016);
        double r19018 = base;
        double r19019 = log(r19018);
        double r19020 = r19017 * r19019;
        double r19021 = atan2(r19013, r19011);
        double r19022 = 0.0;
        double r19023 = r19021 * r19022;
        double r19024 = r19020 + r19023;
        double r19025 = r19019 * r19019;
        double r19026 = r19022 * r19022;
        double r19027 = r19025 + r19026;
        double r19028 = r19024 / r19027;
        return r19028;
}


double f_of(float re, float im, float base) {
        float r19029 = im;
        float r19030 = -4.62649320279714e+120f;
        bool r19031 = r19029 <= r19030;
        float r19032 = -r19029;
        float r19033 = log(r19032);
        float r19034 = base;
        float r19035 = log(r19034);
        float r19036 = r19033 / r19035;
        float r19037 = -7.945478500947738e-259f;
        bool r19038 = r19029 <= r19037;
        float r19039 = r19029 * r19029;
        float r19040 = re;
        float r19041 = r19040 * r19040;
        float r19042 = r19039 + r19041;
        float r19043 = sqrt(r19042);
        float r19044 = log(r19043);
        float r19045 = r19035 * r19044;
        float r19046 = r19035 * r19035;
        float r19047 = r19046 * (r19046 * r19046);
        float r19048 = cbrt(r19047);
        float r19049 = r19045 / r19048;
        float r19050 = 2.196524360140306e-303f;
        bool r19051 = r19029 <= r19050;
        float r19052 = log(r19040);
        float r19053 = r19052 / r19035;
        float r19054 = 1.808337382703412e+83f;
        bool r19055 = r19029 <= r19054;
        float r19056 = log(r19029);
        float r19057 = r19056 / r19035;
        float r19058 = r19055 ? r19049 : r19057;
        float r19059 = r19051 ? r19053 : r19058;
        float r19060 = r19038 ? r19049 : r19059;
        float r19061 = r19031 ? r19036 : r19060;
        return r19061;
}

double f_od(double re, double im, double base) {
        double r19062 = im;
        double r19063 = -4.62649320279714e+120;
        bool r19064 = r19062 <= r19063;
        double r19065 = -r19062;
        double r19066 = log(r19065);
        double r19067 = base;
        double r19068 = log(r19067);
        double r19069 = r19066 / r19068;
        double r19070 = -7.945478500947738e-259;
        bool r19071 = r19062 <= r19070;
        double r19072 = r19062 * r19062;
        double r19073 = re;
        double r19074 = r19073 * r19073;
        double r19075 = r19072 + r19074;
        double r19076 = sqrt(r19075);
        double r19077 = log(r19076);
        double r19078 = r19068 * r19077;
        double r19079 = r19068 * r19068;
        double r19080 = r19079 * (r19079 * r19079);
        double r19081 = cbrt(r19080);
        double r19082 = r19078 / r19081;
        double r19083 = 2.196524360140306e-303;
        bool r19084 = r19062 <= r19083;
        double r19085 = log(r19073);
        double r19086 = r19085 / r19068;
        double r19087 = 1.808337382703412e+83;
        bool r19088 = r19062 <= r19087;
        double r19089 = log(r19062);
        double r19090 = r19089 / r19068;
        double r19091 = r19088 ? r19082 : r19090;
        double r19092 = r19084 ? r19086 : r19091;
        double r19093 = r19071 ? r19082 : r19092;
        double r19094 = r19064 ? r19069 : r19093;
        return r19094;
}

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 r19095, r19096, r19097, r19098, r19099, r19100, r19101, r19102, r19103, r19104, r19105, r19106, r19107, r19108, r19109, r19110, r19111, r19112;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(400);
        mpfr_init(r19095);
        mpfr_init(r19096);
        mpfr_init(r19097);
        mpfr_init(r19098);
        mpfr_init(r19099);
        mpfr_init(r19100);
        mpfr_init(r19101);
        mpfr_init(r19102);
        mpfr_init(r19103);
        mpfr_init(r19104);
        mpfr_init(r19105);
        mpfr_init_set_str(r19106, "0", 10, MPFR_RNDN);
        mpfr_init(r19107);
        mpfr_init(r19108);
        mpfr_init(r19109);
        mpfr_init(r19110);
        mpfr_init(r19111);
        mpfr_init(r19112);
}

double f_im(double re, double im, double base) {
        mpfr_set_d(r19095, re, MPFR_RNDN);
        mpfr_mul(r19096, r19095, r19095, MPFR_RNDN);
        mpfr_set_d(r19097, im, MPFR_RNDN);
        mpfr_mul(r19098, r19097, r19097, MPFR_RNDN);
        mpfr_add(r19099, r19096, r19098, MPFR_RNDN);
        mpfr_sqrt(r19100, r19099, MPFR_RNDN);
        mpfr_log(r19101, r19100, MPFR_RNDN);
        mpfr_set_d(r19102, base, MPFR_RNDN);
        mpfr_log(r19103, r19102, MPFR_RNDN);
        mpfr_mul(r19104, r19101, r19103, MPFR_RNDN);
        mpfr_atan2(r19105, r19097, r19095, MPFR_RNDN);
        ;
        mpfr_mul(r19107, r19105, r19106, MPFR_RNDN);
        mpfr_add(r19108, r19104, r19107, MPFR_RNDN);
        mpfr_mul(r19109, r19103, r19103, MPFR_RNDN);
        mpfr_mul(r19110, r19106, r19106, MPFR_RNDN);
        mpfr_add(r19111, r19109, r19110, MPFR_RNDN);
        mpfr_div(r19112, r19108, r19111, MPFR_RNDN);
        return mpfr_get_d(r19112, MPFR_RNDN);
}

static mpfr_t r19113, r19114, r19115, r19116, r19117, r19118, r19119, r19120, r19121, r19122, r19123, r19124, r19125, r19126, r19127, r19128, r19129, r19130, r19131, r19132, r19133, r19134, r19135, r19136, r19137, r19138, r19139, r19140, r19141, r19142, r19143, r19144, r19145;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(400);
        mpfr_init(r19113);
        mpfr_init_set_str(r19114, "-4.62649320279714e+120", 10, MPFR_RNDN);
        mpfr_init(r19115);
        mpfr_init(r19116);
        mpfr_init(r19117);
        mpfr_init(r19118);
        mpfr_init(r19119);
        mpfr_init(r19120);
        mpfr_init_set_str(r19121, "-7.945478500947738e-259", 10, MPFR_RNDN);
        mpfr_init(r19122);
        mpfr_init(r19123);
        mpfr_init(r19124);
        mpfr_init(r19125);
        mpfr_init(r19126);
        mpfr_init(r19127);
        mpfr_init(r19128);
        mpfr_init(r19129);
        mpfr_init(r19130);
        mpfr_init(r19131);
        mpfr_init(r19132);
        mpfr_init(r19133);
        mpfr_init_set_str(r19134, "2.196524360140306e-303", 10, MPFR_RNDN);
        mpfr_init(r19135);
        mpfr_init(r19136);
        mpfr_init(r19137);
        mpfr_init_set_str(r19138, "1.808337382703412e+83", 10, MPFR_RNDN);
        mpfr_init(r19139);
        mpfr_init(r19140);
        mpfr_init(r19141);
        mpfr_init(r19142);
        mpfr_init(r19143);
        mpfr_init(r19144);
        mpfr_init(r19145);
}

double f_fm(double re, double im, double base) {
        mpfr_set_d(r19113, im, MPFR_RNDN);
        ;
        mpfr_set_si(r19115, mpfr_cmp(r19113, r19114) <= 0, MPFR_RNDN);
        mpfr_neg(r19116, r19113, MPFR_RNDN);
        mpfr_log(r19117, r19116, MPFR_RNDN);
        mpfr_set_d(r19118, base, MPFR_RNDN);
        mpfr_log(r19119, r19118, MPFR_RNDN);
        mpfr_div(r19120, r19117, r19119, MPFR_RNDN);
        ;
        mpfr_set_si(r19122, mpfr_cmp(r19113, r19121) <= 0, MPFR_RNDN);
        mpfr_mul(r19123, r19113, r19113, MPFR_RNDN);
        mpfr_set_d(r19124, re, MPFR_RNDN);
        mpfr_mul(r19125, r19124, r19124, MPFR_RNDN);
        mpfr_add(r19126, r19123, r19125, MPFR_RNDN);
        mpfr_sqrt(r19127, r19126, MPFR_RNDN);
        mpfr_log(r19128, r19127, MPFR_RNDN);
        mpfr_mul(r19129, r19119, r19128, MPFR_RNDN);
        mpfr_sqr(r19130, r19119, MPFR_RNDN);
        mpfr_mul(r19131, r19130, r19130, MPFR_RNDN); mpfr_mul(r19131, r19131, r19130, MPFR_RNDN);
        mpfr_cbrt(r19132, r19131, MPFR_RNDN);
        mpfr_div(r19133, r19129, r19132, MPFR_RNDN);
        ;
        mpfr_set_si(r19135, mpfr_cmp(r19113, r19134) <= 0, MPFR_RNDN);
        mpfr_log(r19136, r19124, MPFR_RNDN);
        mpfr_div(r19137, r19136, r19119, MPFR_RNDN);
        ;
        mpfr_set_si(r19139, mpfr_cmp(r19113, r19138) <= 0, MPFR_RNDN);
        mpfr_log(r19140, r19113, MPFR_RNDN);
        mpfr_div(r19141, r19140, r19119, MPFR_RNDN);
        if (mpfr_get_si(r19139, MPFR_RNDN)) { mpfr_set(r19142, r19133, MPFR_RNDN); } else { mpfr_set(r19142, r19141, MPFR_RNDN); };
        if (mpfr_get_si(r19135, MPFR_RNDN)) { mpfr_set(r19143, r19137, MPFR_RNDN); } else { mpfr_set(r19143, r19142, MPFR_RNDN); };
        if (mpfr_get_si(r19122, MPFR_RNDN)) { mpfr_set(r19144, r19133, MPFR_RNDN); } else { mpfr_set(r19144, r19143, MPFR_RNDN); };
        if (mpfr_get_si(r19115, MPFR_RNDN)) { mpfr_set(r19145, r19120, MPFR_RNDN); } else { mpfr_set(r19145, r19144, MPFR_RNDN); };
        return mpfr_get_d(r19145, MPFR_RNDN);
}

static mpfr_t r19146, r19147, r19148, r19149, r19150, r19151, r19152, r19153, r19154, r19155, r19156, r19157, r19158, r19159, r19160, r19161, r19162, r19163, r19164, r19165, r19166, r19167, r19168, r19169, r19170, r19171, r19172, r19173, r19174, r19175, r19176, r19177, r19178;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(400);
        mpfr_init(r19146);
        mpfr_init_set_str(r19147, "-4.62649320279714e+120", 10, MPFR_RNDN);
        mpfr_init(r19148);
        mpfr_init(r19149);
        mpfr_init(r19150);
        mpfr_init(r19151);
        mpfr_init(r19152);
        mpfr_init(r19153);
        mpfr_init_set_str(r19154, "-7.945478500947738e-259", 10, MPFR_RNDN);
        mpfr_init(r19155);
        mpfr_init(r19156);
        mpfr_init(r19157);
        mpfr_init(r19158);
        mpfr_init(r19159);
        mpfr_init(r19160);
        mpfr_init(r19161);
        mpfr_init(r19162);
        mpfr_init(r19163);
        mpfr_init(r19164);
        mpfr_init(r19165);
        mpfr_init(r19166);
        mpfr_init_set_str(r19167, "2.196524360140306e-303", 10, MPFR_RNDN);
        mpfr_init(r19168);
        mpfr_init(r19169);
        mpfr_init(r19170);
        mpfr_init_set_str(r19171, "1.808337382703412e+83", 10, MPFR_RNDN);
        mpfr_init(r19172);
        mpfr_init(r19173);
        mpfr_init(r19174);
        mpfr_init(r19175);
        mpfr_init(r19176);
        mpfr_init(r19177);
        mpfr_init(r19178);
}

double f_dm(double re, double im, double base) {
        mpfr_set_d(r19146, im, MPFR_RNDN);
        ;
        mpfr_set_si(r19148, mpfr_cmp(r19146, r19147) <= 0, MPFR_RNDN);
        mpfr_neg(r19149, r19146, MPFR_RNDN);
        mpfr_log(r19150, r19149, MPFR_RNDN);
        mpfr_set_d(r19151, base, MPFR_RNDN);
        mpfr_log(r19152, r19151, MPFR_RNDN);
        mpfr_div(r19153, r19150, r19152, MPFR_RNDN);
        ;
        mpfr_set_si(r19155, mpfr_cmp(r19146, r19154) <= 0, MPFR_RNDN);
        mpfr_mul(r19156, r19146, r19146, MPFR_RNDN);
        mpfr_set_d(r19157, re, MPFR_RNDN);
        mpfr_mul(r19158, r19157, r19157, MPFR_RNDN);
        mpfr_add(r19159, r19156, r19158, MPFR_RNDN);
        mpfr_sqrt(r19160, r19159, MPFR_RNDN);
        mpfr_log(r19161, r19160, MPFR_RNDN);
        mpfr_mul(r19162, r19152, r19161, MPFR_RNDN);
        mpfr_sqr(r19163, r19152, MPFR_RNDN);
        mpfr_mul(r19164, r19163, r19163, MPFR_RNDN); mpfr_mul(r19164, r19164, r19163, MPFR_RNDN);
        mpfr_cbrt(r19165, r19164, MPFR_RNDN);
        mpfr_div(r19166, r19162, r19165, MPFR_RNDN);
        ;
        mpfr_set_si(r19168, mpfr_cmp(r19146, r19167) <= 0, MPFR_RNDN);
        mpfr_log(r19169, r19157, MPFR_RNDN);
        mpfr_div(r19170, r19169, r19152, MPFR_RNDN);
        ;
        mpfr_set_si(r19172, mpfr_cmp(r19146, r19171) <= 0, MPFR_RNDN);
        mpfr_log(r19173, r19146, MPFR_RNDN);
        mpfr_div(r19174, r19173, r19152, MPFR_RNDN);
        if (mpfr_get_si(r19172, MPFR_RNDN)) { mpfr_set(r19175, r19166, MPFR_RNDN); } else { mpfr_set(r19175, r19174, MPFR_RNDN); };
        if (mpfr_get_si(r19168, MPFR_RNDN)) { mpfr_set(r19176, r19170, MPFR_RNDN); } else { mpfr_set(r19176, r19175, MPFR_RNDN); };
        if (mpfr_get_si(r19155, MPFR_RNDN)) { mpfr_set(r19177, r19166, MPFR_RNDN); } else { mpfr_set(r19177, r19176, MPFR_RNDN); };
        if (mpfr_get_si(r19148, MPFR_RNDN)) { mpfr_set(r19178, r19153, MPFR_RNDN); } else { mpfr_set(r19178, r19177, MPFR_RNDN); };
        return mpfr_get_d(r19178, MPFR_RNDN);
}

