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

char *name = "sintan (problem 3.4.5)";

double f_if(float x) {
        float r20550 = x;
        float r20551 = sin(r20550);
        float r20552 = r20550 - r20551;
        float r20553 = tan(r20550);
        float r20554 = r20550 - r20553;
        float r20555 = r20552 / r20554;
        return r20555;
}

double f_id(double x) {
        double r20556 = x;
        double r20557 = sin(r20556);
        double r20558 = r20556 - r20557;
        double r20559 = tan(r20556);
        double r20560 = r20556 - r20559;
        double r20561 = r20558 / r20560;
        return r20561;
}


double f_of(float x) {
        float r20562 = x;
        float r20563 = -0.036148537611243085;
        bool r20564 = r20562 <= r20563;
        float r20565 = sin(r20562);
        float r20566 = r20562 - r20565;
        float r20567 = tan(r20562);
        float r20568 = r20562 - r20567;
        float r20569 = r20566 / r20568;
        float r20570 = expm1(r20569);
        float r20571 = log1p(r20570);
        float r20572 = 0.036238543795772536;
        bool r20573 = r20562 <= r20572;
        float r20574 = 9/40;
        float r20575 = r20562 * r20574;
        float r20576 = 351/22400;
        float r20577 = 4;
        float r20578 = pow(r20562, r20577);
        float r20579 = 1;
        float r20580 = fma(r20576, r20578, r20579);
        float r20581 = cbrt(r20580);
        float r20582 = r20581 * r20581;
        float r20583 = r20582 * r20581;
        float r20584 = fma(r20575, r20562, r20583);
        float r20585 = -1/2;
        float r20586 = exp(r20585);
        float r20587 = -r20579;
        float r20588 = fma(r20584, r20586, r20587);
        float r20589 = log1p(r20588);
        float r20590 = r20573 ? r20589 : r20571;
        float r20591 = r20564 ? r20571 : r20590;
        return r20591;
}

double f_od(double x) {
        double r20592 = x;
        double r20593 = -0.036148537611243085;
        bool r20594 = r20592 <= r20593;
        double r20595 = sin(r20592);
        double r20596 = r20592 - r20595;
        double r20597 = tan(r20592);
        double r20598 = r20592 - r20597;
        double r20599 = r20596 / r20598;
        double r20600 = expm1(r20599);
        double r20601 = log1p(r20600);
        double r20602 = 0.036238543795772536;
        bool r20603 = r20592 <= r20602;
        double r20604 = 9/40;
        double r20605 = r20592 * r20604;
        double r20606 = 351/22400;
        double r20607 = 4;
        double r20608 = pow(r20592, r20607);
        double r20609 = 1;
        double r20610 = fma(r20606, r20608, r20609);
        double r20611 = cbrt(r20610);
        double r20612 = r20611 * r20611;
        double r20613 = r20612 * r20611;
        double r20614 = fma(r20605, r20592, r20613);
        double r20615 = -1/2;
        double r20616 = exp(r20615);
        double r20617 = -r20609;
        double r20618 = fma(r20614, r20616, r20617);
        double r20619 = log1p(r20618);
        double r20620 = r20603 ? r20619 : r20601;
        double r20621 = r20594 ? r20601 : r20620;
        return r20621;
}

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 r20622, r20623, r20624, r20625, r20626, r20627;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2448);
        mpfr_init(r20622);
        mpfr_init(r20623);
        mpfr_init(r20624);
        mpfr_init(r20625);
        mpfr_init(r20626);
        mpfr_init(r20627);
}

double f_im(double x) {
        mpfr_set_d(r20622, x, MPFR_RNDN);
        mpfr_sin(r20623, r20622, MPFR_RNDN);
        mpfr_sub(r20624, r20622, r20623, MPFR_RNDN);
        mpfr_tan(r20625, r20622, MPFR_RNDN);
        mpfr_sub(r20626, r20622, r20625, MPFR_RNDN);
        mpfr_div(r20627, r20624, r20626, MPFR_RNDN);
        return mpfr_get_d(r20627, MPFR_RNDN);
}

