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

char *name = "math.sqrt on complex, real part";

double f_if(float re, float im) {
        float r19971 = 0.5f;
        float r19972 = 2.0f;
        float r19973 = re;
        float r19974 = r19973 * r19973;
        float r19975 = im;
        float r19976 = r19975 * r19975;
        float r19977 = r19974 + r19976;
        float r19978 = sqrt(r19977);
        float r19979 = r19978 + r19973;
        float r19980 = r19972 * r19979;
        float r19981 = sqrt(r19980);
        float r19982 = r19971 * r19981;
        return r19982;
}

double f_id(double re, double im) {
        double r19983 = 0.5;
        double r19984 = 2.0;
        double r19985 = re;
        double r19986 = r19985 * r19985;
        double r19987 = im;
        double r19988 = r19987 * r19987;
        double r19989 = r19986 + r19988;
        double r19990 = sqrt(r19989);
        double r19991 = r19990 + r19985;
        double r19992 = r19984 * r19991;
        double r19993 = sqrt(r19992);
        double r19994 = r19983 * r19993;
        return r19994;
}


double f_of(float re, float im) {
        float r19995 = re;
        float r19996 = r19995 * r19995;
        float r19997 = im;
        float r19998 = r19997 * r19997;
        float r19999 = r19996 + r19998;
        float r20000 = sqrt(r19999);
        float r20001 = r20000 + r19995;
        float r20002 = 4.9600759064587394e-23f;
        bool r20003 = r20001 <= r20002;
        float r20004 = 0.5f;
        float r20005 = 2.0f;
        float r20006 = r20005 * r19997;
        float r20007 = r20006 * r19997;
        float r20008 = sqrt(r20007);
        float r20009 = r19995 * r19995;
        float r20010 = r20009 + r19998;
        float r20011 = sqrt(r20010);
        float r20012 = r20011 - r19995;
        float r20013 = sqrt(r20012);
        float r20014 = r20008 / r20013;
        float r20015 = r20004 * r20014;
        float r20016 = 2.7921734948534354e+19f;
        bool r20017 = r20001 <= r20016;
        float r20018 = cbrt(r20010);
        float r20019 = r20018 * (r20018 * r20018);
        float r20020 = sqrt(r20019);
        float r20021 = r20020 + r19995;
        float r20022 = r20005 * r20021;
        float r20023 = sqrt(r20022);
        float r20024 = r20004 * r20023;
        float r20025 = r19997 + r19995;
        float r20026 = r20005 * r20025;
        float r20027 = sqrt(r20026);
        float r20028 = r20004 * r20027;
        float r20029 = r20017 ? r20024 : r20028;
        float r20030 = r20003 ? r20015 : r20029;
        return r20030;
}

double f_od(double re, double im) {
        double r20031 = re;
        double r20032 = r20031 * r20031;
        double r20033 = im;
        double r20034 = r20033 * r20033;
        double r20035 = r20032 + r20034;
        double r20036 = sqrt(r20035);
        double r20037 = r20036 + r20031;
        double r20038 = 4.9600759064587394e-23;
        bool r20039 = r20037 <= r20038;
        double r20040 = 0.5;
        double r20041 = 2.0;
        double r20042 = r20041 * r20033;
        double r20043 = r20042 * r20033;
        double r20044 = sqrt(r20043);
        double r20045 = r20031 * r20031;
        double r20046 = r20045 + r20034;
        double r20047 = sqrt(r20046);
        double r20048 = r20047 - r20031;
        double r20049 = sqrt(r20048);
        double r20050 = r20044 / r20049;
        double r20051 = r20040 * r20050;
        double r20052 = 2.7921734948534354e+19;
        bool r20053 = r20037 <= r20052;
        double r20054 = cbrt(r20046);
        double r20055 = r20054 * (r20054 * r20054);
        double r20056 = sqrt(r20055);
        double r20057 = r20056 + r20031;
        double r20058 = r20041 * r20057;
        double r20059 = sqrt(r20058);
        double r20060 = r20040 * r20059;
        double r20061 = r20033 + r20031;
        double r20062 = r20041 * r20061;
        double r20063 = sqrt(r20062);
        double r20064 = r20040 * r20063;
        double r20065 = r20053 ? r20060 : r20064;
        double r20066 = r20039 ? r20051 : r20065;
        return r20066;
}

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 r20067, r20068, r20069, r20070, r20071, r20072, r20073, r20074, r20075, r20076, r20077, r20078;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(144);
        mpfr_init_set_str(r20067, "0.5", 10, MPFR_RNDN);
        mpfr_init_set_str(r20068, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20069);
        mpfr_init(r20070);
        mpfr_init(r20071);
        mpfr_init(r20072);
        mpfr_init(r20073);
        mpfr_init(r20074);
        mpfr_init(r20075);
        mpfr_init(r20076);
        mpfr_init(r20077);
        mpfr_init(r20078);
}

