#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 r20230 = K;
        float r20231 = m;
        float r20232 = n;
        float r20233 = r20231 + r20232;
        float r20234 = r20230 * r20233;
        float r20235 = 2.0f;
        float r20236 = r20234 / r20235;
        float r20237 = M;
        float r20238 = r20236 - r20237;
        float r20239 = cos(r20238);
        float r20240 = r20233 / r20235;
        float r20241 = r20240 - r20237;
        float r20242 = r20241 * r20241;
        float r20243 = -r20242;
        float r20244 = l;
        float r20245 = r20231 - r20232;
        float r20246 = fabs(r20245);
        float r20247 = r20244 - r20246;
        float r20248 = r20243 - r20247;
        float r20249 = exp(r20248);
        float r20250 = r20239 * r20249;
        return r20250;
}

double f_id(double K, double m, double n, double M, double l) {
        double r20251 = K;
        double r20252 = m;
        double r20253 = n;
        double r20254 = r20252 + r20253;
        double r20255 = r20251 * r20254;
        double r20256 = 2.0;
        double r20257 = r20255 / r20256;
        double r20258 = M;
        double r20259 = r20257 - r20258;
        double r20260 = cos(r20259);
        double r20261 = r20254 / r20256;
        double r20262 = r20261 - r20258;
        double r20263 = r20262 * r20262;
        double r20264 = -r20263;
        double r20265 = l;
        double r20266 = r20252 - r20253;
        double r20267 = fabs(r20266);
        double r20268 = r20265 - r20267;
        double r20269 = r20264 - r20268;
        double r20270 = exp(r20269);
        double r20271 = r20260 * r20270;
        return r20271;
}


double f_of(float K, float m, float n, float M, float l) {
        float r20272 = K;
        float r20273 = m;
        float r20274 = n;
        float r20275 = r20273 + r20274;
        float r20276 = r20272 * r20275;
        float r20277 = 2.0f;
        float r20278 = r20276 / r20277;
        float r20279 = M;
        float r20280 = r20278 - r20279;
        float r20281 = -3.7786722243375715e+304f;
        bool r20282 = r20280 <= r20281;
        float r20283 = 1.0f;
        float r20284 = r20283 / r20279;
        float r20285 = cos(r20284);
        float r20286 = sin(r20284);
        float r20287 = -r20286;
        float r20288 = 0.5f;
        float r20289 = r20288 / r20274;
        float r20290 = r20288 / r20273;
        float r20291 = r20289 + r20290;
        float r20292 = r20291 / r20272;
        float r20293 = sin(r20292);
        float r20294 = r20287 * r20293;
        float r20295 = r20285 - r20294;
        float r20296 = r20274 + r20273;
        float r20297 = r20296 / r20277;
        float r20298 = r20297 - r20279;
        float r20299 = r20298 * r20298;
        float r20300 = l;
        float r20301 = r20273 - r20274;
        float r20302 = fabs(r20301);
        float r20303 = r20300 - r20302;
        float r20304 = r20299 + r20303;
        float r20305 = exp(r20304);
        float r20306 = r20295 / r20305;
        float r20307 = 3.2708293012512454e+304f;
        bool r20308 = r20280 <= r20307;
        float r20309 = cos(r20280);
        float r20310 = cbrt(r20309);
        float r20311 = r20310 * (r20310 * r20310);
        float r20312 = r20275 / r20277;
        float r20313 = r20312 - r20279;
        float r20314 = r20313 * r20313;
        float r20315 = -r20314;
        float r20316 = r20315 - r20303;
        float r20317 = exp(r20316);
        float r20318 = r20311 * r20317;
        float r20319 = r20308 ? r20318 : r20306;
        float r20320 = r20282 ? r20306 : r20319;
        return r20320;
}

