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