double f_im(double re, double im) {
        ;
        ;
        mpfr_set_d(r20069, re, MPFR_RNDN);
        mpfr_mul(r20070, r20069, r20069, MPFR_RNDN);
        mpfr_set_d(r20071, im, MPFR_RNDN);
        mpfr_mul(r20072, r20071, r20071, MPFR_RNDN);
        mpfr_add(r20073, r20070, r20072, MPFR_RNDN);
        mpfr_sqrt(r20074, r20073, MPFR_RNDN);
        mpfr_add(r20075, r20074, r20069, MPFR_RNDN);
        mpfr_mul(r20076, r20068, r20075, MPFR_RNDN);
        mpfr_sqrt(r20077, r20076, MPFR_RNDN);
        mpfr_mul(r20078, r20067, r20077, MPFR_RNDN);
        return mpfr_get_d(r20078, MPFR_RNDN);
}

static mpfr_t r20079, r20080, r20081, r20082, r20083, r20084, r20085, r20086, r20087, r20088, r20089, r20090, r20091, r20092, r20093, r20094, r20095, r20096, r20097, r20098, r20099, r20100, r20101, r20102, r20103, r20104, r20105, r20106, r20107, r20108, r20109, r20110, r20111, r20112, r20113, r20114;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(144);
        mpfr_init(r20079);
        mpfr_init(r20080);
        mpfr_init(r20081);
        mpfr_init(r20082);
        mpfr_init(r20083);
        mpfr_init(r20084);
        mpfr_init(r20085);
        mpfr_init_set_str(r20086, "4.960076f-23", 10, MPFR_RNDN);
        mpfr_init(r20087);
        mpfr_init_set_str(r20088, "0.5", 10, MPFR_RNDN);
        mpfr_init_set_str(r20089, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20090);
        mpfr_init(r20091);
        mpfr_init(r20092);
        mpfr_init(r20093);
        mpfr_init(r20094);
        mpfr_init(r20095);
        mpfr_init(r20096);
        mpfr_init(r20097);
        mpfr_init(r20098);
        mpfr_init(r20099);
        mpfr_init_set_str(r20100, "2.7921735f+19", 10, MPFR_RNDN);
        mpfr_init(r20101);
        mpfr_init(r20102);
        mpfr_init(r20103);
        mpfr_init(r20104);
        mpfr_init(r20105);
        mpfr_init(r20106);
        mpfr_init(r20107);
        mpfr_init(r20108);
        mpfr_init(r20109);
        mpfr_init(r20110);
        mpfr_init(r20111);
        mpfr_init(r20112);
        mpfr_init(r20113);
        mpfr_init(r20114);
}

double f_fm(double re, double im) {
        mpfr_set_d(r20079, re, MPFR_RNDN);
        mpfr_mul(r20080, r20079, r20079, MPFR_RNDN);
        mpfr_set_d(r20081, im, MPFR_RNDN);
        mpfr_mul(r20082, r20081, r20081, MPFR_RNDN);
        mpfr_add(r20083, r20080, r20082, MPFR_RNDN);
        mpfr_sqrt(r20084, r20083, MPFR_RNDN);
        mpfr_add(r20085, r20084, r20079, MPFR_RNDN);
        ;
        mpfr_set_si(r20087, mpfr_cmp(r20085, r20086) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_mul(r20090, r20089, r20081, MPFR_RNDN);
        mpfr_mul(r20091, r20090, r20081, MPFR_RNDN);
        mpfr_sqrt(r20092, r20091, MPFR_RNDN);
        mpfr_sqr(r20093, r20079, MPFR_RNDN);
        mpfr_add(r20094, r20093, r20082, MPFR_RNDN);
        mpfr_sqrt(r20095, r20094, MPFR_RNDN);
        mpfr_sub(r20096, r20095, r20079, MPFR_RNDN);
        mpfr_sqrt(r20097, r20096, MPFR_RNDN);
        mpfr_div(r20098, r20092, r20097, MPFR_RNDN);
        mpfr_mul(r20099, r20088, r20098, MPFR_RNDN);
        ;
        mpfr_set_si(r20101, mpfr_cmp(r20085, r20100) <= 0, MPFR_RNDN);
        mpfr_cbrt(r20102, r20094, MPFR_RNDN);
        mpfr_mul(r20103, r20102, r20102, MPFR_RNDN); mpfr_mul(r20103, r20103, r20102, MPFR_RNDN);
        mpfr_sqrt(r20104, r20103, MPFR_RNDN);
        mpfr_add(r20105, r20104, r20079, MPFR_RNDN);
        mpfr_mul(r20106, r20089, r20105, MPFR_RNDN);
        mpfr_sqrt(r20107, r20106, MPFR_RNDN);
        mpfr_mul(r20108, r20088, r20107, MPFR_RNDN);
        mpfr_add(r20109, r20081, r20079, MPFR_RNDN);
        mpfr_mul(r20110, r20089, r20109, MPFR_RNDN);
        mpfr_sqrt(r20111, r20110, MPFR_RNDN);
        mpfr_mul(r20112, r20088, r20111, MPFR_RNDN);
        if (mpfr_get_si(r20101, MPFR_RNDN)) { mpfr_set(r20113, r20108, MPFR_RNDN); } else { mpfr_set(r20113, r20112, MPFR_RNDN); };
        if (mpfr_get_si(r20087, MPFR_RNDN)) { mpfr_set(r20114, r20099, MPFR_RNDN); } else { mpfr_set(r20114, r20113, MPFR_RNDN); };
        return mpfr_get_d(r20114, MPFR_RNDN);
}

static mpfr_t r20115, r20116, r20117, r20118, r20119, r20120, r20121, r20122, r20123, r20124, r20125, r20126, r20127, r20128, r20129, r20130, r20131, r20132, r20133, r20134, r20135, r20136, r20137, r20138, r20139, r20140, r20141, r20142, r20143, r20144, r20145, r20146, r20147, r20148, r20149, r20150;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(144);
        mpfr_init(r20115);
        mpfr_init(r20116);
        mpfr_init(r20117);
        mpfr_init(r20118);
        mpfr_init(r20119);
        mpfr_init(r20120);
        mpfr_init(r20121);
        mpfr_init_set_str(r20122, "4.960076f-23", 10, MPFR_RNDN);
        mpfr_init(r20123);
        mpfr_init_set_str(r20124, "0.5", 10, MPFR_RNDN);
        mpfr_init_set_str(r20125, "2.0", 10, MPFR_RNDN);
        mpfr_init(r20126);
        mpfr_init(r20127);
        mpfr_init(r20128);
        mpfr_init(r20129);
        mpfr_init(r20130);
        mpfr_init(r20131);
        mpfr_init(r20132);
        mpfr_init(r20133);
        mpfr_init(r20134);
        mpfr_init(r20135);
        mpfr_init_set_str(r20136, "2.7921735f+19", 10, MPFR_RNDN);
        mpfr_init(r20137);
        mpfr_init(r20138);
        mpfr_init(r20139);
        mpfr_init(r20140);
        mpfr_init(r20141);
        mpfr_init(r20142);
        mpfr_init(r20143);
        mpfr_init(r20144);
        mpfr_init(r20145);
        mpfr_init(r20146);
        mpfr_init(r20147);
        mpfr_init(r20148);
        mpfr_init(r20149);
        mpfr_init(r20150);
}

