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

char *name = "Toniolo and Linder, Equation (3a)";

double f_if(float l, float Om, float kx, float ky) {
        float r24556 = 1;
        float r24557 = 2;
        float r24558 = r24556 / r24557;
        float r24559 = l;
        float r24560 = r24557 * r24559;
        float r24561 = Om;
        float r24562 = r24560 / r24561;
        float r24563 = pow(r24562, r24557);
        float r24564 = kx;
        float r24565 = sin(r24564);
        float r24566 = pow(r24565, r24557);
        float r24567 = ky;
        float r24568 = sin(r24567);
        float r24569 = pow(r24568, r24557);
        float r24570 = r24566 + r24569;
        float r24571 = r24563 * r24570;
        float r24572 = r24556 + r24571;
        float r24573 = sqrt(r24572);
        float r24574 = r24556 / r24573;
        float r24575 = r24556 + r24574;
        float r24576 = r24558 * r24575;
        float r24577 = sqrt(r24576);
        return r24577;
}

double f_id(double l, double Om, double kx, double ky) {
        double r24578 = 1;
        double r24579 = 2;
        double r24580 = r24578 / r24579;
        double r24581 = l;
        double r24582 = r24579 * r24581;
        double r24583 = Om;
        double r24584 = r24582 / r24583;
        double r24585 = pow(r24584, r24579);
        double r24586 = kx;
        double r24587 = sin(r24586);
        double r24588 = pow(r24587, r24579);
        double r24589 = ky;
        double r24590 = sin(r24589);
        double r24591 = pow(r24590, r24579);
        double r24592 = r24588 + r24591;
        double r24593 = r24585 * r24592;
        double r24594 = r24578 + r24593;
        double r24595 = sqrt(r24594);
        double r24596 = r24578 / r24595;
        double r24597 = r24578 + r24596;
        double r24598 = r24580 * r24597;
        double r24599 = sqrt(r24598);
        return r24599;
}


double f_of(float l, float Om, float kx, float ky) {
        float r24600 = 1;
        float r24601 = 2;
        float r24602 = r24600 / r24601;
        float r24603 = l;
        float r24604 = Om;
        float r24605 = r24604 / r24601;
        float r24606 = r24603 / r24605;
        float r24607 = kx;
        float r24608 = sin(r24607);
        float r24609 = ky;
        float r24610 = sin(r24609);
        float r24611 = hypot(r24608, r24610);
        float r24612 = r24606 * r24611;
        float r24613 = hypot(r24600, r24612);
        float r24614 = expm1(r24613);
        float r24615 = log1p(r24614);
        float r24616 = r24600 / r24615;
        float r24617 = r24600 + r24616;
        float r24618 = r24602 * r24617;
        float r24619 = sqrt(r24618);
        return r24619;
}

double f_od(double l, double Om, double kx, double ky) {
        double r24620 = 1;
        double r24621 = 2;
        double r24622 = r24620 / r24621;
        double r24623 = l;
        double r24624 = Om;
        double r24625 = r24624 / r24621;
        double r24626 = r24623 / r24625;
        double r24627 = kx;
        double r24628 = sin(r24627);
        double r24629 = ky;
        double r24630 = sin(r24629);
        double r24631 = hypot(r24628, r24630);
        double r24632 = r24626 * r24631;
        double r24633 = hypot(r24620, r24632);
        double r24634 = expm1(r24633);
        double r24635 = log1p(r24634);
        double r24636 = r24620 / r24635;
        double r24637 = r24620 + r24636;
        double r24638 = r24622 * r24637;
        double r24639 = sqrt(r24638);
        return r24639;
}

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 r24640, r24641, r24642, r24643, r24644, r24645, r24646, r24647, r24648, r24649, r24650, r24651, r24652, r24653, r24654, r24655, r24656, r24657, r24658, r24659, r24660, r24661;

void setup_mpfr_f_im() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r24640, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r24641, "2", 10, MPFR_RNDN);
        mpfr_init(r24642);
        mpfr_init(r24643);
        mpfr_init(r24644);
        mpfr_init(r24645);
        mpfr_init(r24646);
        mpfr_init(r24647);
        mpfr_init(r24648);
        mpfr_init(r24649);
        mpfr_init(r24650);
        mpfr_init(r24651);
        mpfr_init(r24652);
        mpfr_init(r24653);
        mpfr_init(r24654);
        mpfr_init(r24655);
        mpfr_init(r24656);
        mpfr_init(r24657);
        mpfr_init(r24658);
        mpfr_init(r24659);
        mpfr_init(r24660);
        mpfr_init(r24661);
}

double f_im(double l, double Om, double kx, double ky) {
        ;
        ;
        mpfr_div(r24642, r24640, r24641, MPFR_RNDN);
        mpfr_set_d(r24643, l, MPFR_RNDN);
        mpfr_mul(r24644, r24641, r24643, MPFR_RNDN);
        mpfr_set_d(r24645, Om, MPFR_RNDN);
        mpfr_div(r24646, r24644, r24645, MPFR_RNDN);
        mpfr_pow(r24647, r24646, r24641, MPFR_RNDN);
        mpfr_set_d(r24648, kx, MPFR_RNDN);
        mpfr_sin(r24649, r24648, MPFR_RNDN);
        mpfr_pow(r24650, r24649, r24641, MPFR_RNDN);
        mpfr_set_d(r24651, ky, MPFR_RNDN);
        mpfr_sin(r24652, r24651, MPFR_RNDN);
        mpfr_pow(r24653, r24652, r24641, MPFR_RNDN);
        mpfr_add(r24654, r24650, r24653, MPFR_RNDN);
        mpfr_mul(r24655, r24647, r24654, MPFR_RNDN);
        mpfr_add(r24656, r24640, r24655, MPFR_RNDN);
        mpfr_sqrt(r24657, r24656, MPFR_RNDN);
        mpfr_div(r24658, r24640, r24657, MPFR_RNDN);
        mpfr_add(r24659, r24640, r24658, MPFR_RNDN);
        mpfr_mul(r24660, r24642, r24659, MPFR_RNDN);
        mpfr_sqrt(r24661, r24660, MPFR_RNDN);
        return mpfr_get_d(r24661, MPFR_RNDN);
}

