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

char *name = "Maksimov and Kolovsky, Equation (32)";

double f_if(float K, float m, float n, float M, float l) {
        float r20246 = K;
        float r20247 = m;
        float r20248 = n;
        float r20249 = r20247 + r20248;
        float r20250 = r20246 * r20249;
        float r20251 = 2.0f;
        float r20252 = r20250 / r20251;
        float r20253 = M;
        float r20254 = r20252 - r20253;
        float r20255 = cos(r20254);
        float r20256 = r20249 / r20251;
        float r20257 = r20256 - r20253;
        float r20258 = r20257 * r20257;
        float r20259 = -r20258;
        float r20260 = l;
        float r20261 = r20247 - r20248;
        float r20262 = fabs(r20261);
        float r20263 = r20260 - r20262;
        float r20264 = r20259 - r20263;
        float r20265 = exp(r20264);
        float r20266 = r20255 * r20265;
        return r20266;
}

double f_id(double K, double m, double n, double M, double l) {
        double r20267 = K;
        double r20268 = m;
        double r20269 = n;
        double r20270 = r20268 + r20269;
        double r20271 = r20267 * r20270;
        double r20272 = 2.0;
        double r20273 = r20271 / r20272;
        double r20274 = M;
        double r20275 = r20273 - r20274;
        double r20276 = cos(r20275);
        double r20277 = r20270 / r20272;
        double r20278 = r20277 - r20274;
        double r20279 = r20278 * r20278;
        double r20280 = -r20279;
        double r20281 = l;
        double r20282 = r20268 - r20269;
        double r20283 = fabs(r20282);
        double r20284 = r20281 - r20283;
        double r20285 = r20280 - r20284;
        double r20286 = exp(r20285);
        double r20287 = r20276 * r20286;
        return r20287;
}


double f_of(float K, float m, float n, float M, float l) {
        float r20288 = K;
        float r20289 = m;
        float r20290 = n;
        float r20291 = r20289 + r20290;
        float r20292 = r20288 * r20291;
        float r20293 = 2.0f;
        float r20294 = r20292 / r20293;
        float r20295 = M;
        float r20296 = r20294 - r20295;
        float r20297 = -3.7786722243375715e+304f;
        bool r20298 = r20296 <= r20297;
        float r20299 = 0.5f;
        float r20300 = r20299 / r20289;
        float r20301 = r20299 / r20290;
        float r20302 = r20300 + r20301;
        float r20303 = r20302 / r20288;
        float r20304 = cos(r20303);
        float r20305 = 1.0f;
        float r20306 = r20305 / r20295;
        float r20307 = cos(r20306);
        float r20308 = r20304 * r20307;
        float r20309 = 0.0f;
        float r20310 = sin(r20306);
        float r20311 = -r20310;
        float r20312 = r20309 * r20311;
        float r20313 = r20308 - r20312;
        float r20314 = r20291 / r20293;
        float r20315 = r20314 - r20295;
        float r20316 = r20315 * r20315;
        float r20317 = -r20316;
        float r20318 = l;
        float r20319 = r20289 - r20290;
        float r20320 = fabs(r20319);
        float r20321 = r20318 - r20320;
        float r20322 = r20317 - r20321;
        float r20323 = exp(r20322);
        float r20324 = r20313 * r20323;
        float r20325 = 3.2708293012512454e+304f;
        bool r20326 = r20296 <= r20325;
        float r20327 = cos(r20296);
        float r20328 = cbrt(r20327);
        float r20329 = r20328 * (r20328 * r20328);
        float r20330 = r20329 * r20323;
        float r20331 = r20326 ? r20330 : r20324;
        float r20332 = r20298 ? r20324 : r20331;
        return r20332;
}

