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

char *name = "Distance on a great circle";

double f_if(float R, float lambda1, float lambda2, float phi1, float phi2) {
        float r20337 = R;
        float r20338 = 2;
        float r20339 = phi1;
        float r20340 = phi2;
        float r20341 = r20339 - r20340;
        float r20342 = r20341 / r20338;
        float r20343 = sin(r20342);
        float r20344 = pow(r20343, r20338);
        float r20345 = cos(r20339);
        float r20346 = cos(r20340);
        float r20347 = r20345 * r20346;
        float r20348 = lambda1;
        float r20349 = lambda2;
        float r20350 = r20348 - r20349;
        float r20351 = r20350 / r20338;
        float r20352 = sin(r20351);
        float r20353 = r20347 * r20352;
        float r20354 = r20353 * r20352;
        float r20355 = r20344 + r20354;
        float r20356 = sqrt(r20355);
        float r20357 = 1;
        float r20358 = r20357 - r20355;
        float r20359 = sqrt(r20358);
        float r20360 = atan2(r20356, r20359);
        float r20361 = r20338 * r20360;
        float r20362 = r20337 * r20361;
        return r20362;
}

double f_id(double R, double lambda1, double lambda2, double phi1, double phi2) {
        double r20363 = R;
        double r20364 = 2;
        double r20365 = phi1;
        double r20366 = phi2;
        double r20367 = r20365 - r20366;
        double r20368 = r20367 / r20364;
        double r20369 = sin(r20368);
        double r20370 = pow(r20369, r20364);
        double r20371 = cos(r20365);
        double r20372 = cos(r20366);
        double r20373 = r20371 * r20372;
        double r20374 = lambda1;
        double r20375 = lambda2;
        double r20376 = r20374 - r20375;
        double r20377 = r20376 / r20364;
        double r20378 = sin(r20377);
        double r20379 = r20373 * r20378;
        double r20380 = r20379 * r20378;
        double r20381 = r20370 + r20380;
        double r20382 = sqrt(r20381);
        double r20383 = 1;
        double r20384 = r20383 - r20381;
        double r20385 = sqrt(r20384);
        double r20386 = atan2(r20382, r20385);
        double r20387 = r20364 * r20386;
        double r20388 = r20363 * r20387;
        return r20388;
}


double f_of(float R, float lambda1, float lambda2, float phi1, float phi2) {
        float r20389 = R;
        float r20390 = 2;
        float r20391 = phi1;
        float r20392 = r20391 / r20390;
        float r20393 = sin(r20392);
        float r20394 = phi2;
        float r20395 = r20394 / r20390;
        float r20396 = cos(r20395);
        float r20397 = r20393 * r20396;
        float r20398 = cos(r20392);
        float r20399 = sin(r20395);
        float r20400 = r20398 * r20399;
        float r20401 = r20397 - r20400;
        float r20402 = pow(r20401, r20390);
        float r20403 = cos(r20391);
        float r20404 = cos(r20394);
        float r20405 = r20403 * r20404;
        float r20406 = lambda1;
        float r20407 = lambda2;
        float r20408 = r20406 - r20407;
        float r20409 = r20408 / r20390;
        float r20410 = sin(r20409);
        float r20411 = 3;
        float r20412 = pow(r20410, r20411);
        float r20413 = cbrt(r20412);
        float r20414 = r20405 * r20413;
        float r20415 = r20414 * r20413;
        float r20416 = r20402 + r20415;
        float r20417 = sqrt(r20416);
        float r20418 = 1;
        float r20419 = r20405 * r20410;
        float r20420 = r20419 * r20410;
        float r20421 = r20402 + r20420;
        float r20422 = r20418 - r20421;
        float r20423 = sqrt(r20422);
        float r20424 = atan2(r20417, r20423);
        float r20425 = r20390 * r20424;
        float r20426 = r20389 * r20425;
        return r20426;
}

