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

char *name = "2sin (example 3.3)";

double f_if(float x, float eps) {
        float r24571 = x;
        float r24572 = eps;
        float r24573 = r24571 + r24572;
        float r24574 = sin(r24573);
        float r24575 = sin(r24571);
        float r24576 = r24574 - r24575;
        return r24576;
}

double f_id(double x, double eps) {
        double r24577 = x;
        double r24578 = eps;
        double r24579 = r24577 + r24578;
        double r24580 = sin(r24579);
        double r24581 = sin(r24577);
        double r24582 = r24580 - r24581;
        return r24582;
}


double f_of(float x, float eps) {
        float r24583 = 2;
        float r24584 = eps;
        float r24585 = r24584 / r24583;
        float r24586 = sin(r24585);
        float r24587 = x;
        float r24588 = r24584 + r24587;
        float r24589 = r24587 + r24588;
        float r24590 = r24589 / r24583;
        float r24591 = cos(r24590);
        float r24592 = expm1(r24591);
        float r24593 = log1p(r24592);
        float r24594 = r24586 * r24593;
        float r24595 = r24583 * r24594;
        float r24596 = -0.02213793962123407;
        bool r24597 = r24595 <= r24596;
        float r24598 = sin(r24587);
        float r24599 = cos(r24584);
        float r24600 = r24598 * r24599;
        float r24601 = cos(r24587);
        float r24602 = sin(r24584);
        float r24603 = r24601 * r24602;
        float r24604 = r24600 + r24603;
        float r24605 = r24604 - r24598;
        float r24606 = 0.014908295515785366;
        bool r24607 = r24595 <= r24606;
        float r24608 = r24586 * r24591;
        float r24609 = r24583 * r24608;
        float r24610 = r24603 - r24598;
        float r24611 = r24600 + r24610;
        float r24612 = r24607 ? r24609 : r24611;
        float r24613 = r24597 ? r24605 : r24612;
        return r24613;
}

double f_od(double x, double eps) {
        double r24614 = 2;
        double r24615 = eps;
        double r24616 = r24615 / r24614;
        double r24617 = sin(r24616);
        double r24618 = x;
        double r24619 = r24615 + r24618;
        double r24620 = r24618 + r24619;
        double r24621 = r24620 / r24614;
        double r24622 = cos(r24621);
        double r24623 = expm1(r24622);
        double r24624 = log1p(r24623);
        double r24625 = r24617 * r24624;
        double r24626 = r24614 * r24625;
        double r24627 = -0.02213793962123407;
        bool r24628 = r24626 <= r24627;
        double r24629 = sin(r24618);
        double r24630 = cos(r24615);
        double r24631 = r24629 * r24630;
        double r24632 = cos(r24618);
        double r24633 = sin(r24615);
        double r24634 = r24632 * r24633;
        double r24635 = r24631 + r24634;
        double r24636 = r24635 - r24629;
        double r24637 = 0.014908295515785366;
        bool r24638 = r24626 <= r24637;
        double r24639 = r24617 * r24622;
        double r24640 = r24614 * r24639;
        double r24641 = r24634 - r24629;
        double r24642 = r24631 + r24641;
        double r24643 = r24638 ? r24640 : r24642;
        double r24644 = r24628 ? r24636 : r24643;
        return r24644;
}

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 r24645, r24646, r24647, r24648, r24649, r24650;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2384);
        mpfr_init(r24645);
        mpfr_init(r24646);
        mpfr_init(r24647);
        mpfr_init(r24648);
        mpfr_init(r24649);
        mpfr_init(r24650);
}

double f_im(double x, double eps) {
        mpfr_set_d(r24645, x, MPFR_RNDN);
        mpfr_set_d(r24646, eps, MPFR_RNDN);
        mpfr_add(r24647, r24645, r24646, MPFR_RNDN);
        mpfr_sin(r24648, r24647, MPFR_RNDN);
        mpfr_sin(r24649, r24645, MPFR_RNDN);
        mpfr_sub(r24650, r24648, r24649, MPFR_RNDN);
        return mpfr_get_d(r24650, MPFR_RNDN);
}

