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

char *name = "3.9.2 real part (p56)";

double f_if() {
        float r8388 = 1;
        float r8389 = -r8388;
        float r8390 = 2;
        float r8391 = r8389 / r8390;
        float r8392 = 3;
        float r8393 = sqrt(r8392);
        float r8394 = r8393 / r8390;
        float r8395 = /* ERROR: no complex support in C */;
        float r8396 = r8395 * r8395;
        float r8397 = r8396 * r8395;
        float r8398 = r8397 * r8395;
        float r8399 = -r8390;
        float r8400 = 0;
        float r8401 = /* ERROR: no complex support in C */;
        float r8402 = r8401 * r8395;
        float r8403 = r8402 * r8395;
        float r8404 = r8403 * r8395;
        float r8405 = r8398 + r8404;
        float r8406 = 5;
        float r8407 = /* ERROR: no complex support in C */;
        float r8408 = r8407 * r8395;
        float r8409 = r8408 * r8395;
        float r8410 = r8405 + r8409;
        float r8411 = 4;
        float r8412 = /* ERROR: no complex support in C */;
        float r8413 = r8412 * r8395;
        float r8414 = r8410 + r8413;
        float r8415 = 7;
        float r8416 = /* ERROR: no complex support in C */;
        float r8417 = r8414 + r8416;
        float r8418 = /* ERROR: no complex support in C */;
        return r8418;
}

double f_id() {
        double r8419 = 1;
        double r8420 = -r8419;
        double r8421 = 2;
        double r8422 = r8420 / r8421;
        double r8423 = 3;
        double r8424 = sqrt(r8423);
        double r8425 = r8424 / r8421;
        double r8426 = /* ERROR: no complex support in C */;
        double r8427 = r8426 * r8426;
        double r8428 = r8427 * r8426;
        double r8429 = r8428 * r8426;
        double r8430 = -r8421;
        double r8431 = 0;
        double r8432 = /* ERROR: no complex support in C */;
        double r8433 = r8432 * r8426;
        double r8434 = r8433 * r8426;
        double r8435 = r8434 * r8426;
        double r8436 = r8429 + r8435;
        double r8437 = 5;
        double r8438 = /* ERROR: no complex support in C */;
        double r8439 = r8438 * r8426;
        double r8440 = r8439 * r8426;
        double r8441 = r8436 + r8440;
        double r8442 = 4;
        double r8443 = /* ERROR: no complex support in C */;
        double r8444 = r8443 * r8426;
        double r8445 = r8441 + r8444;
        double r8446 = 7;
        double r8447 = /* ERROR: no complex support in C */;
        double r8448 = r8445 + r8447;
        double r8449 = /* ERROR: no complex support in C */;
        return r8449;
}


double f_of() {
        float r8450 = 2;
        float r8451 = -r8450;
        float r8452 = 0;
        float r8453 = /* ERROR: no complex support in C */;
        float r8454 = 1;
        float r8455 = -r8454;
        float r8456 = r8455 / r8450;
        float r8457 = 3;
        float r8458 = sqrt(r8457);
        float r8459 = r8458 / r8450;
        float r8460 = /* ERROR: no complex support in C */;
        float r8461 = r8453 + r8460;
        float r8462 = r8450 * r8450;
        float r8463 = r8454 / r8462;
        float r8464 = r8457 / r8462;
        float r8465 = r8463 - r8464;
        float r8466 = r8455 / r8462;
        float r8467 = r8458 + r8458;
        float r8468 = r8466 * r8467;
        float r8469 = /* ERROR: no complex support in C */;
        float r8470 = r8461 * r8469;
        float r8471 = r8470 * r8460;
        float r8472 = 5;
        float r8473 = -r8472;
        float r8474 = r8454 / r8450;
        float r8475 = r8473 * r8474;
        float r8476 = 4;
        float r8477 = r8475 + r8476;
        float r8478 = r8450 / r8458;
        float r8479 = r8472 / r8478;
        float r8480 = /* ERROR: no complex support in C */;
        float r8481 = r8480 * r8460;
        float r8482 = 7;
        float r8483 = /* ERROR: no complex support in C */;
        float r8484 = r8481 + r8483;
        float r8485 = r8471 + r8484;
        float r8486 = /* ERROR: no complex support in C */;
        return r8486;
}