double f_od(double R, double lambda1, double lambda2, double phi1, double phi2) {
        double r20427 = R;
        double r20428 = 2;
        double r20429 = phi1;
        double r20430 = r20429 / r20428;
        double r20431 = sin(r20430);
        double r20432 = phi2;
        double r20433 = r20432 / r20428;
        double r20434 = cos(r20433);
        double r20435 = r20431 * r20434;
        double r20436 = cos(r20430);
        double r20437 = sin(r20433);
        double r20438 = r20436 * r20437;
        double r20439 = r20435 - r20438;
        double r20440 = pow(r20439, r20428);
        double r20441 = cos(r20429);
        double r20442 = cos(r20432);
        double r20443 = r20441 * r20442;
        double r20444 = lambda1;
        double r20445 = lambda2;
        double r20446 = r20444 - r20445;
        double r20447 = r20446 / r20428;
        double r20448 = sin(r20447);
        double r20449 = 3;
        double r20450 = pow(r20448, r20449);
        double r20451 = cbrt(r20450);
        double r20452 = r20443 * r20451;
        double r20453 = r20452 * r20451;
        double r20454 = r20440 + r20453;
        double r20455 = sqrt(r20454);
        double r20456 = 1;
        double r20457 = r20443 * r20448;
        double r20458 = r20457 * r20448;
        double r20459 = r20440 + r20458;
        double r20460 = r20456 - r20459;
        double r20461 = sqrt(r20460);
        double r20462 = atan2(r20455, r20461);
        double r20463 = r20428 * r20462;
        double r20464 = r20427 * r20463;
        return r20464;
}

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 r20465, r20466, r20467, r20468, r20469, r20470, r20471, r20472, r20473, r20474, r20475, r20476, r20477, r20478, r20479, r20480, r20481, r20482, r20483, r20484, r20485, r20486, r20487, r20488, r20489, r20490;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20465);
        mpfr_init_set_str(r20466, "2", 10, MPFR_RNDN);
        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(r20481);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init_set_str(r20485, "1", 10, MPFR_RNDN);
        mpfr_init(r20486);
        mpfr_init(r20487);
        mpfr_init(r20488);
        mpfr_init(r20489);
        mpfr_init(r20490);
}

double f_im(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20465, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20467, phi1, MPFR_RNDN);
        mpfr_set_d(r20468, phi2, MPFR_RNDN);
        mpfr_sub(r20469, r20467, r20468, MPFR_RNDN);
        mpfr_div(r20470, r20469, r20466, MPFR_RNDN);
        mpfr_sin(r20471, r20470, MPFR_RNDN);
        mpfr_pow(r20472, r20471, r20466, MPFR_RNDN);
        mpfr_cos(r20473, r20467, MPFR_RNDN);
        mpfr_cos(r20474, r20468, MPFR_RNDN);
        mpfr_mul(r20475, r20473, r20474, MPFR_RNDN);
        mpfr_set_d(r20476, lambda1, MPFR_RNDN);
        mpfr_set_d(r20477, lambda2, MPFR_RNDN);
        mpfr_sub(r20478, r20476, r20477, MPFR_RNDN);
        mpfr_div(r20479, r20478, r20466, MPFR_RNDN);
        mpfr_sin(r20480, r20479, MPFR_RNDN);
        mpfr_mul(r20481, r20475, r20480, MPFR_RNDN);
        mpfr_mul(r20482, r20481, r20480, MPFR_RNDN);
        mpfr_add(r20483, r20472, r20482, MPFR_RNDN);
        mpfr_sqrt(r20484, r20483, MPFR_RNDN);
        ;
        mpfr_sub(r20486, r20485, r20483, MPFR_RNDN);
        mpfr_sqrt(r20487, r20486, MPFR_RNDN);
        mpfr_atan2(r20488, r20484, r20487, MPFR_RNDN);
        mpfr_mul(r20489, r20466, r20488, MPFR_RNDN);
        mpfr_mul(r20490, r20465, r20489, MPFR_RNDN);
        return mpfr_get_d(r20490, MPFR_RNDN);
}