double f_od(double K, double m, double n, double M, double l) {
        double r20321 = K;
        double r20322 = m;
        double r20323 = n;
        double r20324 = r20322 + r20323;
        double r20325 = r20321 * r20324;
        double r20326 = 2.0;
        double r20327 = r20325 / r20326;
        double r20328 = M;
        double r20329 = r20327 - r20328;
        double r20330 = -3.7786722243375715e+304;
        bool r20331 = r20329 <= r20330;
        double r20332 = 1.0;
        double r20333 = r20332 / r20328;
        double r20334 = cos(r20333);
        double r20335 = sin(r20333);
        double r20336 = -r20335;
        double r20337 = 0.5;
        double r20338 = r20337 / r20323;
        double r20339 = r20337 / r20322;
        double r20340 = r20338 + r20339;
        double r20341 = r20340 / r20321;
        double r20342 = sin(r20341);
        double r20343 = r20336 * r20342;
        double r20344 = r20334 - r20343;
        double r20345 = r20323 + r20322;
        double r20346 = r20345 / r20326;
        double r20347 = r20346 - r20328;
        double r20348 = r20347 * r20347;
        double r20349 = l;
        double r20350 = r20322 - r20323;
        double r20351 = fabs(r20350);
        double r20352 = r20349 - r20351;
        double r20353 = r20348 + r20352;
        double r20354 = exp(r20353);
        double r20355 = r20344 / r20354;
        double r20356 = 3.2708293012512454e+304;
        bool r20357 = r20329 <= r20356;
        double r20358 = cos(r20329);
        double r20359 = cbrt(r20358);
        double r20360 = r20359 * (r20359 * r20359);
        double r20361 = r20324 / r20326;
        double r20362 = r20361 - r20328;
        double r20363 = r20362 * r20362;
        double r20364 = -r20363;
        double r20365 = r20364 - r20352;
        double r20366 = exp(r20365);
        double r20367 = r20360 * r20366;
        double r20368 = r20357 ? r20367 : r20355;
        double r20369 = r20331 ? r20355 : r20368;
        return r20369;
}

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 r20370, r20371, r20372, r20373, r20374, r20375, r20376, r20377, r20378, r20379, r20380, r20381, r20382, r20383, r20384, r20385, r20386, r20387, r20388, r20389, r20390;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20370);
        mpfr_init(r20371);
        mpfr_init(r20372);
        mpfr_init(r20373);
        mpfr_init(r20374);
        mpfr_init_set_str(r20375, "2", 10, MPFR_RNDN);
        mpfr_init(r20376);
        mpfr_init(r20377);
        mpfr_init(r20378);
        mpfr_init(r20379);
        mpfr_init(r20380);
        mpfr_init(r20381);
        mpfr_init(r20382);
        mpfr_init(r20383);
        mpfr_init(r20384);
        mpfr_init(r20385);
        mpfr_init(r20386);
        mpfr_init(r20387);
        mpfr_init(r20388);
        mpfr_init(r20389);
        mpfr_init(r20390);
}

double f_im(double K, double m, double n, double M, double l) {
        mpfr_set_d(r20370, K, MPFR_RNDN);
        mpfr_set_d(r20371, m, MPFR_RNDN);
        mpfr_set_d(r20372, n, MPFR_RNDN);
        mpfr_add(r20373, r20371, r20372, MPFR_RNDN);
        mpfr_mul(r20374, r20370, r20373, MPFR_RNDN);
        ;
        mpfr_div(r20376, r20374, r20375, MPFR_RNDN);
        mpfr_set_d(r20377, M, MPFR_RNDN);
        mpfr_sub(r20378, r20376, r20377, MPFR_RNDN);
        mpfr_cos(r20379, r20378, MPFR_RNDN);
        mpfr_div(r20380, r20373, r20375, MPFR_RNDN);
        mpfr_sub(r20381, r20380, r20377, MPFR_RNDN);
        mpfr_sqr(r20382, r20381, MPFR_RNDN);
        mpfr_neg(r20383, r20382, MPFR_RNDN);
        mpfr_set_d(r20384, l, MPFR_RNDN);
        mpfr_sub(r20385, r20371, r20372, MPFR_RNDN);
        mpfr_abs(r20386, r20385, MPFR_RNDN);
        mpfr_sub(r20387, r20384, r20386, MPFR_RNDN);
        mpfr_sub(r20388, r20383, r20387, MPFR_RNDN);
        mpfr_exp(r20389, r20388, MPFR_RNDN);
        mpfr_mul(r20390, r20379, r20389, MPFR_RNDN);
        return mpfr_get_d(r20390, MPFR_RNDN);
}

static mpfr_t r20391, r20392, r20393, r20394, r20395, r20396, r20397, r20398, 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;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20391);
        mpfr_init(r20392);
        mpfr_init(r20393);
        mpfr_init(r20394);
        mpfr_init(r20395);
        mpfr_init_set_str(r20396, "2", 10, MPFR_RNDN);
        mpfr_init(r20397);
        mpfr_init(r20398);
        mpfr_init(r20399);
        mpfr_init_set_str(r20400, "-3.7786722243375715e+304", 10, MPFR_RNDN);
        mpfr_init(r20401);
        mpfr_init_set_str(r20402, "1", 10, MPFR_RNDN);
        mpfr_init(r20403);
        mpfr_init(r20404);
        mpfr_init(r20405);
        mpfr_init(r20406);
        mpfr_init_set_str(r20407, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20408);
        mpfr_init(r20409);
        mpfr_init(r20410);
        mpfr_init(r20411);
        mpfr_init(r20412);
        mpfr_init(r20413);
        mpfr_init(r20414);
        mpfr_init(r20415);
        mpfr_init(r20416);
        mpfr_init(r20417);
        mpfr_init(r20418);
        mpfr_init(r20419);
        mpfr_init(r20420);
        mpfr_init(r20421);
        mpfr_init(r20422);
        mpfr_init(r20423);
        mpfr_init(r20424);
        mpfr_init(r20425);
        mpfr_init_set_str(r20426, "3.2708293012512454e+304", 10, MPFR_RNDN);
        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(r20436);
        mpfr_init(r20437);
        mpfr_init(r20438);
        mpfr_init(r20439);
}

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