double f_od(double K, double m, double n, double M, double l) {
        double r20333 = K;
        double r20334 = m;
        double r20335 = n;
        double r20336 = r20334 + r20335;
        double r20337 = r20333 * r20336;
        double r20338 = 2.0;
        double r20339 = r20337 / r20338;
        double r20340 = M;
        double r20341 = r20339 - r20340;
        double r20342 = -3.7786722243375715e+304;
        bool r20343 = r20341 <= r20342;
        double r20344 = 0.5;
        double r20345 = r20344 / r20334;
        double r20346 = r20344 / r20335;
        double r20347 = r20345 + r20346;
        double r20348 = r20347 / r20333;
        double r20349 = cos(r20348);
        double r20350 = 1.0;
        double r20351 = r20350 / r20340;
        double r20352 = cos(r20351);
        double r20353 = r20349 * r20352;
        double r20354 = 0.0;
        double r20355 = sin(r20351);
        double r20356 = -r20355;
        double r20357 = r20354 * r20356;
        double r20358 = r20353 - r20357;
        double r20359 = r20336 / r20338;
        double r20360 = r20359 - r20340;
        double r20361 = r20360 * r20360;
        double r20362 = -r20361;
        double r20363 = l;
        double r20364 = r20334 - r20335;
        double r20365 = fabs(r20364);
        double r20366 = r20363 - r20365;
        double r20367 = r20362 - r20366;
        double r20368 = exp(r20367);
        double r20369 = r20358 * r20368;
        double r20370 = 3.2708293012512454e+304;
        bool r20371 = r20341 <= r20370;
        double r20372 = cos(r20341);
        double r20373 = cbrt(r20372);
        double r20374 = r20373 * (r20373 * r20373);
        double r20375 = r20374 * r20368;
        double r20376 = r20371 ? r20375 : r20369;
        double r20377 = r20343 ? r20369 : r20376;
        return r20377;
}

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 r20378, r20379, r20380, r20381, r20382, r20383, r20384, r20385, r20386, r20387, r20388, r20389, r20390, r20391, r20392, r20393, r20394, r20395, r20396, r20397, r20398;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20378);
        mpfr_init(r20379);
        mpfr_init(r20380);
        mpfr_init(r20381);
        mpfr_init(r20382);
        mpfr_init_set_str(r20383, "2", 10, MPFR_RNDN);
        mpfr_init(r20384);
        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);
}

double f_im(double K, double m, double n, double M, double l) {
        mpfr_set_d(r20378, K, MPFR_RNDN);
        mpfr_set_d(r20379, m, MPFR_RNDN);
        mpfr_set_d(r20380, n, MPFR_RNDN);
        mpfr_add(r20381, r20379, r20380, MPFR_RNDN);
        mpfr_mul(r20382, r20378, r20381, MPFR_RNDN);
        ;
        mpfr_div(r20384, r20382, r20383, MPFR_RNDN);
        mpfr_set_d(r20385, M, MPFR_RNDN);
        mpfr_sub(r20386, r20384, r20385, MPFR_RNDN);
        mpfr_cos(r20387, r20386, MPFR_RNDN);
        mpfr_div(r20388, r20381, r20383, MPFR_RNDN);
        mpfr_sub(r20389, r20388, r20385, MPFR_RNDN);
        mpfr_sqr(r20390, r20389, MPFR_RNDN);
        mpfr_neg(r20391, r20390, MPFR_RNDN);
        mpfr_set_d(r20392, l, MPFR_RNDN);
        mpfr_sub(r20393, r20379, r20380, MPFR_RNDN);
        mpfr_abs(r20394, r20393, MPFR_RNDN);
        mpfr_sub(r20395, r20392, r20394, MPFR_RNDN);
        mpfr_sub(r20396, r20391, r20395, MPFR_RNDN);
        mpfr_exp(r20397, r20396, MPFR_RNDN);
        mpfr_mul(r20398, r20387, r20397, MPFR_RNDN);
        return mpfr_get_d(r20398, MPFR_RNDN);
}

static mpfr_t r20399, r20400, r20401, r20402, r20403, r20404, r20405, r20406, r20407, r20408, r20409, r20410, r20411, r20412, r20413, r20414, r20415, r20416, r20417, r20418, r20419, r20420, r20421, r20422, r20423, r20424, r20425, r20426, r20427, r20428, r20429, r20430, r20431, r20432, r20433, r20434, r20435, r20436, r20437, r20438, r20439, r20440, r20441, r20442, r20443;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20399);
        mpfr_init(r20400);
        mpfr_init(r20401);
        mpfr_init(r20402);
        mpfr_init(r20403);
        mpfr_init_set_str(r20404, "2", 10, MPFR_RNDN);
        mpfr_init(r20405);
        mpfr_init(r20406);
        mpfr_init(r20407);
        mpfr_init_set_str(r20408, "-3.7786722243375715e+304", 10, MPFR_RNDN);
        mpfr_init(r20409);
        mpfr_init_set_str(r20410, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20411);
        mpfr_init(r20412);
        mpfr_init(r20413);
        mpfr_init(r20414);
        mpfr_init(r20415);
        mpfr_init_set_str(r20416, "1", 10, MPFR_RNDN);
        mpfr_init(r20417);
        mpfr_init(r20418);
        mpfr_init(r20419);
        mpfr_init_set_str(r20420, "0", 10, MPFR_RNDN);
        mpfr_init(r20421);
        mpfr_init(r20422);
        mpfr_init(r20423);
        mpfr_init(r20424);
        mpfr_init(r20425);
        mpfr_init(r20426);
        mpfr_init(r20427);
        mpfr_init(r20428);
        mpfr_init(r20429);
        mpfr_init(r20430);
        mpfr_init(r20431);
        mpfr_init(r20432);
        mpfr_init(r20433);
        mpfr_init(r20434);
        mpfr_init(r20435);
        mpfr_init_set_str(r20436, "3.2708293012512454e+304", 10, MPFR_RNDN);
        mpfr_init(r20437);
        mpfr_init(r20438);
        mpfr_init(r20439);
        mpfr_init(r20440);
        mpfr_init(r20441);
        mpfr_init(r20442);
        mpfr_init(r20443);
}

