#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 r20305 = R;
        float r20306 = 2;
        float r20307 = phi1;
        float r20308 = phi2;
        float r20309 = r20307 - r20308;
        float r20310 = r20309 / r20306;
        float r20311 = sin(r20310);
        float r20312 = pow(r20311, r20306);
        float r20313 = cos(r20307);
        float r20314 = cos(r20308);
        float r20315 = r20313 * r20314;
        float r20316 = lambda1;
        float r20317 = lambda2;
        float r20318 = r20316 - r20317;
        float r20319 = r20318 / r20306;
        float r20320 = sin(r20319);
        float r20321 = r20315 * r20320;
        float r20322 = r20321 * r20320;
        float r20323 = r20312 + r20322;
        float r20324 = sqrt(r20323);
        float r20325 = 1;
        float r20326 = r20325 - r20323;
        float r20327 = sqrt(r20326);
        float r20328 = atan2(r20324, r20327);
        float r20329 = r20306 * r20328;
        float r20330 = r20305 * r20329;
        return r20330;
}

double f_id(double R, double lambda1, double lambda2, double phi1, double phi2) {
        double r20331 = R;
        double r20332 = 2;
        double r20333 = phi1;
        double r20334 = phi2;
        double r20335 = r20333 - r20334;
        double r20336 = r20335 / r20332;
        double r20337 = sin(r20336);
        double r20338 = pow(r20337, r20332);
        double r20339 = cos(r20333);
        double r20340 = cos(r20334);
        double r20341 = r20339 * r20340;
        double r20342 = lambda1;
        double r20343 = lambda2;
        double r20344 = r20342 - r20343;
        double r20345 = r20344 / r20332;
        double r20346 = sin(r20345);
        double r20347 = r20341 * r20346;
        double r20348 = r20347 * r20346;
        double r20349 = r20338 + r20348;
        double r20350 = sqrt(r20349);
        double r20351 = 1;
        double r20352 = r20351 - r20349;
        double r20353 = sqrt(r20352);
        double r20354 = atan2(r20350, r20353);
        double r20355 = r20332 * r20354;
        double r20356 = r20331 * r20355;
        return r20356;
}


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

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

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 r20421, r20422, r20423, r20424, r20425, r20426, r20427, r20428, r20429, r20430, r20431, r20432, r20433, r20434, r20435, r20436, r20437, r20438, r20439, r20440, r20441, r20442, r20443, r20444, r20445, r20446;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20421);
        mpfr_init_set_str(r20422, "2", 10, MPFR_RNDN);
        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(r20436);
        mpfr_init(r20437);
        mpfr_init(r20438);
        mpfr_init(r20439);
        mpfr_init(r20440);
        mpfr_init_set_str(r20441, "1", 10, MPFR_RNDN);
        mpfr_init(r20442);
        mpfr_init(r20443);
        mpfr_init(r20444);
        mpfr_init(r20445);
        mpfr_init(r20446);
}

double f_im(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20421, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20423, phi1, MPFR_RNDN);
        mpfr_set_d(r20424, phi2, MPFR_RNDN);
        mpfr_sub(r20425, r20423, r20424, MPFR_RNDN);
        mpfr_div(r20426, r20425, r20422, MPFR_RNDN);
        mpfr_sin(r20427, r20426, MPFR_RNDN);
        mpfr_pow(r20428, r20427, r20422, MPFR_RNDN);
        mpfr_cos(r20429, r20423, MPFR_RNDN);
        mpfr_cos(r20430, r20424, MPFR_RNDN);
        mpfr_mul(r20431, r20429, r20430, MPFR_RNDN);
        mpfr_set_d(r20432, lambda1, MPFR_RNDN);
        mpfr_set_d(r20433, lambda2, MPFR_RNDN);
        mpfr_sub(r20434, r20432, r20433, MPFR_RNDN);
        mpfr_div(r20435, r20434, r20422, MPFR_RNDN);
        mpfr_sin(r20436, r20435, MPFR_RNDN);
        mpfr_mul(r20437, r20431, r20436, MPFR_RNDN);
        mpfr_mul(r20438, r20437, r20436, MPFR_RNDN);
        mpfr_add(r20439, r20428, r20438, MPFR_RNDN);
        mpfr_sqrt(r20440, r20439, MPFR_RNDN);
        ;
        mpfr_sub(r20442, r20441, r20439, MPFR_RNDN);
        mpfr_sqrt(r20443, r20442, MPFR_RNDN);
        mpfr_atan2(r20444, r20440, r20443, MPFR_RNDN);
        mpfr_mul(r20445, r20422, r20444, MPFR_RNDN);
        mpfr_mul(r20446, r20421, r20445, MPFR_RNDN);
        return mpfr_get_d(r20446, MPFR_RNDN);
}

static mpfr_t 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;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20447);
        mpfr_init_set_str(r20448, "2", 10, MPFR_RNDN);
        mpfr_init(r20449);
        mpfr_init(r20450);
        mpfr_init(r20451);
        mpfr_init(r20452);
        mpfr_init(r20453);
        mpfr_init(r20454);
        mpfr_init(r20455);
        mpfr_init(r20456);
        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_set_str(r20467, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r20468, "3", 10, MPFR_RNDN);
        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);
}