static mpfr_t r20440, r20441, r20442, r20443, 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(r20440);
        mpfr_init(r20441);
        mpfr_init(r20442);
        mpfr_init(r20443);
        mpfr_init(r20444);
        mpfr_init_set_str(r20445, "2", 10, MPFR_RNDN);
        mpfr_init(r20446);
        mpfr_init(r20447);
        mpfr_init(r20448);
        mpfr_init_set_str(r20449, "-3.7786722243375715e+304", 10, MPFR_RNDN);
        mpfr_init(r20450);
        mpfr_init_set_str(r20451, "1", 10, MPFR_RNDN);
        mpfr_init(r20452);
        mpfr_init(r20453);
        mpfr_init(r20454);
        mpfr_init(r20455);
        mpfr_init_set_str(r20456, "1/2", 10, MPFR_RNDN);
        mpfr_init(r20457);
        mpfr_init(r20458);
        mpfr_init(r20459);
        mpfr_init(r20460);
        mpfr_init(r20461);
        mpfr_init(r20462);
        mpfr_init(r20463);
        mpfr_init(r20464);
        mpfr_init(r20465);
        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_set_str(r20475, "3.2708293012512454e+304", 10, MPFR_RNDN);
        mpfr_init(r20476);
        mpfr_init(r20477);
        mpfr_init(r20478);
        mpfr_init(r20479);
        mpfr_init(r20480);
        mpfr_init(r20481);
        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(r20440, K, MPFR_RNDN);
        mpfr_set_d(r20441, m, MPFR_RNDN);
        mpfr_set_d(r20442, n, MPFR_RNDN);
        mpfr_add(r20443, r20441, r20442, MPFR_RNDN);
        mpfr_mul(r20444, r20440, r20443, MPFR_RNDN);
        ;
        mpfr_div(r20446, r20444, r20445, MPFR_RNDN);
        mpfr_set_d(r20447, M, MPFR_RNDN);
        mpfr_sub(r20448, r20446, r20447, MPFR_RNDN);
        ;
        mpfr_set_si(r20450, mpfr_cmp(r20448, r20449) <= 0, MPFR_RNDN);
        ;
        mpfr_div(r20452, r20451, r20447, MPFR_RNDN);
        mpfr_cos(r20453, r20452, MPFR_RNDN);
        mpfr_sin(r20454, r20452, MPFR_RNDN);
        mpfr_neg(r20455, r20454, MPFR_RNDN);
        ;
        mpfr_div(r20457, r20456, r20442, MPFR_RNDN);
        mpfr_div(r20458, r20456, r20441, MPFR_RNDN);
        mpfr_add(r20459, r20457, r20458, MPFR_RNDN);
        mpfr_div(r20460, r20459, r20440, MPFR_RNDN);
        mpfr_sin(r20461, r20460, MPFR_RNDN);
        mpfr_mul(r20462, r20455, r20461, MPFR_RNDN);
        mpfr_sub(r20463, r20453, r20462, MPFR_RNDN);
        mpfr_add(r20464, r20442, r20441, MPFR_RNDN);
        mpfr_div(r20465, r20464, r20445, MPFR_RNDN);
        mpfr_sub(r20466, r20465, r20447, MPFR_RNDN);
        mpfr_sqr(r20467, r20466, MPFR_RNDN);
        mpfr_set_d(r20468, l, MPFR_RNDN);
        mpfr_sub(r20469, r20441, r20442, MPFR_RNDN);
        mpfr_abs(r20470, r20469, MPFR_RNDN);
        mpfr_sub(r20471, r20468, r20470, MPFR_RNDN);
        mpfr_add(r20472, r20467, r20471, MPFR_RNDN);
        mpfr_exp(r20473, r20472, MPFR_RNDN);
        mpfr_div(r20474, r20463, r20473, MPFR_RNDN);
        ;
        mpfr_set_si(r20476, mpfr_cmp(r20448, r20475) <= 0, MPFR_RNDN);
        mpfr_cos(r20477, r20448, MPFR_RNDN);
        mpfr_cbrt(r20478, r20477, MPFR_RNDN);
        mpfr_mul(r20479, r20478, r20478, MPFR_RNDN); mpfr_mul(r20479, r20479, r20478, MPFR_RNDN);
        mpfr_div(r20480, r20443, r20445, MPFR_RNDN);
        mpfr_sub(r20481, r20480, r20447, MPFR_RNDN);
        mpfr_sqr(r20482, r20481, MPFR_RNDN);
        mpfr_neg(r20483, r20482, MPFR_RNDN);
        mpfr_sub(r20484, r20483, r20471, MPFR_RNDN);
        mpfr_exp(r20485, r20484, MPFR_RNDN);
        mpfr_mul(r20486, r20479, r20485, MPFR_RNDN);
        if (mpfr_get_si(r20476, MPFR_RNDN)) { mpfr_set(r20487, r20486, MPFR_RNDN); } else { mpfr_set(r20487, r20474, MPFR_RNDN); };
        if (mpfr_get_si(r20450, MPFR_RNDN)) { mpfr_set(r20488, r20474, MPFR_RNDN); } else { mpfr_set(r20488, r20487, MPFR_RNDN); };
        return mpfr_get_d(r20488, MPFR_RNDN);
}