#include "gen.h"

#include <stdio.h>

static int mpf1(struct t *s, float (*f)(float))

{

	s->dy = 0;

	setupfenv(s->r);

	s->y = f(s->x);

	s->e = getexcept();

	return 0;

}

static int mpf2(struct t *s, float (*f)(float,float))

{

	s->dy = 0;

	setupfenv(s->r);

	s->y = f(s->x, s->x2);

	s->e = getexcept();

	return 0;

}

static int mpd1(struct t *s, double (*f)(double))

{

	s->dy = 0;

	setupfenv(s->r);

	s->y = f(s->x);

	s->e = getexcept();

//printf("%La %d\n", s->y, s->e);

	return 0;

}

static int mpd2(struct t *s, double (*f)(double, double))

{

	s->dy = 0;

	setupfenv(s->r);

	s->y = f(s->x, s->x2);

	s->e = getexcept();

	return 0;

}

static int mpl1(struct t *s, long double (*f)(long double))

{

	s->dy = 0;

	setupfenv(s->r);

	s->y = f(s->x);

	s->e = getexcept();

	return 0;

}

static int mpl2(struct t *s, long double (*f)(long double, long double))

{

	setupfenv(s->r);

	s->y = f(s->x, s->x2);

	s->dy = 0;

	s->e = getexcept();

	return 0;

}

int mpacos(struct t *t) { return mpd1(t, acos); }

int mpacosf(struct t *t) { return mpf1(t, acosf); }

int mpacosl(struct t *t) { return mpl1(t, acosl); }

int mpacosh(struct t *t) { return mpd1(t, acosh); }

int mpacoshf(struct t *t) { return mpf1(t, acoshf); }

int mpacoshl(struct t *t) { return mpl1(t, acoshl); }

int mpasin(struct t *t) { return mpd1(t, asin); }

int mpasinf(struct t *t) { return mpf1(t, asinf); }

int mpasinl(struct t *t) { return mpl1(t, asinl); }

int mpasinh(struct t *t) { return mpd1(t, asinh); }

int mpasinhf(struct t *t) { return mpf1(t, asinhf); }

int mpasinhl(struct t *t) { return mpl1(t, asinhl); }

int mpatan(struct t *t) { return mpd1(t, atan); }

int mpatanf(struct t *t) { return mpf1(t, atanf); }

int mpatanl(struct t *t) { return mpl1(t, atanl); }

int mpatan2(struct t *t) { return mpd2(t, atan2); }

int mpatan2f(struct t *t) { return mpf2(t, atan2f); }

int mpatan2l(struct t *t) { return mpl2(t, atan2l); }

int mpatanh(struct t *t) { return mpd1(t, atanh); }

int mpatanhf(struct t *t) { return mpf1(t, atanhf); }

int mpatanhl(struct t *t) { return mpl1(t, atanhl); }

int mpcbrt(struct t *t) { return mpd1(t, cbrt); }

int mpcbrtf(struct t *t) { return mpf1(t, cbrtf); }

int mpcbrtl(struct t *t) { return mpl1(t, cbrtl); }

int mpceil(struct t *t) { return mpd1(t, ceil); }

int mpceilf(struct t *t) { return mpf1(t, ceilf); }

int mpceill(struct t *t) { return mpl1(t, ceill); }

int mpcopysign(struct t *t) { return mpd2(t, copysign); }

int mpcopysignf(struct t *t) { return mpf2(t, copysignf); }

int mpcopysignl(struct t *t) { return mpl2(t, copysignl); }

int mpcos(struct t *t) { return mpd1(t, cos); }

int mpcosf(struct t *t) { return mpf1(t, cosf); }

int mpcosl(struct t *t) { return mpl1(t, cosl); }

int mpcosh(struct t *t) { return mpd1(t, cosh); }

int mpcoshf(struct t *t) { return mpf1(t, coshf); }

int mpcoshl(struct t *t) { return mpl1(t, coshl); }

int mperf(struct t *t) { return mpd1(t, erf); }

int mperff(struct t *t) { return mpf1(t, erff); }

int mperfl(struct t *t) { return mpl1(t, erfl); }

int mperfc(struct t *t) { return mpd1(t, erfc); }

int mperfcf(struct t *t) { return mpf1(t, erfcf); }

int mperfcl(struct t *t) { return mpl1(t, erfcl); }