static mpfr_t r20628, r20629, r20630, r20631, r20632, r20633, r20634, r20635, r20636, r20637, r20638, r20639, r20640, r20641, r20642, r20643, r20644, r20645, r20646, r20647, r20648, r20649, r20650, r20651, r20652, r20653, r20654, r20655, r20656, r20657;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2448);
        mpfr_init(r20628);
        mpfr_init_set_str(r20629, "-0.036148537611243085", 10, MPFR_RNDN);
        mpfr_init(r20630);
        mpfr_init(r20631);
        mpfr_init(r20632);
        mpfr_init(r20633);
        mpfr_init(r20634);
        mpfr_init(r20635);
        mpfr_init(r20636);
        mpfr_init(r20637);
        mpfr_init_set_str(r20638, "0.036238543795772536", 10, MPFR_RNDN);
        mpfr_init(r20639);
        mpfr_init_set_str(r20640, "9/40", 10, MPFR_RNDN);
        mpfr_init(r20641);
        mpfr_init_set_str(r20642, "351/22400", 10, MPFR_RNDN);
        mpfr_init_set_str(r20643, "4", 10, MPFR_RNDN);
        mpfr_init(r20644);
        mpfr_init_set_str(r20645, "1", 10, MPFR_RNDN);
        mpfr_init(r20646);
        mpfr_init(r20647);
        mpfr_init(r20648);
        mpfr_init(r20649);
        mpfr_init(r20650);
        mpfr_init_set_str(r20651, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20652);
        mpfr_init(r20653);
        mpfr_init(r20654);
        mpfr_init(r20655);
        mpfr_init(r20656);
        mpfr_init(r20657);
}

double f_fm(double x) {
        mpfr_set_d(r20628, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20630, mpfr_cmp(r20628, r20629) <= 0, MPFR_RNDN);
        mpfr_sin(r20631, r20628, MPFR_RNDN);
        mpfr_sub(r20632, r20628, r20631, MPFR_RNDN);
        mpfr_tan(r20633, r20628, MPFR_RNDN);
        mpfr_sub(r20634, r20628, r20633, MPFR_RNDN);
        mpfr_div(r20635, r20632, r20634, MPFR_RNDN);
        mpfr_expm1(r20636, r20635, MPFR_RNDN);
        mpfr_log1p(r20637, r20636, MPFR_RNDN);
        ;
        mpfr_set_si(r20639, mpfr_cmp(r20628, r20638) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r20641, r20628, r20640, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20644, r20628, r20643, MPFR_RNDN);
        ;
        mpfr_fma(r20646, r20642, r20644, r20645, MPFR_RNDN);
        mpfr_cbrt(r20647, r20646, MPFR_RNDN);
        mpfr_mul(r20648, r20647, r20647, MPFR_RNDN);
        mpfr_mul(r20649, r20648, r20647, MPFR_RNDN);
        mpfr_fma(r20650, r20641, r20628, r20649, MPFR_RNDN);
        ;
        mpfr_exp(r20652, r20651, MPFR_RNDN);
        mpfr_neg(r20653, r20645, MPFR_RNDN);
        mpfr_fma(r20654, r20650, r20652, r20653, MPFR_RNDN);
        mpfr_log1p(r20655, r20654, MPFR_RNDN);
        if (mpfr_get_si(r20639, MPFR_RNDN)) { mpfr_set(r20656, r20655, MPFR_RNDN); } else { mpfr_set(r20656, r20637, MPFR_RNDN); };
        if (mpfr_get_si(r20630, MPFR_RNDN)) { mpfr_set(r20657, r20637, MPFR_RNDN); } else { mpfr_set(r20657, r20656, MPFR_RNDN); };
        return mpfr_get_d(r20657, MPFR_RNDN);
}