static mpfr_t r20491, r20492, r20493, r20494, r20495, r20496, r20497, r20498, r20499, r20500, r20501, r20502, r20503, r20504, r20505, r20506, r20507, r20508, r20509, r20510, r20511, r20512, r20513, r20514, r20515, r20516, r20517, r20518, r20519, r20520, r20521, r20522, r20523, r20524, r20525, r20526, r20527, r20528;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20491);
        mpfr_init_set_str(r20492, "2", 10, MPFR_RNDN);
        mpfr_init(r20493);
        mpfr_init(r20494);
        mpfr_init(r20495);
        mpfr_init(r20496);
        mpfr_init(r20497);
        mpfr_init(r20498);
        mpfr_init(r20499);
        mpfr_init(r20500);
        mpfr_init(r20501);
        mpfr_init(r20502);
        mpfr_init(r20503);
        mpfr_init(r20504);
        mpfr_init(r20505);
        mpfr_init(r20506);
        mpfr_init(r20507);
        mpfr_init(r20508);
        mpfr_init(r20509);
        mpfr_init(r20510);
        mpfr_init(r20511);
        mpfr_init(r20512);
        mpfr_init_set_str(r20513, "3", 10, MPFR_RNDN);
        mpfr_init(r20514);
        mpfr_init(r20515);
        mpfr_init(r20516);
        mpfr_init(r20517);
        mpfr_init(r20518);
        mpfr_init(r20519);
        mpfr_init_set_str(r20520, "1", 10, MPFR_RNDN);
        mpfr_init(r20521);
        mpfr_init(r20522);
        mpfr_init(r20523);
        mpfr_init(r20524);
        mpfr_init(r20525);
        mpfr_init(r20526);
        mpfr_init(r20527);
        mpfr_init(r20528);
}

double f_fm(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20491, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20493, phi1, MPFR_RNDN);
        mpfr_div(r20494, r20493, r20492, MPFR_RNDN);
        mpfr_sin(r20495, r20494, MPFR_RNDN);
        mpfr_set_d(r20496, phi2, MPFR_RNDN);
        mpfr_div(r20497, r20496, r20492, MPFR_RNDN);
        mpfr_cos(r20498, r20497, MPFR_RNDN);
        mpfr_mul(r20499, r20495, r20498, MPFR_RNDN);
        mpfr_cos(r20500, r20494, MPFR_RNDN);
        mpfr_sin(r20501, r20497, MPFR_RNDN);
        mpfr_mul(r20502, r20500, r20501, MPFR_RNDN);
        mpfr_sub(r20503, r20499, r20502, MPFR_RNDN);
        mpfr_pow(r20504, r20503, r20492, MPFR_RNDN);
        mpfr_cos(r20505, r20493, MPFR_RNDN);
        mpfr_cos(r20506, r20496, MPFR_RNDN);
        mpfr_mul(r20507, r20505, r20506, MPFR_RNDN);
        mpfr_set_d(r20508, lambda1, MPFR_RNDN);
        mpfr_set_d(r20509, lambda2, MPFR_RNDN);
        mpfr_sub(r20510, r20508, r20509, MPFR_RNDN);
        mpfr_div(r20511, r20510, r20492, MPFR_RNDN);
        mpfr_sin(r20512, r20511, MPFR_RNDN);
        ;
        mpfr_pow(r20514, r20512, r20513, MPFR_RNDN);
        mpfr_cbrt(r20515, r20514, MPFR_RNDN);
        mpfr_mul(r20516, r20507, r20515, MPFR_RNDN);
        mpfr_mul(r20517, r20516, r20515, MPFR_RNDN);
        mpfr_add(r20518, r20504, r20517, MPFR_RNDN);
        mpfr_sqrt(r20519, r20518, MPFR_RNDN);
        ;
        mpfr_mul(r20521, r20507, r20512, MPFR_RNDN);
        mpfr_mul(r20522, r20521, r20512, MPFR_RNDN);
        mpfr_add(r20523, r20504, r20522, MPFR_RNDN);
        mpfr_sub(r20524, r20520, r20523, MPFR_RNDN);
        mpfr_sqrt(r20525, r20524, MPFR_RNDN);
        mpfr_atan2(r20526, r20519, r20525, MPFR_RNDN);
        mpfr_mul(r20527, r20492, r20526, MPFR_RNDN);
        mpfr_mul(r20528, r20491, r20527, MPFR_RNDN);
        return mpfr_get_d(r20528, MPFR_RNDN);
}