double f_od() {
        double r8487 = 2;
        double r8488 = -r8487;
        double r8489 = 0;
        double r8490 = /* ERROR: no complex support in C */;
        double r8491 = 1;
        double r8492 = -r8491;
        double r8493 = r8492 / r8487;
        double r8494 = 3;
        double r8495 = sqrt(r8494);
        double r8496 = r8495 / r8487;
        double r8497 = /* ERROR: no complex support in C */;
        double r8498 = r8490 + r8497;
        double r8499 = r8487 * r8487;
        double r8500 = r8491 / r8499;
        double r8501 = r8494 / r8499;
        double r8502 = r8500 - r8501;
        double r8503 = r8492 / r8499;
        double r8504 = r8495 + r8495;
        double r8505 = r8503 * r8504;
        double r8506 = /* ERROR: no complex support in C */;
        double r8507 = r8498 * r8506;
        double r8508 = r8507 * r8497;
        double r8509 = 5;
        double r8510 = -r8509;
        double r8511 = r8491 / r8487;
        double r8512 = r8510 * r8511;
        double r8513 = 4;
        double r8514 = r8512 + r8513;
        double r8515 = r8487 / r8495;
        double r8516 = r8509 / r8515;
        double r8517 = /* ERROR: no complex support in C */;
        double r8518 = r8517 * r8497;
        double r8519 = 7;
        double r8520 = /* ERROR: no complex support in C */;
        double r8521 = r8518 + r8520;
        double r8522 = r8508 + r8521;
        double r8523 = /* ERROR: no complex support in C */;
        return r8523;
}

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 r8524, r8525, r8526, r8527, r8528, r8529, r8530, r8531, r8532, r8533, r8534, r8535, r8536, r8537, r8538, r8539, r8540, r8541, r8542, r8543, r8544, r8545, r8546, r8547, r8548, r8549, r8550, r8551, r8552, r8553, r8554;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r8524, "1", 10, MPFR_RNDN);
        mpfr_init(r8525);
        mpfr_init_set_str(r8526, "2", 10, MPFR_RNDN);
        mpfr_init(r8527);
        mpfr_init_set_str(r8528, "3", 10, MPFR_RNDN);
        mpfr_init(r8529);
        mpfr_init(r8530);
        mpfr_init(r8531);
        mpfr_init(r8532);
        mpfr_init(r8533);
        mpfr_init(r8534);
        mpfr_init(r8535);
        mpfr_init_set_str(r8536, "0", 10, MPFR_RNDN);
        mpfr_init(r8537);
        mpfr_init(r8538);
        mpfr_init(r8539);
        mpfr_init(r8540);
        mpfr_init(r8541);
        mpfr_init_set_str(r8542, "5", 10, MPFR_RNDN);
        mpfr_init(r8543);
        mpfr_init(r8544);
        mpfr_init(r8545);
        mpfr_init(r8546);
        mpfr_init_set_str(r8547, "4", 10, MPFR_RNDN);
        mpfr_init(r8548);
        mpfr_init(r8549);
        mpfr_init(r8550);
        mpfr_init_set_str(r8551, "7", 10, MPFR_RNDN);
        mpfr_init(r8552);
        mpfr_init(r8553);
        mpfr_init(r8554);
}