double f_fm(double K, double m, double n, double M, double l) {
        mpfr_set_d(r20399, K, MPFR_RNDN);
        mpfr_set_d(r20400, m, MPFR_RNDN);
        mpfr_set_d(r20401, n, MPFR_RNDN);
        mpfr_add(r20402, r20400, r20401, MPFR_RNDN);
        mpfr_mul(r20403, r20399, r20402, MPFR_RNDN);
        ;
        mpfr_div(r20405, r20403, r20404, MPFR_RNDN);
        mpfr_set_d(r20406, M, MPFR_RNDN);
        mpfr_sub(r20407, r20405, r20406, MPFR_RNDN);
        ;
        mpfr_set_si(r20409, mpfr_cmp(r20407, r20408) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20411, r20410, r20400, MPFR_RNDN);
        mpfr_div(r20412, r20410, r20401, MPFR_RNDN);
        mpfr_add(r20413, r20411, r20412, MPFR_RNDN);
        mpfr_div(r20414, r20413, r20399, MPFR_RNDN);
        mpfr_cos(r20415, r20414, MPFR_RNDN);
        ;
        mpfr_div(r20417, r20416, r20406, MPFR_RNDN);
        mpfr_cos(r20418, r20417, MPFR_RNDN);
        mpfr_mul(r20419, r20415, r20418, MPFR_RNDN);
        ;
        mpfr_sin(r20421, r20417, MPFR_RNDN);
        mpfr_neg(r20422, r20421, MPFR_RNDN);
        mpfr_mul(r20423, r20420, r20422, MPFR_RNDN);
        mpfr_sub(r20424, r20419, r20423, MPFR_RNDN);
        mpfr_div(r20425, r20402, r20404, MPFR_RNDN);
        mpfr_sub(r20426, r20425, r20406, MPFR_RNDN);
        mpfr_sqr(r20427, r20426, MPFR_RNDN);
        mpfr_neg(r20428, r20427, MPFR_RNDN);
        mpfr_set_d(r20429, l, MPFR_RNDN);
        mpfr_sub(r20430, r20400, r20401, MPFR_RNDN);
        mpfr_abs(r20431, r20430, MPFR_RNDN);
        mpfr_sub(r20432, r20429, r20431, MPFR_RNDN);
        mpfr_sub(r20433, r20428, r20432, MPFR_RNDN);
        mpfr_exp(r20434, r20433, MPFR_RNDN);
        mpfr_mul(r20435, r20424, r20434, MPFR_RNDN);
        ;
        mpfr_set_si(r20437, mpfr_cmp(r20407, r20436) <= 0, MPFR_RNDN);
        mpfr_cos(r20438, r20407, MPFR_RNDN);
        mpfr_cbrt(r20439, r20438, MPFR_RNDN);
        mpfr_mul(r20440, r20439, r20439, MPFR_RNDN); mpfr_mul(r20440, r20440, r20439, MPFR_RNDN);
        mpfr_mul(r20441, r20440, r20434, MPFR_RNDN);
        if (mpfr_get_si(r20437, MPFR_RNDN)) { mpfr_set(r20442, r20441, MPFR_RNDN); } else { mpfr_set(r20442, r20435, MPFR_RNDN); };
        if (mpfr_get_si(r20409, MPFR_RNDN)) { mpfr_set(r20443, r20435, MPFR_RNDN); } else { mpfr_set(r20443, r20442, MPFR_RNDN); };
        return mpfr_get_d(r20443, MPFR_RNDN);
}

