#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 r24468 = 1;
        float r24469 = -r24468;
        float r24470 = 2;
        float r24471 = r24469 / r24470;
        float r24472 = 3;
        float r24473 = sqrt(r24472);
        float r24474 = r24473 / r24470;
        float r24475 = /* ERROR: no complex support in C */;
        float r24476 = r24475 * r24475;
        float r24477 = r24476 * r24475;
        float r24478 = r24477 * r24475;
        float r24479 = -r24470;
        float r24480 = 0;
        float r24481 = /* ERROR: no complex support in C */;
        float r24482 = r24481 * r24475;
        float r24483 = r24482 * r24475;
        float r24484 = r24483 * r24475;
        float r24485 = r24478 + r24484;
        float r24486 = 5;
        float r24487 = /* ERROR: no complex support in C */;
        float r24488 = r24487 * r24475;
        float r24489 = r24488 * r24475;
        float r24490 = r24485 + r24489;
        float r24491 = 4;
        float r24492 = /* ERROR: no complex support in C */;
        float r24493 = r24492 * r24475;
        float r24494 = r24490 + r24493;
        float r24495 = 7;
        float r24496 = /* ERROR: no complex support in C */;
        float r24497 = r24494 + r24496;
        float r24498 = /* ERROR: no complex support in C */;
        return r24498;
}

double f_id() {
        double r24499 = 1;
        double r24500 = -r24499;
        double r24501 = 2;
        double r24502 = r24500 / r24501;
        double r24503 = 3;
        double r24504 = sqrt(r24503);
        double r24505 = r24504 / r24501;
        double r24506 = /* ERROR: no complex support in C */;
        double r24507 = r24506 * r24506;
        double r24508 = r24507 * r24506;
        double r24509 = r24508 * r24506;
        double r24510 = -r24501;
        double r24511 = 0;
        double r24512 = /* ERROR: no complex support in C */;
        double r24513 = r24512 * r24506;
        double r24514 = r24513 * r24506;
        double r24515 = r24514 * r24506;
        double r24516 = r24509 + r24515;
        double r24517 = 5;
        double r24518 = /* ERROR: no complex support in C */;
        double r24519 = r24518 * r24506;
        double r24520 = r24519 * r24506;
        double r24521 = r24516 + r24520;
        double r24522 = 4;
        double r24523 = /* ERROR: no complex support in C */;
        double r24524 = r24523 * r24506;
        double r24525 = r24521 + r24524;
        double r24526 = 7;
        double r24527 = /* ERROR: no complex support in C */;
        double r24528 = r24525 + r24527;
        double r24529 = /* ERROR: no complex support in C */;
        return r24529;
}


double f_of() {
        float r24530 = 1;
        float r24531 = 2;
        float r24532 = r24530 / r24531;
        float r24533 = -r24532;
        float r24534 = 3;
        float r24535 = sqrt(r24534);
        float r24536 = r24535 / r24531;
        float r24537 = /* ERROR: no complex support in C */;
        float r24538 = r24537 * r24537;
        float r24539 = r24532 + r24531;
        float r24540 = r24539 * r24532;
        float r24541 = r24534 / r24531;
        float r24542 = r24541 / r24531;
        float r24543 = r24540 - r24542;
        float r24544 = -r24531;
        float r24545 = r24532 + r24532;
        float r24546 = r24544 - r24545;
        float r24547 = r24536 * r24546;
        float r24548 = /* ERROR: no complex support in C */;
        float r24549 = r24538 * r24548;
        float r24550 = 7;
        float r24551 = 0;
        float r24552 = /* ERROR: no complex support in C */;
        float r24553 = 5;
        float r24554 = -r24553;
        float r24555 = r24554 * r24532;
        float r24556 = 4;
        float r24557 = r24555 + r24556;
        float r24558 = r24536 * r24553;
        float r24559 = /* ERROR: no complex support in C */;
        float r24560 = r24537 * r24559;
        float r24561 = r24552 + r24560;
        float r24562 = r24549 + r24561;
        float r24563 = /* ERROR: no complex support in C */;
        return r24563;
}

