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

char *name = "tanhf (example 3.4)";

double f_if(float x) {
        float r20521 = 1;
        float r20522 = x;
        float r20523 = cos(r20522);
        float r20524 = r20521 - r20523;
        float r20525 = sin(r20522);
        float r20526 = r20524 / r20525;
        return r20526;
}

double f_id(double x) {
        double r20527 = 1;
        double r20528 = x;
        double r20529 = cos(r20528);
        double r20530 = r20527 - r20529;
        double r20531 = sin(r20528);
        double r20532 = r20530 / r20531;
        return r20532;
}


double f_of(float x) {
        float r20533 = x;
        float r20534 = -3.979550813088296e-22;
        bool r20535 = r20533 <= r20534;
        float r20536 = sin(r20533);
        float r20537 = r20536 * r20536;
        float r20538 = 1;
        float r20539 = cos(r20533);
        float r20540 = r20538 + r20539;
        float r20541 = r20537 / r20540;
        float r20542 = r20541 / r20536;
        float r20543 = 0.802860764679358;
        bool r20544 = r20533 <= r20543;
        float r20545 = 1/24;
        float r20546 = 3;
        float r20547 = pow(r20533, r20546);
        float r20548 = r20545 * r20547;
        float r20549 = 1/240;
        float r20550 = 5;
        float r20551 = pow(r20533, r20550);
        float r20552 = r20549 * r20551;
        float r20553 = 1/2;
        float r20554 = r20553 * r20533;
        float r20555 = r20552 + r20554;
        float r20556 = r20548 + r20555;
        float r20557 = r20544 ? r20556 : r20542;
        float r20558 = r20535 ? r20542 : r20557;
        return r20558;
}

double f_od(double x) {
        double r20559 = x;
        double r20560 = -3.979550813088296e-22;
        bool r20561 = r20559 <= r20560;
        double r20562 = sin(r20559);
        double r20563 = r20562 * r20562;
        double r20564 = 1;
        double r20565 = cos(r20559);
        double r20566 = r20564 + r20565;
        double r20567 = r20563 / r20566;
        double r20568 = r20567 / r20562;
        double r20569 = 0.802860764679358;
        bool r20570 = r20559 <= r20569;
        double r20571 = 1/24;
        double r20572 = 3;
        double r20573 = pow(r20559, r20572);
        double r20574 = r20571 * r20573;
        double r20575 = 1/240;
        double r20576 = 5;
        double r20577 = pow(r20559, r20576);
        double r20578 = r20575 * r20577;
        double r20579 = 1/2;
        double r20580 = r20579 * r20559;
        double r20581 = r20578 + r20580;
        double r20582 = r20574 + r20581;
        double r20583 = r20570 ? r20582 : r20568;
        double r20584 = r20561 ? r20568 : r20583;
        return r20584;
}

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 r20585, r20586, r20587, r20588, r20589, r20590;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2448);
        mpfr_init_set_str(r20585, "1", 10, MPFR_RNDN);
        mpfr_init(r20586);
        mpfr_init(r20587);
        mpfr_init(r20588);
        mpfr_init(r20589);
        mpfr_init(r20590);
}

double f_im(double x) {
        ;
        mpfr_set_d(r20586, x, MPFR_RNDN);
        mpfr_cos(r20587, r20586, MPFR_RNDN);
        mpfr_sub(r20588, r20585, r20587, MPFR_RNDN);
        mpfr_sin(r20589, r20586, MPFR_RNDN);
        mpfr_div(r20590, r20588, r20589, MPFR_RNDN);
        return mpfr_get_d(r20590, MPFR_RNDN);
}

static mpfr_t r20591, r20592, r20593, r20594, r20595, r20596, r20597, r20598, r20599, r20600, r20601, r20602, r20603, r20604, r20605, r20606, r20607, r20608, r20609, r20610, r20611, r20612, r20613, r20614, r20615, r20616;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2448);
        mpfr_init(r20591);
        mpfr_init_set_str(r20592, "-3.979550813088296e-22", 10, MPFR_RNDN);
        mpfr_init(r20593);
        mpfr_init(r20594);
        mpfr_init(r20595);
        mpfr_init_set_str(r20596, "1", 10, MPFR_RNDN);
        mpfr_init(r20597);
        mpfr_init(r20598);
        mpfr_init(r20599);
        mpfr_init(r20600);
        mpfr_init_set_str(r20601, "0.802860764679358", 10, MPFR_RNDN);
        mpfr_init(r20602);
        mpfr_init_set_str(r20603, "1/24", 10, MPFR_RNDN);
        mpfr_init_set_str(r20604, "3", 10, MPFR_RNDN);
        mpfr_init(r20605);
        mpfr_init(r20606);
        mpfr_init_set_str(r20607, "1/240", 10, MPFR_RNDN);
        mpfr_init_set_str(r20608, "5", 10, MPFR_RNDN);
        mpfr_init(r20609);
        mpfr_init(r20610);
        mpfr_init_set_str(r20611, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20612);
        mpfr_init(r20613);
        mpfr_init(r20614);
        mpfr_init(r20615);
        mpfr_init(r20616);
}