static mpfr_t r20658, r20659, r20660, r20661, r20662, r20663, r20664, r20665, r20666, r20667, r20668, r20669, r20670, r20671, r20672, r20673, r20674, r20675, r20676, r20677, r20678, r20679, r20680, r20681, r20682, r20683, r20684, r20685, r20686, r20687;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2448);
        mpfr_init(r20658);
        mpfr_init_set_str(r20659, "-0.036148537611243085", 10, MPFR_RNDN);
        mpfr_init(r20660);
        mpfr_init(r20661);
        mpfr_init(r20662);
        mpfr_init(r20663);
        mpfr_init(r20664);
        mpfr_init(r20665);
        mpfr_init(r20666);
        mpfr_init(r20667);
        mpfr_init_set_str(r20668, "0.036238543795772536", 10, MPFR_RNDN);
        mpfr_init(r20669);
        mpfr_init_set_str(r20670, "9/40", 10, MPFR_RNDN);
        mpfr_init(r20671);
        mpfr_init_set_str(r20672, "351/22400", 10, MPFR_RNDN);
        mpfr_init_set_str(r20673, "4", 10, MPFR_RNDN);
        mpfr_init(r20674);
        mpfr_init_set_str(r20675, "1", 10, MPFR_RNDN);
        mpfr_init(r20676);
        mpfr_init(r20677);
        mpfr_init(r20678);
        mpfr_init(r20679);
        mpfr_init(r20680);
        mpfr_init_set_str(r20681, "-1/2", 10, MPFR_RNDN);
        mpfr_init(r20682);
        mpfr_init(r20683);
        mpfr_init(r20684);
        mpfr_init(r20685);
        mpfr_init(r20686);
        mpfr_init(r20687);
}

double f_dm(double x) {
        mpfr_set_d(r20658, x, MPFR_RNDN);
        ;
        mpfr_set_si(r20660, mpfr_cmp(r20658, r20659) <= 0, MPFR_RNDN);
        mpfr_sin(r20661, r20658, MPFR_RNDN);
        mpfr_sub(r20662, r20658, r20661, MPFR_RNDN);
        mpfr_tan(r20663, r20658, MPFR_RNDN);
        mpfr_sub(r20664, r20658, r20663, MPFR_RNDN);
        mpfr_div(r20665, r20662, r20664, MPFR_RNDN);
        mpfr_expm1(r20666, r20665, MPFR_RNDN);
        mpfr_log1p(r20667, r20666, MPFR_RNDN);
        ;
        mpfr_set_si(r20669, mpfr_cmp(r20658, r20668) <= 0, MPFR_RNDN);
        ;
        mpfr_mul(r20671, r20658, r20670, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20674, r20658, r20673, MPFR_RNDN);
        ;
        mpfr_fma(r20676, r20672, r20674, r20675, MPFR_RNDN);
        mpfr_cbrt(r20677, r20676, MPFR_RNDN);
        mpfr_mul(r20678, r20677, r20677, MPFR_RNDN);
        mpfr_mul(r20679, r20678, r20677, MPFR_RNDN);
        mpfr_fma(r20680, r20671, r20658, r20679, MPFR_RNDN);
        ;
        mpfr_exp(r20682, r20681, MPFR_RNDN);
        mpfr_neg(r20683, r20675, MPFR_RNDN);
        mpfr_fma(r20684, r20680, r20682, r20683, MPFR_RNDN);
        mpfr_log1p(r20685, r20684, MPFR_RNDN);
        if (mpfr_get_si(r20669, MPFR_RNDN)) { mpfr_set(r20686, r20685, MPFR_RNDN); } else { mpfr_set(r20686, r20667, MPFR_RNDN); };
        if (mpfr_get_si(r20660, MPFR_RNDN)) { mpfr_set(r20687, r20667, MPFR_RNDN); } else { mpfr_set(r20687, r20686, MPFR_RNDN); };
        return mpfr_get_d(r20687, MPFR_RNDN);
}