#include #include #include #include #include char *name = "jeff quadratic root 1"; double f_if(float a, float b, float c) { float r20092 = b; float r20093 = 0; bool r20094 = r20092 >= r20093; float r20095 = -r20092; float r20096 = r20092 * r20092; float r20097 = 4; float r20098 = a; float r20099 = r20097 * r20098; float r20100 = c; float r20101 = r20099 * r20100; float r20102 = r20096 - r20101; float r20103 = sqrt(r20102); float r20104 = r20095 - r20103; float r20105 = 2; float r20106 = r20105 * r20098; float r20107 = r20104 / r20106; float r20108 = r20105 * r20100; float r20109 = r20095 + r20103; float r20110 = r20108 / r20109; float r20111 = r20094 ? r20107 : r20110; return r20111; } double f_id(double a, double b, double c) { double r20112 = b; double r20113 = 0; bool r20114 = r20112 >= r20113; double r20115 = -r20112; double r20116 = r20112 * r20112; double r20117 = 4; double r20118 = a; double r20119 = r20117 * r20118; double r20120 = c; double r20121 = r20119 * r20120; double r20122 = r20116 - r20121; double r20123 = sqrt(r20122); double r20124 = r20115 - r20123; double r20125 = 2; double r20126 = r20125 * r20118; double r20127 = r20124 / r20126; double r20128 = r20125 * r20120; double r20129 = r20115 + r20123; double r20130 = r20128 / r20129; double r20131 = r20114 ? r20127 : r20130; return r20131; } double f_of(float a, float b, float c) { float r20132 = b; float r20133 = -1.0544208354676505e+66; bool r20134 = r20132 <= r20133; float r20135 = 0; bool r20136 = r20132 >= r20135; float r20137 = -r20132; float r20138 = r20132 * r20132; float r20139 = c; float r20140 = a; float r20141 = 4; float r20142 = r20140 * r20141; float r20143 = r20139 * r20142; float r20144 = r20138 - r20143; float r20145 = sqrt(r20144); float r20146 = r20137 - r20145; float r20147 = r20140 + r20140; float r20148 = r20146 / r20147; float r20149 = r20140 / r20132; float r20150 = r20149 * r20139; float r20151 = r20150 - r20132; float r20152 = r20139 / r20151; float r20153 = r20136 ? r20148 : r20152; float r20154 = 4.6725193171305676e+91; bool r20155 = r20132 <= r20154; float r20156 = r20141 * r20140; float r20157 = r20156 * r20139; float r20158 = r20138 - r20157; float r20159 = sqrt(r20158); float r20160 = r20137 - r20159; float r20161 = 2; float r20162 = r20161 * r20140; float r20163 = r20160 / r20162; float r20164 = r20161 * r20139; float r20165 = r20141 * r20139; float r20166 = r20140 * r20165; float r20167 = r20138 - r20166; float r20168 = cbrt(r20167); float r20169 = fabs(r20168); float r20170 = cbrt(r20158); float r20171 = sqrt(r20170); float r20172 = r20169 * r20171; float r20173 = r20137 + r20172; float r20174 = r20164 / r20173; float r20175 = r20136 ? r20163 : r20174; float r20176 = r20139 / r20132; float r20177 = r20132 / r20140; float r20178 = r20176 - r20177; float r20179 = r20139 + r20139; float r20180 = r20145 + r20137; float r20181 = r20179 / r20180; float r20182 = r20136 ? r20178 : r20181; float r20183 = r20155 ? r20175 : r20182; float r20184 = r20134 ? r20153 : r20183; return r20184; } double f_od(double a, double b, double c) { double r20185 = b; double r20186 = -1.0544208354676505e+66; bool r20187 = r20185 <= r20186; double r20188 = 0; bool r20189 = r20185 >= r20188; double r20190 = -r20185; double r20191 = r20185 * r20185; double r20192 = c; double r20193 = a; double r20194 = 4; double r20195 = r20193 * r20194; double r20196 = r20192 * r20195; double r20197 = r20191 - r20196; double r20198 = sqrt(r20197); double r20199 = r20190 - r20198; double r20200 = r20193 + r20193; double r20201 = r20199 / r20200; double r20202 = r20193 / r20185; double r20203 = r20202 * r20192; double r20204 = r20203 - r20185; double r20205 = r20192 / r20204; double r20206 = r20189 ? r20201 : r20205; double r20207 = 4.6725193171305676e+91; bool r20208 = r20185 <= r20207; double r20209 = r20194 * r20193; double r20210 = r20209 * r20192; double r20211 = r20191 - r20210; double r20212 = sqrt(r20211); double r20213 = r20190 - r20212; double r20214 = 2; double r20215 = r20214 * r20193; double r20216 = r20213 / r20215; double r20217 = r20214 * r20192; double r20218 = r20194 * r20192; double r20219 = r20193 * r20218; double r20220 = r20191 - r20219; double r20221 = cbrt(r20220); double r20222 = fabs(r20221); double r20223 = cbrt(r20211); double r20224 = sqrt(r20223); double r20225 = r20222 * r20224; double r20226 = r20190 + r20225; double r20227 = r20217 / r20226; double r20228 = r20189 ? r20216 : r20227; double r20229 = r20192 / r20185; double r20230 = r20185 / r20193; double r20231 = r20229 - r20230; double r20232 = r20192 + r20192; double r20233 = r20198 + r20190; double r20234 = r20232 / r20233; double r20235 = r20189 ? r20231 : r20234; double r20236 = r20208 ? r20228 : r20235; double r20237 = r20187 ? r20206 : r20236; return r20237; } 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 r20238, r20239, r20240, r20241, r20242, r20243, r20244, r20245, r20246, r20247, r20248, r20249, r20250, r20251, r20252, r20253, r20254, r20255, r20256, r20257; void setup_mpfr_f_im() { mpfr_set_default_prec(400); mpfr_init(r20238); mpfr_init_set_str(r20239, "0", 10, MPFR_RNDN); mpfr_init(r20240); mpfr_init(r20241); mpfr_init(r20242); mpfr_init_set_str(r20243, "4", 10, MPFR_RNDN); mpfr_init(r20244); mpfr_init(r20245); mpfr_init(r20246); mpfr_init(r20247); mpfr_init(r20248); mpfr_init(r20249); mpfr_init(r20250); mpfr_init_set_str(r20251, "2", 10, MPFR_RNDN); mpfr_init(r20252); mpfr_init(r20253); mpfr_init(r20254); mpfr_init(r20255); mpfr_init(r20256); mpfr_init(r20257); } double f_im(double a, double b, double c) { mpfr_set_d(r20238, b, MPFR_RNDN); ; mpfr_set_si(r20240, mpfr_cmp(r20238, r20239) >= 0, MPFR_RNDN); mpfr_neg(r20241, r20238, MPFR_RNDN); mpfr_mul(r20242, r20238, r20238, MPFR_RNDN); ; mpfr_set_d(r20244, a, MPFR_RNDN); mpfr_mul(r20245, r20243, r20244, MPFR_RNDN); mpfr_set_d(r20246, c, MPFR_RNDN); mpfr_mul(r20247, r20245, r20246, MPFR_RNDN); mpfr_sub(r20248, r20242, r20247, MPFR_RNDN); mpfr_sqrt(r20249, r20248, MPFR_RNDN); mpfr_sub(r20250, r20241, r20249, MPFR_RNDN); ; mpfr_mul(r20252, r20251, r20244, MPFR_RNDN); mpfr_div(r20253, r20250, r20252, MPFR_RNDN); mpfr_mul(r20254, r20251, r20246, MPFR_RNDN); mpfr_add(r20255, r20241, r20249, MPFR_RNDN); mpfr_div(r20256, r20254, r20255, MPFR_RNDN); if (mpfr_get_si(r20240, MPFR_RNDN)) { mpfr_set(r20257, r20253, MPFR_RNDN); } else { mpfr_set(r20257, r20256, MPFR_RNDN); }; return mpfr_get_d(r20257, MPFR_RNDN); } static mpfr_t r20258, r20259, r20260, r20261, r20262, r20263, r20264, r20265, r20266, r20267, r20268, r20269, r20270, r20271, r20272, r20273, r20274, r20275, r20276, r20277, r20278, r20279, r20280, r20281, r20282, r20283, r20284, r20285, r20286, r20287, r20288, r20289, r20290, r20291, r20292, r20293, r20294, r20295, r20296, r20297, r20298, r20299, r20300, r20301, r20302, r20303, r20304, r20305, r20306, r20307, r20308, r20309, r20310; void setup_mpfr_f_fm() { mpfr_set_default_prec(400); mpfr_init(r20258); mpfr_init_set_str(r20259, "-1.0544208354676505e+66", 10, MPFR_RNDN); mpfr_init(r20260); mpfr_init_set_str(r20261, "0", 10, MPFR_RNDN); mpfr_init(r20262); mpfr_init(r20263); mpfr_init(r20264); mpfr_init(r20265); mpfr_init(r20266); mpfr_init_set_str(r20267, "4", 10, MPFR_RNDN); mpfr_init(r20268); mpfr_init(r20269); mpfr_init(r20270); mpfr_init(r20271); mpfr_init(r20272); mpfr_init(r20273); mpfr_init(r20274); mpfr_init(r20275); mpfr_init(r20276); mpfr_init(r20277); mpfr_init(r20278); mpfr_init(r20279); mpfr_init_set_str(r20280, "4.6725193171305676e+91", 10, MPFR_RNDN); mpfr_init(r20281); mpfr_init(r20282); mpfr_init(r20283); mpfr_init(r20284); mpfr_init(r20285); mpfr_init(r20286); mpfr_init_set_str(r20287, "2", 10, MPFR_RNDN); mpfr_init(r20288); mpfr_init(r20289); mpfr_init(r20290); mpfr_init(r20291); mpfr_init(r20292); mpfr_init(r20293); mpfr_init(r20294); mpfr_init(r20295); mpfr_init(r20296); mpfr_init(r20297); mpfr_init(r20298); mpfr_init(r20299); mpfr_init(r20300); mpfr_init(r20301); mpfr_init(r20302); mpfr_init(r20303); mpfr_init(r20304); mpfr_init(r20305); mpfr_init(r20306); mpfr_init(r20307); mpfr_init(r20308); mpfr_init(r20309); mpfr_init(r20310); } double f_fm(double a, double b, double c) { mpfr_set_d(r20258, b, MPFR_RNDN); ; mpfr_set_si(r20260, mpfr_cmp(r20258, r20259) <= 0, MPFR_RNDN); ; mpfr_set_si(r20262, mpfr_cmp(r20258, r20261) >= 0, MPFR_RNDN); mpfr_neg(r20263, r20258, MPFR_RNDN); mpfr_mul(r20264, r20258, r20258, MPFR_RNDN); mpfr_set_d(r20265, c, MPFR_RNDN); mpfr_set_d(r20266, a, MPFR_RNDN); ; mpfr_mul(r20268, r20266, r20267, MPFR_RNDN); mpfr_mul(r20269, r20265, r20268, MPFR_RNDN); mpfr_sub(r20270, r20264, r20269, MPFR_RNDN); mpfr_sqrt(r20271, r20270, MPFR_RNDN); mpfr_sub(r20272, r20263, r20271, MPFR_RNDN); mpfr_add(r20273, r20266, r20266, MPFR_RNDN); mpfr_div(r20274, r20272, r20273, MPFR_RNDN); mpfr_div(r20275, r20266, r20258, MPFR_RNDN); mpfr_mul(r20276, r20275, r20265, MPFR_RNDN); mpfr_sub(r20277, r20276, r20258, MPFR_RNDN); mpfr_div(r20278, r20265, r20277, MPFR_RNDN); if (mpfr_get_si(r20262, MPFR_RNDN)) { mpfr_set(r20279, r20274, MPFR_RNDN); } else { mpfr_set(r20279, r20278, MPFR_RNDN); }; ; mpfr_set_si(r20281, mpfr_cmp(r20258, r20280) <= 0, MPFR_RNDN); mpfr_mul(r20282, r20267, r20266, MPFR_RNDN); mpfr_mul(r20283, r20282, r20265, MPFR_RNDN); mpfr_sub(r20284, r20264, r20283, MPFR_RNDN); mpfr_sqrt(r20285, r20284, MPFR_RNDN); mpfr_sub(r20286, r20263, r20285, MPFR_RNDN); ; mpfr_mul(r20288, r20287, r20266, MPFR_RNDN); mpfr_div(r20289, r20286, r20288, MPFR_RNDN); mpfr_mul(r20290, r20287, r20265, MPFR_RNDN); mpfr_mul(r20291, r20267, r20265, MPFR_RNDN); mpfr_mul(r20292, r20266, r20291, MPFR_RNDN); mpfr_sub(r20293, r20264, r20292, MPFR_RNDN); mpfr_cbrt(r20294, r20293, MPFR_RNDN); mpfr_abs(r20295, r20294, MPFR_RNDN); mpfr_cbrt(r20296, r20284, MPFR_RNDN); mpfr_sqrt(r20297, r20296, MPFR_RNDN); mpfr_mul(r20298, r20295, r20297, MPFR_RNDN); mpfr_add(r20299, r20263, r20298, MPFR_RNDN); mpfr_div(r20300, r20290, r20299, MPFR_RNDN); if (mpfr_get_si(r20262, MPFR_RNDN)) { mpfr_set(r20301, r20289, MPFR_RNDN); } else { mpfr_set(r20301, r20300, MPFR_RNDN); }; mpfr_div(r20302, r20265, r20258, MPFR_RNDN); mpfr_div(r20303, r20258, r20266, MPFR_RNDN); mpfr_sub(r20304, r20302, r20303, MPFR_RNDN); mpfr_add(r20305, r20265, r20265, MPFR_RNDN); mpfr_add(r20306, r20271, r20263, MPFR_RNDN); mpfr_div(r20307, r20305, r20306, MPFR_RNDN); if (mpfr_get_si(r20262, MPFR_RNDN)) { mpfr_set(r20308, r20304, MPFR_RNDN); } else { mpfr_set(r20308, r20307, MPFR_RNDN); }; if (mpfr_get_si(r20281, MPFR_RNDN)) { mpfr_set(r20309, r20301, MPFR_RNDN); } else { mpfr_set(r20309, r20308, MPFR_RNDN); }; if (mpfr_get_si(r20260, MPFR_RNDN)) { mpfr_set(r20310, r20279, MPFR_RNDN); } else { mpfr_set(r20310, r20309, MPFR_RNDN); }; return mpfr_get_d(r20310, MPFR_RNDN); } static mpfr_t r20311, r20312, r20313, r20314, r20315, r20316, r20317, r20318, r20319, r20320, r20321, r20322, r20323, r20324, r20325, r20326, r20327, r20328, r20329, r20330, r20331, r20332, r20333, r20334, r20335, r20336, r20337, r20338, r20339, r20340, r20341, r20342, r20343, r20344, r20345, r20346, r20347, r20348, r20349, r20350, r20351, r20352, r20353, r20354, r20355, r20356, r20357, r20358, r20359, r20360, r20361, r20362, r20363; void setup_mpfr_f_dm() { mpfr_set_default_prec(400); mpfr_init(r20311); mpfr_init_set_str(r20312, "-1.0544208354676505e+66", 10, MPFR_RNDN); mpfr_init(r20313); mpfr_init_set_str(r20314, "0", 10, MPFR_RNDN); mpfr_init(r20315); mpfr_init(r20316); mpfr_init(r20317); mpfr_init(r20318); mpfr_init(r20319); mpfr_init_set_str(r20320, "4", 10, MPFR_RNDN); mpfr_init(r20321); mpfr_init(r20322); mpfr_init(r20323); mpfr_init(r20324); mpfr_init(r20325); mpfr_init(r20326); mpfr_init(r20327); mpfr_init(r20328); mpfr_init(r20329); mpfr_init(r20330); mpfr_init(r20331); mpfr_init(r20332); mpfr_init_set_str(r20333, "4.6725193171305676e+91", 10, MPFR_RNDN); mpfr_init(r20334); mpfr_init(r20335); mpfr_init(r20336); mpfr_init(r20337); mpfr_init(r20338); mpfr_init(r20339); mpfr_init_set_str(r20340, "2", 10, MPFR_RNDN); mpfr_init(r20341); mpfr_init(r20342); mpfr_init(r20343); mpfr_init(r20344); mpfr_init(r20345); mpfr_init(r20346); mpfr_init(r20347); mpfr_init(r20348); mpfr_init(r20349); mpfr_init(r20350); mpfr_init(r20351); mpfr_init(r20352); mpfr_init(r20353); mpfr_init(r20354); mpfr_init(r20355); mpfr_init(r20356); mpfr_init(r20357); mpfr_init(r20358); mpfr_init(r20359); mpfr_init(r20360); mpfr_init(r20361); mpfr_init(r20362); mpfr_init(r20363); } double f_dm(double a, double b, double c) { mpfr_set_d(r20311, b, MPFR_RNDN); ; mpfr_set_si(r20313, mpfr_cmp(r20311, r20312) <= 0, MPFR_RNDN); ; mpfr_set_si(r20315, mpfr_cmp(r20311, r20314) >= 0, MPFR_RNDN); mpfr_neg(r20316, r20311, MPFR_RNDN); mpfr_mul(r20317, r20311, r20311, MPFR_RNDN); mpfr_set_d(r20318, c, MPFR_RNDN); mpfr_set_d(r20319, a, MPFR_RNDN); ; mpfr_mul(r20321, r20319, r20320, MPFR_RNDN); mpfr_mul(r20322, r20318, r20321, MPFR_RNDN); mpfr_sub(r20323, r20317, r20322, MPFR_RNDN); mpfr_sqrt(r20324, r20323, MPFR_RNDN); mpfr_sub(r20325, r20316, r20324, MPFR_RNDN); mpfr_add(r20326, r20319, r20319, MPFR_RNDN); mpfr_div(r20327, r20325, r20326, MPFR_RNDN); mpfr_div(r20328, r20319, r20311, MPFR_RNDN); mpfr_mul(r20329, r20328, r20318, MPFR_RNDN); mpfr_sub(r20330, r20329, r20311, MPFR_RNDN); mpfr_div(r20331, r20318, r20330, MPFR_RNDN); if (mpfr_get_si(r20315, MPFR_RNDN)) { mpfr_set(r20332, r20327, MPFR_RNDN); } else { mpfr_set(r20332, r20331, MPFR_RNDN); }; ; mpfr_set_si(r20334, mpfr_cmp(r20311, r20333) <= 0, MPFR_RNDN); mpfr_mul(r20335, r20320, r20319, MPFR_RNDN); mpfr_mul(r20336, r20335, r20318, MPFR_RNDN); mpfr_sub(r20337, r20317, r20336, MPFR_RNDN); mpfr_sqrt(r20338, r20337, MPFR_RNDN); mpfr_sub(r20339, r20316, r20338, MPFR_RNDN); ; mpfr_mul(r20341, r20340, r20319, MPFR_RNDN); mpfr_div(r20342, r20339, r20341, MPFR_RNDN); mpfr_mul(r20343, r20340, r20318, MPFR_RNDN); mpfr_mul(r20344, r20320, r20318, MPFR_RNDN); mpfr_mul(r20345, r20319, r20344, MPFR_RNDN); mpfr_sub(r20346, r20317, r20345, MPFR_RNDN); mpfr_cbrt(r20347, r20346, MPFR_RNDN); mpfr_abs(r20348, r20347, MPFR_RNDN); mpfr_cbrt(r20349, r20337, MPFR_RNDN); mpfr_sqrt(r20350, r20349, MPFR_RNDN); mpfr_mul(r20351, r20348, r20350, MPFR_RNDN); mpfr_add(r20352, r20316, r20351, MPFR_RNDN); mpfr_div(r20353, r20343, r20352, MPFR_RNDN); if (mpfr_get_si(r20315, MPFR_RNDN)) { mpfr_set(r20354, r20342, MPFR_RNDN); } else { mpfr_set(r20354, r20353, MPFR_RNDN); }; mpfr_div(r20355, r20318, r20311, MPFR_RNDN); mpfr_div(r20356, r20311, r20319, MPFR_RNDN); mpfr_sub(r20357, r20355, r20356, MPFR_RNDN); mpfr_add(r20358, r20318, r20318, MPFR_RNDN); mpfr_add(r20359, r20324, r20316, MPFR_RNDN); mpfr_div(r20360, r20358, r20359, MPFR_RNDN); if (mpfr_get_si(r20315, MPFR_RNDN)) { mpfr_set(r20361, r20357, MPFR_RNDN); } else { mpfr_set(r20361, r20360, MPFR_RNDN); }; if (mpfr_get_si(r20334, MPFR_RNDN)) { mpfr_set(r20362, r20354, MPFR_RNDN); } else { mpfr_set(r20362, r20361, MPFR_RNDN); }; if (mpfr_get_si(r20313, MPFR_RNDN)) { mpfr_set(r20363, r20332, MPFR_RNDN); } else { mpfr_set(r20363, r20362, MPFR_RNDN); }; return mpfr_get_d(r20363, MPFR_RNDN); }