static mpfr_t r20529, r20530, r20531, r20532, r20533, r20534, r20535, r20536, r20537, r20538, r20539, r20540, r20541, r20542, r20543, r20544, r20545, r20546, r20547, r20548, r20549, r20550, r20551, r20552, r20553, r20554, r20555, r20556, r20557, r20558, r20559, r20560, r20561, r20562, r20563, r20564, r20565, r20566;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20529);
        mpfr_init_set_str(r20530, "2", 10, MPFR_RNDN);
        mpfr_init(r20531);
        mpfr_init(r20532);
        mpfr_init(r20533);
        mpfr_init(r20534);
        mpfr_init(r20535);
        mpfr_init(r20536);
        mpfr_init(r20537);
        mpfr_init(r20538);
        mpfr_init(r20539);
        mpfr_init(r20540);
        mpfr_init(r20541);
        mpfr_init(r20542);
        mpfr_init(r20543);
        mpfr_init(r20544);
        mpfr_init(r20545);
        mpfr_init(r20546);
        mpfr_init(r20547);
        mpfr_init(r20548);
        mpfr_init(r20549);
        mpfr_init(r20550);
        mpfr_init_set_str(r20551, "3", 10, MPFR_RNDN);
        mpfr_init(r20552);
        mpfr_init(r20553);
        mpfr_init(r20554);
        mpfr_init(r20555);
        mpfr_init(r20556);
        mpfr_init(r20557);
        mpfr_init_set_str(r20558, "1", 10, MPFR_RNDN);
        mpfr_init(r20559);
        mpfr_init(r20560);
        mpfr_init(r20561);
        mpfr_init(r20562);
        mpfr_init(r20563);
        mpfr_init(r20564);
        mpfr_init(r20565);
        mpfr_init(r20566);
}

double f_dm(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20529, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20531, phi1, MPFR_RNDN);
        mpfr_div(r20532, r20531, r20530, MPFR_RNDN);
        mpfr_sin(r20533, r20532, MPFR_RNDN);
        mpfr_set_d(r20534, phi2, MPFR_RNDN);
        mpfr_div(r20535, r20534, r20530, MPFR_RNDN);
        mpfr_cos(r20536, r20535, MPFR_RNDN);
        mpfr_mul(r20537, r20533, r20536, MPFR_RNDN);
        mpfr_cos(r20538, r20532, MPFR_RNDN);
        mpfr_sin(r20539, r20535, MPFR_RNDN);
        mpfr_mul(r20540, r20538, r20539, MPFR_RNDN);
        mpfr_sub(r20541, r20537, r20540, MPFR_RNDN);
        mpfr_pow(r20542, r20541, r20530, MPFR_RNDN);
        mpfr_cos(r20543, r20531, MPFR_RNDN);
        mpfr_cos(r20544, r20534, MPFR_RNDN);
        mpfr_mul(r20545, r20543, r20544, MPFR_RNDN);
        mpfr_set_d(r20546, lambda1, MPFR_RNDN);
        mpfr_set_d(r20547, lambda2, MPFR_RNDN);
        mpfr_sub(r20548, r20546, r20547, MPFR_RNDN);
        mpfr_div(r20549, r20548, r20530, MPFR_RNDN);
        mpfr_sin(r20550, r20549, MPFR_RNDN);
        ;
        mpfr_pow(r20552, r20550, r20551, MPFR_RNDN);
        mpfr_cbrt(r20553, r20552, MPFR_RNDN);
        mpfr_mul(r20554, r20545, r20553, MPFR_RNDN);
        mpfr_mul(r20555, r20554, r20553, MPFR_RNDN);
        mpfr_add(r20556, r20542, r20555, MPFR_RNDN);
        mpfr_sqrt(r20557, r20556, MPFR_RNDN);
        ;
        mpfr_mul(r20559, r20545, r20550, MPFR_RNDN);
        mpfr_mul(r20560, r20559, r20550, MPFR_RNDN);
        mpfr_add(r20561, r20542, r20560, MPFR_RNDN);
        mpfr_sub(r20562, r20558, r20561, MPFR_RNDN);
        mpfr_sqrt(r20563, r20562, MPFR_RNDN);
        mpfr_atan2(r20564, r20557, r20563, MPFR_RNDN);
        mpfr_mul(r20565, r20530, r20564, MPFR_RNDN);
        mpfr_mul(r20566, r20529, r20565, MPFR_RNDN);
        return mpfr_get_d(r20566, MPFR_RNDN);
}