double f_fm(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20447, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20449, phi1, MPFR_RNDN);
        mpfr_set_d(r20450, phi2, MPFR_RNDN);
        mpfr_sub(r20451, r20449, r20450, MPFR_RNDN);
        mpfr_div(r20452, r20451, r20448, MPFR_RNDN);
        mpfr_sin(r20453, r20452, MPFR_RNDN);
        mpfr_pow(r20454, r20453, r20448, MPFR_RNDN);
        mpfr_cos(r20455, r20449, MPFR_RNDN);
        mpfr_cos(r20456, r20450, MPFR_RNDN);
        mpfr_mul(r20457, r20455, r20456, MPFR_RNDN);
        mpfr_set_d(r20458, lambda1, MPFR_RNDN);
        mpfr_set_d(r20459, lambda2, MPFR_RNDN);
        mpfr_sub(r20460, r20458, r20459, MPFR_RNDN);
        mpfr_div(r20461, r20460, r20448, MPFR_RNDN);
        mpfr_sin(r20462, r20461, MPFR_RNDN);
        mpfr_mul(r20463, r20457, r20462, MPFR_RNDN);
        mpfr_mul(r20464, r20463, r20462, MPFR_RNDN);
        mpfr_add(r20465, r20454, r20464, MPFR_RNDN);
        mpfr_sqrt(r20466, r20465, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20469, r20462, r20468, MPFR_RNDN);
        mpfr_cbrt(r20470, r20469, MPFR_RNDN);
        mpfr_mul(r20471, r20457, r20470, MPFR_RNDN);
        mpfr_mul(r20472, r20471, r20470, MPFR_RNDN);
        mpfr_add(r20473, r20454, r20472, MPFR_RNDN);
        mpfr_sub(r20474, r20467, r20473, MPFR_RNDN);
        mpfr_sqrt(r20475, r20474, MPFR_RNDN);
        mpfr_atan2(r20476, r20466, r20475, MPFR_RNDN);
        mpfr_mul(r20477, r20448, r20476, MPFR_RNDN);
        mpfr_mul(r20478, r20447, r20477, MPFR_RNDN);
        return mpfr_get_d(r20478, MPFR_RNDN);
}

static mpfr_t r20479, r20480, r20481, r20482, r20483, r20484, r20485, r20486, r20487, r20488, r20489, r20490, r20491, r20492, r20493, r20494, r20495, r20496, r20497, r20498, r20499, r20500, r20501, r20502, r20503, r20504, r20505, r20506, r20507, r20508, r20509, r20510;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20479);
        mpfr_init_set_str(r20480, "2", 10, MPFR_RNDN);
        mpfr_init(r20481);
        mpfr_init(r20482);
        mpfr_init(r20483);
        mpfr_init(r20484);
        mpfr_init(r20485);
        mpfr_init(r20486);
        mpfr_init(r20487);
        mpfr_init(r20488);
        mpfr_init(r20489);
        mpfr_init(r20490);
        mpfr_init(r20491);
        mpfr_init(r20492);
        mpfr_init(r20493);
        mpfr_init(r20494);
        mpfr_init(r20495);
        mpfr_init(r20496);
        mpfr_init(r20497);
        mpfr_init(r20498);
        mpfr_init_set_str(r20499, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r20500, "3", 10, MPFR_RNDN);
        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);
}

double f_dm(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20479, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20481, phi1, MPFR_RNDN);
        mpfr_set_d(r20482, phi2, MPFR_RNDN);
        mpfr_sub(r20483, r20481, r20482, MPFR_RNDN);
        mpfr_div(r20484, r20483, r20480, MPFR_RNDN);
        mpfr_sin(r20485, r20484, MPFR_RNDN);
        mpfr_pow(r20486, r20485, r20480, MPFR_RNDN);
        mpfr_cos(r20487, r20481, MPFR_RNDN);
        mpfr_cos(r20488, r20482, MPFR_RNDN);
        mpfr_mul(r20489, r20487, r20488, MPFR_RNDN);
        mpfr_set_d(r20490, lambda1, MPFR_RNDN);
        mpfr_set_d(r20491, lambda2, MPFR_RNDN);
        mpfr_sub(r20492, r20490, r20491, MPFR_RNDN);
        mpfr_div(r20493, r20492, r20480, MPFR_RNDN);
        mpfr_sin(r20494, r20493, MPFR_RNDN);
        mpfr_mul(r20495, r20489, r20494, MPFR_RNDN);
        mpfr_mul(r20496, r20495, r20494, MPFR_RNDN);
        mpfr_add(r20497, r20486, r20496, MPFR_RNDN);
        mpfr_sqrt(r20498, r20497, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20501, r20494, r20500, MPFR_RNDN);
        mpfr_cbrt(r20502, r20501, MPFR_RNDN);
        mpfr_mul(r20503, r20489, r20502, MPFR_RNDN);
        mpfr_mul(r20504, r20503, r20502, MPFR_RNDN);
        mpfr_add(r20505, r20486, r20504, MPFR_RNDN);
        mpfr_sub(r20506, r20499, r20505, MPFR_RNDN);
        mpfr_sqrt(r20507, r20506, MPFR_RNDN);
        mpfr_atan2(r20508, r20498, r20507, MPFR_RNDN);
        mpfr_mul(r20509, r20480, r20508, MPFR_RNDN);
        mpfr_mul(r20510, r20479, r20509, MPFR_RNDN);
        return mpfr_get_d(r20510, MPFR_RNDN);
}