double f_fm(double x) {
        mpfr_set_d(r20591, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20593, mpfr_cmp(r20591, r20592) <= 0, MPFR_RNDN);
        mpfr_sin(r20594, r20591, MPFR_RNDN);
        mpfr_mul(r20595, r20594, r20594, MPFR_RNDN);
        ;
        mpfr_cos(r20597, r20591, MPFR_RNDN);
        mpfr_add(r20598, r20596, r20597, MPFR_RNDN);
        mpfr_div(r20599, r20595, r20598, MPFR_RNDN);
        mpfr_div(r20600, r20599, r20594, MPFR_RNDN);
        ;
        mpfr_set_si(r20602, mpfr_cmp(r20591, r20601) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20605, r20591, r20604, MPFR_RNDN);
        mpfr_mul(r20606, r20603, r20605, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20609, r20591, r20608, MPFR_RNDN);
        mpfr_mul(r20610, r20607, r20609, MPFR_RNDN);
        ;
        mpfr_mul(r20612, r20611, r20591, MPFR_RNDN);
        mpfr_add(r20613, r20610, r20612, MPFR_RNDN);
        mpfr_add(r20614, r20606, r20613, MPFR_RNDN);
        if (mpfr_get_si(r20602, MPFR_RNDN)) { mpfr_set(r20615, r20614, MPFR_RNDN); } else { mpfr_set(r20615, r20600, MPFR_RNDN); };
        if (mpfr_get_si(r20593, MPFR_RNDN)) { mpfr_set(r20616, r20600, MPFR_RNDN); } else { mpfr_set(r20616, r20615, MPFR_RNDN); };
        return mpfr_get_d(r20616, MPFR_RNDN);
}

static mpfr_t r20617, r20618, r20619, r20620, r20621, r20622, r20623, r20624, r20625, r20626, r20627, r20628, r20629, r20630, r20631, r20632, r20633, r20634, r20635, r20636, r20637, r20638, r20639, r20640, r20641, r20642;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2448);
        mpfr_init(r20617);
        mpfr_init_set_str(r20618, "-3.979550813088296e-22", 10, MPFR_RNDN);
        mpfr_init(r20619);
        mpfr_init(r20620);
        mpfr_init(r20621);
        mpfr_init_set_str(r20622, "1", 10, MPFR_RNDN);
        mpfr_init(r20623);
        mpfr_init(r20624);
        mpfr_init(r20625);
        mpfr_init(r20626);
        mpfr_init_set_str(r20627, "0.802860764679358", 10, MPFR_RNDN);
        mpfr_init(r20628);
        mpfr_init_set_str(r20629, "1/24", 10, MPFR_RNDN);
        mpfr_init_set_str(r20630, "3", 10, MPFR_RNDN);
        mpfr_init(r20631);
        mpfr_init(r20632);
        mpfr_init_set_str(r20633, "1/240", 10, MPFR_RNDN);
        mpfr_init_set_str(r20634, "5", 10, MPFR_RNDN);
        mpfr_init(r20635);
        mpfr_init(r20636);
        mpfr_init_set_str(r20637, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20638);
        mpfr_init(r20639);
        mpfr_init(r20640);
        mpfr_init(r20641);
        mpfr_init(r20642);
}

double f_dm(double x) {
        mpfr_set_d(r20617, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20619, mpfr_cmp(r20617, r20618) <= 0, MPFR_RNDN);
        mpfr_sin(r20620, r20617, MPFR_RNDN);
        mpfr_mul(r20621, r20620, r20620, MPFR_RNDN);
        ;
        mpfr_cos(r20623, r20617, MPFR_RNDN);
        mpfr_add(r20624, r20622, r20623, MPFR_RNDN);
        mpfr_div(r20625, r20621, r20624, MPFR_RNDN);
        mpfr_div(r20626, r20625, r20620, MPFR_RNDN);
        ;
        mpfr_set_si(r20628, mpfr_cmp(r20617, r20627) <= 0, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20631, r20617, r20630, MPFR_RNDN);
        mpfr_mul(r20632, r20629, r20631, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20635, r20617, r20634, MPFR_RNDN);
        mpfr_mul(r20636, r20633, r20635, MPFR_RNDN);
        ;
        mpfr_mul(r20638, r20637, r20617, MPFR_RNDN);
        mpfr_add(r20639, r20636, r20638, MPFR_RNDN);
        mpfr_add(r20640, r20632, r20639, MPFR_RNDN);
        if (mpfr_get_si(r20628, MPFR_RNDN)) { mpfr_set(r20641, r20640, MPFR_RNDN); } else { mpfr_set(r20641, r20626, MPFR_RNDN); };
        if (mpfr_get_si(r20619, MPFR_RNDN)) { mpfr_set(r20642, r20626, MPFR_RNDN); } else { mpfr_set(r20642, r20641, MPFR_RNDN); };
        return mpfr_get_d(r20642, MPFR_RNDN);
}