static mpfr_t r24651, r24652, r24653, r24654, r24655, r24656, r24657, r24658, r24659, r24660, r24661, r24662, r24663, r24664, r24665, r24666, r24667, r24668, r24669, r24670, r24671, r24672, r24673, r24674, r24675, r24676, r24677, r24678, r24679, r24680, r24681;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2384);
        mpfr_init_set_str(r24651, "2", 10, MPFR_RNDN);
        mpfr_init(r24652);
        mpfr_init(r24653);
        mpfr_init(r24654);
        mpfr_init(r24655);
        mpfr_init(r24656);
        mpfr_init(r24657);
        mpfr_init(r24658);
        mpfr_init(r24659);
        mpfr_init(r24660);
        mpfr_init(r24661);
        mpfr_init(r24662);
        mpfr_init(r24663);
        mpfr_init_set_str(r24664, "-0.02213793962123407", 10, MPFR_RNDN);
        mpfr_init(r24665);
        mpfr_init(r24666);
        mpfr_init(r24667);
        mpfr_init(r24668);
        mpfr_init(r24669);
        mpfr_init(r24670);
        mpfr_init(r24671);
        mpfr_init(r24672);
        mpfr_init(r24673);
        mpfr_init_set_str(r24674, "0.014908295515785366", 10, MPFR_RNDN);
        mpfr_init(r24675);
        mpfr_init(r24676);
        mpfr_init(r24677);
        mpfr_init(r24678);
        mpfr_init(r24679);
        mpfr_init(r24680);
        mpfr_init(r24681);
}

double f_fm(double x, double eps) {
        ;
        mpfr_set_d(r24652, eps, MPFR_RNDN);
        mpfr_div(r24653, r24652, r24651, MPFR_RNDN);
        mpfr_sin(r24654, r24653, MPFR_RNDN);
        mpfr_set_d(r24655, x, MPFR_RNDN);
        mpfr_add(r24656, r24652, r24655, MPFR_RNDN);
        mpfr_add(r24657, r24655, r24656, MPFR_RNDN);
        mpfr_div(r24658, r24657, r24651, MPFR_RNDN);
        mpfr_cos(r24659, r24658, MPFR_RNDN);
        mpfr_expm1(r24660, r24659, MPFR_RNDN);
        mpfr_log1p(r24661, r24660, MPFR_RNDN);
        mpfr_mul(r24662, r24654, r24661, MPFR_RNDN);
        mpfr_mul(r24663, r24651, r24662, MPFR_RNDN);
        ;
        mpfr_set_si(r24665, mpfr_cmp(r24663, r24664) <= 0, MPFR_RNDN);
        mpfr_sin(r24666, r24655, MPFR_RNDN);
        mpfr_cos(r24667, r24652, MPFR_RNDN);
        mpfr_mul(r24668, r24666, r24667, MPFR_RNDN);
        mpfr_cos(r24669, r24655, MPFR_RNDN);
        mpfr_sin(r24670, r24652, MPFR_RNDN);
        mpfr_mul(r24671, r24669, r24670, MPFR_RNDN);
        mpfr_add(r24672, r24668, r24671, MPFR_RNDN);
        mpfr_sub(r24673, r24672, r24666, MPFR_RNDN);
        ;
        mpfr_set_si(r24675, mpfr_cmp(r24663, r24674) <= 0, MPFR_RNDN);
        mpfr_mul(r24676, r24654, r24659, MPFR_RNDN);
        mpfr_mul(r24677, r24651, r24676, MPFR_RNDN);
        mpfr_sub(r24678, r24671, r24666, MPFR_RNDN);
        mpfr_add(r24679, r24668, r24678, MPFR_RNDN);
        if (mpfr_get_si(r24675, MPFR_RNDN)) { mpfr_set(r24680, r24677, MPFR_RNDN); } else { mpfr_set(r24680, r24679, MPFR_RNDN); };
        if (mpfr_get_si(r24665, MPFR_RNDN)) { mpfr_set(r24681, r24673, MPFR_RNDN); } else { mpfr_set(r24681, r24680, MPFR_RNDN); };
        return mpfr_get_d(r24681, MPFR_RNDN);
}