double f_od() {
        double r24564 = 1;
        double r24565 = 2;
        double r24566 = r24564 / r24565;
        double r24567 = -r24566;
        double r24568 = 3;
        double r24569 = sqrt(r24568);
        double r24570 = r24569 / r24565;
        double r24571 = /* ERROR: no complex support in C */;
        double r24572 = r24571 * r24571;
        double r24573 = r24566 + r24565;
        double r24574 = r24573 * r24566;
        double r24575 = r24568 / r24565;
        double r24576 = r24575 / r24565;
        double r24577 = r24574 - r24576;
        double r24578 = -r24565;
        double r24579 = r24566 + r24566;
        double r24580 = r24578 - r24579;
        double r24581 = r24570 * r24580;
        double r24582 = /* ERROR: no complex support in C */;
        double r24583 = r24572 * r24582;
        double r24584 = 7;
        double r24585 = 0;
        double r24586 = /* ERROR: no complex support in C */;
        double r24587 = 5;
        double r24588 = -r24587;
        double r24589 = r24588 * r24566;
        double r24590 = 4;
        double r24591 = r24589 + r24590;
        double r24592 = r24570 * r24587;
        double r24593 = /* ERROR: no complex support in C */;
        double r24594 = r24571 * r24593;
        double r24595 = r24586 + r24594;
        double r24596 = r24583 + r24595;
        double r24597 = /* ERROR: no complex support in C */;
        return r24597;
}

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 r24598, r24599, r24600, r24601, r24602, r24603, r24604, r24605, r24606, r24607, r24608, r24609, r24610, r24611, r24612, r24613, r24614, r24615, r24616, r24617, r24618, r24619, r24620, r24621, r24622, r24623, r24624, r24625, r24626, r24627, r24628;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24598, "1", 10, MPFR_RNDN);
        mpfr_init(r24599);
        mpfr_init_set_str(r24600, "2", 10, MPFR_RNDN);
        mpfr_init(r24601);
        mpfr_init_set_str(r24602, "3", 10, MPFR_RNDN);
        mpfr_init(r24603);
        mpfr_init(r24604);
        mpfr_init(r24605);
        mpfr_init(r24606);
        mpfr_init(r24607);
        mpfr_init(r24608);
        mpfr_init(r24609);
        mpfr_init_set_str(r24610, "0", 10, MPFR_RNDN);
        mpfr_init(r24611);
        mpfr_init(r24612);
        mpfr_init(r24613);
        mpfr_init(r24614);
        mpfr_init(r24615);
        mpfr_init_set_str(r24616, "5", 10, MPFR_RNDN);
        mpfr_init(r24617);
        mpfr_init(r24618);
        mpfr_init(r24619);
        mpfr_init(r24620);
        mpfr_init_set_str(r24621, "4", 10, MPFR_RNDN);
        mpfr_init(r24622);
        mpfr_init(r24623);
        mpfr_init(r24624);
        mpfr_init_set_str(r24625, "7", 10, MPFR_RNDN);
        mpfr_init(r24626);
        mpfr_init(r24627);
        mpfr_init(r24628);
}