double f_im() {
        ;
        mpfr_neg(r8525, r8524, MPFR_RNDN);
        ;
        mpfr_div(r8527, r8525, r8526, MPFR_RNDN);
        ;
        mpfr_sqrt(r8529, r8528, MPFR_RNDN);
        mpfr_div(r8530, r8529, r8526, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r8532, r8531, r8531, MPFR_RNDN);
        mpfr_mul(r8533, r8532, r8531, MPFR_RNDN);
        mpfr_mul(r8534, r8533, r8531, MPFR_RNDN);
        mpfr_neg(r8535, r8526, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r8538, r8537, r8531, MPFR_RNDN);
        mpfr_mul(r8539, r8538, r8531, MPFR_RNDN);
        mpfr_mul(r8540, r8539, r8531, MPFR_RNDN);
        mpfr_add(r8541, r8534, r8540, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r8544, r8543, r8531, MPFR_RNDN);
        mpfr_mul(r8545, r8544, r8531, MPFR_RNDN);
        mpfr_add(r8546, r8541, r8545, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r8549, r8548, r8531, MPFR_RNDN);
        mpfr_add(r8550, r8546, r8549, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r8553, r8550, r8552, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r8554, MPFR_RNDN);
}

static mpfr_t r8555, r8556, r8557, r8558, r8559, r8560, r8561, r8562, r8563, r8564, r8565, r8566, r8567, r8568, r8569, r8570, r8571, r8572, r8573, r8574, r8575, r8576, r8577, r8578, r8579, r8580, r8581, r8582, r8583, r8584, r8585, r8586, r8587, r8588, r8589, r8590, r8591;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r8555, "2", 10, MPFR_RNDN);
        mpfr_init(r8556);
        mpfr_init_set_str(r8557, "0", 10, MPFR_RNDN);
        mpfr_init(r8558);
        mpfr_init_set_str(r8559, "1", 10, MPFR_RNDN);
        mpfr_init(r8560);
        mpfr_init(r8561);
        mpfr_init_set_str(r8562, "3", 10, MPFR_RNDN);
        mpfr_init(r8563);
        mpfr_init(r8564);
        mpfr_init(r8565);
        mpfr_init(r8566);
        mpfr_init(r8567);
        mpfr_init(r8568);
        mpfr_init(r8569);
        mpfr_init(r8570);
        mpfr_init(r8571);
        mpfr_init(r8572);
        mpfr_init(r8573);
        mpfr_init(r8574);
        mpfr_init(r8575);
        mpfr_init(r8576);
        mpfr_init_set_str(r8577, "5", 10, MPFR_RNDN);
        mpfr_init(r8578);
        mpfr_init(r8579);
        mpfr_init(r8580);
        mpfr_init_set_str(r8581, "4", 10, MPFR_RNDN);
        mpfr_init(r8582);
        mpfr_init(r8583);
        mpfr_init(r8584);
        mpfr_init(r8585);
        mpfr_init(r8586);
        mpfr_init_set_str(r8587, "7", 10, MPFR_RNDN);
        mpfr_init(r8588);
        mpfr_init(r8589);
        mpfr_init(r8590);
        mpfr_init(r8591);
}