static mpfr_t r24682, r24683, r24684, r24685, r24686, r24687, r24688, r24689, r24690, r24691, r24692, r24693, r24694, r24695, r24696, r24697, r24698, r24699, r24700, r24701, r24702, r24703, r24704, r24705, r24706, r24707, r24708, r24709, r24710, r24711, r24712;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2384);
        mpfr_init_set_str(r24682, "2", 10, MPFR_RNDN);
        mpfr_init(r24683);
        mpfr_init(r24684);
        mpfr_init(r24685);
        mpfr_init(r24686);
        mpfr_init(r24687);
        mpfr_init(r24688);
        mpfr_init(r24689);
        mpfr_init(r24690);
        mpfr_init(r24691);
        mpfr_init(r24692);
        mpfr_init(r24693);
        mpfr_init(r24694);
        mpfr_init_set_str(r24695, "-0.02213793962123407", 10, MPFR_RNDN);
        mpfr_init(r24696);
        mpfr_init(r24697);
        mpfr_init(r24698);
        mpfr_init(r24699);
        mpfr_init(r24700);
        mpfr_init(r24701);
        mpfr_init(r24702);
        mpfr_init(r24703);
        mpfr_init(r24704);
        mpfr_init_set_str(r24705, "0.014908295515785366", 10, MPFR_RNDN);
        mpfr_init(r24706);
        mpfr_init(r24707);
        mpfr_init(r24708);
        mpfr_init(r24709);
        mpfr_init(r24710);
        mpfr_init(r24711);
        mpfr_init(r24712);
}

double f_dm(double x, double eps) {
        ;
        mpfr_set_d(r24683, eps, MPFR_RNDN);
        mpfr_div(r24684, r24683, r24682, MPFR_RNDN);
        mpfr_sin(r24685, r24684, MPFR_RNDN);
        mpfr_set_d(r24686, x, MPFR_RNDN);
        mpfr_add(r24687, r24683, r24686, MPFR_RNDN);
        mpfr_add(r24688, r24686, r24687, MPFR_RNDN);
        mpfr_div(r24689, r24688, r24682, MPFR_RNDN);
        mpfr_cos(r24690, r24689, MPFR_RNDN);
        mpfr_expm1(r24691, r24690, MPFR_RNDN);
        mpfr_log1p(r24692, r24691, MPFR_RNDN);
        mpfr_mul(r24693, r24685, r24692, MPFR_RNDN);
        mpfr_mul(r24694, r24682, r24693, MPFR_RNDN);
        ;
        mpfr_set_si(r24696, mpfr_cmp(r24694, r24695) <= 0, MPFR_RNDN);
        mpfr_sin(r24697, r24686, MPFR_RNDN);
        mpfr_cos(r24698, r24683, MPFR_RNDN);
        mpfr_mul(r24699, r24697, r24698, MPFR_RNDN);
        mpfr_cos(r24700, r24686, MPFR_RNDN);
        mpfr_sin(r24701, r24683, MPFR_RNDN);
        mpfr_mul(r24702, r24700, r24701, MPFR_RNDN);
        mpfr_add(r24703, r24699, r24702, MPFR_RNDN);
        mpfr_sub(r24704, r24703, r24697, MPFR_RNDN);
        ;
        mpfr_set_si(r24706, mpfr_cmp(r24694, r24705) <= 0, MPFR_RNDN);
        mpfr_mul(r24707, r24685, r24690, MPFR_RNDN);
        mpfr_mul(r24708, r24682, r24707, MPFR_RNDN);
        mpfr_sub(r24709, r24702, r24697, MPFR_RNDN);
        mpfr_add(r24710, r24699, r24709, MPFR_RNDN);
        if (mpfr_get_si(r24706, MPFR_RNDN)) { mpfr_set(r24711, r24708, MPFR_RNDN); } else { mpfr_set(r24711, r24710, MPFR_RNDN); };
        if (mpfr_get_si(r24696, MPFR_RNDN)) { mpfr_set(r24712, r24704, MPFR_RNDN); } else { mpfr_set(r24712, r24711, MPFR_RNDN); };
        return mpfr_get_d(r24712, MPFR_RNDN);
}