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

char *name = "2tan (problem 3.3.2)";

double f_if(float x, float eps) {
        float r20223 = x;
        float r20224 = eps;
        float r20225 = r20223 + r20224;
        float r20226 = tan(r20225);
        float r20227 = tan(r20223);
        float r20228 = r20226 - r20227;
        return r20228;
}

double f_id(double x, double eps) {
        double r20229 = x;
        double r20230 = eps;
        double r20231 = r20229 + r20230;
        double r20232 = tan(r20231);
        double r20233 = tan(r20229);
        double r20234 = r20232 - r20233;
        return r20234;
}


double f_of(float x, float eps) {
        float r20235 = eps;
        float r20236 = -1.9479733961868206e-39f;
        bool r20237 = r20235 <= r20236;
        float r20238 = x;
        float r20239 = tan(r20238);
        float r20240 = tan(r20235);
        float r20241 = r20239 + r20240;
        float r20242 = 1.0f;
        float r20243 = sin(r20238);
        float r20244 = sin(r20235);
        float r20245 = r20243 * r20244;
        float r20246 = cos(r20238);
        float r20247 = cos(r20235);
        float r20248 = r20246 * r20247;
        float r20249 = r20245 / r20248;
        float r20250 = r20242 - r20249;
        float r20251 = r20241 / r20250;
        float r20252 = r20251 - r20239;
        float r20253 = 5.496498246559763e-32f;
        bool r20254 = r20235 <= r20253;
        float r20255 = r20238 * r20238;
        float r20256 = r20235 * (r20235 * r20235);
        float r20257 = r20255 * r20256;
        float r20258 = 4.0f;
        float r20259 = pow(r20235, r20258);
        float r20260 = r20238 * (r20238 * r20238);
        float r20261 = r20259 * r20260;
        float r20262 = r20257 + r20261;
        float r20263 = r20262 + r20235;
        float r20264 = r20239 * r20239;
        float r20265 = r20240 * r20240;
        float r20266 = r20264 - r20265;
        float r20267 = r20239 * r20240;
        float r20268 = r20242 - r20267;
        float r20269 = r20239 - r20240;
        float r20270 = r20268 * r20269;
        float r20271 = r20266 / r20270;
        float r20272 = r20271 - r20239;
        float r20273 = r20254 ? r20263 : r20272;
        float r20274 = r20237 ? r20252 : r20273;
        return r20274;
}

double f_od(double x, double eps) {
        double r20275 = eps;
        double r20276 = -1.9479733961868206e-39;
        bool r20277 = r20275 <= r20276;
        double r20278 = x;
        double r20279 = tan(r20278);
        double r20280 = tan(r20275);
        double r20281 = r20279 + r20280;
        double r20282 = 1.0;
        double r20283 = sin(r20278);
        double r20284 = sin(r20275);
        double r20285 = r20283 * r20284;
        double r20286 = cos(r20278);
        double r20287 = cos(r20275);
        double r20288 = r20286 * r20287;
        double r20289 = r20285 / r20288;
        double r20290 = r20282 - r20289;
        double r20291 = r20281 / r20290;
        double r20292 = r20291 - r20279;
        double r20293 = 5.496498246559763e-32;
        bool r20294 = r20275 <= r20293;
        double r20295 = r20278 * r20278;
        double r20296 = r20275 * (r20275 * r20275);
        double r20297 = r20295 * r20296;
        double r20298 = 4.0;
        double r20299 = pow(r20275, r20298);
        double r20300 = r20278 * (r20278 * r20278);
        double r20301 = r20299 * r20300;
        double r20302 = r20297 + r20301;
        double r20303 = r20302 + r20275;
        double r20304 = r20279 * r20279;
        double r20305 = r20280 * r20280;
        double r20306 = r20304 - r20305;
        double r20307 = r20279 * r20280;
        double r20308 = r20282 - r20307;
        double r20309 = r20279 - r20280;
        double r20310 = r20308 * r20309;
        double r20311 = r20306 / r20310;
        double r20312 = r20311 - r20279;
        double r20313 = r20294 ? r20303 : r20312;
        double r20314 = r20277 ? r20292 : r20313;
        return r20314;
}

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 r20315, r20316, r20317, r20318, r20319, r20320;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20315);
        mpfr_init(r20316);
        mpfr_init(r20317);
        mpfr_init(r20318);
        mpfr_init(r20319);
        mpfr_init(r20320);
}