double f_fm() {
        ;
        mpfr_neg(r8556, r8555, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        ;
        mpfr_neg(r8560, r8559, MPFR_RNDN);
        mpfr_div(r8561, r8560, r8555, MPFR_RNDN);
        ;
        mpfr_sqrt(r8563, r8562, MPFR_RNDN);
        mpfr_div(r8564, r8563, r8555, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_add(r8566, r8558, r8565, MPFR_RNDN);
        mpfr_mul(r8567, r8555, r8555, MPFR_RNDN);
        mpfr_div(r8568, r8559, r8567, MPFR_RNDN);
        mpfr_div(r8569, r8562, r8567, MPFR_RNDN);
        mpfr_sub(r8570, r8568, r8569, MPFR_RNDN);
        mpfr_div(r8571, r8560, r8567, MPFR_RNDN);
        mpfr_add(r8572, r8563, r8563, MPFR_RNDN);
        mpfr_mul(r8573, r8571, r8572, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r8575, r8566, r8574, MPFR_RNDN);
        mpfr_mul(r8576, r8575, r8565, MPFR_RNDN);
        ;
        mpfr_neg(r8578, r8577, MPFR_RNDN);
        mpfr_div(r8579, r8559, r8555, MPFR_RNDN);
        mpfr_mul(r8580, r8578, r8579, MPFR_RNDN);
        ;
        mpfr_add(r8582, r8580, r8581, MPFR_RNDN);
        mpfr_div(r8583, r8555, r8563, MPFR_RNDN);
        mpfr_div(r8584, r8577, r8583, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r8586, r8585, r8565, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r8589, r8586, r8588, MPFR_RNDN);
        mpfr_add(r8590, r8576, r8589, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r8591, MPFR_RNDN);
}

static mpfr_t r8592, r8593, r8594, r8595, r8596, r8597, r8598, r8599, r8600, r8601, r8602, r8603, r8604, r8605, r8606, r8607, r8608, r8609, r8610, r8611, r8612, r8613, r8614, r8615, r8616, r8617, r8618, r8619, r8620, r8621, r8622, r8623, r8624, r8625, r8626, r8627, r8628;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r8592, "2", 10, MPFR_RNDN);
        mpfr_init(r8593);
        mpfr_init_set_str(r8594, "0", 10, MPFR_RNDN);
        mpfr_init(r8595);
        mpfr_init_set_str(r8596, "1", 10, MPFR_RNDN);
        mpfr_init(r8597);
        mpfr_init(r8598);
        mpfr_init_set_str(r8599, "3", 10, MPFR_RNDN);
        mpfr_init(r8600);
        mpfr_init(r8601);
        mpfr_init(r8602);
        mpfr_init(r8603);
        mpfr_init(r8604);
        mpfr_init(r8605);
        mpfr_init(r8606);
        mpfr_init(r8607);
        mpfr_init(r8608);
        mpfr_init(r8609);
        mpfr_init(r8610);
        mpfr_init(r8611);
        mpfr_init(r8612);
        mpfr_init(r8613);
        mpfr_init_set_str(r8614, "5", 10, MPFR_RNDN);
        mpfr_init(r8615);
        mpfr_init(r8616);
        mpfr_init(r8617);
        mpfr_init_set_str(r8618, "4", 10, MPFR_RNDN);
        mpfr_init(r8619);
        mpfr_init(r8620);
        mpfr_init(r8621);
        mpfr_init(r8622);
        mpfr_init(r8623);
        mpfr_init_set_str(r8624, "7", 10, MPFR_RNDN);
        mpfr_init(r8625);
        mpfr_init(r8626);
        mpfr_init(r8627);
        mpfr_init(r8628);
}

double f_dm() {
        ;
        mpfr_neg(r8593, r8592, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        ;
        mpfr_neg(r8597, r8596, MPFR_RNDN);
        mpfr_div(r8598, r8597, r8592, MPFR_RNDN);
        ;
        mpfr_sqrt(r8600, r8599, MPFR_RNDN);
        mpfr_div(r8601, r8600, r8592, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_add(r8603, r8595, r8602, MPFR_RNDN);
        mpfr_mul(r8604, r8592, r8592, MPFR_RNDN);
        mpfr_div(r8605, r8596, r8604, MPFR_RNDN);
        mpfr_div(r8606, r8599, r8604, MPFR_RNDN);
        mpfr_sub(r8607, r8605, r8606, MPFR_RNDN);
        mpfr_div(r8608, r8597, r8604, MPFR_RNDN);
        mpfr_add(r8609, r8600, r8600, MPFR_RNDN);
        mpfr_mul(r8610, r8608, r8609, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r8612, r8603, r8611, MPFR_RNDN);
        mpfr_mul(r8613, r8612, r8602, MPFR_RNDN);
        ;
        mpfr_neg(r8615, r8614, MPFR_RNDN);
        mpfr_div(r8616, r8596, r8592, MPFR_RNDN);
        mpfr_mul(r8617, r8615, r8616, MPFR_RNDN);
        ;
        mpfr_add(r8619, r8617, r8618, MPFR_RNDN);
        mpfr_div(r8620, r8592, r8600, MPFR_RNDN);
        mpfr_div(r8621, r8614, r8620, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r8623, r8622, r8602, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r8626, r8623, r8625, MPFR_RNDN);
        mpfr_add(r8627, r8613, r8626, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r8628, MPFR_RNDN);
}