int mpexp(struct t *t) { return mpd1(t, exp); }

int mpexpf(struct t *t) { return mpf1(t, expf); }

int mpexpl(struct t *t) { return mpl1(t, expl); }

int mpexp2(struct t *t) { return mpd1(t, exp2); }

int mpexp2f(struct t *t) { return mpf1(t, exp2f); }

int mpexp2l(struct t *t) { return mpl1(t, exp2l); }

int mpexpm1(struct t *t) { return mpd1(t, expm1); }

int mpexpm1f(struct t *t) { return mpf1(t, expm1f); }

int mpexpm1l(struct t *t) { return mpl1(t, expm1l); }

int mpfabs(struct t *t) { return mpd1(t, fabs); }

int mpfabsf(struct t *t) { return mpf1(t, fabsf); }

int mpfabsl(struct t *t) { return mpl1(t, fabsl); }

int mpfdim(struct t *t) { return mpd2(t, fdim); }

int mpfdimf(struct t *t) { return mpf2(t, fdimf); }

int mpfdiml(struct t *t) { return mpl2(t, fdiml); }

int mpfloor(struct t *t) { return mpd1(t, floor); }

int mpfloorf(struct t *t) { return mpf1(t, floorf); }

int mpfloorl(struct t *t) { return mpl1(t, floorl); }

int mpfmax(struct t *t) { return mpd2(t, fmax); }

int mpfmaxf(struct t *t) { return mpf2(t, fmaxf); }

int mpfmaxl(struct t *t) { return mpl2(t, fmaxl); }

int mpfmin(struct t *t) { return mpd2(t, fmin); }

int mpfminf(struct t *t) { return mpf2(t, fminf); }

int mpfminl(struct t *t) { return mpl2(t, fminl); }

int mpfmod(struct t *t) { return mpd2(t, fmod); }

int mpfmodf(struct t *t) { return mpf2(t, fmodf); }

int mpfmodl(struct t *t) { return mpl2(t, fmodl); }

int mphypot(struct t *t) { return mpd2(t, hypot); }

int mphypotf(struct t *t) { return mpf2(t, hypotf); }

int mphypotl(struct t *t) { return mpl2(t, hypotl); }

int mplog(struct t *t) { return mpd1(t, log); }

int mplogf(struct t *t) { return mpf1(t, logf); }

int mplogl(struct t *t) { return mpl1(t, logl); }

int mplog10(struct t *t) { return mpd1(t, log10); }

int mplog10f(struct t *t) { return mpf1(t, log10f); }

int mplog10l(struct t *t) { return mpl1(t, log10l); }

int mplog1p(struct t *t) { return mpd1(t, log1p); }

int mplog1pf(struct t *t) { return mpf1(t, log1pf); }

int mplog1pl(struct t *t) { return mpl1(t, log1pl); }

int mplog2(struct t *t) { return mpd1(t, log2); }

int mplog2f(struct t *t) { return mpf1(t, log2f); }

int mplog2l(struct t *t) { return mpl1(t, log2l); }

int mplogb(struct t *t) { return mpd1(t, logb); }

int mplogbf(struct t *t) { return mpf1(t, logbf); }

int mplogbl(struct t *t) { return mpl1(t, logbl); }

int mpnearbyint(struct t *t) { return mpd1(t, nearbyint); }

int mpnearbyintf(struct t *t) { return mpf1(t, nearbyintf); }

int mpnearbyintl(struct t *t) { return mpl1(t, nearbyintl); }

int mpnextafter(struct t *t) { return mpd2(t, nextafter); }

int mpnextafterf(struct t *t) { return mpf2(t, nextafterf); }

int mpnextafterl(struct t *t) { return mpl2(t, nextafterl); }

int mpnexttowardl(struct t *t) { return mpl2(t, nexttowardl); }

int mppow(struct t *t) { return mpd2(t, pow); }

int mppowf(struct t *t) { return mpf2(t, powf); }

int mppowl(struct t *t) { return mpl2(t, powl); }

int mpremainder(struct t *t) { return mpd2(t, remainder); }

int mpremainderf(struct t *t) { return mpf2(t, remainderf); }

int mpremainderl(struct t *t) { return mpl2(t, remainderl); }

int mprint(struct t *t) { return mpd1(t, rint); }

int mprintf(struct t *t) { return mpf1(t, rintf); }

int mprintl(struct t *t) { return mpl1(t, rintl); }