double f_im(double x, double eps) {
        mpfr_set_d(r20315, x, MPFR_RNDN);
        mpfr_set_d(r20316, eps, MPFR_RNDN);
        mpfr_add(r20317, r20315, r20316, MPFR_RNDN);
        mpfr_tan(r20318, r20317, MPFR_RNDN);
        mpfr_tan(r20319, r20315, MPFR_RNDN);
        mpfr_sub(r20320, r20318, r20319, MPFR_RNDN);
        return mpfr_get_d(r20320, MPFR_RNDN);
}

static mpfr_t r20321, r20322, r20323, r20324, r20325, r20326, r20327, r20328, r20329, r20330, r20331, r20332, r20333, r20334, r20335, r20336, r20337, r20338, r20339, r20340, r20341, r20342, r20343, r20344, r20345, r20346, r20347, r20348, r20349, r20350, r20351, r20352, r20353, r20354, r20355, r20356, r20357, r20358, r20359, r20360;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20321);
        mpfr_init_set_str(r20322, "-1.9479733961868206e-39", 10, MPFR_RNDN);
        mpfr_init(r20323);
        mpfr_init(r20324);
        mpfr_init(r20325);
        mpfr_init(r20326);
        mpfr_init(r20327);
        mpfr_init_set_str(r20328, "1", 10, MPFR_RNDN);
        mpfr_init(r20329);
        mpfr_init(r20330);
        mpfr_init(r20331);
        mpfr_init(r20332);
        mpfr_init(r20333);
        mpfr_init(r20334);
        mpfr_init(r20335);
        mpfr_init(r20336);
        mpfr_init(r20337);
        mpfr_init(r20338);
        mpfr_init_set_str(r20339, "5.496498246559763e-32", 10, MPFR_RNDN);
        mpfr_init(r20340);
        mpfr_init(r20341);
        mpfr_init(r20342);
        mpfr_init(r20343);
        mpfr_init_set_str(r20344, "4", 10, MPFR_RNDN);
        mpfr_init(r20345);
        mpfr_init(r20346);
        mpfr_init(r20347);
        mpfr_init(r20348);
        mpfr_init(r20349);
        mpfr_init(r20350);
        mpfr_init(r20351);
        mpfr_init(r20352);
        mpfr_init(r20353);
        mpfr_init(r20354);
        mpfr_init(r20355);
        mpfr_init(r20356);
        mpfr_init(r20357);
        mpfr_init(r20358);
        mpfr_init(r20359);
        mpfr_init(r20360);
}