double f_im() {
        ;
        mpfr_neg(r24599, r24598, MPFR_RNDN);
        ;
        mpfr_div(r24601, r24599, r24600, MPFR_RNDN);
        ;
        mpfr_sqrt(r24603, r24602, MPFR_RNDN);
        mpfr_div(r24604, r24603, r24600, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24606, r24605, r24605, MPFR_RNDN);
        mpfr_mul(r24607, r24606, r24605, MPFR_RNDN);
        mpfr_mul(r24608, r24607, r24605, MPFR_RNDN);
        mpfr_neg(r24609, r24600, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24612, r24611, r24605, MPFR_RNDN);
        mpfr_mul(r24613, r24612, r24605, MPFR_RNDN);
        mpfr_mul(r24614, r24613, r24605, MPFR_RNDN);
        mpfr_add(r24615, r24608, r24614, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24618, r24617, r24605, MPFR_RNDN);
        mpfr_mul(r24619, r24618, r24605, MPFR_RNDN);
        mpfr_add(r24620, r24615, r24619, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_mul(r24623, r24622, r24605, MPFR_RNDN);
        mpfr_add(r24624, r24620, r24623, MPFR_RNDN);
        ;
        /* ERROR: no complex support in C */;
        mpfr_add(r24627, r24624, r24626, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24628, MPFR_RNDN);
}

static mpfr_t r24629, r24630, r24631, r24632, r24633, r24634, r24635, r24636, r24637, r24638, r24639, r24640, r24641, r24642, r24643, r24644, r24645, r24646, r24647, r24648, r24649, r24650, r24651, r24652, r24653, r24654, r24655, r24656, r24657, r24658, r24659, r24660, r24661, r24662;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24629, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r24630, "2", 10, MPFR_RNDN);
        mpfr_init(r24631);
        mpfr_init(r24632);
        mpfr_init_set_str(r24633, "3", 10, MPFR_RNDN);
        mpfr_init(r24634);
        mpfr_init(r24635);
        mpfr_init(r24636);
        mpfr_init(r24637);
        mpfr_init(r24638);
        mpfr_init(r24639);
        mpfr_init(r24640);
        mpfr_init(r24641);
        mpfr_init(r24642);
        mpfr_init(r24643);
        mpfr_init(r24644);
        mpfr_init(r24645);
        mpfr_init(r24646);
        mpfr_init(r24647);
        mpfr_init(r24648);
        mpfr_init_set_str(r24649, "7", 10, MPFR_RNDN);
        mpfr_init_set_str(r24650, "0", 10, MPFR_RNDN);
        mpfr_init(r24651);
        mpfr_init_set_str(r24652, "5", 10, MPFR_RNDN);
        mpfr_init(r24653);
        mpfr_init(r24654);
        mpfr_init_set_str(r24655, "4", 10, MPFR_RNDN);
        mpfr_init(r24656);
        mpfr_init(r24657);
        mpfr_init(r24658);
        mpfr_init(r24659);
        mpfr_init(r24660);
        mpfr_init(r24661);
        mpfr_init(r24662);
}

double f_fm() {
        ;
        ;
        mpfr_div(r24631, r24629, r24630, MPFR_RNDN);
        mpfr_neg(r24632, r24631, MPFR_RNDN);
        ;
        mpfr_sqrt(r24634, r24633, MPFR_RNDN);
        mpfr_div(r24635, r24634, r24630, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24637, r24636, r24636, MPFR_RNDN);
        mpfr_add(r24638, r24631, r24630, MPFR_RNDN);
        mpfr_mul(r24639, r24638, r24631, MPFR_RNDN);
        mpfr_div(r24640, r24633, r24630, MPFR_RNDN);
        mpfr_div(r24641, r24640, r24630, MPFR_RNDN);
        mpfr_sub(r24642, r24639, r24641, MPFR_RNDN);
        mpfr_neg(r24643, r24630, MPFR_RNDN);
        mpfr_add(r24644, r24631, r24631, MPFR_RNDN);
        mpfr_sub(r24645, r24643, r24644, MPFR_RNDN);
        mpfr_mul(r24646, r24635, r24645, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24648, r24637, r24647, MPFR_RNDN);
        ;
        ;
        /* ERROR: no complex support in C */;
        ;
        mpfr_neg(r24653, r24652, MPFR_RNDN);
        mpfr_mul(r24654, r24653, r24631, MPFR_RNDN);
        ;
        mpfr_add(r24656, r24654, r24655, MPFR_RNDN);
        mpfr_mul(r24657, r24635, r24652, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24659, r24636, r24658, MPFR_RNDN);
        mpfr_add(r24660, r24651, r24659, MPFR_RNDN);
        mpfr_add(r24661, r24648, r24660, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24662, MPFR_RNDN);
}