static mpfr_t r24662, r24663, r24664, r24665, r24666, r24667, r24668, r24669, r24670, r24671, r24672, r24673, r24674, r24675, r24676, r24677, r24678, r24679, r24680, r24681;

void setup_mpfr_f_fm() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r24662, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r24663, "2", 10, MPFR_RNDN);
        mpfr_init(r24664);
        mpfr_init(r24665);
        mpfr_init(r24666);
        mpfr_init(r24667);
        mpfr_init(r24668);
        mpfr_init(r24669);
        mpfr_init(r24670);
        mpfr_init(r24671);
        mpfr_init(r24672);
        mpfr_init(r24673);
        mpfr_init(r24674);
        mpfr_init(r24675);
        mpfr_init(r24676);
        mpfr_init(r24677);
        mpfr_init(r24678);
        mpfr_init(r24679);
        mpfr_init(r24680);
        mpfr_init(r24681);
}

double f_fm(double l, double Om, double kx, double ky) {
        ;
        ;
        mpfr_div(r24664, r24662, r24663, MPFR_RNDN);
        mpfr_set_d(r24665, l, MPFR_RNDN);
        mpfr_set_d(r24666, Om, MPFR_RNDN);
        mpfr_div(r24667, r24666, r24663, MPFR_RNDN);
        mpfr_div(r24668, r24665, r24667, MPFR_RNDN);
        mpfr_set_d(r24669, kx, MPFR_RNDN);
        mpfr_sin(r24670, r24669, MPFR_RNDN);
        mpfr_set_d(r24671, ky, MPFR_RNDN);
        mpfr_sin(r24672, r24671, MPFR_RNDN);
        mpfr_hypot(r24673, r24670, r24672, MPFR_RNDN);
        mpfr_mul(r24674, r24668, r24673, MPFR_RNDN);
        mpfr_hypot(r24675, r24662, r24674, MPFR_RNDN);
        mpfr_expm1(r24676, r24675, MPFR_RNDN);
        mpfr_log1p(r24677, r24676, MPFR_RNDN);
        mpfr_div(r24678, r24662, r24677, MPFR_RNDN);
        mpfr_add(r24679, r24662, r24678, MPFR_RNDN);
        mpfr_mul(r24680, r24664, r24679, MPFR_RNDN);
        mpfr_sqrt(r24681, r24680, MPFR_RNDN);
        return mpfr_get_d(r24681, MPFR_RNDN);
}

static mpfr_t r24682, r24683, r24684, r24685, r24686, r24687, r24688, r24689, r24690, r24691, r24692, r24693, r24694, r24695, r24696, r24697, r24698, r24699, r24700, r24701;

void setup_mpfr_f_dm() {
        mpfr_set_default_prec(336);
        mpfr_init_set_str(r24682, "1", 10, MPFR_RNDN);
        mpfr_init_set_str(r24683, "2", 10, MPFR_RNDN);
        mpfr_init(r24684);
        mpfr_init(r24685);
        mpfr_init(r24686);
        mpfr_init(r24687);
        mpfr_init(r24688);
        mpfr_init(r24689);
        mpfr_init(r24690);
        mpfr_init(r24691);
        mpfr_init(r24692);
        mpfr_init(r24693);
        mpfr_init(r24694);
        mpfr_init(r24695);
        mpfr_init(r24696);
        mpfr_init(r24697);
        mpfr_init(r24698);
        mpfr_init(r24699);
        mpfr_init(r24700);
        mpfr_init(r24701);
}

double f_dm(double l, double Om, double kx, double ky) {
        ;
        ;
        mpfr_div(r24684, r24682, r24683, MPFR_RNDN);
        mpfr_set_d(r24685, l, MPFR_RNDN);
        mpfr_set_d(r24686, Om, MPFR_RNDN);
        mpfr_div(r24687, r24686, r24683, MPFR_RNDN);
        mpfr_div(r24688, r24685, r24687, MPFR_RNDN);
        mpfr_set_d(r24689, kx, MPFR_RNDN);
        mpfr_sin(r24690, r24689, MPFR_RNDN);
        mpfr_set_d(r24691, ky, MPFR_RNDN);
        mpfr_sin(r24692, r24691, MPFR_RNDN);
        mpfr_hypot(r24693, r24690, r24692, MPFR_RNDN);
        mpfr_mul(r24694, r24688, r24693, MPFR_RNDN);
        mpfr_hypot(r24695, r24682, r24694, MPFR_RNDN);
        mpfr_expm1(r24696, r24695, MPFR_RNDN);
        mpfr_log1p(r24697, r24696, MPFR_RNDN);
        mpfr_div(r24698, r24682, r24697, MPFR_RNDN);
        mpfr_add(r24699, r24682, r24698, MPFR_RNDN);
        mpfr_mul(r24700, r24684, r24699, MPFR_RNDN);
        mpfr_sqrt(r24701, r24700, MPFR_RNDN);
        return mpfr_get_d(r24701, MPFR_RNDN);
}