double f_fm(double x, double eps) {
        mpfr_set_d(r20321, eps, MPFR_RNDN);
        ;
        mpfr_set_si(r20323, mpfr_cmp(r20321, r20322) <= 0, MPFR_RNDN);
        mpfr_set_d(r20324, x, MPFR_RNDN);
        mpfr_tan(r20325, r20324, MPFR_RNDN);
        mpfr_tan(r20326, r20321, MPFR_RNDN);
        mpfr_add(r20327, r20325, r20326, MPFR_RNDN);
        ;
        mpfr_sin(r20329, r20324, MPFR_RNDN);
        mpfr_sin(r20330, r20321, MPFR_RNDN);
        mpfr_mul(r20331, r20329, r20330, MPFR_RNDN);
        mpfr_cos(r20332, r20324, MPFR_RNDN);
        mpfr_cos(r20333, r20321, MPFR_RNDN);
        mpfr_mul(r20334, r20332, r20333, MPFR_RNDN);
        mpfr_div(r20335, r20331, r20334, MPFR_RNDN);
        mpfr_sub(r20336, r20328, r20335, MPFR_RNDN);
        mpfr_div(r20337, r20327, r20336, MPFR_RNDN);
        mpfr_sub(r20338, r20337, r20325, MPFR_RNDN);
        ;
        mpfr_set_si(r20340, mpfr_cmp(r20321, r20339) <= 0, MPFR_RNDN);
        mpfr_sqr(r20341, r20324, MPFR_RNDN);
        mpfr_mul(r20342, r20321, r20321, MPFR_RNDN); mpfr_mul(r20342, r20342, r20321, MPFR_RNDN);
        mpfr_mul(r20343, r20341, r20342, MPFR_RNDN);
        ;
        mpfr_pow(r20345, r20321, r20344, MPFR_RNDN);
        mpfr_mul(r20346, r20324, r20324, MPFR_RNDN); mpfr_mul(r20346, r20346, r20324, MPFR_RNDN);
        mpfr_mul(r20347, r20345, r20346, MPFR_RNDN);
        mpfr_add(r20348, r20343, r20347, MPFR_RNDN);
        mpfr_add(r20349, r20348, r20321, MPFR_RNDN);
        mpfr_sqr(r20350, r20325, MPFR_RNDN);
        mpfr_sqr(r20351, r20326, MPFR_RNDN);
        mpfr_sub(r20352, r20350, r20351, MPFR_RNDN);
        mpfr_mul(r20353, r20325, r20326, MPFR_RNDN);
        mpfr_sub(r20354, r20328, r20353, MPFR_RNDN);
        mpfr_sub(r20355, r20325, r20326, MPFR_RNDN);
        mpfr_mul(r20356, r20354, r20355, MPFR_RNDN);
        mpfr_div(r20357, r20352, r20356, MPFR_RNDN);
        mpfr_sub(r20358, r20357, r20325, MPFR_RNDN);
        if (mpfr_get_si(r20340, MPFR_RNDN)) { mpfr_set(r20359, r20349, MPFR_RNDN); } else { mpfr_set(r20359, r20358, MPFR_RNDN); };
        if (mpfr_get_si(r20323, MPFR_RNDN)) { mpfr_set(r20360, r20338, MPFR_RNDN); } else { mpfr_set(r20360, r20359, MPFR_RNDN); };
        return mpfr_get_d(r20360, MPFR_RNDN);
}

static mpfr_t r20361, r20362, r20363, r20364, r20365, r20366, r20367, r20368, r20369, r20370, r20371, r20372, r20373, r20374, r20375, r20376, r20377, r20378, r20379, r20380, r20381, r20382, r20383, r20384, r20385, r20386, r20387, r20388, r20389, r20390, r20391, r20392, r20393, r20394, r20395, r20396, r20397, r20398, r20399, r20400;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(2192);
        mpfr_init(r20361);
        mpfr_init_set_str(r20362, "-1.9479733961868206e-39", 10, MPFR_RNDN);
        mpfr_init(r20363);
        mpfr_init(r20364);
        mpfr_init(r20365);
        mpfr_init(r20366);
        mpfr_init(r20367);
        mpfr_init_set_str(r20368, "1", 10, MPFR_RNDN);
        mpfr_init(r20369);
        mpfr_init(r20370);
        mpfr_init(r20371);
        mpfr_init(r20372);
        mpfr_init(r20373);
        mpfr_init(r20374);
        mpfr_init(r20375);
        mpfr_init(r20376);
        mpfr_init(r20377);
        mpfr_init(r20378);
        mpfr_init_set_str(r20379, "5.496498246559763e-32", 10, MPFR_RNDN);
        mpfr_init(r20380);
        mpfr_init(r20381);
        mpfr_init(r20382);
        mpfr_init(r20383);
        mpfr_init_set_str(r20384, "4", 10, MPFR_RNDN);
        mpfr_init(r20385);
        mpfr_init(r20386);
        mpfr_init(r20387);
        mpfr_init(r20388);
        mpfr_init(r20389);
        mpfr_init(r20390);
        mpfr_init(r20391);
        mpfr_init(r20392);
        mpfr_init(r20393);
        mpfr_init(r20394);
        mpfr_init(r20395);
        mpfr_init(r20396);
        mpfr_init(r20397);
        mpfr_init(r20398);
        mpfr_init(r20399);
        mpfr_init(r20400);
}