double f_dm(double re, double im) {
        mpfr_set_d(r20115, re, MPFR_RNDN);
        mpfr_mul(r20116, r20115, r20115, MPFR_RNDN);
        mpfr_set_d(r20117, im, MPFR_RNDN);
        mpfr_mul(r20118, r20117, r20117, MPFR_RNDN);
        mpfr_add(r20119, r20116, r20118, MPFR_RNDN);
        mpfr_sqrt(r20120, r20119, MPFR_RNDN);
        mpfr_add(r20121, r20120, r20115, MPFR_RNDN);
        ;
        mpfr_set_si(r20123, mpfr_cmp(r20121, r20122) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_mul(r20126, r20125, r20117, MPFR_RNDN);
        mpfr_mul(r20127, r20126, r20117, MPFR_RNDN);
        mpfr_sqrt(r20128, r20127, MPFR_RNDN);
        mpfr_sqr(r20129, r20115, MPFR_RNDN);
        mpfr_add(r20130, r20129, r20118, MPFR_RNDN);
        mpfr_sqrt(r20131, r20130, MPFR_RNDN);
        mpfr_sub(r20132, r20131, r20115, MPFR_RNDN);
        mpfr_sqrt(r20133, r20132, MPFR_RNDN);
        mpfr_div(r20134, r20128, r20133, MPFR_RNDN);
        mpfr_mul(r20135, r20124, r20134, MPFR_RNDN);
        ;
        mpfr_set_si(r20137, mpfr_cmp(r20121, r20136) <= 0, MPFR_RNDN);
        mpfr_cbrt(r20138, r20130, MPFR_RNDN);
        mpfr_mul(r20139, r20138, r20138, MPFR_RNDN); mpfr_mul(r20139, r20139, r20138, MPFR_RNDN);
        mpfr_sqrt(r20140, r20139, MPFR_RNDN);
        mpfr_add(r20141, r20140, r20115, MPFR_RNDN);
        mpfr_mul(r20142, r20125, r20141, MPFR_RNDN);
        mpfr_sqrt(r20143, r20142, MPFR_RNDN);
        mpfr_mul(r20144, r20124, r20143, MPFR_RNDN);
        mpfr_add(r20145, r20117, r20115, MPFR_RNDN);
        mpfr_mul(r20146, r20125, r20145, MPFR_RNDN);
        mpfr_sqrt(r20147, r20146, MPFR_RNDN);
        mpfr_mul(r20148, r20124, r20147, MPFR_RNDN);
        if (mpfr_get_si(r20137, MPFR_RNDN)) { mpfr_set(r20149, r20144, MPFR_RNDN); } else { mpfr_set(r20149, r20148, MPFR_RNDN); };
        if (mpfr_get_si(r20123, MPFR_RNDN)) { mpfr_set(r20150, r20135, MPFR_RNDN); } else { mpfr_set(r20150, r20149, MPFR_RNDN); };
        return mpfr_get_d(r20150, MPFR_RNDN);
}