#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 r20333 = R;
        float r20334 = 2;
        float r20335 = phi1;
        float r20336 = phi2;
        float r20337 = r20335 - r20336;
        float r20338 = r20337 / r20334;
        float r20339 = sin(r20338);
        float r20340 = pow(r20339, r20334);
        float r20341 = cos(r20335);
        float r20342 = cos(r20336);
        float r20343 = r20341 * r20342;
        float r20344 = lambda1;
        float r20345 = lambda2;
        float r20346 = r20344 - r20345;
        float r20347 = r20346 / r20334;
        float r20348 = sin(r20347);
        float r20349 = r20343 * r20348;
        float r20350 = r20349 * r20348;
        float r20351 = r20340 + r20350;
        float r20352 = sqrt(r20351);
        float r20353 = 1;
        float r20354 = r20353 - r20351;
        float r20355 = sqrt(r20354);
        float r20356 = atan2(r20352, r20355);
        float r20357 = r20334 * r20356;
        float r20358 = r20333 * r20357;
        return r20358;
}

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


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

double f_od(double R, double lambda1, double lambda2, double phi1, double phi2) {
        double r20417 = R;
        double r20418 = 2;
        double r20419 = phi1;
        double r20420 = phi2;
        double r20421 = r20419 - r20420;
        double r20422 = r20421 / r20418;
        double r20423 = sin(r20422);
        double r20424 = pow(r20423, r20418);
        double r20425 = cos(r20419);
        double r20426 = cos(r20420);
        double r20427 = r20425 * r20426;
        double r20428 = lambda1;
        double r20429 = lambda2;
        double r20430 = r20428 - r20429;
        double r20431 = r20430 / r20418;
        double r20432 = sin(r20431);
        double r20433 = r20427 * r20432;
        double r20434 = r20433 * r20432;
        double r20435 = r20424 + r20434;
        double r20436 = sqrt(r20435);
        double r20437 = 1;
        double r20438 = 3;
        double r20439 = pow(r20432, r20438);
        double r20440 = cbrt(r20439);
        double r20441 = r20427 * r20440;
        double r20442 = r20441 * r20440;
        double r20443 = r20424 + r20442;
        double r20444 = r20437 - r20443;
        double r20445 = sqrt(r20444);
        double r20446 = atan2(r20436, r20445);
        double r20447 = r20418 * r20446;
        double r20448 = r20417 * r20447;
        return r20448;
}

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

void setup_mpfr_f_im() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20449);
        mpfr_init_set_str(r20450, "2", 10, MPFR_RNDN);
        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(r20467);
        mpfr_init(r20468);
        mpfr_init_set_str(r20469, "1", 10, MPFR_RNDN);
        mpfr_init(r20470);
        mpfr_init(r20471);
        mpfr_init(r20472);
        mpfr_init(r20473);
        mpfr_init(r20474);
}

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

static mpfr_t r20475, r20476, r20477, r20478, 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;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20475);
        mpfr_init_set_str(r20476, "2", 10, MPFR_RNDN);
        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);
        mpfr_init(r20489);
        mpfr_init(r20490);
        mpfr_init(r20491);
        mpfr_init(r20492);
        mpfr_init(r20493);
        mpfr_init(r20494);
        mpfr_init_set_str(r20495, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r20496, "3", 10, MPFR_RNDN);
        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);
}

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

static mpfr_t r20507, r20508, r20509, r20510, r20511, r20512, r20513, r20514, r20515, r20516, r20517, r20518, r20519, r20520, r20521, r20522, r20523, r20524, r20525, r20526, r20527, r20528, r20529, r20530, r20531, r20532, r20533, r20534, r20535, r20536, r20537, r20538;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(1424);
        mpfr_init(r20507);
        mpfr_init_set_str(r20508, "2", 10, MPFR_RNDN);
        mpfr_init(r20509);
        mpfr_init(r20510);
        mpfr_init(r20511);
        mpfr_init(r20512);
        mpfr_init(r20513);
        mpfr_init(r20514);
        mpfr_init(r20515);
        mpfr_init(r20516);
        mpfr_init(r20517);
        mpfr_init(r20518);
        mpfr_init(r20519);
        mpfr_init(r20520);
        mpfr_init(r20521);
        mpfr_init(r20522);
        mpfr_init(r20523);
        mpfr_init(r20524);
        mpfr_init(r20525);
        mpfr_init(r20526);
        mpfr_init_set_str(r20527, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r20528, "3", 10, MPFR_RNDN);
        mpfr_init(r20529);
        mpfr_init(r20530);
        mpfr_init(r20531);
        mpfr_init(r20532);
        mpfr_init(r20533);
        mpfr_init(r20534);
        mpfr_init(r20535);
        mpfr_init(r20536);
        mpfr_init(r20537);
        mpfr_init(r20538);
}

double f_dm(double R, double lambda1, double lambda2, double phi1, double phi2) {
        mpfr_set_d(r20507, R, MPFR_RNDN);
        ;
        mpfr_set_d(r20509, phi1, MPFR_RNDN);
        mpfr_set_d(r20510, phi2, MPFR_RNDN);
        mpfr_sub(r20511, r20509, r20510, MPFR_RNDN);
        mpfr_div(r20512, r20511, r20508, MPFR_RNDN);
        mpfr_sin(r20513, r20512, MPFR_RNDN);
        mpfr_pow(r20514, r20513, r20508, MPFR_RNDN);
        mpfr_cos(r20515, r20509, MPFR_RNDN);
        mpfr_cos(r20516, r20510, MPFR_RNDN);
        mpfr_mul(r20517, r20515, r20516, MPFR_RNDN);
        mpfr_set_d(r20518, lambda1, MPFR_RNDN);
        mpfr_set_d(r20519, lambda2, MPFR_RNDN);
        mpfr_sub(r20520, r20518, r20519, MPFR_RNDN);
        mpfr_div(r20521, r20520, r20508, MPFR_RNDN);
        mpfr_sin(r20522, r20521, MPFR_RNDN);
        mpfr_mul(r20523, r20517, r20522, MPFR_RNDN);
        mpfr_mul(r20524, r20523, r20522, MPFR_RNDN);
        mpfr_add(r20525, r20514, r20524, MPFR_RNDN);
        mpfr_sqrt(r20526, r20525, MPFR_RNDN);
        ;
        ;
        mpfr_pow(r20529, r20522, r20528, MPFR_RNDN);
        mpfr_cbrt(r20530, r20529, MPFR_RNDN);
        mpfr_mul(r20531, r20517, r20530, MPFR_RNDN);
        mpfr_mul(r20532, r20531, r20530, MPFR_RNDN);
        mpfr_add(r20533, r20514, r20532, MPFR_RNDN);
        mpfr_sub(r20534, r20527, r20533, MPFR_RNDN);
        mpfr_sqrt(r20535, r20534, MPFR_RNDN);
        mpfr_atan2(r20536, r20526, r20535, MPFR_RNDN);
        mpfr_mul(r20537, r20508, r20536, MPFR_RNDN);
        mpfr_mul(r20538, r20507, r20537, MPFR_RNDN);
        return mpfr_get_d(r20538, MPFR_RNDN);
}