double f_dm(double x, double eps) {
        mpfr_set_d(r20361, eps, MPFR_RNDN);
        ;
        mpfr_set_si(r20363, mpfr_cmp(r20361, r20362) <= 0, MPFR_RNDN);
        mpfr_set_d(r20364, x, MPFR_RNDN);
        mpfr_tan(r20365, r20364, MPFR_RNDN);
        mpfr_tan(r20366, r20361, MPFR_RNDN);
        mpfr_add(r20367, r20365, r20366, MPFR_RNDN);
        ;
        mpfr_sin(r20369, r20364, MPFR_RNDN);
        mpfr_sin(r20370, r20361, MPFR_RNDN);
        mpfr_mul(r20371, r20369, r20370, MPFR_RNDN);
        mpfr_cos(r20372, r20364, MPFR_RNDN);
        mpfr_cos(r20373, r20361, MPFR_RNDN);
        mpfr_mul(r20374, r20372, r20373, MPFR_RNDN);
        mpfr_div(r20375, r20371, r20374, MPFR_RNDN);
        mpfr_sub(r20376, r20368, r20375, MPFR_RNDN);
        mpfr_div(r20377, r20367, r20376, MPFR_RNDN);
        mpfr_sub(r20378, r20377, r20365, MPFR_RNDN);
        ;
        mpfr_set_si(r20380, mpfr_cmp(r20361, r20379) <= 0, MPFR_RNDN);
        mpfr_sqr(r20381, r20364, MPFR_RNDN);
        mpfr_mul(r20382, r20361, r20361, MPFR_RNDN); mpfr_mul(r20382, r20382, r20361, MPFR_RNDN);
        mpfr_mul(r20383, r20381, r20382, MPFR_RNDN);
        ;
        mpfr_pow(r20385, r20361, r20384, MPFR_RNDN);
        mpfr_mul(r20386, r20364, r20364, MPFR_RNDN); mpfr_mul(r20386, r20386, r20364, MPFR_RNDN);
        mpfr_mul(r20387, r20385, r20386, MPFR_RNDN);
        mpfr_add(r20388, r20383, r20387, MPFR_RNDN);
        mpfr_add(r20389, r20388, r20361, MPFR_RNDN);
        mpfr_sqr(r20390, r20365, MPFR_RNDN);
        mpfr_sqr(r20391, r20366, MPFR_RNDN);
        mpfr_sub(r20392, r20390, r20391, MPFR_RNDN);
        mpfr_mul(r20393, r20365, r20366, MPFR_RNDN);
        mpfr_sub(r20394, r20368, r20393, MPFR_RNDN);
        mpfr_sub(r20395, r20365, r20366, MPFR_RNDN);
        mpfr_mul(r20396, r20394, r20395, MPFR_RNDN);
        mpfr_div(r20397, r20392, r20396, MPFR_RNDN);
        mpfr_sub(r20398, r20397, r20365, MPFR_RNDN);
        if (mpfr_get_si(r20380, MPFR_RNDN)) { mpfr_set(r20399, r20389, MPFR_RNDN); } else { mpfr_set(r20399, r20398, MPFR_RNDN); };
        if (mpfr_get_si(r20363, MPFR_RNDN)) { mpfr_set(r20400, r20378, MPFR_RNDN); } else { mpfr_set(r20400, r20399, MPFR_RNDN); };
        return mpfr_get_d(r20400, MPFR_RNDN);
}