static mpfr_t r20444, r20445, r20446, r20447, r20448, r20449, r20450, r20451, r20452, r20453, r20454, r20455, r20456, r20457, r20458, r20459, r20460, r20461, r20462, r20463, r20464, r20465, r20466, r20467, r20468, r20469, r20470, r20471, r20472, r20473, r20474, r20475, r20476, r20477, r20478, r20479, r20480, r20481, r20482, r20483, r20484, r20485, r20486, r20487, r20488;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20444);
        mpfr_init(r20445);
        mpfr_init(r20446);
        mpfr_init(r20447);
        mpfr_init(r20448);
        mpfr_init_set_str(r20449, "2", 10, MPFR_RNDN);
        mpfr_init(r20450);
        mpfr_init(r20451);
        mpfr_init(r20452);
        mpfr_init_set_str(r20453, "-3.7786722243375715e+304", 10, MPFR_RNDN);
        mpfr_init(r20454);
        mpfr_init_set_str(r20455, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20456);
        mpfr_init(r20457);
        mpfr_init(r20458);
        mpfr_init(r20459);
        mpfr_init(r20460);
        mpfr_init_set_str(r20461, "1", 10, MPFR_RNDN);
        mpfr_init(r20462);
        mpfr_init(r20463);
        mpfr_init(r20464);
        mpfr_init_set_str(r20465, "0", 10, MPFR_RNDN);
        mpfr_init(r20466);
        mpfr_init(r20467);
        mpfr_init(r20468);
        mpfr_init(r20469);
        mpfr_init(r20470);
        mpfr_init(r20471);
        mpfr_init(r20472);
        mpfr_init(r20473);
        mpfr_init(r20474);
        mpfr_init(r20475);
        mpfr_init(r20476);
        mpfr_init(r20477);
        mpfr_init(r20478);
        mpfr_init(r20479);
        mpfr_init(r20480);
        mpfr_init_set_str(r20481, "3.2708293012512454e+304", 10, MPFR_RNDN);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init(r20485);
        mpfr_init(r20486);
        mpfr_init(r20487);
        mpfr_init(r20488);
}

double f_dm(double K, double m, double n, double M, double l) {
        mpfr_set_d(r20444, K, MPFR_RNDN);
        mpfr_set_d(r20445, m, MPFR_RNDN);
        mpfr_set_d(r20446, n, MPFR_RNDN);
        mpfr_add(r20447, r20445, r20446, MPFR_RNDN);
        mpfr_mul(r20448, r20444, r20447, MPFR_RNDN);
        ;
        mpfr_div(r20450, r20448, r20449, MPFR_RNDN);
        mpfr_set_d(r20451, M, MPFR_RNDN);
        mpfr_sub(r20452, r20450, r20451, MPFR_RNDN);
        ;
        mpfr_set_si(r20454, mpfr_cmp(r20452, r20453) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20456, r20455, r20445, MPFR_RNDN);
        mpfr_div(r20457, r20455, r20446, MPFR_RNDN);
        mpfr_add(r20458, r20456, r20457, MPFR_RNDN);
        mpfr_div(r20459, r20458, r20444, MPFR_RNDN);
        mpfr_cos(r20460, r20459, MPFR_RNDN);
        ;
        mpfr_div(r20462, r20461, r20451, MPFR_RNDN);
        mpfr_cos(r20463, r20462, MPFR_RNDN);
        mpfr_mul(r20464, r20460, r20463, MPFR_RNDN);
        ;
        mpfr_sin(r20466, r20462, MPFR_RNDN);
        mpfr_neg(r20467, r20466, MPFR_RNDN);
        mpfr_mul(r20468, r20465, r20467, MPFR_RNDN);
        mpfr_sub(r20469, r20464, r20468, MPFR_RNDN);
        mpfr_div(r20470, r20447, r20449, MPFR_RNDN);
        mpfr_sub(r20471, r20470, r20451, MPFR_RNDN);
        mpfr_sqr(r20472, r20471, MPFR_RNDN);
        mpfr_neg(r20473, r20472, MPFR_RNDN);
        mpfr_set_d(r20474, l, MPFR_RNDN);
        mpfr_sub(r20475, r20445, r20446, MPFR_RNDN);
        mpfr_abs(r20476, r20475, MPFR_RNDN);
        mpfr_sub(r20477, r20474, r20476, MPFR_RNDN);
        mpfr_sub(r20478, r20473, r20477, MPFR_RNDN);
        mpfr_exp(r20479, r20478, MPFR_RNDN);
        mpfr_mul(r20480, r20469, r20479, MPFR_RNDN);
        ;
        mpfr_set_si(r20482, mpfr_cmp(r20452, r20481) <= 0, MPFR_RNDN);
        mpfr_cos(r20483, r20452, MPFR_RNDN);
        mpfr_cbrt(r20484, r20483, MPFR_RNDN);
        mpfr_mul(r20485, r20484, r20484, MPFR_RNDN); mpfr_mul(r20485, r20485, r20484, MPFR_RNDN);
        mpfr_mul(r20486, r20485, r20479, MPFR_RNDN);
        if (mpfr_get_si(r20482, MPFR_RNDN)) { mpfr_set(r20487, r20486, MPFR_RNDN); } else { mpfr_set(r20487, r20480, MPFR_RNDN); };
        if (mpfr_get_si(r20454, MPFR_RNDN)) { mpfr_set(r20488, r20480, MPFR_RNDN); } else { mpfr_set(r20488, r20487, MPFR_RNDN); };
        return mpfr_get_d(r20488, MPFR_RNDN);
}