static mpfr_t r24663, r24664, r24665, r24666, r24667, r24668, r24669, r24670, r24671, r24672, r24673, r24674, r24675, r24676, r24677, r24678, r24679, r24680, r24681, r24682, r24683, r24684, r24685, r24686, r24687, r24688, r24689, r24690, r24691, r24692, r24693, r24694, r24695, r24696;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1104);
        mpfr_init_set_str(r24663, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r24664, "2", 10, MPFR_RNDN);
        mpfr_init(r24665);
        mpfr_init(r24666);
        mpfr_init_set_str(r24667, "3", 10, MPFR_RNDN);
        mpfr_init(r24668);
        mpfr_init(r24669);
        mpfr_init(r24670);
        mpfr_init(r24671);
        mpfr_init(r24672);
        mpfr_init(r24673);
        mpfr_init(r24674);
        mpfr_init(r24675);
        mpfr_init(r24676);
        mpfr_init(r24677);
        mpfr_init(r24678);
        mpfr_init(r24679);
        mpfr_init(r24680);
        mpfr_init(r24681);
        mpfr_init(r24682);
        mpfr_init_set_str(r24683, "7", 10, MPFR_RNDN);
        mpfr_init_set_str(r24684, "0", 10, MPFR_RNDN);
        mpfr_init(r24685);
        mpfr_init_set_str(r24686, "5", 10, MPFR_RNDN);
        mpfr_init(r24687);
        mpfr_init(r24688);
        mpfr_init_set_str(r24689, "4", 10, MPFR_RNDN);
        mpfr_init(r24690);
        mpfr_init(r24691);
        mpfr_init(r24692);
        mpfr_init(r24693);
        mpfr_init(r24694);
        mpfr_init(r24695);
        mpfr_init(r24696);
}

double f_dm() {
        ;
        ;
        mpfr_div(r24665, r24663, r24664, MPFR_RNDN);
        mpfr_neg(r24666, r24665, MPFR_RNDN);
        ;
        mpfr_sqrt(r24668, r24667, MPFR_RNDN);
        mpfr_div(r24669, r24668, r24664, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24671, r24670, r24670, MPFR_RNDN);
        mpfr_add(r24672, r24665, r24664, MPFR_RNDN);
        mpfr_mul(r24673, r24672, r24665, MPFR_RNDN);
        mpfr_div(r24674, r24667, r24664, MPFR_RNDN);
        mpfr_div(r24675, r24674, r24664, MPFR_RNDN);
        mpfr_sub(r24676, r24673, r24675, MPFR_RNDN);
        mpfr_neg(r24677, r24664, MPFR_RNDN);
        mpfr_add(r24678, r24665, r24665, MPFR_RNDN);
        mpfr_sub(r24679, r24677, r24678, MPFR_RNDN);
        mpfr_mul(r24680, r24669, r24679, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24682, r24671, r24681, MPFR_RNDN);
        ;
        ;
        /* ERROR: no complex support in C */;
        ;
        mpfr_neg(r24687, r24686, MPFR_RNDN);
        mpfr_mul(r24688, r24687, r24665, MPFR_RNDN);
        ;
        mpfr_add(r24690, r24688, r24689, MPFR_RNDN);
        mpfr_mul(r24691, r24669, r24686, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        mpfr_mul(r24693, r24670, r24692, MPFR_RNDN);
        mpfr_add(r24694, r24685, r24693, MPFR_RNDN);
        mpfr_add(r24695, r24682, r24694, MPFR_RNDN);
        /* ERROR: no complex support in C */;
        return mpfr_get_d(r24696, MPFR_RNDN);
}