int mpround(struct t *t) { return mpd1(t, round); }

int mproundf(struct t *t) { return mpf1(t, roundf); }

int mproundl(struct t *t) { return mpl1(t, roundl); }

int mpsin(struct t *t) { return mpd1(t, sin); }

int mpsinf(struct t *t) { return mpf1(t, sinf); }

int mpsinl(struct t *t) { return mpl1(t, sinl); }

int mpsinh(struct t *t) { return mpd1(t, sinh); }

int mpsinhf(struct t *t) { return mpf1(t, sinhf); }

int mpsinhl(struct t *t) { return mpl1(t, sinhl); }

int mpsqrt(struct t *t) { return mpd1(t, sqrt); }

int mpsqrtf(struct t *t) { return mpf1(t, sqrtf); }

int mpsqrtl(struct t *t) { return mpl1(t, sqrtl); }

int mptan(struct t *t) { return mpd1(t, tan); }

int mptanf(struct t *t) { return mpf1(t, tanf); }

int mptanl(struct t *t) { return mpl1(t, tanl); }

int mptanh(struct t *t) { return mpd1(t, tanh); }

int mptanhf(struct t *t) { return mpf1(t, tanhf); }

int mptanhl(struct t *t) { return mpl1(t, tanhl); }

int mptgamma(struct t *t) { return mpd1(t, tgamma); }

int mptgammaf(struct t *t) { return mpf1(t, tgammaf); }

int mptgammal(struct t *t) { return mpl1(t, tgammal); }

int mptrunc(struct t *t) { return mpd1(t, trunc); }

int mptruncf(struct t *t) { return mpf1(t, truncf); }

int mptruncl(struct t *t) { return mpl1(t, truncl); }

int mpj0(struct t *t) { return mpd1(t, j0); }

int mpj1(struct t *t) { return mpd1(t, j1); }

int mpy0(struct t *t) { return mpd1(t, y0); }

int mpy1(struct t *t) { return mpd1(t, y1); }

int mpscalb(struct t *t) { return mpd2(t, scalb); }

int mpscalbf(struct t *t) { return mpf2(t, scalbf); }

int mpj0f(struct t *t) { return mpf1(t, j0f); }

int mpj0l(struct t *t) { return -1;}//mpl1(t, j0l); }

int mpj1f(struct t *t) { return mpf1(t, j1f); }

int mpj1l(struct t *t) { return -1;}//mpl1(t, j1l); }

int mpy0f(struct t *t) { return mpf1(t, y0f); }

int mpy0l(struct t *t) { return -1;}//mpl1(t, y0l); }

int mpy1f(struct t *t) { return mpf1(t, y1f); }

int mpy1l(struct t *t) { return -1;}//mpl1(t, y1l); }

int mpexp10(struct t *t) { return mpd1(t, exp10); }

int mpexp10f(struct t *t) { return mpf1(t, exp10f); }

int mpexp10l(struct t *t) { return mpl1(t, exp10l); }

int mppow10(struct t *t) { return mpd1(t, pow10); }

int mppow10f(struct t *t) { return mpf1(t, pow10f); }

int mppow10l(struct t *t) { return mpl1(t, pow10l); }

int mpfrexp(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = frexp(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}

int mpfrexpf(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = frexpf(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}

int mpfrexpl(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = frexpl(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}

int mpldexp(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = ldexp(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpldexpf(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = ldexpf(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpldexpl(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = ldexpl(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalbn(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalbn(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalbnf(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalbnf(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalbnl(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalbnl(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalbln(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalbln(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalblnf(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalblnf(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mpscalblnl(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = scalblnl(t->x, t->i);

	t->e = getexcept();

	return 0;

}

int mplgamma(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgamma(t->x);

	t->e = getexcept();

	t->i = signgam;

	return 0;

}

int mplgammaf(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgammaf(t->x);

	t->e = getexcept();

	t->i = signgam;

	return 0;

}

int mplgammal(struct t *t)

{

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgammal(t->x);

	t->e = getexcept();

	t->i = signgam;

	return 0;

}

int mplgamma_r(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgamma_r(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}

int mplgammaf_r(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgammaf_r(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}

int mplgammal_r(struct t *t)

{

	int i;

	t->dy = 0;

	setupfenv(t->r);

	t->y = lgammal_r(t->x, &i);

	t->e = getexcept();

	t->i = i;

	return 0;

}