heston core code

gistfile1.txt

fun {i32} num_bits_698f() = {
  {8i32}
}

fun {i32} num_bits_864f() = {
  {16i32}
}

fun {i32} num_bits_1034f() = {
  {32i32}
}

fun {i32} num_bits_1204f() = {
  {64i32}
}

fun {i32} num_bits_1374f() = {
  {8i32}
}

fun {i32} num_bits_1544f() = {
  {16i32}
}

fun {i32} num_bits_1714f() = {
  {32i32}
}

fun {i32} num_bits_1884f() = {
  {64i32}
}

fun {i32} num_bits_2070f() = {
  {64i32}
}

fun {f64} /_15594(f64 x_66298, f64 y_66299) = {
  let {f64 res_66300} = fdiv64(x_66298, y_66299)
  in {res_66300}
}

fun {f64} inf_2082f() = {
  let {f64 res_66301} = /_15594(1.0f64, 0.0f64)
  in {res_66301}
}

fun {f64} nan_2083f() = {
  let {f64 res_66302} = /_15594(0.0f64, 0.0f64)
  in {res_66302}
}

fun {f64} pi_2084f() = {
  {3.141592653589793f64}
}

fun {f64} e_2085f() = {
  {2.718281828459045f64}
}

fun {i32} num_bits_2267f() = {
  {32i32}
}

fun {f32} /_15600(f32 x_66303, f32 y_66304) = {
  let {f32 res_66305} = fdiv32(x_66303, y_66304)
  in {res_66305}
}

fun {f32} inf_2279f() = {
  let {f32 res_66306} = /_15600(1.0f32, 0.0f32)
  in {res_66306}
}

fun {f32} nan_2280f() = {
  let {f32 res_66307} = /_15600(0.0f32, 0.0f32)
  in {res_66307}
}

fun {f32} f64_15606(f64 x_66308) = {
  let {f32 res_66309} = fpconv f64 x_66308 to f32
  in {res_66309}
}

fun {f32} pi_2281f() = {
  let {f64 pi_66310} = pi_2084f()
  let {f32 res_66311} = f64_15606(pi_66310)
  in {res_66311}
}

fun {f32} e_2282f() = {
  let {f64 pi_66312} = pi_2084f()
  let {f32 res_66313} = f64_15606(pi_66312)
  in {res_66313}
}

fun {} reduce_6963f() = {
  {}
}

fun {i32} a_3486f() = {
  {48271i32}
}

fun {i32} c_3487f() = {
  {0i32}
}

fun {i32} m_3488f() = {
  {2147483647i32}
}

fun {} reduce_6968f() = {
  {}
}

fun {i32} unsign_15615(i32 x_66314) = {
  let {i32 res_66315} = zext i32 x_66314 to i32
  in {res_66315}
}

fun {i32} i32_15612(i32 x_66316) = {
  let {i32 arg_66317} = zext i32 x_66316 to i32
  let {i32 res_66318} = unsign_15615(arg_66317)
  in {res_66318}
}

fun {i32} min_6767f() = {
  let {i32 res_66319} = i32_15612(0i32)
  in {res_66319}
}

fun {i32} max_6768f() = {
  let {i32 m_66320} = m_3488f()
  in {m_66320}
}

fun {i32} a_3590f() = {
  {16807i32}
}

fun {i32} c_3591f() = {
  {0i32}
}

fun {i32} m_3592f() = {
  {2147483647i32}
}

fun {i32} min_6776f() = {
  let {i32 res_66321} = i32_15612(0i32)
  in {res_66321}
}

fun {i32} max_6777f() = {
  let {i32 m_66322} = m_3592f()
  in {m_66322}
}

fun {i32} w_3694f() = {
  {24i32}
}

fun {i32} s_3695f() = {
  {10i32}
}

fun {i32} r_3696f() = {
  {24i32}
}

fun {i32} long_lag_6778f() = {
  let {i32 r_66323} = r_3696f()
  in {r_66323}
}

fun {i32} word_size_6779f() = {
  let {i32 w_66324} = w_3694f()
  in {w_66324}
}

fun {i32} short_lag_6780f() = {
  let {i32 s_66325} = s_3695f()
  in {s_66325}
}

fun {i32} modulus_6781f() = {
  let {i32 word_size_66326} = word_size_6779f()
  let {i32 arg_66327} = shl32(1i32, word_size_66326)
  let {i32 res_66328} = i32_15612(arg_66327)
  in {res_66328}
}

fun {i32} u32_15631(i32 x_66329) = {
  let {i32 x_66330} = zext i32 x_66329 to i32
  let {i32 res_66331} = zext i32 x_66330 to i32
  in {res_66331}
}

fun {i32} u32_15629(i32 x_66332) = {
  let {i32 arg_66333} = u32_15631(x_66332)
  let {i32 res_66334} = unsign_15615(arg_66333)
  in {res_66334}
}

fun {i32} a_6783f() = {
  let {i32 res_66335} = u32_15629(40014i32)
  in {res_66335}
}

fun {i32} c_6784f() = {
  let {i32 res_66336} = u32_15629(0i32)
  in {res_66336}
}

fun {i32} m_6785f() = {
  let {i32 res_66337} = u32_15629(2147483563i32)
  in {res_66337}
}

fun {i32} min_6793f() = {
  let {i32 res_66338} = i32_15612(0i32)
  in {res_66338}
}

fun {i32} max_6794f() = {
  let {i32 m_66339} = m_6785f()
  in {m_66339}
}

fun {i32} min_6802f() = {
  let {i32 res_66340} = i32_15612(0i32)
  in {res_66340}
}

fun {i32} sign_15648(i32 x_66341) = {
  let {i32 res_66342} = zext i32 x_66341 to i32
  in {res_66342}
}

fun {i32} -_15646(i32 x_66343, i32 y_66344) = {
  let {i32 x_66345} = sign_15648(x_66343)
  let {i32 y_66346} = sign_15648(y_66344)
  let {i32 arg_66347} = sub32(x_66345, y_66346)
  let {i32 res_66348} = unsign_15615(arg_66347)
  in {res_66348}
}

fun {i32} max_6803f() = {
  let {i32 modulus_66349} = modulus_6781f()
  let {i32 arg_66350} = i32_15612(1i32)
  let {i32 res_66351} = -_15646(modulus_66349, arg_66350)
  in {res_66351}
}

fun {i32} w_3798f() = {
  {48i32}
}

fun {i32} s_3799f() = {
  {5i32}
}

fun {i32} r_3800f() = {
  {12i32}
}

fun {i32} long_lag_6804f() = {
  let {i32 r_66352} = r_3800f()
  in {r_66352}
}

fun {i32} word_size_6805f() = {
  let {i32 w_66353} = w_3798f()
  in {w_66353}
}

fun {i32} short_lag_6806f() = {
  let {i32 s_66354} = s_3799f()
  in {s_66354}
}

fun {i64} unsign_15664(i64 x_66355) = {
  let {i64 res_66356} = zext i64 x_66355 to i64
  in {res_66356}
}

fun {i64} i32_15661(i32 x_66357) = {
  let {i64 arg_66358} = zext i32 x_66357 to i64
  let {i64 res_66359} = unsign_15664(arg_66358)
  in {res_66359}
}

fun {i64} modulus_6807f() = {
  let {i32 word_size_66360} = word_size_6805f()
  let {i32 arg_66361} = shl32(1i32, word_size_66360)
  let {i64 res_66362} = i32_15661(arg_66361)
  in {res_66362}
}

fun {i64} u32_15671(i32 x_66363) = {
  let {i32 x_66364} = zext i32 x_66363 to i32
  let {i64 res_66365} = zext i32 x_66364 to i64
  in {res_66365}
}

fun {i64} u32_15669(i32 x_66366) = {
  let {i64 arg_66367} = u32_15671(x_66366)
  let {i64 res_66368} = unsign_15664(arg_66367)
  in {res_66368}
}

fun {i64} a_6809f() = {
  let {i64 res_66369} = u32_15669(40014i32)
  in {res_66369}
}

fun {i64} c_6810f() = {
  let {i64 res_66370} = u32_15669(0i32)
  in {res_66370}
}

fun {i64} m_6811f() = {
  let {i64 res_66371} = u32_15669(2147483563i32)
  in {res_66371}
}

fun {} reduce_6981f() = {
  {}
}

fun {i64} min_6819f() = {
  let {i64 res_66372} = i32_15661(0i32)
  in {res_66372}
}

fun {i64} max_6820f() = {
  let {i64 m_66373} = m_6811f()
  in {m_66373}
}

fun {i64} min_6828f() = {
  let {i64 res_66374} = i32_15661(0i32)
  in {res_66374}
}

fun {i64} sign_15688(i64 x_66375) = {
  let {i64 res_66376} = zext i64 x_66375 to i64
  in {res_66376}
}

fun {i64} -_15686(i64 x_66377, i64 y_66378) = {
  let {i64 x_66379} = sign_15688(x_66377)
  let {i64 y_66380} = sign_15688(y_66378)
  let {i64 arg_66381} = sub64(x_66379, y_66380)
  let {i64 res_66382} = unsign_15664(arg_66381)
  in {res_66382}
}

fun {i64} max_6829f() = {
  let {i64 modulus_66383} = modulus_6807f()
  let {i64 arg_66384} = i32_15661(1i32)
  let {i64 res_66385} = -_15686(modulus_66383, arg_66384)
  in {res_66385}
}

fun {i32} p_3902f() = {
  {223i32}
}

fun {i32} r_3903f() = {
  {23i32}
}

fun {i32} min_6833f() = {
  let {i32 min_66386} = min_6802f()
  in {min_66386}
}

fun {i32} max_6834f() = {
  let {i32 max_66387} = max_6803f()
  in {max_66387}
}

fun {} reduce_6990f() = {
  {}
}

fun {i32} p_4005f() = {
  {389i32}
}

fun {i32} r_4006f() = {
  {11i32}
}

fun {i64} min_6842f() = {
  let {i64 min_66388} = min_6828f()
  in {min_66388}
}

fun {i64} max_6843f() = {
  let {i64 max_66389} = max_6829f()
  in {max_66389}
}

fun {i32} k_4108f() = {
  {256i32}
}

fun {i32} min_6856f() = {
  let {i32 min_66390} = min_6776f()
  in {min_66390}
}

fun {i32} max_6857f() = {
  let {i32 max_66391} = max_6777f()
  in {max_66391}
}

fun {} reduce_6991f() = {
  {}
}

fun {i64} min_4269f() = {
  {0i64}
}

fun {i64} mask_15702(i64 x_66392) = {
  let {i64 complement_arg_66393} = shl64(1i64, 63i64)
  let {i64 y_66394} = complement64 complement_arg_66393
  let {i64 res_66395} = and64(x_66392, y_66394)
  in {res_66395}
}

fun {i64} max_4270f() = {
  let {i64 res_66396} = mask_15702(-1i64)
  in {res_66396}
}

fun {} reduce_6992f() = {
  {}
}

fun {i32} min_4378f() = {
  {0i32}
}

fun {i32} max_4379f() = {
  {-1i32}
}

fun {i32} hours_in_day_5056f() = {
  {24i32}
}

fun {i32} minutes_in_day_5057f() = {
  let {i32 hours_in_day_66397} = hours_in_day_5056f()
  let {i32 res_66398} = mul32(hours_in_day_66397, 60i32)
  in {res_66398}
}

fun {f64} i32_15713(i32 x_66399) = {
  let {f64 res_66400} = sitofp i32 x_66399 to f64
  in {res_66400}
}

fun {f64} r64_15711(i32 x_66401) = {
  let {f64 res_66402} = i32_15713(x_66401)
  in {res_66402}
}

fun {f64} fminutes_in_day_5059f() = {
  let {i32 minutes_in_day_66403} = minutes_in_day_5057f()
  let {f64 res_66404} = r64_15711(minutes_in_day_66403)
  in {res_66404}
}

fun {i32} minutes_to_noon_5060f() = {
  let {i32 hours_in_day_66405} = hours_in_day_5056f()
  let {i32 x_66406} = sdiv32(hours_in_day_66405, 2i32)
  let {i32 res_66407} = mul32(x_66406, 60i32)
  in {res_66407}
}

fun {f64} fminutes_in_365_5189f() = {
  let {i32 minutes_in_day_66408} = minutes_in_day_5057f()
  let {i32 arg_66409} = mul32(minutes_in_day_66408, 365i32)
  let {f64 res_66410} = r64_15711(arg_66409)
  in {res_66410}
}

fun {f64} inv_fminutes_in_365_5191f() = {
  let {f64 fminutes_in_365_66411} = fminutes_in_365_5189f()
  let {f64 res_66412} = fdiv64(1.0f64, fminutes_in_365_66411)
  in {res_66412}
}

fun {f64} inv_fminutes_in_day_5193f() = {
  let {f64 fminutes_in_day_66413} = fminutes_in_day_5059f()
  let {f64 res_66414} = fdiv64(1.0f64, fminutes_in_day_66413)
  in {res_66414}
}

fun {bool} ten_6100f() = {
  {true}
}

fun {bool} twenty_6101f() = {
  {false}
}

fun {f32} real_15728(f64 x_66415) = {
  let {f32 res_66416} = f64_15606(x_66415)
  in {res_66416}
}

fun {f32} i32_15734(i32 x_66417) = {
  let {f32 res_66418} = sitofp i32 x_66417 to f32
  in {res_66418}
}

fun {f32, f32} mk_re_15732(f32 a_66419) = {
  let {f32 res_66420} = i32_15734(0i32)
  in {a_66419, res_66420}
}

fun {f32, f32} zero_6895f() = {
  let {f32 arg_66421} = real_15728(0.0f64)
  let {f32 res_66422, f32 res_66423} = mk_re_15732(arg_66421)
  in {res_66422, res_66423}
}

fun {f32, f32} one_6896f() = {
  let {f32 arg_66424} = real_15728(1.0f64)
  let {f32 res_66425, f32 res_66426} = mk_re_15732(arg_66424)
  in {res_66425, res_66426}
}

fun {f32, f32} two_6897f() = {
  let {f32 arg_66427} = real_15728(2.0f64)
  let {f32 res_66428, f32 res_66429} = mk_re_15732(arg_66427)
  in {res_66428, res_66429}
}

fun {f32} **_15751(f32 x_66430, f32 y_66431) = {
  let {f32 res_66432} = fpow32(x_66430, y_66431)
  in {res_66432}
}

fun {f32} *_15756(f32 x_66433, f32 y_66434) = {
  let {f32 res_66435} = fmul32(x_66433, y_66434)
  in {res_66435}
}

fun {f32} isqrt2pi_6898f() = {
  let {f32 arg_66436} = real_15728(2.0f64)
  let {f32 pi_66437} = pi_2281f()
  let {f64 arg_66438} = fsub64(0.0f64, 0.5f64)
  let {f32 arg_66439} = real_15728(arg_66438)
  let {f32 arg_66440} = **_15751(pi_66437, arg_66439)
  let {f32 res_66441} = *_15756(arg_66436, arg_66440)
  in {res_66441}
}

fun {f32} sqrt_15762(f32 x_66442) = {
  let {f32 res_66443} = sqrt32(x_66442)
  in {res_66443}
}

fun {f32} inv_sqrt2_6899f() = {
  let {f32 arg_66444} = real_15728(1.0f64)
  let {f32 arg_66445} = real_15728(2.0f64)
  let {f32 arg_66446} = sqrt_15762(arg_66445)
  let {f32 res_66447} = /_15600(arg_66444, arg_66446)
  in {res_66447}
}

fun {bool} normal_6907f() = {
  {true}
}

fun {bool} normal_6912f() = {
  {false}
}

fun {} map2_6998f() = {
  {}
}

fun {} map2_7000f() = {
  {}
}

fun {} map3_7001f() = {
  {}
}

fun {} map2_7002f() = {
  {}
}

fun {} reduce_7003f() = {
  {}
}

fun {i32} max_iterations_reached_6947f() = {
  {0i32}
}

fun {i32} max_global_reached_6948f() = {
  {1i32}
}

fun {i32} target_reached_6949f() = {
  {2i32}
}

fun {} map2_7006f() = {
  {}
}

fun {} map3_7007f() = {
  {}
}

fun {} reduce_comm_7008f() = {
  {}
}

fun {} map4_7014f() = {
  {}
}

fun {} map3_7015f() = {
  {}
}

fun {} filter_7016f() = {
  {}
}

fun {} map2_7022f() = {
  {}
}

fun {} filter_7023f() = {
  {}
}

fun {} scan_7024f() = {
  {}
}

fun {} map2_7027f() = {
  {}
}

fun {} map4_7028f() = {
  {}
}

fun {f32} int_15769(i32 x_66448) = {
  let {f32 res_66449} = i32_15734(x_66448)
  in {res_66449}
}

fun {bool, f32, f32, f32, f32} optimize_value_15776(f32 r_66450, f32 r_66451,
                                                    f32 r_66452) = {
  let {f32 res_66453} = i32_15734(0i32)
  in {false, res_66453, r_66450, r_66451, r_66452}
}

fun {[?0]bool, [?0]f32, [?0]f32, [?0]f32, [?0]f32} default_variables_6959f() = {
  let {f32 arg_66454} = f64_15606(1.0e-6f64)
  let {f32 arg_66455} = f64_15606(4.0e-2f64)
  let {f32 arg_66456} = int_15769(1i32)
  let {bool arr_elem_66457, f32 arr_elem_66458, f32 arr_elem_66459,
       f32 arr_elem_66460, f32 arr_elem_66461} = optimize_value_15776(arg_66455,
                                                                      arg_66454,
                                                                      arg_66456)
  let {f32 arg_66462} = f64_15606(1.0e-6f64)
  let {f32 arg_66463} = f64_15606(4.0e-2f64)
  let {f32 arg_66464} = int_15769(1i32)
  let {bool arr_elem_66465, f32 arr_elem_66466, f32 arr_elem_66467,
       f32 arr_elem_66468, f32 arr_elem_66469} = optimize_value_15776(arg_66463,
                                                                      arg_66462,
                                                                      arg_66464)
  let {i32 arg_66470} = sub32(0i32, 1i32)
  let {f32 arg_66471} = int_15769(arg_66470)
  let {f64 arg_66472} = fsub64(0.0f64, 0.5f64)
  let {f32 arg_66473} = f64_15606(arg_66472)
  let {f32 arg_66474} = int_15769(0i32)
  let {bool arr_elem_66475, f32 arr_elem_66476, f32 arr_elem_66477,
       f32 arr_elem_66478, f32 arr_elem_66479} = optimize_value_15776(arg_66473,
                                                                      arg_66471,
                                                                      arg_66474)
  let {f32 arg_66480} = f64_15606(1.0e-4f64)
  let {f32 arg_66481} = f64_15606(1.0e-2f64)
  let {f32 arg_66482} = int_15769(4i32)
  let {bool arr_elem_66483, f32 arr_elem_66484, f32 arr_elem_66485,
       f32 arr_elem_66486, f32 arr_elem_66487} = optimize_value_15776(arg_66481,
                                                                      arg_66480,
                                                                      arg_66482)
  let {f32 arg_66488} = f64_15606(1.0e-4f64)
  let {f32 arg_66489} = f64_15606(0.4f64)
  let {f32 arg_66490} = int_15769(2i32)
  let {bool arr_elem_66491, f32 arr_elem_66492, f32 arr_elem_66493,
       f32 arr_elem_66494, f32 arr_elem_66495} = optimize_value_15776(arg_66489,
                                                                      arg_66488,
                                                                      arg_66490)
  let {[5i32]bool res_66496} = [arr_elem_66457, arr_elem_66465, arr_elem_66475,
                                arr_elem_66483, arr_elem_66491]
  let {[5i32]f32 res_66497} = [arr_elem_66458, arr_elem_66466, arr_elem_66476,
                               arr_elem_66484, arr_elem_66492]
  let {[5i32]f32 res_66498} = [arr_elem_66459, arr_elem_66467, arr_elem_66477,
                               arr_elem_66485, arr_elem_66493]
  let {[5i32]f32 res_66499} = [arr_elem_66460, arr_elem_66468, arr_elem_66478,
                               arr_elem_66486, arr_elem_66494]
  let {[5i32]f32 res_66500} = [arr_elem_66461, arr_elem_66469, arr_elem_66479,
                               arr_elem_66487, arr_elem_66495]
  let {bool assert_arg_66501} = eq_i32(5i32, 5i32)
  let {cert shape_cert_66502} = assert(assert_arg_66501,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:120:5-120:5")
  -- result_proper_shape_66503 aliases res_66496
  let {[5i32]bool result_proper_shape_66503} = <shape_cert_66502>reshape((~5i32),
                                                                         res_66496)
  let {bool assert_arg_66504} = eq_i32(5i32, 5i32)
  let {cert shape_cert_66505} = assert(assert_arg_66504,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:120:5-120:5")
  -- result_proper_shape_66506 aliases res_66497
  let {[5i32]f32 result_proper_shape_66506} = <shape_cert_66505>reshape((~5i32),
                                                                        res_66497)
  let {bool assert_arg_66507} = eq_i32(5i32, 5i32)
  let {cert shape_cert_66508} = assert(assert_arg_66507,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:120:5-120:5")
  -- result_proper_shape_66509 aliases res_66498
  let {[5i32]f32 result_proper_shape_66509} = <shape_cert_66508>reshape((~5i32),
                                                                        res_66498)
  let {bool assert_arg_66510} = eq_i32(5i32, 5i32)
  let {cert shape_cert_66511} = assert(assert_arg_66510,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:120:5-120:5")
  -- result_proper_shape_66512 aliases res_66499
  let {[5i32]f32 result_proper_shape_66512} = <shape_cert_66511>reshape((~5i32),
                                                                        res_66499)
  let {bool assert_arg_66513} = eq_i32(5i32, 5i32)
  let {cert shape_cert_66514} = assert(assert_arg_66513,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:120:5-120:5")
  -- result_proper_shape_66515 aliases res_66500
  let {[5i32]f32 result_proper_shape_66515} = <shape_cert_66514>reshape((~5i32),
                                                                        res_66500)
  in {5i32, result_proper_shape_66503, result_proper_shape_66506,
      result_proper_shape_66509, result_proper_shape_66512,
      result_proper_shape_66515}
}

fun {} map3_7029f() = {
  {}
}

fun {i32} date_of_gregorian_15889(i32 d_66516, i32 hr_66517, i32 mn_66518,
                                  i32 m_66519, i32 y_66520) = {
  let {bool cond_66521} = eq_i32(m_66519, 1i32)
  let {bool eq_66522} = logand(cond_66521, true)
  let {bool cond_66523} =
    -- Branch returns: {bool}
    if eq_66522
    then {true} else {
      let {bool res_66524} = eq_i32(m_66519, 2i32)
      let {bool eq_66525} = logand(res_66524, true)
      in {eq_66525}
    }
  let {i32 x_66526} =
    -- Branch returns: {i32}
    if cond_66523
    then {
      let {i32 x_66527} = add32(y_66520, 4800i32)
      let {i32 y_66528} = sub32(x_66527, 1i32)
      let {i32 x_66529} = mul32(1461i32, y_66528)
      let {i32 x_66530} = sdiv32(x_66529, 4i32)
      let {i32 y_66531} = add32(m_66519, 10i32)
      let {i32 x_66532} = mul32(367i32, y_66531)
      let {i32 y_66533} = sdiv32(x_66532, 12i32)
      let {i32 x_66534} = add32(x_66530, y_66533)
      let {i32 x_66535} = add32(y_66520, 4900i32)
      let {i32 x_66536} = sub32(x_66535, 1i32)
      let {i32 y_66537} = sdiv32(x_66536, 100i32)
      let {i32 x_66538} = mul32(3i32, y_66537)
      let {i32 y_66539} = sdiv32(x_66538, 4i32)
      let {i32 res_66540} = sub32(x_66534, y_66539)
      in {res_66540}
    } else {
      let {i32 y_66541} = add32(y_66520, 4800i32)
      let {i32 x_66542} = mul32(1461i32, y_66541)
      let {i32 x_66543} = sdiv32(x_66542, 4i32)
      let {i32 y_66544} = sub32(m_66519, 2i32)
      let {i32 x_66545} = mul32(367i32, y_66544)
      let {i32 y_66546} = sdiv32(x_66545, 12i32)
      let {i32 x_66547} = add32(x_66543, y_66546)
      let {i32 x_66548} = add32(y_66520, 4900i32)
      let {i32 y_66549} = sdiv32(x_66548, 100i32)
      let {i32 x_66550} = mul32(3i32, y_66549)
      let {i32 y_66551} = sdiv32(x_66550, 4i32)
      let {i32 res_66552} = sub32(x_66547, y_66551)
      in {res_66552}
    }
  let {i32 x_66553} = add32(x_66526, d_66516)
  let {i32 x_66554} = sub32(x_66553, 32075i32)
  let {i32 x_66555} = sub32(x_66554, 2444238i32)
  let {i32 minutes_in_day_66556} = minutes_in_day_5057f()
  let {i32 x_66557} = mul32(x_66555, minutes_in_day_66556)
  let {i32 y_66558} = mul32(hr_66517, 60i32)
  let {i32 x_66559} = add32(x_66557, y_66558)
  let {i32 res_66560} = add32(x_66559, mn_66518)
  in {res_66560}
}

fun {i32} date_of_triple_15883(i32 year_66561, i32 month_66562,
                               i32 day_66563) = {
  let {i32 res_66564} = date_of_gregorian_15889(day_66563, 12i32, 0i32,
                                                month_66562, year_66561)
  in {res_66564}
}

fun {i32} date_of_int_15872(i32 x_66565) = {
  let {i32 res_66566} = smod32(x_66565, 100i32)
  let {i32 d_66567} = res_66566
  let {i32 x_66568} = sdiv32(x_66565, 100i32)
  let {i32 res_66569} = smod32(x_66568, 100i32)
  let {i32 m_66570} = res_66569
  let {i32 res_66571} = sdiv32(x_66565, 10000i32)
  let {i32 y_66572} = res_66571
  let {i32 res_66573} = date_of_triple_15883(y_66572, m_66570, d_66567)
  in {res_66573}
}

fun {i32} lifted_15935(i32 f_66574) = {
  {f_66574}
}

fun {[?0]i32, i32} lifted_15940(i32 n_66575, i32 f_66576,
                                [n_66575]i32 as_66577) = {
  let {bool assert_arg_66578} = eq_i32(n_66575, n_66575)
  let {cert shape_cert_66579} = assert(assert_arg_66578,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66580 aliases as_66577
  let {[n_66575]i32 result_proper_shape_66580} = <shape_cert_66579>reshape((~n_66575),
                                                                           as_66577)
  in {n_66575, result_proper_shape_66580, f_66576}
}

fun {[?0]i32, [?1]f32, i32} lifted_15955(i32 n_66581, i32 size_66582,
                                         [size_66582]i32 as_66583, i32 f_66584,
                                         [n_66581]f32 bs_66585) = {
  let {bool assert_arg_66586} = eq_i32(size_66582, size_66582)
  let {cert shape_cert_66587} = assert(assert_arg_66586,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66588 aliases as_66583
  let {[size_66582]i32 result_proper_shape_66588} = <shape_cert_66587>reshape((~size_66582),
                                                                              as_66583)
  let {bool assert_arg_66589} = eq_i32(n_66581, n_66581)
  let {cert shape_cert_66590} = assert(assert_arg_66589,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66591 aliases bs_66585
  let {[n_66581]f32 result_proper_shape_66591} = <shape_cert_66590>reshape((~n_66581),
                                                                           bs_66585)
  in {size_66582, n_66581, result_proper_shape_66588, result_proper_shape_66591,
      f_66584}
}

fun {i32, i32} lifted_15998(i32 date_of_int_66592, i32 m_66593) = {
  {date_of_int_66592, m_66593}
}

fun {i32, f32, i32} lifted_16004(i32 date_of_int_66594, i32 m_66595,
                                 f32 k_66596) = {
  {date_of_int_66594, k_66596, m_66595}
}

fun {i32} lifted_16034(i32 minutes_in_day_66597, i32 d_66598, i32 hr_66599,
                       i32 mn_66600, i32 m_66601, i32 y_66602) = {
  let {bool cond_66603} = eq_i32(m_66601, 1i32)
  let {bool eq_66604} = logand(cond_66603, true)
  let {bool cond_66605} =
    -- Branch returns: {bool}
    if eq_66604
    then {true} else {
      let {bool res_66606} = eq_i32(m_66601, 2i32)
      let {bool eq_66607} = logand(res_66606, true)
      in {eq_66607}
    }
  let {i32 x_66608} =
    -- Branch returns: {i32}
    if cond_66605
    then {
      let {i32 x_66609} = add32(y_66602, 4800i32)
      let {i32 y_66610} = sub32(x_66609, 1i32)
      let {i32 x_66611} = mul32(1461i32, y_66610)
      let {i32 x_66612} = sdiv32(x_66611, 4i32)
      let {i32 y_66613} = add32(m_66601, 10i32)
      let {i32 x_66614} = mul32(367i32, y_66613)
      let {i32 y_66615} = sdiv32(x_66614, 12i32)
      let {i32 x_66616} = add32(x_66612, y_66615)
      let {i32 x_66617} = add32(y_66602, 4900i32)
      let {i32 x_66618} = sub32(x_66617, 1i32)
      let {i32 y_66619} = sdiv32(x_66618, 100i32)
      let {i32 x_66620} = mul32(3i32, y_66619)
      let {i32 y_66621} = sdiv32(x_66620, 4i32)
      let {i32 res_66622} = sub32(x_66616, y_66621)
      in {res_66622}
    } else {
      let {i32 y_66623} = add32(y_66602, 4800i32)
      let {i32 x_66624} = mul32(1461i32, y_66623)
      let {i32 x_66625} = sdiv32(x_66624, 4i32)
      let {i32 y_66626} = sub32(m_66601, 2i32)
      let {i32 x_66627} = mul32(367i32, y_66626)
      let {i32 y_66628} = sdiv32(x_66627, 12i32)
      let {i32 x_66629} = add32(x_66625, y_66628)
      let {i32 x_66630} = add32(y_66602, 4900i32)
      let {i32 y_66631} = sdiv32(x_66630, 100i32)
      let {i32 x_66632} = mul32(3i32, y_66631)
      let {i32 y_66633} = sdiv32(x_66632, 4i32)
      let {i32 res_66634} = sub32(x_66629, y_66633)
      in {res_66634}
    }
  let {i32 x_66635} = add32(x_66608, d_66598)
  let {i32 x_66636} = sub32(x_66635, 32075i32)
  let {i32 x_66637} = sub32(x_66636, 2444238i32)
  let {i32 x_66638} = mul32(x_66637, minutes_in_day_66597)
  let {i32 y_66639} = mul32(hr_66599, 60i32)
  let {i32 x_66640} = add32(x_66638, y_66639)
  let {i32 res_66641} = add32(x_66640, mn_66600)
  in {res_66641}
}

fun {i32} lifted_16027(i32 date_of_gregorian_66642, i32 year_66643,
                       i32 month_66644, i32 day_66645) = {
  let {i32 res_66646} = lifted_16034(date_of_gregorian_66642, day_66645, 12i32,
                                     0i32, month_66644, year_66643)
  in {res_66646}
}

fun {i32} lifted_16015(i32 date_of_triple_66647, i32 x_66648) = {
  let {i32 res_66649} = smod32(x_66648, 100i32)
  let {i32 d_66650} = res_66649
  let {i32 x_66651} = sdiv32(x_66648, 100i32)
  let {i32 res_66652} = smod32(x_66651, 100i32)
  let {i32 m_66653} = res_66652
  let {i32 res_66654} = sdiv32(x_66648, 10000i32)
  let {i32 y_66655} = res_66654
  let {i32 res_66656} = lifted_16027(date_of_triple_66647, y_66655, m_66653,
                                     d_66650)
  in {res_66656}
}

fun {i32, f32, f32} lifted_16012(i32 date_of_int_66657, f32 k_66658,
                                 i32 m_66659, f32 q_66660) = {
  let {i32 res_66661} = lifted_16015(date_of_int_66657, m_66659)
  in {res_66661, q_66660, k_66658}
}

fun {*[?0]i32, *[?0]f32, *[?0]f32} lifted_15980(i32 n_66662, i32 size_66663,
                                                i32 size_66664,
                                                [size_66663]i32 as_66665,
                                                [size_66664]f32 bs_66666,
                                                i32 f_66667,
                                                [n_66662]f32 cs_66668) = {
  let {bool zip_cmp_66669} = eq_i32(size_66663, size_66664)
  let {cert zip_assert_66670} = assert(zip_cmp_66669, "arrays differ in length",
                                       "./futlib/array.fut:67:32-67:32")
  -- bs_zip_res_66671 aliases bs_66666
  let {[size_66663]f32 bs_zip_res_66671} = <zip_assert_66670>reshape((~size_66663),
                                                                     bs_66666)
  let {bool zip_cmp_66672} = eq_i32(size_66663, n_66662)
  let {cert zip_assert_66673} = assert(zip_cmp_66672, "arrays differ in length",
                                       "./futlib/array.fut:67:32-67:32")
  -- cs_zip_res_66674 aliases cs_66668
  let {[size_66663]f32 cs_zip_res_66674} = <zip_assert_66673>reshape((~size_66663),
                                                                     cs_66668)
  let {bool zip_cmp_66675} = eq_i32(size_66663, size_66663)
  let {cert zip_assert_66676} = assert(zip_cmp_66675, "arrays differ in length",
                                       "./futlib/array.fut:67:3-67:3")
  -- bs_zip_res_zip_res_66677 aliases bs_zip_res_66671
  let {[size_66663]f32 bs_zip_res_zip_res_66677} = <zip_assert_66676>reshape((~size_66663),
                                                                             bs_zip_res_66671)
  let {bool zip_cmp_66678} = eq_i32(size_66663, size_66663)
  let {cert zip_assert_66679} = assert(zip_cmp_66678, "arrays differ in length",
                                       "./futlib/array.fut:67:3-67:3")
  -- cs_zip_res_zip_res_66680 aliases cs_zip_res_66674
  let {[size_66663]f32 cs_zip_res_zip_res_66680} = <zip_assert_66679>reshape((~size_66663),
                                                                             cs_zip_res_66674)
  let {[size_66663]i32 res_66681, [size_66663]f32 res_66682,
       [size_66663]f32 res_66683} =
    map(size_66663,
        fn {i32, f32, f32} (i32 a_66684, f32 b_66685, f32 c_66686) =>
          let {i32 arg_66687, i32 arg_66688} = lifted_15998(f_66667, a_66684)
          let {i32 arg_66689, f32 arg_66690,
               i32 arg_66691} = lifted_16004(arg_66687, arg_66688, b_66685)
          let {i32 res_66692, f32 res_66693,
               f32 res_66694} = lifted_16012(arg_66689, arg_66690, arg_66691,
                                             c_66686)
          in {res_66692, res_66693, res_66694},
        as_66665, bs_zip_res_zip_res_66677, cs_zip_res_zip_res_66680)
  let {bool assert_arg_66695} = eq_i32(size_66663, size_66663)
  let {cert shape_cert_66696} = assert(assert_arg_66695,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66697 aliases res_66681
  let {[size_66663]i32 result_proper_shape_66697} = <shape_cert_66696>reshape((~size_66663),
                                                                              res_66681)
  let {bool assert_arg_66698} = eq_i32(size_66663, size_66663)
  let {cert shape_cert_66699} = assert(assert_arg_66698,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66700 aliases res_66682
  let {[size_66663]f32 result_proper_shape_66700} = <shape_cert_66699>reshape((~size_66663),
                                                                              res_66682)
  let {bool assert_arg_66701} = eq_i32(size_66663, size_66663)
  let {cert shape_cert_66702} = assert(assert_arg_66701,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66703 aliases res_66683
  let {[size_66663]f32 result_proper_shape_66703} = <shape_cert_66702>reshape((~size_66663),
                                                                              res_66683)
  in {size_66663, result_proper_shape_66697, result_proper_shape_66700,
      result_proper_shape_66703}
}

fun {[?0]i32} lifted_16155(i32 size_66704, [size_66704]i32 f_66705) = {
  let {bool assert_arg_66706} = eq_i32(size_66704, size_66704)
  let {cert shape_cert_66707} = assert(assert_arg_66706,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66708 aliases f_66705
  let {[size_66704]i32 result_proper_shape_66708} = <shape_cert_66707>reshape((~size_66704),
                                                                              f_66705)
  in {size_66704, result_proper_shape_66708}
}

fun {[?0]i32, [?1]i32} lifted_16168(i32 n_66709, i32 size_66710,
                                    [size_66710]i32 f_66711,
                                    [n_66709]i32 as_66712) = {
  let {bool assert_arg_66713} = eq_i32(n_66709, n_66709)
  let {cert shape_cert_66714} = assert(assert_arg_66713,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66715 aliases as_66712
  let {[n_66709]i32 result_proper_shape_66715} = <shape_cert_66714>reshape((~n_66709),
                                                                           as_66712)
  let {bool assert_arg_66716} = eq_i32(size_66710, size_66710)
  let {cert shape_cert_66717} = assert(assert_arg_66716,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66718 aliases f_66711
  let {[size_66710]i32 result_proper_shape_66718} = <shape_cert_66717>reshape((~size_66710),
                                                                              f_66711)
  in {n_66709, size_66710, result_proper_shape_66715, result_proper_shape_66718}
}

fun {*[?0]i32} iota_16188(i32 n_66719) = {
  let {i32 subtracted_step_66720} = sub32(1i32, 0i32)
  let {bool step_zero_66721} = eq_i32(0i32, 1i32)
  let {i32 s_sign_66722} = ssignum32 subtracted_step_66720
  let {bool bounds_invalid_downwards_66723} = sle32(0i32, n_66719)
  let {bool bounds_invalid_upwards_66724} = slt32(n_66719, 0i32)
  let {bool step_wrong_dir_66725} = eq_i32(s_sign_66722, -1i32)
  let {i32 distance_66726} = sub32(n_66719, 0i32)
  let {bool step_invalid_66727} = logor(step_wrong_dir_66725, step_zero_66721)
  let {bool range_invalid_66728} = logor(step_invalid_66727, bounds_invalid_upwards_66724)
  let {i32 pos_step_66729} = mul32(subtracted_step_66720, s_sign_66722)
  let {i32 num_elems_66730} =
    -- Branch returns: {i32}
    if range_invalid_66728
    then {
      let {i32 x_66731} = 0i32
      in {x_66731}
    } else {
      let {i32 y_66732} = sub32(pos_step_66729, 1i32)
      let {i32 x_66733} = add32(distance_66726, y_66732)
      let {i32 x_66734} = squot32(x_66733, pos_step_66729)
      in {x_66734}
    }
  let {[num_elems_66730]i32 res_66735} = iota32(num_elems_66730, 0i32,
                                                subtracted_step_66720)
  let {bool assert_arg_66736} = eq_i32(num_elems_66730, num_elems_66730)
  let {cert shape_cert_66737} = assert(assert_arg_66736,
                                       "shape of function result does not match shapes in return type",
                                       "./futlib/math.fut:334:7-334:7")
  -- result_proper_shape_66738 aliases res_66735
  let {[num_elems_66730]i32 result_proper_shape_66738} = <shape_cert_66737>reshape((~num_elems_66730),
                                                                                   res_66735)
  in {num_elems_66730, result_proper_shape_66738}
}

fun {*[n_66739]i32} iota_16186(i32 n_66739) = {
  let {i32 size_66740; [size_66740]i32 res_66741} = iota_16188(n_66739)
  let {bool assert_arg_66742} = eq_i32(n_66739, size_66740)
  let {cert shape_cert_66743} = assert(assert_arg_66742,
                                       "shape of function result does not match shapes in return type",
                                       "./futlib/array.fut:45:5-45:5")
  -- result_proper_shape_66744 aliases res_66741
  let {[n_66739]i32 result_proper_shape_66744} = <shape_cert_66743>reshape((~n_66739),
                                                                           res_66741)
  in {result_proper_shape_66744}
}

fun {[?0]i32, i32} lifted_16233(i32 size_66745, [size_66745]i32 dates_66746,
                                i32 x_66747) = {
  let {bool assert_arg_66748} = eq_i32(size_66745, size_66745)
  let {cert shape_cert_66749} = assert(assert_arg_66748,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66750 aliases dates_66746
  let {[size_66745]i32 result_proper_shape_66750} = <shape_cert_66749>reshape((~size_66745),
                                                                              dates_66746)
  in {size_66745, result_proper_shape_66750, x_66747}
}

fun {i32} lifted_16252(i32 x_66751) = {
  {x_66751}
}

fun {bool} lifted_16258(i32 x_66752, i32 y_66753) = {
  let {bool res_66754} = eq_i32(x_66752, y_66753)
  let {bool eq_66755} = logand(res_66754, true)
  in {eq_66755}
}

fun {bool} lifted_16248(i32 size_66756, [size_66756]i32 dates_66757,
                        i32 x_66758, i32 i_66759) = {
  let {bool cond_66760} = eq_i32(i_66759, 0i32)
  let {bool eq_66761} = logand(cond_66760, true)
  let {bool res_66762} =
    -- Branch returns: {bool}
    if eq_66761
    then {true} else {
      let {i32 arg_66763} = lifted_16252(x_66758)
      let {i32 i_66764} = sub32(i_66759, 1i32)
      let {i32 arg_66765} = dates_66757[i_66764]
      let {bool not_arg_66766} = lifted_16258(arg_66763, arg_66765)
      let {bool res_66767} = ! not_arg_66766
      in {res_66767}
    }
  in {res_66762}
}

fun {*[?0]bool} lifted_16220(i32 n_66768, i32 size_66769, i32 size_66770,
                             [size_66769]i32 as_66771, [size_66770]i32 f_66772,
                             [n_66768]i32 bs_66773) = {
  let {bool zip_cmp_66774} = eq_i32(size_66769, n_66768)
  let {cert zip_assert_66775} = assert(zip_cmp_66774, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_66776 aliases bs_66773
  let {[size_66769]i32 bs_zip_res_66776} = <zip_assert_66775>reshape((~size_66769),
                                                                     bs_66773)
  let {bool zip_cmp_66777} = eq_i32(size_66769, size_66769)
  let {cert zip_assert_66778} = assert(zip_cmp_66777, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_66779 aliases bs_zip_res_66776
  let {[size_66769]i32 bs_zip_res_zip_res_66779} = <zip_assert_66778>reshape((~size_66769),
                                                                             bs_zip_res_66776)
  let {[size_66769]bool res_66780} =
    map(size_66769,
        fn {bool} (i32 a_66781, i32 b_66782) =>
          let {bool assert_arg_66783} = eq_i32(size_66770, size_66770)
          let {cert shape_cert_66784} = assert(assert_arg_66783,
                                               "function arguments of wrong shape",
                                               "./futlib/array.fut:63:19-63:19")
          -- f_66785 aliases f_66772
          let {[size_66770]i32 f_66785} = <shape_cert_66784>reshape((~size_66770),
                                                                    f_66772)
          -- arg_66787 aliases size_66770, a_66781, f_66785
          let {i32 size_66786; [size_66786]i32 arg_66787,
                               i32 arg_66788} = lifted_16233(size_66770,
                                                             f_66785, a_66781)
          let {bool assert_arg_66789} = eq_i32(size_66786, size_66786)
          let {cert shape_cert_66790} = assert(assert_arg_66789,
                                               "function arguments of wrong shape",
                                               "./futlib/array.fut:63:19-63:19")
          -- arg_66791 aliases arg_66787
          let {[size_66786]i32 arg_66791} = <shape_cert_66790>reshape((~size_66786),
                                                                      arg_66787)
          let {bool res_66792} = lifted_16248(size_66786, arg_66791, arg_66788,
                                              b_66782)
          in {res_66792},
        as_66771, bs_zip_res_zip_res_66779)
  let {bool assert_arg_66793} = eq_i32(size_66769, size_66769)
  let {cert shape_cert_66794} = assert(assert_arg_66793,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66795 aliases res_66780
  let {[size_66769]bool result_proper_shape_66795} = <shape_cert_66794>reshape((~size_66769),
                                                                               res_66780)
  in {size_66769, result_proper_shape_66795}
}

fun {} lifted_16288() = {
  {}
}

fun {bool} lifted_16304(bool x_66796, i32 nameless_66797) = {
  {x_66796}
}

fun {*[?0]bool, *[?0]i32} lifted_16297(i32 size_66798,
                                       [size_66798]bool as_66799,
                                       [size_66798]i32 as_66800) = {
  let {[size_66798]i32 increments_66801, [size_66798]i32 increments_66802,
       [size_66798]i32 increments_66803} =
    map(size_66798,
        fn {i32, i32, i32} (bool x_66804, i32 x_66805) =>
          let {bool cond_66806} = lifted_16304(x_66804, x_66805)
          let {i32 res_66807} =
            -- Branch returns: {i32}
            if cond_66806
            then {0i32} else {1i32}
          let {bool is_i_66808} = eq_i32(res_66807, 0i32)
          let {i32 part_res_66809, i32 part_res_66810, i32 part_res_66811} =
            -- Branch returns: {i32, i32, i32}
            if is_i_66808
            then {0i32, 1i32, 0i32} else {1i32, 0i32, 1i32}
          in {part_res_66809, part_res_66810, part_res_66811},
        as_66799, as_66800)
  let {[size_66798]i32 offsets_66812} =
    scan(size_66798,
         fn {i32} (i32 x_66813, i32 y_66814) =>
           let {i32 z_66815} = add32(x_66813, y_66814)
           in {z_66815},
         {0i32}, increments_66802)
  let {i32 last_index_66816} = sub32(size_66798, 1i32)
  let {bool is_empty_66817} = eq_i32(size_66798, 0i32)
  let {i32 partition_size_66818} =
    -- Branch returns: {i32}
    if is_empty_66817
    then {0i32} else {
      let {i32 last_offset_66819} = offsets_66812[last_index_66816]
      in {last_offset_66819}
    }
  let {i32 sum_of_partition_sizes_66820} = add32(partition_size_66818, 0i32)
  let {[sum_of_partition_sizes_66820]bool partition_dest_66821} = scratch(bool,
                                                                          sum_of_partition_sizes_66820)
  let {[sum_of_partition_sizes_66820]i32 partition_dest_66822} = scratch(i32,
                                                                         sum_of_partition_sizes_66820)
  let {[sum_of_partition_sizes_66820]bool partition_res_66823,
       [sum_of_partition_sizes_66820]i32 partition_res_66824} =
    -- Consumes partition_dest_66821, partition_dest_66822
    scatter(size_66798,
            fn {i32, i32, bool, i32} (i32 c_66825, i32 offset_66826,
                                      bool v_66827, i32 v_66828) =>
              let {bool is_this_one_66829} = eq_i32(c_66825, 0i32)
              let {i32 this_offset_66830} = add32(offset_66826, -1i32)
              let {i32 total_res_66831} =
                -- Branch returns: {i32}
                if is_this_one_66829
                then {this_offset_66830} else {-1i32}
              in {total_res_66831, total_res_66831, v_66827, v_66828},
            {increments_66801, offsets_66812, as_66799, as_66800}, (1,
                                                                    partition_dest_66821),
            (1, partition_dest_66822))
  let {[1i32]i32 partition_sizes_66832} = [partition_size_66818]
  let {bool assert_arg_66833} = eq_i32(sum_of_partition_sizes_66820, sum_of_partition_sizes_66820)
  let {cert shape_cert_66834} = assert(assert_arg_66833,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_66835 aliases partition_res_66823
  let {[sum_of_partition_sizes_66820]bool correct_shape_66835} = <shape_cert_66834>reshape((~sum_of_partition_sizes_66820),
                                                                                           partition_res_66823)
  let {bool assert_arg_66836} = eq_i32(sum_of_partition_sizes_66820, sum_of_partition_sizes_66820)
  let {cert shape_cert_66837} = assert(assert_arg_66836,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_66838 aliases partition_res_66824
  let {[sum_of_partition_sizes_66820]i32 correct_shape_66838} = <shape_cert_66837>reshape((~sum_of_partition_sizes_66820),
                                                                                          partition_res_66824)
  let {bool assert_arg_66839} = eq_i32(1i32, 1i32)
  let {cert shape_cert_66840} = assert(assert_arg_66839,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_66841 aliases partition_sizes_66832
  let {[1i32]i32 correct_shape_66841} = <shape_cert_66840>reshape((~1i32),
                                                                  partition_sizes_66832)
  -- as'_66842 aliases correct_shape_66835
  let {[sum_of_partition_sizes_66820]bool as'_66842} = correct_shape_66835
  -- as'_66843 aliases correct_shape_66838
  let {[sum_of_partition_sizes_66820]i32 as'_66843} = correct_shape_66838
  -- is_66844 aliases correct_shape_66841
  let {[1i32]i32 is_66844} = correct_shape_66841
  let {i32 s_sign_66845} = ssignum32 1i32
  let {bool backwards_66846} = eq_i32(s_sign_66845, -1i32)
  let {i32 w_minus_1_66847} = sub32(sum_of_partition_sizes_66820, 1i32)
  let {i32 i_def_66848} =
    -- Branch returns: {i32}
    if backwards_66846
    then {w_minus_1_66847} else {0i32}
  let {bool x_66849} = sle32(0i32, 0i32)
  let {bool y_66850} = slt32(0i32, 1i32)
  let {bool assert_arg_66851} = logand(x_66849, y_66850)
  let {cert bounds_check_66852} = assert(assert_arg_66851,
                                         "index out of bounds",
                                         "./futlib/array.fut:99:11-99:11")
  let {i32 j_66853} = <bounds_check_66852>is_66844[0i32]
  let {i32 j_m_i_66854} = sub32(j_66853, i_def_66848)
  let {i32 x_66855} = abs32 j_m_i_66854
  let {i32 x_66856} = abs32 1i32
  let {i32 y_66857} = sub32(x_66856, 1i32)
  let {i32 x_66858} = add32(x_66855, y_66857)
  let {i32 y_66859} = abs32 1i32
  let {i32 n_66860} = squot32(x_66858, y_66859)
  let {bool empty_slice_66861} = eq_i32(n_66860, 0i32)
  let {i32 m_66862} = sub32(n_66860, 1i32)
  let {i32 m_t_s_66863} = mul32(m_66862, 1i32)
  let {i32 i_p_m_t_s_66864} = add32(i_def_66848, m_t_s_66863)
  let {bool zero_leq_i_p_m_t_s_66865} = sle32(0i32, i_p_m_t_s_66864)
  let {bool i_p_m_t_s_leq_w_66866} = sle32(i_p_m_t_s_66864, sum_of_partition_sizes_66820)
  let {bool i_p_m_t_s_leq_w_66867} = slt32(i_p_m_t_s_66864, sum_of_partition_sizes_66820)
  let {bool zero_lte_i_66868} = sle32(0i32, i_def_66848)
  let {bool i_lte_j_66869} = sle32(i_def_66848, j_66853)
  let {bool y_66870} = logand(i_p_m_t_s_leq_w_66867, zero_lte_i_66868)
  let {bool y_66871} = logand(zero_leq_i_p_m_t_s_66865, y_66870)
  let {bool y_66872} = logand(i_lte_j_66869, y_66871)
  let {bool forwards_ok_66873} = logand(zero_lte_i_66868, y_66872)
  let {bool negone_lte_j_66874} = sle32(-1i32, j_66853)
  let {bool j_lte_i_66875} = sle32(j_66853, i_def_66848)
  let {bool y_66876} = logand(i_p_m_t_s_leq_w_66866, negone_lte_j_66874)
  let {bool y_66877} = logand(zero_leq_i_p_m_t_s_66865, y_66876)
  let {bool y_66878} = logand(j_lte_i_66875, y_66877)
  let {bool backwards_ok_66879} = logand(negone_lte_j_66874, y_66878)
  let {bool slice_ok_66880} =
    -- Branch returns: {bool}
    if backwards_66846
    then {backwards_ok_66879} else {forwards_ok_66873}
  let {bool ok_or_empty_66881} = logor(empty_slice_66861, slice_ok_66880)
  let {cert slice_cert_66882} = assert(ok_or_empty_66881, "slice out of bounds",
                                       "./futlib/array.fut:99:6-99:6")
  -- res_66883 aliases as'_66842
  let {[n_66860]bool res_66883} = <slice_cert_66882>as'_66842[i_def_66848:+n_66860*1i32]
  -- res_66884 aliases as'_66843
  let {[n_66860]i32 res_66884} = <slice_cert_66882>as'_66843[i_def_66848:+n_66860*1i32]
  let {bool assert_arg_66885} = eq_i32(n_66860, n_66860)
  let {cert shape_cert_66886} = assert(assert_arg_66885,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66887 aliases res_66883
  let {[n_66860]bool result_proper_shape_66887} = <shape_cert_66886>reshape((~n_66860),
                                                                            res_66883)
  let {bool assert_arg_66888} = eq_i32(n_66860, n_66860)
  let {cert shape_cert_66889} = assert(assert_arg_66888,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66890 aliases res_66884
  let {[n_66860]i32 result_proper_shape_66890} = <shape_cert_66889>reshape((~n_66860),
                                                                           res_66884)
  in {n_66860, result_proper_shape_66887, result_proper_shape_66890}
}

fun {} lifted_16404() = {
  {}
}

fun {i32} lifted_16407(i32 ne_66891) = {
  {ne_66891}
}

fun {i32} bool_16411(bool x_66892) = {
  let {i32 res_66893} =
    -- Branch returns: {i32}
    if x_66892
    then {1i32} else {0i32}
  in {res_66893}
}

fun {i32} lifted_16423(i32 x_66894) = {
  {x_66894}
}

fun {i32} lifted_16427(i32 x_66895, i32 x_66896) = {
  let {i32 res_66897} = add32(x_66895, x_66896)
  in {res_66897}
}

fun {*[?0]i32} lifted_16419(i32 n_66898, i32 ne_66899,
                            [n_66898]i32 as_66900) = {
  let {[n_66898]i32 res_66901} =
    scan(n_66898,
         fn {i32} (i32 x_66902, i32 x_66903) =>
           let {i32 arg_66904} = lifted_16423(x_66902)
           let {i32 res_66905} = lifted_16427(arg_66904, x_66903)
           in {res_66905},
         {ne_66899}, as_66900)
  let {bool assert_arg_66906} = eq_i32(n_66898, n_66898)
  let {cert shape_cert_66907} = assert(assert_arg_66906,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_66908 aliases res_66901
  let {[n_66898]i32 result_proper_shape_66908} = <shape_cert_66907>reshape((~n_66898),
                                                                           res_66901)
  in {n_66898, result_proper_shape_66908}
}

fun {[?0]i32, [n_66909]i32} distinct_maturities_16152(i32 n_66909,
                                                      [n_66909]i32 dates_66910) = {
  let {} = map2_7022f()
  let {bool assert_arg_66911} = eq_i32(n_66909, n_66909)
  let {cert shape_cert_66912} = assert(assert_arg_66911,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- dates_66913 aliases dates_66910
  let {[n_66909]i32 dates_66913} = <shape_cert_66912>reshape((~n_66909),
                                                             dates_66910)
  -- arg_66915 aliases n_66909, dates_66913
  let {i32 size_66914; [size_66914]i32 arg_66915} = lifted_16155(n_66909,
                                                                 dates_66913)
  let {bool assert_arg_66916} = eq_i32(size_66914, size_66914)
  let {cert shape_cert_66917} = assert(assert_arg_66916,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- arg_66918 aliases arg_66915
  let {[size_66914]i32 arg_66918} = <shape_cert_66917>reshape((~size_66914),
                                                              arg_66915)
  let {bool assert_arg_66919} = eq_i32(n_66909, n_66909)
  let {cert shape_cert_66920} = assert(assert_arg_66919,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- dates_66921 aliases dates_66910
  let {[n_66909]i32 dates_66921} = <shape_cert_66920>reshape((~n_66909),
                                                             dates_66910)
  -- arg_66924 aliases n_66909, size_66914, arg_66918, dates_66921
  -- arg_66925 aliases n_66909, size_66914, arg_66918, dates_66921
  let {i32 size_66922, i32 size_66923; [size_66922]i32 arg_66924,
                                       [size_66923]i32 arg_66925} = lifted_16168(n_66909,
                                                                                 size_66914,
                                                                                 arg_66918,
                                                                                 dates_66921)
  let {[n_66909]i32 arg_66926} = iota_16186(n_66909)
  let {bool assert_arg_66927} = eq_i32(size_66922, size_66922)
  let {cert shape_cert_66928} = assert(assert_arg_66927,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- arg_66929 aliases arg_66924
  let {[size_66922]i32 arg_66929} = <shape_cert_66928>reshape((~size_66922),
                                                              arg_66924)
  let {bool assert_arg_66930} = eq_i32(size_66923, size_66923)
  let {cert shape_cert_66931} = assert(assert_arg_66930,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- arg_66932 aliases arg_66925
  let {[size_66923]i32 arg_66932} = <shape_cert_66931>reshape((~size_66923),
                                                              arg_66925)
  let {bool assert_arg_66933} = eq_i32(n_66909, n_66909)
  let {cert shape_cert_66934} = assert(assert_arg_66933,
                                       "function arguments of wrong shape",
                                       "./heston.fut:67:18-67:18")
  -- arg_66935 aliases arg_66926
  let {[n_66909]i32 arg_66935} = <shape_cert_66934>reshape((~n_66909),
                                                           arg_66926)
  let {i32 size_66936; [size_66936]bool res_66937} = lifted_16220(n_66909,
                                                                  size_66922,
                                                                  size_66923,
                                                                  arg_66929,
                                                                  arg_66932,
                                                                  arg_66935)
  let {bool assert_arg_66938} = eq_i32(size_66936, size_66936)
  let {cert shape_cert_66939} = assert(assert_arg_66938,
                                       "value cannot match pattern",
                                       "./heston.fut:67:3-67:3")
  -- correct_shape_66940 aliases res_66937
  let {[size_66936]bool correct_shape_66940} = <shape_cert_66939>reshape((~size_66936),
                                                                         res_66937)
  -- switches_66941 aliases correct_shape_66940
  let {[size_66936]bool switches_66941} = correct_shape_66940
  let {} = filter_7023f()
  let {} = lifted_16288()
  let {bool zip_cmp_66942} = eq_i32(size_66936, n_66909)
  let {cert zip_assert_66943} = assert(zip_cmp_66942, "arrays differ in length",
                                       "./heston.fut:68:37-68:37")
  -- dates_zip_res_66944 aliases dates_66910
  let {[size_66936]i32 dates_zip_res_66944} = <zip_assert_66943>reshape((~size_66936),
                                                                        dates_66910)
  let {bool assert_arg_66945} = eq_i32(size_66936, size_66936)
  let {cert shape_cert_66946} = assert(assert_arg_66945,
                                       "function arguments of wrong shape",
                                       "./heston.fut:68:15-68:15")
  -- switches_66947 aliases switches_66941
  let {[size_66936]bool switches_66947} = <shape_cert_66946>reshape((~size_66936),
                                                                    switches_66941)
  let {bool assert_arg_66948} = eq_i32(size_66936, size_66936)
  let {cert shape_cert_66949} = assert(assert_arg_66948,
                                       "function arguments of wrong shape",
                                       "./heston.fut:68:15-68:15")
  -- dates_zip_res_66950 aliases dates_zip_res_66944
  let {[size_66936]i32 dates_zip_res_66950} = <shape_cert_66949>reshape((~size_66936),
                                                                        dates_zip_res_66944)
  let {i32 size_66951; [size_66951]bool res_66952,
                       [size_66951]i32 res_66953} = lifted_16297(size_66936,
                                                                 switches_66947,
                                                                 dates_zip_res_66950)
  let {} = scan_7024f()
  let {} = lifted_16404()
  let {i32 arg_66954} = lifted_16407(0i32)
  let {[size_66936]i32 arg_66955} =
    map(size_66936,
        fn {i32} (bool x_66956) =>
          let {i32 res_66957} = bool_16411(x_66956)
          in {res_66957},
        switches_66941)
  let {bool assert_arg_66958} = eq_i32(size_66936, size_66936)
  let {cert shape_cert_66959} = assert(assert_arg_66958,
                                       "function arguments of wrong shape",
                                       "./heston.fut:69:24-69:24")
  -- arg_66960 aliases arg_66955
  let {[size_66936]i32 arg_66960} = <shape_cert_66959>reshape((~size_66936),
                                                              arg_66955)
  let {i32 size_66961; [size_66961]i32 zip_arg_66962} = lifted_16419(size_66936,
                                                                     arg_66954,
                                                                     arg_66960)
  let {[size_66961]i32 res_66963} =
    map(size_66961,
        fn {i32} (i32 x_66964) =>
          let {i32 res_66965} = sub32(x_66964, 1i32)
          in {res_66965},
        zip_arg_66962)
  let {bool assert_arg_66966} = eq_i32(size_66951, size_66951)
  let {cert shape_cert_66967} = assert(assert_arg_66966,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:64:5-64:5")
  -- result_proper_shape_66968 aliases res_66953
  let {[size_66951]i32 result_proper_shape_66968} = <shape_cert_66967>reshape((~size_66951),
                                                                              res_66953)
  let {bool assert_arg_66969} = eq_i32(n_66909, size_66961)
  let {cert shape_cert_66970} = assert(assert_arg_66969,
                                       "shape of function result does not match shapes in return type",
                                       "./heston.fut:64:5-64:5")
  -- result_proper_shape_66971 aliases res_66963
  let {[n_66909]i32 result_proper_shape_66971} = <shape_cert_66970>reshape((~n_66909),
                                                                           res_66963)
  in {size_66951, result_proper_shape_66968, result_proper_shape_66971}
}

fun {i32} int_of_date_16482(i32 x_66972) = {
  {x_66972}
}

fun {f64} days_between_16480(i32 t1_66973, i32 t2_66974) = {
  let {i32 x_66975} = int_of_date_16482(t2_66974)
  let {i32 y_66976} = int_of_date_16482(t1_66973)
  let {i32 arg_66977} = sub32(x_66975, y_66976)
  let {f64 x_66978} = r64_15711(arg_66977)
  let {f64 inv_fminutes_in_day_66979} = inv_fminutes_in_day_5193f()
  let {f64 res_66980} = fmul64(x_66978, inv_fminutes_in_day_66979)
  in {res_66980}
}

fun {f64} diff_dates_16477(i32 t1_66981, i32 t2_66982) = {
  let {f64 x_66983} = days_between_16480(t1_66981, t2_66982)
  let {f64 res_66984} = fdiv64(x_66983, 365.0f64)
  in {res_66984}
}

fun {f32} *._16500(f32 x_66985, f32 y_66986) = {
  let {f32 res_66987} = *_15756(x_66985, y_66986)
  in {res_66987}
}

fun {f32} exp_16504(f32 x_66988) = {
  let {f32 res_66989} = exp32(x_66988)
  in {res_66989}
}

fun {f32} -_16513(f32 x_66990, f32 y_66991) = {
  let {f32 res_66992} = fsub32(x_66990, y_66991)
  in {res_66992}
}

fun {f32} -._16510(f32 x_66993, f32 y_66994) = {
  let {f32 res_66995} = -_16513(x_66993, y_66994)
  in {res_66995}
}

fun {f32} /._16519(f32 x_66996, f32 y_66997) = {
  let {f32 res_66998} = -_16513(x_66996, y_66997)
  in {res_66998}
}

fun {bool} <=_16528(f32 x_66999, f32 y_67000) = {
  let {bool res_67001} = le32(x_66999, y_67000)
  in {res_67001}
}

fun {bool} <=._16525(f32 x_67002, f32 y_67003) = {
  let {bool res_67004} = <=_16528(x_67002, y_67003)
  in {res_67004}
}

fun {f32} maturity_weight_16496(f32 x0_67005, f32 gamma_67006, f32 x_67007) = {
  let {f32 arg_67008} = int_15769(1i32)
  let {f32 arg_67009} = *._16500(gamma_67006, x0_67005)
  let {f32 arg_67010} = exp_16504(arg_67009)
  let {f32 arg_67011} = int_15769(1i32)
  let {f32 arg_67012} = -._16510(arg_67010, arg_67011)
  let {f32 res_67013} = /._16519(arg_67008, arg_67012)
  let {f32 k_67014} = res_67013
  let {bool cond_67015} = <=._16525(x_67007, x0_67005)
  let {f32 res_67016} =
    -- Branch returns: {f32}
    if cond_67015
    then {
      let {f32 arg_67017} = *._16500(gamma_67006, x_67007)
      let {f32 arg_67018} = exp_16504(arg_67017)
      let {f32 arg_67019} = int_15769(1i32)
      let {f32 arg_67020} = -._16510(arg_67018, arg_67019)
      let {f32 res_67021} = *._16500(k_67014, arg_67020)
      in {res_67021}
    } else {
      let {f32 res_67022} = int_15769(1i32)
      in {res_67022}
    }
  in {res_67016}
}

fun {f32} log_16544(f32 x_67023) = {
  let {f32 res_67024} = log32(x_67023)
  in {res_67024}
}

fun {f32} +_16553(f32 x_67025, f32 y_67026) = {
  let {f32 res_67027} = fadd32(x_67025, y_67026)
  in {res_67027}
}

fun {f32} +._16550(f32 x_67028, f32 y_67029) = {
  let {f32 res_67030} = +_16553(x_67028, y_67029)
  in {res_67030}
}

fun {f32} strike_weight_16542(f32 p_67031, f32 x_67032) = {
  let {f32 arg_67033} = log_16544(x_67032)
  let {f32 arg_67034} = int_15769(1i32)
  let {f32 arg_67035} = +._16550(arg_67033, arg_67034)
  let {f32 arg_67036} = -._16510(arg_67035, x_67032)
  let {f32 arg_67037} = *._16500(p_67031, arg_67036)
  let {f32 res_67038} = exp_16504(arg_67037)
  in {res_67038}
}

fun {f32} weight_16474(f32 maturity_weight_gamma_67039,
                       f32 maturity_weight_x0_67040,
                       f32 strike_weight_bandwidth_67041, i32 today_67042,
                       f32 strike_67043, i32 mat_67044) = {
  let {f64 arg_67045} = diff_dates_16477(today_67042, mat_67044)
  let {f32 arg_67046} = f64_15606(arg_67045)
  let {f32 arg_67047} = maturity_weight_16496(maturity_weight_x0_67040,
                                              maturity_weight_gamma_67039,
                                              arg_67046)
  let {f32 arg_67048} = strike_weight_16542(strike_weight_bandwidth_67041,
                                            strike_67043)
  let {f32 res_67049} = *._16500(arg_67047, arg_67048)
  in {res_67049}
}

fun {bool} same_date_16591(i32 x_67050, i32 y_67051) = {
  let {bool res_67052} = eq_i32(x_67050, y_67051)
  let {bool eq_67053} = logand(res_67052, true)
  in {eq_67053}
}

fun {f32} int_16600(i32 x_67054) = {
  let {f32 res_67055} = i32_15734(x_67054)
  in {res_67055}
}

fun {f32} max_16606(f32 x_67056, f32 y_67057) = {
  let {f32 res_67058} = fmax32(x_67056, y_67057)
  in {res_67058}
}

fun {f32} d_16630(f32 strike_67059, f32 vol_67060, f32 t_67061,
                  f32 sqrt_t_67062, f32 fwd_67063, f32 add_67064) = {
  let {f32 arg_67065} = /_15600(fwd_67063, strike_67059)
  let {f32 arg_67066} = log_16544(arg_67065)
  let {f32 arg_67067} = real_15728(0.5f64)
  let {f32 arg_67068} = *_15756(add_67064, arg_67067)
  let {f32 arg_67069} = *_15756(arg_67068, vol_67060)
  let {f32 arg_67070} = *_15756(arg_67069, vol_67060)
  let {f32 arg_67071} = *_15756(arg_67070, t_67061)
  let {f32 arg_67072} = +_16553(arg_67066, arg_67071)
  let {f32 arg_67073} = *_15756(vol_67060, sqrt_t_67062)
  let {f32 res_67074} = /_15600(arg_67072, arg_67073)
  in {res_67074}
}

fun {bool} <_16659(f32 x_67075, f32 y_67076) = {
  let {bool res_67077} = lt32(x_67075, y_67076)
  in {res_67077}
}

fun {f32} negate_16663(f32 x_67078) = {
  let {f32 res_67079} = fsub32(0.0f32, x_67078)
  in {res_67079}
}

fun {f32} erf_16667(f32 x_67080) = {
  let {f32 res_67081} = real_15728(0.254829592f64)
  let {f32 a1_67082} = res_67081
  let {f64 arg_67083} = fsub64(0.0f64, 0.284496736f64)
  let {f32 res_67084} = real_15728(arg_67083)
  let {f32 a2_67085} = res_67084
  let {f32 res_67086} = real_15728(1.421413741f64)
  let {f32 a3_67087} = res_67086
  let {f64 arg_67088} = fsub64(0.0f64, 1.453152027f64)
  let {f32 res_67089} = real_15728(arg_67088)
  let {f32 a4_67090} = res_67089
  let {f32 res_67091} = real_15728(1.061405429f64)
  let {f32 a5_67092} = res_67091
  let {f32 res_67093} = real_15728(0.3275911f64)
  let {f32 p_67094} = res_67093
  let {f32 arg_67095} = int_16600(1i32)
  let {f32 arg_67096} = int_16600(1i32)
  let {f32 arg_67097} = *_15756(p_67094, x_67080)
  let {f32 arg_67098} = +_16553(arg_67096, arg_67097)
  let {f32 res_67099} = /_15600(arg_67095, arg_67098)
  let {f32 t_67100} = res_67099
  let {f32 res_67101} = *_15756(t_67100, t_67100)
  let {f32 t2_67102} = res_67101
  let {f32 res_67103} = *_15756(t_67100, t2_67102)
  let {f32 t3_67104} = res_67103
  let {f32 res_67105} = *_15756(t_67100, t3_67104)
  let {f32 t4_67106} = res_67105
  let {f32 res_67107} = *_15756(t_67100, t4_67106)
  let {f32 t5_67108} = res_67107
  let {f32 arg_67109} = int_16600(1i32)
  let {f32 arg_67110} = *_15756(a1_67082, t_67100)
  let {f32 arg_67111} = *_15756(a2_67085, t2_67102)
  let {f32 arg_67112} = +_16553(arg_67110, arg_67111)
  let {f32 arg_67113} = *_15756(a3_67087, t3_67104)
  let {f32 arg_67114} = +_16553(arg_67112, arg_67113)
  let {f32 arg_67115} = *_15756(a4_67090, t4_67106)
  let {f32 arg_67116} = +_16553(arg_67114, arg_67115)
  let {f32 arg_67117} = *_15756(a5_67092, t5_67108)
  let {f32 arg_67118} = +_16553(arg_67116, arg_67117)
  let {f32 arg_67119} = negate_16663(x_67080)
  let {f32 arg_67120} = *_15756(arg_67119, x_67080)
  let {f32 arg_67121} = exp_16504(arg_67120)
  let {f32 arg_67122} = *_15756(arg_67118, arg_67121)
  let {f32 res_67123} = -_16513(arg_67109, arg_67122)
  in {res_67123}
}

fun {f32} pnorm_16651(f32 x_67124) = {
  let {f32 arg_67125} = int_16600(2i32)
  let {f32 arg_67126} = sqrt_15762(arg_67125)
  let {f32 res_67127} = /_15600(x_67124, arg_67126)
  let {f32 u_67128} = res_67127
  let {f32 arg_67129} = int_16600(0i32)
  let {bool cond_67130} = <_16659(u_67128, arg_67129)
  let {f32 res_67131} =
    -- Branch returns: {f32}
    if cond_67130
    then {
      let {f32 arg_67132} = negate_16663(u_67128)
      let {f32 arg_67133} = erf_16667(arg_67132)
      let {f32 res_67134} = negate_16663(arg_67133)
      in {res_67134}
    } else {
      let {f32 res_67135} = erf_16667(u_67128)
      in {res_67135}
    }
  let {f32 erf_67136} = res_67131
  let {f32 arg_67137} = real_15728(0.5f64)
  let {f32 arg_67138} = int_16600(1i32)
  let {f32 arg_67139} = +_16553(arg_67138, erf_67136)
  let {f32 res_67140} = *_15756(arg_67137, arg_67139)
  in {res_67140}
}

fun {f32} normal_dist_16649(f32 x_67141) = {
  let {f32 res_67142} = pnorm_16651(x_67141)
  in {res_67142}
}

fun {f32} gauss_16734(f32 x_67143) = {
  let {f64 arg_67144} = fsub64(0.0f64, 0.5f64)
  let {f32 arg_67145} = real_15728(arg_67144)
  let {f32 arg_67146} = *_15756(arg_67145, x_67143)
  let {f32 arg_67147} = *_15756(arg_67146, x_67143)
  let {f32 arg_67148} = exp_16504(arg_67147)
  let {f32 arg_67149} = int_16600(2i32)
  let {f32 pi_67150} = pi_2281f()
  let {f32 arg_67151} = *_15756(arg_67149, pi_67150)
  let {f32 arg_67152} = sqrt_15762(arg_67151)
  let {f32 res_67153} = /_15600(arg_67148, arg_67152)
  in {res_67153}
}

fun {f32, f32} bs_call_16588(bool call_67154, i32 today_67155, f32 spot_67156,
                             f32 strike_67157, i32 maturity_67158,
                             f32 vol_67159) = {
  let {bool cond_67160} = same_date_16591(today_67155, maturity_67158)
  let {bool cond_67161} =
    -- Branch returns: {bool}
    if cond_67160
    then {true} else {
      let {f32 arg_67162} = real_15728(1.0e-15f64)
      let {bool res_67163} = <=_16528(vol_67159, arg_67162)
      in {res_67163}
    }
  let {f32 res_67164, f32 res_67165} =
    -- Branch returns: {f32, f32}
    if cond_67161
    then {
      let {f32 forward_67166} = spot_67156
      let {f32 arg_67167} = int_16600(0i32)
      let {f32 arg_67168} = -_16513(forward_67166, strike_67157)
      let {f32 res_67169} = max_16606(arg_67167, arg_67168)
      let {f32 p_67170} = res_67169
      let {f32 res_67171} = int_16600(0i32)
      in {p_67170, res_67171}
    } else {
      let {f32 res_67172} =
        -- Branch returns: {f32}
        if call_67154
        then {
          let {f32 res_67173} = int_16600(1i32)
          in {res_67173}
        } else {
          let {i32 arg_67174} = sub32(0i32, 1i32)
          let {f32 res_67175} = int_16600(arg_67174)
          in {res_67175}
        }
      let {f32 eps_67176} = res_67172
      let {f64 arg_67177} = diff_dates_16477(today_67155, maturity_67158)
      let {f32 res_67178} = real_15728(arg_67177)
      let {f32 t_67179} = res_67178
      let {f32 res_67180} = sqrt_15762(t_67179)
      let {f32 sqrt_t_67181} = res_67180
      let {f32 res_67182} = int_16600(1i32)
      let {f32 df_r_67183} = res_67182
      let {f32 res_67184} = int_16600(1i32)
      let {f32 df_d_67185} = res_67184
      let {f32 arg_67186} = *_15756(spot_67156, df_d_67185)
      let {f32 res_67187} = /_15600(arg_67186, df_r_67183)
      let {f32 fwd_67188} = res_67187
      let {f32 arg_67189} = int_16600(1i32)
      let {f32 res_67190} = d_16630(strike_67157, vol_67159, t_67179,
                                    sqrt_t_67181, fwd_67188, arg_67189)
      let {i32 arg_67191} = sub32(0i32, 1i32)
      let {f32 arg_67192} = int_16600(arg_67191)
      let {f32 res_67193} = d_16630(strike_67157, vol_67159, t_67179,
                                    sqrt_t_67181, fwd_67188, arg_67192)
      let {f32 d1_67194} = res_67190
      let {f32 d2_67195} = res_67193
      let {f32 arg_67196} = *_15756(eps_67176, d1_67194)
      let {f32 res_67197} = normal_dist_16649(arg_67196)
      let {f32 arg_67198} = *_15756(eps_67176, d2_67195)
      let {f32 res_67199} = normal_dist_16649(arg_67198)
      let {f32 n1_67200} = res_67197
      let {f32 n2_67201} = res_67199
      let {f32 arg_67202} = *_15756(eps_67176, df_r_67183)
      let {f32 arg_67203} = *_15756(fwd_67188, n1_67200)
      let {f32 arg_67204} = *_15756(strike_67157, n2_67201)
      let {f32 arg_67205} = -_16513(arg_67203, arg_67204)
      let {f32 res_67206} = *_15756(arg_67202, arg_67205)
      let {f32 arg_67207} = *_15756(spot_67156, df_d_67185)
      let {f32 arg_67208} = *_15756(arg_67207, sqrt_t_67181)
      let {f32 arg_67209} = gauss_16734(d1_67194)
      let {f32 res_67210} = *_15756(arg_67208, arg_67209)
      in {res_67206, res_67210}
    }
  in {res_67164, res_67165}
}

fun {f32, f32} price_and_vega_of_quote_16580(i32 today_67211, f32 strike_67212,
                                             i32 maturity_67213,
                                             f32 quote_67214) = {
  let {f32 arg_67215} = int_15769(1i32)
  let {f32 res_67216, f32 res_67217} = bs_call_16588(true, today_67211,
                                                     arg_67215, strike_67212,
                                                     maturity_67213,
                                                     quote_67214)
  let {f32 price_67218} = res_67216
  let {f32 vega_67219} = res_67217
  let {f32 arg_67220} = f64_15606(0.1f64)
  let {f32 res_67221} = max_16606(arg_67220, vega_67219)
  in {price_67218, res_67221}
}

fun {} lifted_16769() = {
  {}
}

fun {[?0]f32, [?0]f32} lifted_16775(i32 n_67222, [n_67222]f32 as_67223,
                                    [n_67222]f32 as_67224) = {
  let {bool assert_arg_67225} = eq_i32(n_67222, n_67222)
  let {cert shape_cert_67226} = assert(assert_arg_67225,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67227 aliases as_67223
  let {[n_67222]f32 result_proper_shape_67227} = <shape_cert_67226>reshape((~n_67222),
                                                                           as_67223)
  let {bool assert_arg_67228} = eq_i32(n_67222, n_67222)
  let {cert shape_cert_67229} = assert(assert_arg_67228,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67230 aliases as_67224
  let {[n_67222]f32 result_proper_shape_67230} = <shape_cert_67229>reshape((~n_67222),
                                                                           as_67224)
  in {n_67222, result_proper_shape_67227, result_proper_shape_67230}
}

fun {f32, f32} lifted_16819(f32 p_67231, f32 v_67232) = {
  {p_67231, v_67232}
}

fun {f32} lifted_16830(f32 x_67233) = {
  {x_67233}
}

fun {f32} lifted_16837(f32 x_67234) = {
  {x_67234}
}

fun {f32} lifted_16841(f32 x_67235, f32 y_67236) = {
  let {f32 res_67237} = fmul32(x_67235, y_67236)
  in {res_67237}
}

fun {f32} lifted_16835(f32 x_67238, f32 y_67239) = {
  let {f32 arg_67240} = lifted_16837(x_67238)
  let {f32 res_67241} = lifted_16841(arg_67240, y_67239)
  in {res_67241}
}

fun {f32} lifted_16847(f32 x_67242) = {
  {x_67242}
}

fun {f32} lifted_16854(f32 x_67243) = {
  {x_67243}
}

fun {f32} lifted_16858(f32 x_67244, f32 y_67245) = {
  let {f32 res_67246} = fsub32(x_67244, y_67245)
  in {res_67246}
}

fun {f32} lifted_16852(f32 x_67247, f32 y_67248) = {
  let {f32 arg_67249} = lifted_16854(x_67247)
  let {f32 res_67250} = lifted_16858(arg_67249, y_67248)
  in {res_67250}
}

fun {f32} lifted_16827(f32 p_67251, f32 v_67252, f32 w_67253) = {
  let {f32 arg_67254} = lifted_16830(w_67253)
  let {f32 arg_67255} = lifted_16835(arg_67254, p_67251)
  let {f32 arg_67256} = lifted_16847(arg_67255)
  let {f32 res_67257} = lifted_16852(arg_67256, v_67252)
  in {res_67257}
}

fun {*[?0]f32} lifted_16798(i32 n_67258, i32 size_67259,
                            [size_67259]f32 as_67260, [size_67259]f32 as_67261,
                            [n_67258]f32 bs_67262) = {
  let {bool zip_cmp_67263} = eq_i32(size_67259, size_67259)
  let {cert zip_assert_67264} = assert(zip_cmp_67263, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- as_zip_res_67265 aliases as_67261
  let {[size_67259]f32 as_zip_res_67265} = <zip_assert_67264>reshape((~size_67259),
                                                                     as_67261)
  let {bool zip_cmp_67266} = eq_i32(size_67259, n_67258)
  let {cert zip_assert_67267} = assert(zip_cmp_67266, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_67268 aliases bs_67262
  let {[size_67259]f32 bs_zip_res_67268} = <zip_assert_67267>reshape((~size_67259),
                                                                     bs_67262)
  let {bool zip_cmp_67269} = eq_i32(size_67259, size_67259)
  let {cert zip_assert_67270} = assert(zip_cmp_67269, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- as_zip_res_zip_res_67271 aliases as_zip_res_67265
  let {[size_67259]f32 as_zip_res_zip_res_67271} = <zip_assert_67270>reshape((~size_67259),
                                                                             as_zip_res_67265)
  let {bool zip_cmp_67272} = eq_i32(size_67259, size_67259)
  let {cert zip_assert_67273} = assert(zip_cmp_67272, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_67274 aliases bs_zip_res_67268
  let {[size_67259]f32 bs_zip_res_zip_res_67274} = <zip_assert_67273>reshape((~size_67259),
                                                                             bs_zip_res_67268)
  let {[size_67259]f32 res_67275} =
    map(size_67259,
        fn {f32} (f32 a_67276, f32 a_67277, f32 b_67278) =>
          let {f32 arg_67279, f32 arg_67280} = lifted_16819(a_67276, a_67277)
          let {f32 res_67281} = lifted_16827(arg_67279, arg_67280, b_67278)
          in {res_67281},
        as_67260, as_zip_res_zip_res_67271, bs_zip_res_zip_res_67274)
  let {bool assert_arg_67282} = eq_i32(size_67259, size_67259)
  let {cert shape_cert_67283} = assert(assert_arg_67282,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67284 aliases res_67275
  let {[size_67259]f32 result_proper_shape_67284} = <shape_cert_67283>reshape((~size_67259),
                                                                              res_67275)
  in {size_67259, result_proper_shape_67284}
}

fun {} lifted_16883() = {
  {}
}

fun {[?0]i32, [?0]f32, [?0]f32} lifted_16890(i32 n_67285, [n_67285]i32 as_67286,
                                             [n_67285]f32 as_67287,
                                             [n_67285]f32 as_67288) = {
  let {bool assert_arg_67289} = eq_i32(n_67285, n_67285)
  let {cert shape_cert_67290} = assert(assert_arg_67289,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67291 aliases as_67286
  let {[n_67285]i32 result_proper_shape_67291} = <shape_cert_67290>reshape((~n_67285),
                                                                           as_67286)
  let {bool assert_arg_67292} = eq_i32(n_67285, n_67285)
  let {cert shape_cert_67293} = assert(assert_arg_67292,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67294 aliases as_67287
  let {[n_67285]f32 result_proper_shape_67294} = <shape_cert_67293>reshape((~n_67285),
                                                                           as_67287)
  let {bool assert_arg_67295} = eq_i32(n_67285, n_67285)
  let {cert shape_cert_67296} = assert(assert_arg_67295,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67297 aliases as_67288
  let {[n_67285]f32 result_proper_shape_67297} = <shape_cert_67296>reshape((~n_67285),
                                                                           as_67288)
  in {n_67285, result_proper_shape_67291, result_proper_shape_67294,
      result_proper_shape_67297}
}

fun {[?0]i32, [?0]f32, [?0]f32, [?1]f32} lifted_16921(i32 n_67298,
                                                      i32 size_67299,
                                                      [size_67299]i32 as_67300,
                                                      [size_67299]f32 as_67301,
                                                      [size_67299]f32 as_67302,
                                                      [n_67298]f32 bs_67303) = {
  let {bool assert_arg_67304} = eq_i32(size_67299, size_67299)
  let {cert shape_cert_67305} = assert(assert_arg_67304,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67306 aliases as_67300
  let {[size_67299]i32 result_proper_shape_67306} = <shape_cert_67305>reshape((~size_67299),
                                                                              as_67300)
  let {bool assert_arg_67307} = eq_i32(size_67299, size_67299)
  let {cert shape_cert_67308} = assert(assert_arg_67307,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67309 aliases as_67301
  let {[size_67299]f32 result_proper_shape_67309} = <shape_cert_67308>reshape((~size_67299),
                                                                              as_67301)
  let {bool assert_arg_67310} = eq_i32(size_67299, size_67299)
  let {cert shape_cert_67311} = assert(assert_arg_67310,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67312 aliases as_67302
  let {[size_67299]f32 result_proper_shape_67312} = <shape_cert_67311>reshape((~size_67299),
                                                                              as_67302)
  let {bool assert_arg_67313} = eq_i32(n_67298, n_67298)
  let {cert shape_cert_67314} = assert(assert_arg_67313,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67315 aliases bs_67303
  let {[n_67298]f32 result_proper_shape_67315} = <shape_cert_67314>reshape((~n_67298),
                                                                           bs_67303)
  in {size_67299, n_67298, result_proper_shape_67306, result_proper_shape_67309,
      result_proper_shape_67312, result_proper_shape_67315}
}

fun {[?0]i32, [?0]f32, [?0]f32, [?1]f32, [?2]f32, [?2]f32} lifted_16964
(i32 n_67316, i32 size_67317, i32 size_67318, [size_67317]i32 as_67319,
 [size_67317]f32 as_67320, [size_67317]f32 as_67321, [size_67318]f32 bs_67322,
 [n_67316]f32 cs_67323, [n_67316]f32 cs_67324) = {
  let {bool assert_arg_67325} = eq_i32(size_67317, size_67317)
  let {cert shape_cert_67326} = assert(assert_arg_67325,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67327 aliases as_67319
  let {[size_67317]i32 result_proper_shape_67327} = <shape_cert_67326>reshape((~size_67317),
                                                                              as_67319)
  let {bool assert_arg_67328} = eq_i32(size_67317, size_67317)
  let {cert shape_cert_67329} = assert(assert_arg_67328,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67330 aliases as_67320
  let {[size_67317]f32 result_proper_shape_67330} = <shape_cert_67329>reshape((~size_67317),
                                                                              as_67320)
  let {bool assert_arg_67331} = eq_i32(size_67317, size_67317)
  let {cert shape_cert_67332} = assert(assert_arg_67331,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67333 aliases as_67321
  let {[size_67317]f32 result_proper_shape_67333} = <shape_cert_67332>reshape((~size_67317),
                                                                              as_67321)
  let {bool assert_arg_67334} = eq_i32(size_67318, size_67318)
  let {cert shape_cert_67335} = assert(assert_arg_67334,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67336 aliases bs_67322
  let {[size_67318]f32 result_proper_shape_67336} = <shape_cert_67335>reshape((~size_67318),
                                                                              bs_67322)
  let {bool assert_arg_67337} = eq_i32(n_67316, n_67316)
  let {cert shape_cert_67338} = assert(assert_arg_67337,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67339 aliases cs_67323
  let {[n_67316]f32 result_proper_shape_67339} = <shape_cert_67338>reshape((~n_67316),
                                                                           cs_67323)
  let {bool assert_arg_67340} = eq_i32(n_67316, n_67316)
  let {cert shape_cert_67341} = assert(assert_arg_67340,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67342 aliases cs_67324
  let {[n_67316]f32 result_proper_shape_67342} = <shape_cert_67341>reshape((~n_67316),
                                                                           cs_67324)
  in {size_67317, size_67318, n_67316, result_proper_shape_67327,
      result_proper_shape_67330, result_proper_shape_67333,
      result_proper_shape_67336, result_proper_shape_67339,
      result_proper_shape_67342}
}

fun {f32} lifted_17075(i32 nameless_67343, f32 nameless_67344,
                       f32 strike_67345) = {
  {strike_67345}
}

fun {f32, f32} lifted_17079(f32 strike_67346, f32 w_67347) = {
  {strike_67346, w_67347}
}

fun {f32, f32, f32} lifted_17087(f32 strike_67348, f32 w_67349,
                                 f32 nameless_67350, f32 v_67351) = {
  {strike_67348, v_67351, w_67349}
}

fun {i32, f32, f32, f32} lifted_17095(f32 strike_67352, f32 v_67353,
                                      f32 w_67354, i32 i_67355) = {
  {i_67355, strike_67352, v_67353, w_67354}
}

fun {*[?0]i32, *[?0]f32, *[?0]f32, *[?0]f32} lifted_17024(i32 n_67356,
                                                          i32 size_67357,
                                                          i32 size_67358,
                                                          i32 size_67359,
                                                          [size_67357]i32 as_67360,
                                                          [size_67357]f32 as_67361,
                                                          [size_67357]f32 as_67362,
                                                          [size_67358]f32 bs_67363,
                                                          [size_67359]f32 cs_67364,
                                                          [size_67359]f32 cs_67365,
                                                          [n_67356]i32 ds_67366) = {
  let {bool zip_cmp_67367} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67368} = assert(zip_cmp_67367, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- as_zip_res_67369 aliases as_67361
  let {[size_67357]f32 as_zip_res_67369} = <zip_assert_67368>reshape((~size_67357),
                                                                     as_67361)
  let {bool zip_cmp_67370} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67371} = assert(zip_cmp_67370, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- as_zip_res_67372 aliases as_67362
  let {[size_67357]f32 as_zip_res_67372} = <zip_assert_67371>reshape((~size_67357),
                                                                     as_67362)
  let {bool zip_cmp_67373} = eq_i32(size_67357, size_67358)
  let {cert zip_assert_67374} = assert(zip_cmp_67373, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- bs_zip_res_67375 aliases bs_67363
  let {[size_67357]f32 bs_zip_res_67375} = <zip_assert_67374>reshape((~size_67357),
                                                                     bs_67363)
  let {bool zip_cmp_67376} = eq_i32(size_67357, size_67359)
  let {cert zip_assert_67377} = assert(zip_cmp_67376, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- cs_zip_res_67378 aliases cs_67364
  let {[size_67357]f32 cs_zip_res_67378} = <zip_assert_67377>reshape((~size_67357),
                                                                     cs_67364)
  let {bool zip_cmp_67379} = eq_i32(size_67357, size_67359)
  let {cert zip_assert_67380} = assert(zip_cmp_67379, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- cs_zip_res_67381 aliases cs_67365
  let {[size_67357]f32 cs_zip_res_67381} = <zip_assert_67380>reshape((~size_67357),
                                                                     cs_67365)
  let {bool zip_cmp_67382} = eq_i32(size_67357, n_67356)
  let {cert zip_assert_67383} = assert(zip_cmp_67382, "arrays differ in length",
                                       "./futlib/array.fut:71:37-71:37")
  -- ds_zip_res_67384 aliases ds_67366
  let {[size_67357]i32 ds_zip_res_67384} = <zip_assert_67383>reshape((~size_67357),
                                                                     ds_67366)
  let {bool zip_cmp_67385} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67386} = assert(zip_cmp_67385, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- as_zip_res_zip_res_67387 aliases as_zip_res_67369
  let {[size_67357]f32 as_zip_res_zip_res_67387} = <zip_assert_67386>reshape((~size_67357),
                                                                             as_zip_res_67369)
  let {bool zip_cmp_67388} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67389} = assert(zip_cmp_67388, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- as_zip_res_zip_res_67390 aliases as_zip_res_67372
  let {[size_67357]f32 as_zip_res_zip_res_67390} = <zip_assert_67389>reshape((~size_67357),
                                                                             as_zip_res_67372)
  let {bool zip_cmp_67391} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67392} = assert(zip_cmp_67391, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- bs_zip_res_zip_res_67393 aliases bs_zip_res_67375
  let {[size_67357]f32 bs_zip_res_zip_res_67393} = <zip_assert_67392>reshape((~size_67357),
                                                                             bs_zip_res_67375)
  let {bool zip_cmp_67394} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67395} = assert(zip_cmp_67394, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- cs_zip_res_zip_res_67396 aliases cs_zip_res_67378
  let {[size_67357]f32 cs_zip_res_zip_res_67396} = <zip_assert_67395>reshape((~size_67357),
                                                                             cs_zip_res_67378)
  let {bool zip_cmp_67397} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67398} = assert(zip_cmp_67397, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- cs_zip_res_zip_res_67399 aliases cs_zip_res_67381
  let {[size_67357]f32 cs_zip_res_zip_res_67399} = <zip_assert_67398>reshape((~size_67357),
                                                                             cs_zip_res_67381)
  let {bool zip_cmp_67400} = eq_i32(size_67357, size_67357)
  let {cert zip_assert_67401} = assert(zip_cmp_67400, "arrays differ in length",
                                       "./futlib/array.fut:71:3-71:3")
  -- ds_zip_res_zip_res_67402 aliases ds_zip_res_67384
  let {[size_67357]i32 ds_zip_res_zip_res_67402} = <zip_assert_67401>reshape((~size_67357),
                                                                             ds_zip_res_67384)
  let {[size_67357]i32 res_67403, [size_67357]f32 res_67404,
       [size_67357]f32 res_67405, [size_67357]f32 res_67406} =
    map(size_67357,
        fn {i32, f32, f32, f32} (i32 a_67407, f32 a_67408, f32 a_67409,
                                 f32 b_67410, f32 c_67411, f32 c_67412,
                                 i32 d_67413) =>
          let {f32 arg_67414} = lifted_17075(a_67407, a_67408, a_67409)
          let {f32 arg_67415, f32 arg_67416} = lifted_17079(arg_67414, b_67410)
          let {f32 arg_67417, f32 arg_67418,
               f32 arg_67419} = lifted_17087(arg_67415, arg_67416, c_67411,
                                             c_67412)
          let {i32 res_67420, f32 res_67421, f32 res_67422,
               f32 res_67423} = lifted_17095(arg_67417, arg_67418, arg_67419,
                                             d_67413)
          in {res_67420, res_67421, res_67422, res_67423},
        as_67360, as_zip_res_zip_res_67387, as_zip_res_zip_res_67390,
        bs_zip_res_zip_res_67393, cs_zip_res_zip_res_67396,
        cs_zip_res_zip_res_67399, ds_zip_res_zip_res_67402)
  let {bool assert_arg_67424} = eq_i32(size_67357, size_67357)
  let {cert shape_cert_67425} = assert(assert_arg_67424,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67426 aliases res_67403
  let {[size_67357]i32 result_proper_shape_67426} = <shape_cert_67425>reshape((~size_67357),
                                                                              res_67403)
  let {bool assert_arg_67427} = eq_i32(size_67357, size_67357)
  let {cert shape_cert_67428} = assert(assert_arg_67427,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67429 aliases res_67404
  let {[size_67357]f32 result_proper_shape_67429} = <shape_cert_67428>reshape((~size_67357),
                                                                              res_67404)
  let {bool assert_arg_67430} = eq_i32(size_67357, size_67357)
  let {cert shape_cert_67431} = assert(assert_arg_67430,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67432 aliases res_67405
  let {[size_67357]f32 result_proper_shape_67432} = <shape_cert_67431>reshape((~size_67357),
                                                                              res_67405)
  let {bool assert_arg_67433} = eq_i32(size_67357, size_67357)
  let {cert shape_cert_67434} = assert(assert_arg_67433,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67435 aliases res_67406
  let {[size_67357]f32 result_proper_shape_67435} = <shape_cert_67434>reshape((~size_67357),
                                                                              res_67406)
  in {size_67357, result_proper_shape_67426, result_proper_shape_67429,
      result_proper_shape_67432, result_proper_shape_67435}
}

fun {*[?0]f32, *[?1]f32} gauss_laguerre_coefficients_17166(bool nb_67436) = {
  let {bool ten_67437} = ten_6100f()
  let {bool cond_67438} = eq_bool(nb_67436, ten_67437)
  let {bool eq_67439} = logand(cond_67438, true)
  let {i32 size_67440, i32 size_67441; [size_67440]f32 res_67442,
                                       [size_67441]f32 res_67443} =
    -- Branch returns: {[?0]f32, [?1]f32}
    if eq_67439
    then {
      let {[10i32]f64 zip_arg_67444} = [0.13779347054049243f64,
                                        0.7294545495031708f64,
                                        1.8083429017403143f64,
                                        3.401433697854835f64,
                                        5.55249614006424f64,
                                        8.330152746763265f64,
                                        11.843785837901915f64,
                                        16.279257831376615f64,
                                        21.99658581198136f64,
                                        29.920697012273774f64]
      let {[10i32]f32 res_67445} =
        map(10i32,
            fn {f32} (f64 x_67446) =>
              let {f32 res_67447} = real_15728(x_67446)
              in {res_67447},
            zip_arg_67444)
      let {[10i32]f64 zip_arg_67448} = [0.354009738606998f64,
                                        0.8319023010435621f64,
                                        1.3302885617494675f64,
                                        1.8630639031111378f64,
                                        2.450255558073156f64,
                                        3.122764155173507f64,
                                        3.9341526954948387f64,
                                        4.992414872215118f64,
                                        6.572202485111805f64,
                                        9.784695840367801f64]
      let {[10i32]f32 res_67449} =
        map(10i32,
            fn {f32} (f64 x_67450) =>
              let {f32 res_67451} = real_15728(x_67450)
              in {res_67451},
            zip_arg_67448)
      in {10i32, 10i32, res_67445, res_67449}
    } else {
      let {[20i32]f64 zip_arg_67452} = [7.053988969198874e-2f64,
                                        0.3721268180016133f64,
                                        0.9165821024832457f64,
                                        1.7073065310281683f64,
                                        2.749199255315394f64,
                                        4.04892531380806f64,
                                        5.6151749709388366f64,
                                        7.459017454225468f64,
                                        9.594392865483231f64,
                                        12.03880256060886f64,
                                        14.814293416061961f64,
                                        17.94889554312255f64,
                                        21.478788273773706f64,
                                        25.451702644185488f64,
                                        29.932554890200286f64,
                                        35.013433968980074f64,
                                        40.83305723940129f64,
                                        47.619993970772065f64,
                                        55.81079576805181f64,
                                        66.52441652386588f64]
      let {[20i32]f32 res_67453} =
        map(20i32,
            fn {f32} (f64 x_67454) =>
              let {f32 res_67455} = real_15728(x_67454)
              in {res_67455},
            zip_arg_67452)
      let {[20i32]f64 zip_arg_67456} = [0.18108006241898922f64,
                                        0.4225567678786019f64,
                                        0.6669095467014556f64,
                                        0.9153523727812171f64,
                                        1.1695397072804468f64,
                                        1.4313549860432604f64,
                                        1.702981136708622f64,
                                        1.9870159022074663f64,
                                        2.286635720019974f64,
                                        2.6058349131697116f64,
                                        2.949783261906035f64,
                                        3.3253969236002114f64,
                                        3.742254738382389f64,
                                        4.214237825042351f64,
                                        4.7625161918999765f64,
                                        5.421727418640771f64,
                                        6.254011265769629f64,
                                        7.38731454069754f64,
                                        9.151328572719786f64,
                                        12.893388638453542f64]
      let {[20i32]f32 res_67457} =
        map(20i32,
            fn {f32} (f64 x_67458) =>
              let {f32 res_67459} = real_15728(x_67458)
              in {res_67459},
            zip_arg_67456)
      in {20i32, 20i32, res_67453, res_67457}
    }
  let {bool assert_arg_67460} = eq_i32(size_67440, size_67440)
  let {cert shape_cert_67461} = assert(assert_arg_67460,
                                       "shape of function result does not match shapes in return type",
                                       "./price_european_calls.fut:96:5-96:5")
  -- result_proper_shape_67462 aliases res_67442
  let {[size_67440]f32 result_proper_shape_67462} = <shape_cert_67461>reshape((~size_67440),
                                                                              res_67442)
  let {bool assert_arg_67463} = eq_i32(size_67441, size_67441)
  let {cert shape_cert_67464} = assert(assert_arg_67463,
                                       "shape of function result does not match shapes in return type",
                                       "./price_european_calls.fut:96:5-96:5")
  -- result_proper_shape_67465 aliases res_67443
  let {[size_67441]f32 result_proper_shape_67465} = <shape_cert_67464>reshape((~size_67441),
                                                                              res_67443)
  in {size_67440, size_67441, result_proper_shape_67462,
      result_proper_shape_67465}
}

fun {} lifted_17254() = {
  {}
}

fun {bool} lifted_17298(i32 nameless_67466, bool fixed_67467,
                        f32 nameless_67468, f32 nameless_67469,
                        f32 nameless_67470, f32 nameless_67471) = {
  let {bool res_67472} = ! fixed_67467
  in {res_67472}
}

fun {*[?0]i32, *[?0]bool, *[?0]f32, *[?0]f32, *[?0]f32, *[?0]f32} lifted_17280
(i32 size_67473, [size_67473]i32 as_67474, [size_67473]bool as_67475,
 [size_67473]f32 as_67476, [size_67473]f32 as_67477, [size_67473]f32 as_67478,
 [size_67473]f32 as_67479) = {
  let {[size_67473]i32 increments_67480, [size_67473]i32 increments_67481,
       [size_67473]i32 increments_67482} =
    map(size_67473,
        fn {i32, i32, i32} (i32 x_67483, bool x_67484, f32 x_67485, f32 x_67486,
                            f32 x_67487, f32 x_67488) =>
          let {bool cond_67489} = lifted_17298(x_67483, x_67484, x_67485,
                                               x_67486, x_67487, x_67488)
          let {i32 res_67490} =
            -- Branch returns: {i32}
            if cond_67489
            then {0i32} else {1i32}
          let {bool is_i_67491} = eq_i32(res_67490, 0i32)
          let {i32 part_res_67492, i32 part_res_67493, i32 part_res_67494} =
            -- Branch returns: {i32, i32, i32}
            if is_i_67491
            then {0i32, 1i32, 0i32} else {1i32, 0i32, 1i32}
          in {part_res_67492, part_res_67493, part_res_67494},
        as_67474, as_67475, as_67476, as_67477, as_67478, as_67479)
  let {[size_67473]i32 offsets_67495} =
    scan(size_67473,
         fn {i32} (i32 x_67496, i32 y_67497) =>
           let {i32 z_67498} = add32(x_67496, y_67497)
           in {z_67498},
         {0i32}, increments_67481)
  let {i32 last_index_67499} = sub32(size_67473, 1i32)
  let {bool is_empty_67500} = eq_i32(size_67473, 0i32)
  let {i32 partition_size_67501} =
    -- Branch returns: {i32}
    if is_empty_67500
    then {0i32} else {
      let {i32 last_offset_67502} = offsets_67495[last_index_67499]
      in {last_offset_67502}
    }
  let {i32 sum_of_partition_sizes_67503} = add32(partition_size_67501, 0i32)
  let {[sum_of_partition_sizes_67503]i32 partition_dest_67504} = scratch(i32,
                                                                         sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]bool partition_dest_67505} = scratch(bool,
                                                                          sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]f32 partition_dest_67506} = scratch(f32,
                                                                         sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]f32 partition_dest_67507} = scratch(f32,
                                                                         sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]f32 partition_dest_67508} = scratch(f32,
                                                                         sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]f32 partition_dest_67509} = scratch(f32,
                                                                         sum_of_partition_sizes_67503)
  let {[sum_of_partition_sizes_67503]i32 partition_res_67510,
       [sum_of_partition_sizes_67503]bool partition_res_67511,
       [sum_of_partition_sizes_67503]f32 partition_res_67512,
       [sum_of_partition_sizes_67503]f32 partition_res_67513,
       [sum_of_partition_sizes_67503]f32 partition_res_67514,
       [sum_of_partition_sizes_67503]f32 partition_res_67515} =
    -- Consumes partition_dest_67504, partition_dest_67505, partition_dest_67506, partition_dest_67507, partition_dest_67508, partition_dest_67509
    scatter(size_67473,
            fn {i32, i32, i32, i32, i32, i32, i32, bool, f32, f32, f32,
                f32} (i32 c_67516, i32 offset_67517, i32 v_67518, bool v_67519,
                      f32 v_67520, f32 v_67521, f32 v_67522, f32 v_67523) =>
              let {bool is_this_one_67524} = eq_i32(c_67516, 0i32)
              let {i32 this_offset_67525} = add32(offset_67517, -1i32)
              let {i32 total_res_67526} =
                -- Branch returns: {i32}
                if is_this_one_67524
                then {this_offset_67525} else {-1i32}
              in {total_res_67526, total_res_67526, total_res_67526,
                  total_res_67526, total_res_67526, total_res_67526, v_67518,
                  v_67519, v_67520, v_67521, v_67522, v_67523},
            {increments_67480, offsets_67495, as_67474, as_67475, as_67476,
             as_67477, as_67478, as_67479}, (1, partition_dest_67504), (1,
                                                                        partition_dest_67505),
            (1, partition_dest_67506), (1, partition_dest_67507), (1,
                                                                   partition_dest_67508),
            (1, partition_dest_67509))
  let {[1i32]i32 partition_sizes_67527} = [partition_size_67501]
  let {bool assert_arg_67528} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67529} = assert(assert_arg_67528,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67530 aliases partition_res_67510
  let {[sum_of_partition_sizes_67503]i32 correct_shape_67530} = <shape_cert_67529>reshape((~sum_of_partition_sizes_67503),
                                                                                          partition_res_67510)
  let {bool assert_arg_67531} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67532} = assert(assert_arg_67531,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67533 aliases partition_res_67511
  let {[sum_of_partition_sizes_67503]bool correct_shape_67533} = <shape_cert_67532>reshape((~sum_of_partition_sizes_67503),
                                                                                           partition_res_67511)
  let {bool assert_arg_67534} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67535} = assert(assert_arg_67534,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67536 aliases partition_res_67512
  let {[sum_of_partition_sizes_67503]f32 correct_shape_67536} = <shape_cert_67535>reshape((~sum_of_partition_sizes_67503),
                                                                                          partition_res_67512)
  let {bool assert_arg_67537} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67538} = assert(assert_arg_67537,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67539 aliases partition_res_67513
  let {[sum_of_partition_sizes_67503]f32 correct_shape_67539} = <shape_cert_67538>reshape((~sum_of_partition_sizes_67503),
                                                                                          partition_res_67513)
  let {bool assert_arg_67540} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67541} = assert(assert_arg_67540,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67542 aliases partition_res_67514
  let {[sum_of_partition_sizes_67503]f32 correct_shape_67542} = <shape_cert_67541>reshape((~sum_of_partition_sizes_67503),
                                                                                          partition_res_67514)
  let {bool assert_arg_67543} = eq_i32(sum_of_partition_sizes_67503, sum_of_partition_sizes_67503)
  let {cert shape_cert_67544} = assert(assert_arg_67543,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67545 aliases partition_res_67515
  let {[sum_of_partition_sizes_67503]f32 correct_shape_67545} = <shape_cert_67544>reshape((~sum_of_partition_sizes_67503),
                                                                                          partition_res_67515)
  let {bool assert_arg_67546} = eq_i32(1i32, 1i32)
  let {cert shape_cert_67547} = assert(assert_arg_67546,
                                       "value cannot match pattern",
                                       "./futlib/array.fut:98:3-98:3")
  -- correct_shape_67548 aliases partition_sizes_67527
  let {[1i32]i32 correct_shape_67548} = <shape_cert_67547>reshape((~1i32),
                                                                  partition_sizes_67527)
  -- as'_67549 aliases correct_shape_67530
  let {[sum_of_partition_sizes_67503]i32 as'_67549} = correct_shape_67530
  -- as'_67550 aliases correct_shape_67533
  let {[sum_of_partition_sizes_67503]bool as'_67550} = correct_shape_67533
  -- as'_67551 aliases correct_shape_67536
  let {[sum_of_partition_sizes_67503]f32 as'_67551} = correct_shape_67536
  -- as'_67552 aliases correct_shape_67539
  let {[sum_of_partition_sizes_67503]f32 as'_67552} = correct_shape_67539
  -- as'_67553 aliases correct_shape_67542
  let {[sum_of_partition_sizes_67503]f32 as'_67553} = correct_shape_67542
  -- as'_67554 aliases correct_shape_67545
  let {[sum_of_partition_sizes_67503]f32 as'_67554} = correct_shape_67545
  -- is_67555 aliases correct_shape_67548
  let {[1i32]i32 is_67555} = correct_shape_67548
  let {i32 s_sign_67556} = ssignum32 1i32
  let {bool backwards_67557} = eq_i32(s_sign_67556, -1i32)
  let {i32 w_minus_1_67558} = sub32(sum_of_partition_sizes_67503, 1i32)
  let {i32 i_def_67559} =
    -- Branch returns: {i32}
    if backwards_67557
    then {w_minus_1_67558} else {0i32}
  let {bool x_67560} = sle32(0i32, 0i32)
  let {bool y_67561} = slt32(0i32, 1i32)
  let {bool assert_arg_67562} = logand(x_67560, y_67561)
  let {cert bounds_check_67563} = assert(assert_arg_67562,
                                         "index out of bounds",
                                         "./futlib/array.fut:99:11-99:11")
  let {i32 j_67564} = <bounds_check_67563>is_67555[0i32]
  let {i32 j_m_i_67565} = sub32(j_67564, i_def_67559)
  let {i32 x_67566} = abs32 j_m_i_67565
  let {i32 x_67567} = abs32 1i32
  let {i32 y_67568} = sub32(x_67567, 1i32)
  let {i32 x_67569} = add32(x_67566, y_67568)
  let {i32 y_67570} = abs32 1i32
  let {i32 n_67571} = squot32(x_67569, y_67570)
  let {bool empty_slice_67572} = eq_i32(n_67571, 0i32)
  let {i32 m_67573} = sub32(n_67571, 1i32)
  let {i32 m_t_s_67574} = mul32(m_67573, 1i32)
  let {i32 i_p_m_t_s_67575} = add32(i_def_67559, m_t_s_67574)
  let {bool zero_leq_i_p_m_t_s_67576} = sle32(0i32, i_p_m_t_s_67575)
  let {bool i_p_m_t_s_leq_w_67577} = sle32(i_p_m_t_s_67575, sum_of_partition_sizes_67503)
  let {bool i_p_m_t_s_leq_w_67578} = slt32(i_p_m_t_s_67575, sum_of_partition_sizes_67503)
  let {bool zero_lte_i_67579} = sle32(0i32, i_def_67559)
  let {bool i_lte_j_67580} = sle32(i_def_67559, j_67564)
  let {bool y_67581} = logand(i_p_m_t_s_leq_w_67578, zero_lte_i_67579)
  let {bool y_67582} = logand(zero_leq_i_p_m_t_s_67576, y_67581)
  let {bool y_67583} = logand(i_lte_j_67580, y_67582)
  let {bool forwards_ok_67584} = logand(zero_lte_i_67579, y_67583)
  let {bool negone_lte_j_67585} = sle32(-1i32, j_67564)
  let {bool j_lte_i_67586} = sle32(j_67564, i_def_67559)
  let {bool y_67587} = logand(i_p_m_t_s_leq_w_67577, negone_lte_j_67585)
  let {bool y_67588} = logand(zero_leq_i_p_m_t_s_67576, y_67587)
  let {bool y_67589} = logand(j_lte_i_67586, y_67588)
  let {bool backwards_ok_67590} = logand(negone_lte_j_67585, y_67589)
  let {bool slice_ok_67591} =
    -- Branch returns: {bool}
    if backwards_67557
    then {backwards_ok_67590} else {forwards_ok_67584}
  let {bool ok_or_empty_67592} = logor(empty_slice_67572, slice_ok_67591)
  let {cert slice_cert_67593} = assert(ok_or_empty_67592, "slice out of bounds",
                                       "./futlib/array.fut:99:6-99:6")
  -- res_67594 aliases as'_67549
  let {[n_67571]i32 res_67594} = <slice_cert_67593>as'_67549[i_def_67559:+n_67571*1i32]
  -- res_67595 aliases as'_67550
  let {[n_67571]bool res_67595} = <slice_cert_67593>as'_67550[i_def_67559:+n_67571*1i32]
  -- res_67596 aliases as'_67551
  let {[n_67571]f32 res_67596} = <slice_cert_67593>as'_67551[i_def_67559:+n_67571*1i32]
  -- res_67597 aliases as'_67552
  let {[n_67571]f32 res_67597} = <slice_cert_67593>as'_67552[i_def_67559:+n_67571*1i32]
  -- res_67598 aliases as'_67553
  let {[n_67571]f32 res_67598} = <slice_cert_67593>as'_67553[i_def_67559:+n_67571*1i32]
  -- res_67599 aliases as'_67554
  let {[n_67571]f32 res_67599} = <slice_cert_67593>as'_67554[i_def_67559:+n_67571*1i32]
  let {bool assert_arg_67600} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67601} = assert(assert_arg_67600,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67602 aliases res_67594
  let {[n_67571]i32 result_proper_shape_67602} = <shape_cert_67601>reshape((~n_67571),
                                                                           res_67594)
  let {bool assert_arg_67603} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67604} = assert(assert_arg_67603,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67605 aliases res_67595
  let {[n_67571]bool result_proper_shape_67605} = <shape_cert_67604>reshape((~n_67571),
                                                                            res_67595)
  let {bool assert_arg_67606} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67607} = assert(assert_arg_67606,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67608 aliases res_67596
  let {[n_67571]f32 result_proper_shape_67608} = <shape_cert_67607>reshape((~n_67571),
                                                                           res_67596)
  let {bool assert_arg_67609} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67610} = assert(assert_arg_67609,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67611 aliases res_67597
  let {[n_67571]f32 result_proper_shape_67611} = <shape_cert_67610>reshape((~n_67571),
                                                                           res_67597)
  let {bool assert_arg_67612} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67613} = assert(assert_arg_67612,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67614 aliases res_67598
  let {[n_67571]f32 result_proper_shape_67614} = <shape_cert_67613>reshape((~n_67571),
                                                                           res_67598)
  let {bool assert_arg_67615} = eq_i32(n_67571, n_67571)
  let {cert shape_cert_67616} = assert(assert_arg_67615,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67617 aliases res_67599
  let {[n_67571]f32 result_proper_shape_67617} = <shape_cert_67616>reshape((~n_67571),
                                                                           res_67599)
  in {n_67571, result_proper_shape_67602, result_proper_shape_67605,
      result_proper_shape_67608, result_proper_shape_67611,
      result_proper_shape_67614, result_proper_shape_67617}
}

fun {i32} length_17491(i32 n_67618, [n_67618]bool nameless_67619,
                       [n_67618]f32 nameless_67620, [n_67618]f32 nameless_67621,
                       [n_67618]f32 nameless_67622,
                       [n_67618]f32 nameless_67623) = {
  {n_67618}
}

fun {i32} const_17522(i32 x_67624, i32 nameless_67625) = {
  {x_67624}
}

fun {*[?0]i32} replicate_17515(i32 n_67626, i32 x_67627) = {
  let {i32 size_67628; [size_67628]i32 zip_arg_67629} = iota_16188(n_67626)
  let {[size_67628]i32 res_67630} =
    map(size_67628,
        fn {i32} (i32 x_67631) =>
          let {i32 res_67632} = const_17522(x_67627, x_67631)
          in {res_67632},
        zip_arg_67629)
  let {bool assert_arg_67633} = eq_i32(size_67628, size_67628)
  let {cert shape_cert_67634} = assert(assert_arg_67633,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67635 aliases res_67630
  let {[size_67628]i32 result_proper_shape_67635} = <shape_cert_67634>reshape((~size_67628),
                                                                              res_67630)
  in {size_67628, result_proper_shape_67635}
}

fun {*[n_67636]i32} replicate_17512(i32 n_67636, i32 x_67637) = {
  let {i32 size_67638; [size_67638]i32 res_67639} = replicate_17515(n_67636,
                                                                    x_67637)
  let {bool assert_arg_67640} = eq_i32(n_67636, size_67638)
  let {cert shape_cert_67641} = assert(assert_arg_67640,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67642 aliases res_67639
  let {[n_67636]i32 result_proper_shape_67642} = <shape_cert_67641>reshape((~n_67636),
                                                                           res_67639)
  in {result_proper_shape_67642}
}

fun {*[m_67643]i32} scatter_17540(i32 m_67643, i32 n_67644,
                                  *[m_67643]i32 dest_67645,
                                  [n_67644]i32 is_67646,
                                  [n_67644]i32 vs_67647) = {
  let {bool write_cmp_67648} = eq_i32(n_67644, n_67644)
  let {cert write_cert_67649} = assert(write_cmp_67648,
                                       "length of index and value array does not match",
                                       "./futlib/array.fut:130:3-130:3")
  -- vs_write_sv_67650 aliases vs_67647
  let {[n_67644]i32 vs_write_sv_67650} = <write_cert_67649>reshape((~n_67644),
                                                                   vs_67647)
  let {[m_67643]i32 res_67651} =
    -- Consumes dest_67645
    scatter(n_67644,
            fn {i32, i32} (i32 write_index_67652, i32 write_value_67653) =>
              {write_index_67652, write_value_67653},
            {is_67646, vs_write_sv_67650}, (1, dest_67645))
  let {bool assert_arg_67654} = eq_i32(m_67643, m_67643)
  let {cert shape_cert_67655} = assert(assert_arg_67654,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67656 aliases res_67651
  let {[m_67643]i32 result_proper_shape_67656} = <shape_cert_67655>reshape((~m_67643),
                                                                           res_67651)
  in {result_proper_shape_67656}
}

fun {bool} >_17600(i32 x_67657, i32 y_67658) = {
  let {bool res_67659} = slt32(y_67658, x_67657)
  in {res_67659}
}

fun {f32} from_fraction_17605(i32 x_67660, i32 y_67661) = {
  let {f32 arg_67662} = i32_15734(x_67660)
  let {f32 arg_67663} = i32_15734(y_67661)
  let {f32 res_67664} = /_15600(arg_67662, arg_67663)
  in {res_67664}
}

fun {i32} u64_17670(i64 x_67665) = {
  let {i64 x_67666} = zext i64 x_67665 to i64
  let {i32 res_67667} = zext i64 x_67666 to i32
  in {res_67667}
}

fun {i32} u64_17668(i64 x_67668) = {
  let {i32 arg_67669} = u64_17670(x_67668)
  let {i32 res_67670} = unsign_15615(arg_67669)
  in {res_67670}
}

fun {i64, i64, i32} rand_17658(i64 inc_67671, i64 state_67672) = {
  let {i64 oldstate_67673} = state_67672
  let {i64 x_67674} = mul64(oldstate_67673, 6364136223846793005i64)
  let {i64 y_67675} = or64(inc_67671, 1i64)
  let {i64 res_67676} = add64(x_67674, y_67675)
  let {i64 state_67677} = res_67676
  let {i64 x_67678} = lshr64(oldstate_67673, 18i64)
  let {i64 x_67679} = xor64(x_67678, oldstate_67673)
  let {i64 arg_67680} = lshr64(x_67679, 27i64)
  let {i32 res_67681} = u64_17668(arg_67680)
  let {i32 xorshifted_67682} = res_67681
  let {i64 arg_67683} = lshr64(oldstate_67673, 59i64)
  let {i32 res_67684} = u64_17668(arg_67683)
  let {i32 rot_67685} = res_67684
  let {i32 x_67686} = lshr32(xorshifted_67682, rot_67685)
  let {i32 x_67687} = sub32(0i32, rot_67685)
  let {i32 y_67688} = and32(x_67687, 31i32)
  let {i32 y_67689} = shl32(xorshifted_67682, y_67688)
  let {i32 res_67690} = or32(x_67686, y_67689)
  in {inc_67671, state_67677, res_67690}
}

fun {i64, i64} rng_from_seed_17650(i32 size_67691, [size_67691]i32 xs_67692) = {
  let {i64 initseq_67693} = -2720673578348880933i64
  let {i64 state_67694} = 0i64
  let {i64 x_67695} = shl64(initseq_67693, 1i64)
  let {i64 res_67696} = or64(x_67695, 1i64)
  let {i64 inc_67697} = res_67696
  let {i64 res_67698, i64 res_67699, i32 res_67700} = rand_17658(inc_67697,
                                                                 state_67694)
  let {i64 inc_67701} = res_67698
  let {i64 state_67702} = res_67699
  let {i64 state_67703} = state_67702
  let {i64 res_67704} =
    loop {i64 state_67705} = {state_67703}
    for i_67707:i32 < size_67691
        i32 x_67706 in xs_67692 do {
      let {i64 y_67708} = i32_15661(x_67706)
      let {i64 res_67709} = add64(state_67705, y_67708)
      in {res_67709}
    }
  let {i64 state_67710} = res_67704
  let {i64 res_67711, i64 res_67712, i32 res_67713} = rand_17658(inc_67701,
                                                                 state_67710)
  in {res_67711, res_67712}
}

fun {i32} hash_17717(i32 x_67714) = {
  let {i32 x_67715} = lshr32(x_67714, 16i32)
  let {i32 x_67716} = xor32(x_67715, x_67714)
  let {i32 res_67717} = mul32(x_67716, 73244475i32)
  let {i32 x_67718} = res_67717
  let {i32 x_67719} = lshr32(x_67718, 16i32)
  let {i32 x_67720} = xor32(x_67719, x_67718)
  let {i32 res_67721} = mul32(x_67720, 73244475i32)
  let {i32 x_67722} = res_67721
  let {i32 x_67723} = lshr32(x_67722, 16i32)
  let {i32 res_67724} = xor32(x_67723, x_67722)
  let {i32 x_67725} = res_67724
  in {x_67725}
}

fun {[n_67726]i64, [n_67726]i64} split_rng_17712(i32 n_67726, i64 inc_67727,
                                                 i64 state_67728) = {
  let {[n_67726]i32 zip_arg_67729} = iota_16186(n_67726)
  let {[n_67726]i64 res_67730, [n_67726]i64 res_67731} =
    map(n_67726,
        fn {i64, i64} (i32 i_67732) =>
          let {i32 arg_67733} = xor32(i_67732, n_67726)
          let {i32 arg_67734} = hash_17717(arg_67733)
          let {i64 y_67735} = i32_15661(arg_67734)
          let {i64 arg_67736} = mul64(state_67728, y_67735)
          let {i64 res_67737, i64 res_67738,
               i32 res_67739} = rand_17658(inc_67727, arg_67736)
          in {res_67737, res_67738},
        zip_arg_67729)
  let {bool assert_arg_67740} = eq_i32(n_67726, n_67726)
  let {cert shape_cert_67741} = assert(assert_arg_67740,
                                       "shape of function result does not match shapes in return type",
                                       "[builtin]/futlib/random.fut:364:7-364:7")
  -- result_proper_shape_67742 aliases res_67730
  let {[n_67726]i64 result_proper_shape_67742} = <shape_cert_67741>reshape((~n_67726),
                                                                           res_67730)
  let {bool assert_arg_67743} = eq_i32(n_67726, n_67726)
  let {cert shape_cert_67744} = assert(assert_arg_67743,
                                       "shape of function result does not match shapes in return type",
                                       "[builtin]/futlib/random.fut:364:7-364:7")
  -- result_proper_shape_67745 aliases res_67731
  let {[n_67726]i64 result_proper_shape_67745} = <shape_cert_67744>reshape((~n_67726),
                                                                           res_67731)
  in {result_proper_shape_67742, result_proper_shape_67745}
}

fun {i64} to_i64_17801(i32 x_67746) = {
  let {i32 x_67747} = sign_15648(x_67746)
  let {i64 res_67748} = zext i32 x_67747 to i64
  in {res_67748}
}

fun {f32} i64_17806(i64 x_67749) = {
  let {f32 res_67750} = sitofp i64 x_67749 to f32
  in {res_67750}
}

fun {f32} to_D_17799(i32 x_67751) = {
  let {i64 arg_67752} = to_i64_17801(x_67751)
  let {f32 res_67753} = i64_17806(arg_67752)
  in {res_67753}
}

fun {i64, i64, f32} rand_17790(f32 min_r_67754, f32 max_r_67755, i64 rng_67756,
                               i64 rng_67757) = {
  let {i64 res_67758, i64 res_67759, i32 res_67760} = rand_17658(rng_67756,
                                                                 rng_67757)
  let {i64 rng'_67761} = res_67758
  let {i64 rng'_67762} = res_67759
  let {i32 x_67763} = res_67760
  let {f32 arg_67764} = to_D_17799(x_67763)
  let {i32 max_67765} = max_4379f()
  let {f32 arg_67766} = to_D_17799(max_67765)
  let {f32 res_67767} = /_15600(arg_67764, arg_67766)
  let {f32 x'_67768} = res_67767
  let {f32 arg_67769} = -_16513(max_r_67755, min_r_67754)
  let {f32 arg_67770} = *_15756(x'_67768, arg_67769)
  let {f32 res_67771} = +_16553(min_r_67754, arg_67770)
  in {rng'_67761, rng'_67762, res_67771}
}

fun {} lifted_17864() = {
  {}
}

fun {i64} lifted_17867(i64 ne_67772) = {
  {ne_67772}
}

fun {i64} lifted_17877(i64 x_67773) = {
  {x_67773}
}

fun {i64} lifted_17881(i64 x_67774, i64 x_67775) = {
  let {i64 res_67776} = mul64(x_67774, x_67775)
  in {res_67776}
}

fun {i64} lifted_17873(i32 size_67777, i64 ne_67778,
                       [size_67777]i64 as_67779) = {
  let {i64 res_67780} =
    reduce(size_67777,
           fn {i64} (i64 x_67781, i64 x_67782) =>
             let {i64 arg_67783} = lifted_17877(x_67781)
             let {i64 res_67784} = lifted_17881(arg_67783, x_67782)
             in {res_67784},
           {ne_67778}, as_67779)
  in {res_67780}
}

fun {} lifted_17891() = {
  {}
}

fun {i64} lifted_17894(i64 ne_67785) = {
  {ne_67785}
}

fun {i64} lifted_17904(i64 x_67786) = {
  {x_67786}
}

fun {i64} lifted_17908(i64 x_67787, i64 x_67788) = {
  let {i64 res_67789} = or64(x_67787, x_67788)
  in {res_67789}
}

fun {i64} lifted_17900(i32 size_67790, i64 ne_67791,
                       [size_67790]i64 as_67792) = {
  let {i64 res_67793} =
    reduce(size_67790,
           fn {i64} (i64 x_67794, i64 x_67795) =>
             let {i64 arg_67796} = lifted_17904(x_67794)
             let {i64 res_67797} = lifted_17908(arg_67796, x_67795)
             in {res_67797},
           {ne_67791}, as_67792)
  in {res_67793}
}

fun {i64, i64} join_rng_17840(i32 size_67798, [size_67798]i64 rngs_67799,
                              [size_67798]i64 rngs_67800) = {
  let {bool zip_cmp_67801} = eq_i32(size_67798, size_67798)
  let {cert zip_assert_67802} = assert(zip_cmp_67801, "arrays differ in length",
                                       "[builtin]/futlib/random.fut:368:18-368:18")
  -- rngs_zip_res_67803 aliases rngs_67800
  let {[size_67798]i64 rngs_zip_res_67803} = <zip_assert_67802>reshape((~size_67798),
                                                                       rngs_67800)
  let {[size_67798]i64 res_67804} =
    map(size_67798,
        fn {i64} (i64 x_67805, i64 x_67806) =>
          {x_67806},
        rngs_67799, rngs_zip_res_67803)
  let {bool assert_arg_67807} = eq_i32(size_67798, size_67798)
  let {cert shape_cert_67808} = assert(assert_arg_67807,
                                       "value cannot match pattern",
                                       "[builtin]/futlib/random.fut:368:5-368:5")
  -- correct_shape_67809 aliases res_67804
  let {[size_67798]i64 correct_shape_67809} = <shape_cert_67808>reshape((~size_67798),
                                                                        res_67804)
  -- states_67810 aliases correct_shape_67809
  let {[size_67798]i64 states_67810} = correct_shape_67809
  let {bool zip_cmp_67811} = eq_i32(size_67798, size_67798)
  let {cert zip_assert_67812} = assert(zip_cmp_67811, "arrays differ in length",
                                       "[builtin]/futlib/random.fut:369:16-369:16")
  -- rngs_zip_res_67813 aliases rngs_67800
  let {[size_67798]i64 rngs_zip_res_67813} = <zip_assert_67812>reshape((~size_67798),
                                                                       rngs_67800)
  let {[size_67798]i64 res_67814} =
    map(size_67798,
        fn {i64} (i64 x_67815, i64 x_67816) =>
          {x_67815},
        rngs_67799, rngs_zip_res_67813)
  let {bool assert_arg_67817} = eq_i32(size_67798, size_67798)
  let {cert shape_cert_67818} = assert(assert_arg_67817,
                                       "value cannot match pattern",
                                       "[builtin]/futlib/random.fut:369:5-369:5")
  -- correct_shape_67819 aliases res_67814
  let {[size_67798]i64 correct_shape_67819} = <shape_cert_67818>reshape((~size_67798),
                                                                        res_67814)
  -- incs_67820 aliases correct_shape_67819
  let {[size_67798]i64 incs_67820} = correct_shape_67819
  let {} = reduce_6992f()
  let {} = lifted_17864()
  let {i64 arg_67821} = lifted_17867(1i64)
  let {bool assert_arg_67822} = eq_i32(size_67798, size_67798)
  let {cert shape_cert_67823} = assert(assert_arg_67822,
                                       "function arguments of wrong shape",
                                       "[builtin]/futlib/random.fut:370:17-370:17")
  -- states_67824 aliases states_67810
  let {[size_67798]i64 states_67824} = <shape_cert_67823>reshape((~size_67798),
                                                                 states_67810)
  let {i64 res_67825} = lifted_17873(size_67798, arg_67821, states_67824)
  let {i64 state_67826} = res_67825
  let {} = reduce_6992f()
  let {} = lifted_17891()
  let {i64 arg_67827} = lifted_17894(0i64)
  let {bool assert_arg_67828} = eq_i32(size_67798, size_67798)
  let {cert shape_cert_67829} = assert(assert_arg_67828,
                                       "function arguments of wrong shape",
                                       "[builtin]/futlib/random.fut:371:15-371:15")
  -- incs_67830 aliases incs_67820
  let {[size_67798]i64 incs_67830} = <shape_cert_67829>reshape((~size_67798),
                                                               incs_67820)
  let {i64 res_67831} = lifted_17900(size_67798, arg_67827, incs_67830)
  let {i64 inc_67832} = res_67831
  in {inc_67832, state_67826}
}

fun {i64, i64, *[?0]f32} nrand_17767(f32 d_67833, f32 d_67834, i64 rng_67835,
                                     i64 rng_67836, i32 n_67837) = {
  -- res_67838 aliases rng_67835, rng_67836, n_67837
  -- res_67839 aliases rng_67835, rng_67836, n_67837
  let {[n_67837]i64 res_67838,
       [n_67837]i64 res_67839} = split_rng_17712(n_67837, rng_67835, rng_67836)
  let {bool assert_arg_67840} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67841} = assert(assert_arg_67840,
                                       "value cannot match pattern",
                                       "./least_squares.fut:75:5-75:5")
  -- correct_shape_67842 aliases res_67838
  let {[n_67837]i64 correct_shape_67842} = <shape_cert_67841>reshape((~n_67837),
                                                                     res_67838)
  let {bool assert_arg_67843} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67844} = assert(assert_arg_67843,
                                       "value cannot match pattern",
                                       "./least_squares.fut:75:5-75:5")
  -- correct_shape_67845 aliases res_67839
  let {[n_67837]i64 correct_shape_67845} = <shape_cert_67844>reshape((~n_67837),
                                                                     res_67839)
  -- rngs_67846 aliases correct_shape_67842
  let {[n_67837]i64 rngs_67846} = correct_shape_67842
  -- rngs_67847 aliases correct_shape_67845
  let {[n_67837]i64 rngs_67847} = correct_shape_67845
  let {bool zip_cmp_67848} = eq_i32(n_67837, n_67837)
  let {cert zip_assert_67849} = assert(zip_cmp_67848, "arrays differ in length",
                                       "./least_squares.fut:76:30-76:30")
  -- rngs_zip_res_67850 aliases rngs_67847
  let {[n_67837]i64 rngs_zip_res_67850} = <zip_assert_67849>reshape((~n_67837),
                                                                    rngs_67847)
  let {[n_67837]i64 res_67851, [n_67837]i64 res_67852, [n_67837]f32 res_67853} =
    map(n_67837,
        fn {i64, i64, f32} (i64 rng_67854, i64 rng_67855) =>
          let {i64 res_67856, i64 res_67857,
               f32 res_67858} = rand_17790(d_67833, d_67834, rng_67854,
                                           rng_67855)
          in {res_67856, res_67857, res_67858},
        rngs_67846, rngs_zip_res_67850)
  let {bool assert_arg_67859} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67860} = assert(assert_arg_67859,
                                       "value cannot match pattern",
                                       "./least_squares.fut:76:5-76:5")
  -- correct_shape_67861 aliases res_67851
  let {[n_67837]i64 correct_shape_67861} = <shape_cert_67860>reshape((~n_67837),
                                                                     res_67851)
  let {bool assert_arg_67862} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67863} = assert(assert_arg_67862,
                                       "value cannot match pattern",
                                       "./least_squares.fut:76:5-76:5")
  -- correct_shape_67864 aliases res_67852
  let {[n_67837]i64 correct_shape_67864} = <shape_cert_67863>reshape((~n_67837),
                                                                     res_67852)
  let {bool assert_arg_67865} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67866} = assert(assert_arg_67865,
                                       "value cannot match pattern",
                                       "./least_squares.fut:76:5-76:5")
  -- correct_shape_67867 aliases res_67853
  let {[n_67837]f32 correct_shape_67867} = <shape_cert_67866>reshape((~n_67837),
                                                                     res_67853)
  -- rngs'_67868 aliases correct_shape_67861
  let {[n_67837]i64 rngs'_67868} = correct_shape_67861
  -- rngs'_67869 aliases correct_shape_67864
  let {[n_67837]i64 rngs'_67869} = correct_shape_67864
  -- xs_67870 aliases correct_shape_67867
  let {[n_67837]f32 xs_67870} = correct_shape_67867
  let {bool assert_arg_67871} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67872} = assert(assert_arg_67871,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:77:9-77:9")
  -- rngs'_67873 aliases rngs'_67868
  let {[n_67837]i64 rngs'_67873} = <shape_cert_67872>reshape((~n_67837),
                                                             rngs'_67868)
  let {bool assert_arg_67874} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67875} = assert(assert_arg_67874,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:77:9-77:9")
  -- rngs'_67876 aliases rngs'_67869
  let {[n_67837]i64 rngs'_67876} = <shape_cert_67875>reshape((~n_67837),
                                                             rngs'_67869)
  let {i64 res_67877, i64 res_67878} = join_rng_17840(n_67837, rngs'_67873,
                                                      rngs'_67876)
  let {bool assert_arg_67879} = eq_i32(n_67837, n_67837)
  let {cert shape_cert_67880} = assert(assert_arg_67879,
                                       "shape of function result does not match shapes in return type",
                                       "./least_squares.fut:74:7-74:7")
  -- result_proper_shape_67881 aliases xs_67870
  let {[n_67837]f32 result_proper_shape_67881} = <shape_cert_67880>reshape((~n_67837),
                                                                           xs_67870)
  in {n_67837, res_67877, res_67878, result_proper_shape_67881}
}

fun {} lifted_17969() = {
  {}
}

fun {[?0]f32} lifted_17973(i32 n_67882, [n_67882]f32 as_67883) = {
  let {bool assert_arg_67884} = eq_i32(n_67882, n_67882)
  let {cert shape_cert_67885} = assert(assert_arg_67884,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67886 aliases as_67883
  let {[n_67882]f32 result_proper_shape_67886} = <shape_cert_67885>reshape((~n_67882),
                                                                           as_67883)
  in {n_67882, result_proper_shape_67886}
}

fun {[?0]f32, [?1]f32} lifted_17987(i32 n_67887, i32 size_67888,
                                    [size_67888]f32 as_67889,
                                    [n_67887]f32 bs_67890) = {
  let {bool assert_arg_67891} = eq_i32(size_67888, size_67888)
  let {cert shape_cert_67892} = assert(assert_arg_67891,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67893 aliases as_67889
  let {[size_67888]f32 result_proper_shape_67893} = <shape_cert_67892>reshape((~size_67888),
                                                                              as_67889)
  let {bool assert_arg_67894} = eq_i32(n_67887, n_67887)
  let {cert shape_cert_67895} = assert(assert_arg_67894,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67896 aliases bs_67890
  let {[n_67887]f32 result_proper_shape_67896} = <shape_cert_67895>reshape((~n_67887),
                                                                           bs_67890)
  in {size_67888, n_67887, result_proper_shape_67893, result_proper_shape_67896}
}

fun {f32} lifted_18031(f32 lower_bound_67897) = {
  {lower_bound_67897}
}

fun {f32, f32} lifted_18038(f32 lower_bound_67898, f32 upper_bound_67899) = {
  {lower_bound_67898, upper_bound_67899}
}

fun {f32} lifted_18049(f32 x_67900) = {
  {x_67900}
}

fun {f32} lifted_18052(f32 x_67901) = {
  {x_67901}
}

fun {f32} lifted_18056(f32 x_67902, f32 y_67903) = {
  let {f32 res_67904} = fsub32(x_67902, y_67903)
  in {res_67904}
}

fun {f32} lifted_18060(f32 x_67905) = {
  {x_67905}
}

fun {f32} lifted_18064(f32 x_67906, f32 y_67907) = {
  let {f32 res_67908} = fmul32(x_67906, y_67907)
  in {res_67908}
}

fun {f32} lifted_18069(f32 x_67909, f32 y_67910) = {
  let {f32 res_67911} = fadd32(x_67909, y_67910)
  in {res_67911}
}

fun {f32} lifted_18047(f32 lower_bound_67912, f32 upper_bound_67913,
                       f32 r_67914) = {
  let {f32 arg_67915} = lifted_18049(lower_bound_67912)
  let {f32 arg_67916} = lifted_18052(upper_bound_67913)
  let {f32 arg_67917} = lifted_18056(arg_67916, lower_bound_67912)
  let {f32 arg_67918} = lifted_18060(arg_67917)
  let {f32 arg_67919} = lifted_18064(arg_67918, r_67914)
  let {f32 res_67920} = lifted_18069(arg_67915, arg_67919)
  in {res_67920}
}

fun {*[?0]f32} lifted_18011(i32 n_67921, i32 size_67922, i32 size_67923,
                            [size_67922]f32 as_67924, [size_67923]f32 bs_67925,
                            [n_67921]f32 cs_67926) = {
  let {bool zip_cmp_67927} = eq_i32(size_67922, size_67923)
  let {cert zip_assert_67928} = assert(zip_cmp_67927, "arrays differ in length",
                                       "./futlib/array.fut:67:32-67:32")
  -- bs_zip_res_67929 aliases bs_67925
  let {[size_67922]f32 bs_zip_res_67929} = <zip_assert_67928>reshape((~size_67922),
                                                                     bs_67925)
  let {bool zip_cmp_67930} = eq_i32(size_67922, n_67921)
  let {cert zip_assert_67931} = assert(zip_cmp_67930, "arrays differ in length",
                                       "./futlib/array.fut:67:32-67:32")
  -- cs_zip_res_67932 aliases cs_67926
  let {[size_67922]f32 cs_zip_res_67932} = <zip_assert_67931>reshape((~size_67922),
                                                                     cs_67926)
  let {bool zip_cmp_67933} = eq_i32(size_67922, size_67922)
  let {cert zip_assert_67934} = assert(zip_cmp_67933, "arrays differ in length",
                                       "./futlib/array.fut:67:3-67:3")
  -- bs_zip_res_zip_res_67935 aliases bs_zip_res_67929
  let {[size_67922]f32 bs_zip_res_zip_res_67935} = <zip_assert_67934>reshape((~size_67922),
                                                                             bs_zip_res_67929)
  let {bool zip_cmp_67936} = eq_i32(size_67922, size_67922)
  let {cert zip_assert_67937} = assert(zip_cmp_67936, "arrays differ in length",
                                       "./futlib/array.fut:67:3-67:3")
  -- cs_zip_res_zip_res_67938 aliases cs_zip_res_67932
  let {[size_67922]f32 cs_zip_res_zip_res_67938} = <zip_assert_67937>reshape((~size_67922),
                                                                             cs_zip_res_67932)
  let {[size_67922]f32 res_67939} =
    map(size_67922,
        fn {f32} (f32 a_67940, f32 b_67941, f32 c_67942) =>
          let {f32 arg_67943} = lifted_18031(a_67940)
          let {f32 arg_67944, f32 arg_67945} = lifted_18038(arg_67943, b_67941)
          let {f32 res_67946} = lifted_18047(arg_67944, arg_67945, c_67942)
          in {res_67946},
        as_67924, bs_zip_res_zip_res_67935, cs_zip_res_zip_res_67938)
  let {bool assert_arg_67947} = eq_i32(size_67922, size_67922)
  let {cert shape_cert_67948} = assert(assert_arg_67947,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67949 aliases res_67939
  let {[size_67922]f32 result_proper_shape_67949} = <shape_cert_67948>reshape((~size_67922),
                                                                              res_67939)
  in {size_67922, result_proper_shape_67949}
}

fun {*[?0]f32} init_i_17967(i32 num_free_vars_67950,
                            [num_free_vars_67950]f32 lower_bounds_67951,
                            [num_free_vars_67950]f32 upper_bounds_67952,
                            [num_free_vars_67950]f32 rs_67953) = {
  let {} = map3_7007f()
  let {} = lifted_17969()
  let {bool assert_arg_67954} = eq_i32(num_free_vars_67950, num_free_vars_67950)
  let {cert shape_cert_67955} = assert(assert_arg_67954,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- lower_bounds_67956 aliases lower_bounds_67951
  let {[num_free_vars_67950]f32 lower_bounds_67956} = <shape_cert_67955>reshape((~num_free_vars_67950),
                                                                                lower_bounds_67951)
  -- arg_67958 aliases num_free_vars_67950, lower_bounds_67956
  let {i32 size_67957; [size_67957]f32 arg_67958} = lifted_17973(num_free_vars_67950,
                                                                 lower_bounds_67956)
  let {bool assert_arg_67959} = eq_i32(size_67957, size_67957)
  let {cert shape_cert_67960} = assert(assert_arg_67959,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- arg_67961 aliases arg_67958
  let {[size_67957]f32 arg_67961} = <shape_cert_67960>reshape((~size_67957),
                                                              arg_67958)
  let {bool assert_arg_67962} = eq_i32(num_free_vars_67950, num_free_vars_67950)
  let {cert shape_cert_67963} = assert(assert_arg_67962,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- upper_bounds_67964 aliases upper_bounds_67952
  let {[num_free_vars_67950]f32 upper_bounds_67964} = <shape_cert_67963>reshape((~num_free_vars_67950),
                                                                                upper_bounds_67952)
  -- arg_67967 aliases num_free_vars_67950, size_67957, arg_67961, upper_bounds_67964
  -- arg_67968 aliases num_free_vars_67950, size_67957, arg_67961, upper_bounds_67964
  let {i32 size_67965, i32 size_67966; [size_67965]f32 arg_67967,
                                       [size_67966]f32 arg_67968} = lifted_17987(num_free_vars_67950,
                                                                                 size_67957,
                                                                                 arg_67961,
                                                                                 upper_bounds_67964)
  let {bool assert_arg_67969} = eq_i32(size_67965, size_67965)
  let {cert shape_cert_67970} = assert(assert_arg_67969,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- arg_67971 aliases arg_67967
  let {[size_67965]f32 arg_67971} = <shape_cert_67970>reshape((~size_67965),
                                                              arg_67967)
  let {bool assert_arg_67972} = eq_i32(size_67966, size_67966)
  let {cert shape_cert_67973} = assert(assert_arg_67972,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- arg_67974 aliases arg_67968
  let {[size_67966]f32 arg_67974} = <shape_cert_67973>reshape((~size_67966),
                                                              arg_67968)
  let {bool assert_arg_67975} = eq_i32(num_free_vars_67950, num_free_vars_67950)
  let {cert shape_cert_67976} = assert(assert_arg_67975,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:136:53-136:53")
  -- rs_67977 aliases rs_67953
  let {[num_free_vars_67950]f32 rs_67977} = <shape_cert_67976>reshape((~num_free_vars_67950),
                                                                      rs_67953)
  let {i32 size_67978; [size_67978]f32 res_67979} = lifted_18011(num_free_vars_67950,
                                                                 size_67965,
                                                                 size_67966,
                                                                 arg_67971,
                                                                 arg_67974,
                                                                 rs_67977)
  let {bool assert_arg_67980} = eq_i32(size_67978, size_67978)
  let {cert shape_cert_67981} = assert(assert_arg_67980,
                                       "shape of function result does not match shapes in return type",
                                       "./least_squares.fut:136:14-136:14")
  -- result_proper_shape_67982 aliases res_67979
  let {[size_67978]f32 result_proper_shape_67982} = <shape_cert_67981>reshape((~size_67978),
                                                                              res_67979)
  in {size_67978, result_proper_shape_67982}
}

fun {[?0]f32} lifted_18132(i32 size_67983, [size_67983]f32 f_67984) = {
  let {bool assert_arg_67985} = eq_i32(size_67983, size_67983)
  let {cert shape_cert_67986} = assert(assert_arg_67985,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67987 aliases f_67984
  let {[size_67983]f32 result_proper_shape_67987} = <shape_cert_67986>reshape((~size_67983),
                                                                              f_67984)
  in {size_67983, result_proper_shape_67987}
}

fun {[?0]i32, [?1]f32} lifted_18145(i32 n_67988, i32 size_67989,
                                    [size_67989]f32 f_67990,
                                    [n_67988]i32 as_67991) = {
  let {bool assert_arg_67992} = eq_i32(n_67988, n_67988)
  let {cert shape_cert_67993} = assert(assert_arg_67992,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67994 aliases as_67991
  let {[n_67988]i32 result_proper_shape_67994} = <shape_cert_67993>reshape((~n_67988),
                                                                           as_67991)
  let {bool assert_arg_67995} = eq_i32(size_67989, size_67989)
  let {cert shape_cert_67996} = assert(assert_arg_67995,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_67997 aliases f_67990
  let {[size_67989]f32 result_proper_shape_67997} = <shape_cert_67996>reshape((~size_67989),
                                                                              f_67990)
  in {n_67988, size_67989, result_proper_shape_67994, result_proper_shape_67997}
}

fun {i32, [?0]f32} lifted_18214(i32 size_67998, [size_67998]f32 xs_67999,
                                i32 fv_68000) = {
  let {bool assert_arg_68001} = eq_i32(size_67998, size_67998)
  let {cert shape_cert_68002} = assert(assert_arg_68001,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68003 aliases xs_67999
  let {[size_67998]f32 result_proper_shape_68003} = <shape_cert_68002>reshape((~size_67998),
                                                                              xs_67999)
  in {size_67998, fv_68000, result_proper_shape_68003}
}

fun {f32} lifted_18234(i32 size_68004, i32 fv_68005, [size_68004]f32 xs_68006,
                       bool fixed_68007, f32 x_68008, f32 nameless_68009,
                       f32 nameless_68010, f32 nameless_68011) = {
  let {f32 res_68012} =
    -- Branch returns: {f32}
    if fixed_68007
    then {x_68008} else {
      let {f32 res_68013} = xs_68006[fv_68005]
      in {res_68013}
    }
  in {res_68012}
}

fun {*[?0]f32} lifted_18173(i32 n_68014, i32 size_68015, i32 size_68016,
                            [size_68015]i32 as_68017, [size_68016]f32 f_68018,
                            [n_68014]bool bs_68019, [n_68014]f32 bs_68020,
                            [n_68014]f32 bs_68021, [n_68014]f32 bs_68022,
                            [n_68014]f32 bs_68023) = {
  let {bool zip_cmp_68024} = eq_i32(size_68015, n_68014)
  let {cert zip_assert_68025} = assert(zip_cmp_68024, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_68026 aliases bs_68019
  let {[size_68015]bool bs_zip_res_68026} = <zip_assert_68025>reshape((~size_68015),
                                                                      bs_68019)
  let {bool zip_cmp_68027} = eq_i32(size_68015, n_68014)
  let {cert zip_assert_68028} = assert(zip_cmp_68027, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_68029 aliases bs_68020
  let {[size_68015]f32 bs_zip_res_68029} = <zip_assert_68028>reshape((~size_68015),
                                                                     bs_68020)
  let {bool zip_cmp_68030} = eq_i32(size_68015, n_68014)
  let {cert zip_assert_68031} = assert(zip_cmp_68030, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_68032 aliases bs_68021
  let {[size_68015]f32 bs_zip_res_68032} = <zip_assert_68031>reshape((~size_68015),
                                                                     bs_68021)
  let {bool zip_cmp_68033} = eq_i32(size_68015, n_68014)
  let {cert zip_assert_68034} = assert(zip_cmp_68033, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_68035 aliases bs_68022
  let {[size_68015]f32 bs_zip_res_68035} = <zip_assert_68034>reshape((~size_68015),
                                                                     bs_68022)
  let {bool zip_cmp_68036} = eq_i32(size_68015, n_68014)
  let {cert zip_assert_68037} = assert(zip_cmp_68036, "arrays differ in length",
                                       "./futlib/array.fut:63:27-63:27")
  -- bs_zip_res_68038 aliases bs_68023
  let {[size_68015]f32 bs_zip_res_68038} = <zip_assert_68037>reshape((~size_68015),
                                                                     bs_68023)
  let {bool zip_cmp_68039} = eq_i32(size_68015, size_68015)
  let {cert zip_assert_68040} = assert(zip_cmp_68039, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_68041 aliases bs_zip_res_68026
  let {[size_68015]bool bs_zip_res_zip_res_68041} = <zip_assert_68040>reshape((~size_68015),
                                                                              bs_zip_res_68026)
  let {bool zip_cmp_68042} = eq_i32(size_68015, size_68015)
  let {cert zip_assert_68043} = assert(zip_cmp_68042, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_68044 aliases bs_zip_res_68029
  let {[size_68015]f32 bs_zip_res_zip_res_68044} = <zip_assert_68043>reshape((~size_68015),
                                                                             bs_zip_res_68029)
  let {bool zip_cmp_68045} = eq_i32(size_68015, size_68015)
  let {cert zip_assert_68046} = assert(zip_cmp_68045, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_68047 aliases bs_zip_res_68032
  let {[size_68015]f32 bs_zip_res_zip_res_68047} = <zip_assert_68046>reshape((~size_68015),
                                                                             bs_zip_res_68032)
  let {bool zip_cmp_68048} = eq_i32(size_68015, size_68015)
  let {cert zip_assert_68049} = assert(zip_cmp_68048, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_68050 aliases bs_zip_res_68035
  let {[size_68015]f32 bs_zip_res_zip_res_68050} = <zip_assert_68049>reshape((~size_68015),
                                                                             bs_zip_res_68035)
  let {bool zip_cmp_68051} = eq_i32(size_68015, size_68015)
  let {cert zip_assert_68052} = assert(zip_cmp_68051, "arrays differ in length",
                                       "./futlib/array.fut:63:3-63:3")
  -- bs_zip_res_zip_res_68053 aliases bs_zip_res_68038
  let {[size_68015]f32 bs_zip_res_zip_res_68053} = <zip_assert_68052>reshape((~size_68015),
                                                                             bs_zip_res_68038)
  let {[size_68015]f32 res_68054} =
    map(size_68015,
        fn {f32} (i32 a_68055, bool b_68056, f32 b_68057, f32 b_68058,
                  f32 b_68059, f32 b_68060) =>
          let {bool assert_arg_68061} = eq_i32(size_68016, size_68016)
          let {cert shape_cert_68062} = assert(assert_arg_68061,
                                               "function arguments of wrong shape",
                                               "./futlib/array.fut:63:19-63:19")
          -- f_68063 aliases f_68018
          let {[size_68016]f32 f_68063} = <shape_cert_68062>reshape((~size_68016),
                                                                    f_68018)
          -- arg_68066 aliases size_68016, a_68055, f_68063
          let {i32 size_68064; i32 arg_68065,
                               [size_68064]f32 arg_68066} = lifted_18214(size_68016,
                                                                         f_68063,
                                                                         a_68055)
          let {bool assert_arg_68067} = eq_i32(size_68064, size_68064)
          let {cert shape_cert_68068} = assert(assert_arg_68067,
                                               "function arguments of wrong shape",
                                               "./futlib/array.fut:63:19-63:19")
          -- arg_68069 aliases arg_68066
          let {[size_68064]f32 arg_68069} = <shape_cert_68068>reshape((~size_68064),
                                                                      arg_68066)
          let {f32 res_68070} = lifted_18234(size_68064, arg_68065, arg_68069,
                                             b_68056, b_68057, b_68058, b_68059,
                                             b_68060)
          in {res_68070},
        as_68017, bs_zip_res_zip_res_68041, bs_zip_res_zip_res_68044,
        bs_zip_res_zip_res_68047, bs_zip_res_zip_res_68050,
        bs_zip_res_zip_res_68053)
  let {bool assert_arg_68071} = eq_i32(size_68015, size_68015)
  let {cert shape_cert_68072} = assert(assert_arg_68071,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68073 aliases res_68054
  let {[size_68015]f32 result_proper_shape_68073} = <shape_cert_68072>reshape((~size_68015),
                                                                              res_68054)
  in {size_68015, result_proper_shape_68073}
}

fun {*[?0]f32} active_vars_18129(i32 num_vars_68074, i32 num_active_68075,
                                 [num_vars_68074]i32 vars_to_free_vars_68076,
                                 [num_vars_68074]bool variables_68077,
                                 [num_vars_68074]f32 variables_68078,
                                 [num_vars_68074]f32 variables_68079,
                                 [num_vars_68074]f32 variables_68080,
                                 [num_vars_68074]f32 variables_68081,
                                 [num_active_68075]f32 xs_68082) = {
  let {} = map2_7006f()
  let {bool assert_arg_68083} = eq_i32(num_active_68075, num_active_68075)
  let {cert shape_cert_68084} = assert(assert_arg_68083,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- xs_68085 aliases xs_68082
  let {[num_active_68075]f32 xs_68085} = <shape_cert_68084>reshape((~num_active_68075),
                                                                   xs_68082)
  -- arg_68087 aliases num_active_68075, xs_68085
  let {i32 size_68086; [size_68086]f32 arg_68087} = lifted_18132(num_active_68075,
                                                                 xs_68085)
  let {bool assert_arg_68088} = eq_i32(size_68086, size_68086)
  let {cert shape_cert_68089} = assert(assert_arg_68088,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- arg_68090 aliases arg_68087
  let {[size_68086]f32 arg_68090} = <shape_cert_68089>reshape((~size_68086),
                                                              arg_68087)
  let {bool assert_arg_68091} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68092} = assert(assert_arg_68091,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- vars_to_free_vars_68093 aliases vars_to_free_vars_68076
  let {[num_vars_68074]i32 vars_to_free_vars_68093} = <shape_cert_68092>reshape((~num_vars_68074),
                                                                                vars_to_free_vars_68076)
  -- arg_68096 aliases num_vars_68074, size_68086, arg_68090, vars_to_free_vars_68093
  -- arg_68097 aliases num_vars_68074, size_68086, arg_68090, vars_to_free_vars_68093
  let {i32 size_68094, i32 size_68095; [size_68094]i32 arg_68096,
                                       [size_68095]f32 arg_68097} = lifted_18145(num_vars_68074,
                                                                                 size_68086,
                                                                                 arg_68090,
                                                                                 vars_to_free_vars_68093)
  let {bool assert_arg_68098} = eq_i32(size_68094, size_68094)
  let {cert shape_cert_68099} = assert(assert_arg_68098,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- arg_68100 aliases arg_68096
  let {[size_68094]i32 arg_68100} = <shape_cert_68099>reshape((~size_68094),
                                                              arg_68096)
  let {bool assert_arg_68101} = eq_i32(size_68095, size_68095)
  let {cert shape_cert_68102} = assert(assert_arg_68101,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- arg_68103 aliases arg_68097
  let {[size_68095]f32 arg_68103} = <shape_cert_68102>reshape((~size_68095),
                                                              arg_68097)
  let {bool assert_arg_68104} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68105} = assert(assert_arg_68104,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- variables_68106 aliases variables_68077
  let {[num_vars_68074]bool variables_68106} = <shape_cert_68105>reshape((~num_vars_68074),
                                                                         variables_68077)
  let {bool assert_arg_68107} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68108} = assert(assert_arg_68107,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- variables_68109 aliases variables_68078
  let {[num_vars_68074]f32 variables_68109} = <shape_cert_68108>reshape((~num_vars_68074),
                                                                        variables_68078)
  let {bool assert_arg_68110} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68111} = assert(assert_arg_68110,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- variables_68112 aliases variables_68079
  let {[num_vars_68074]f32 variables_68112} = <shape_cert_68111>reshape((~num_vars_68074),
                                                                        variables_68079)
  let {bool assert_arg_68113} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68114} = assert(assert_arg_68113,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- variables_68115 aliases variables_68080
  let {[num_vars_68074]f32 variables_68115} = <shape_cert_68114>reshape((~num_vars_68074),
                                                                        variables_68080)
  let {bool assert_arg_68116} = eq_i32(num_vars_68074, num_vars_68074)
  let {cert shape_cert_68117} = assert(assert_arg_68116,
                                       "function arguments of wrong shape",
                                       "./least_squares.fut:106:5-106:5")
  -- variables_68118 aliases variables_68081
  let {[num_vars_68074]f32 variables_68118} = <shape_cert_68117>reshape((~num_vars_68074),
                                                                        variables_68081)
  let {i32 size_68119; [size_68119]f32 res_68120} = lifted_18173(num_vars_68074,
                                                                 size_68094,
                                                                 size_68095,
                                                                 arg_68100,
                                                                 arg_68103,
                                                                 variables_68106,
                                                                 variables_68109,
                                                                 variables_68112,
                                                                 variables_68115,
                                                                 variables_68118)
  let {bool assert_arg_68121} = eq_i32(size_68119, size_68119)
  let {cert shape_cert_68122} = assert(assert_arg_68121,
                                       "shape of function result does not match shapes in return type",
                                       "./least_squares.fut:102:7-102:7")
  -- result_proper_shape_68123 aliases res_68120
  let {[size_68119]f32 result_proper_shape_68123} = <shape_cert_68122>reshape((~size_68119),
                                                                              res_68120)
  in {size_68119, result_proper_shape_68123}
}

fun {f32, f32, f32, f32, f32} heston_parameters_from_vector_18311
([5i32]f32 x_68124) = {
  let {bool x_68125} = sle32(0i32, 0i32)
  let {bool y_68126} = slt32(0i32, 5i32)
  let {bool assert_arg_68127} = logand(x_68125, y_68126)
  let {cert bounds_check_68128} = assert(assert_arg_68127,
                                         "index out of bounds",
                                         "./heston.fut:27:24-27:24")
  let {f32 res_68129} = <bounds_check_68128>x_68124[0i32]
  let {bool x_68130} = sle32(0i32, 1i32)
  let {bool y_68131} = slt32(1i32, 5i32)
  let {bool assert_arg_68132} = logand(x_68130, y_68131)
  let {cert bounds_check_68133} = assert(assert_arg_68132,
                                         "index out of bounds",
                                         "./heston.fut:28:26-28:26")
  let {f32 res_68134} = <bounds_check_68133>x_68124[1i32]
  let {bool x_68135} = sle32(0i32, 2i32)
  let {bool y_68136} = slt32(2i32, 5i32)
  let {bool assert_arg_68137} = logand(x_68135, y_68136)
  let {cert bounds_check_68138} = assert(assert_arg_68137,
                                         "index out of bounds",
                                         "./heston.fut:29:19-29:19")
  let {f32 res_68139} = <bounds_check_68138>x_68124[2i32]
  let {bool x_68140} = sle32(0i32, 3i32)
  let {bool y_68141} = slt32(3i32, 5i32)
  let {bool assert_arg_68142} = logand(x_68140, y_68141)
  let {cert bounds_check_68143} = assert(assert_arg_68142,
                                         "index out of bounds",
                                         "./heston.fut:30:22-30:22")
  let {f32 res_68144} = <bounds_check_68143>x_68124[3i32]
  let {bool x_68145} = sle32(0i32, 4i32)
  let {bool y_68146} = slt32(4i32, 5i32)
  let {bool assert_arg_68147} = logand(x_68145, y_68146)
  let {cert bounds_check_68148} = assert(assert_arg_68147,
                                         "index out of bounds",
                                         "./heston.fut:31:27-31:27")
  let {f32 res_68149} = <bounds_check_68148>x_68124[4i32]
  in {res_68139, res_68129, res_68134, res_68144, res_68149}
}

fun {f32, f32} *_18441(f32 a_68150, f32 b_68151, f32 c_68152, f32 d_68153) = {
  let {f32 arg_68154} = *_15756(a_68150, c_68152)
  let {f32 arg_68155} = *_15756(b_68151, d_68153)
  let {f32 res_68156} = -_16513(arg_68154, arg_68155)
  let {f32 arg_68157} = *_15756(b_68151, c_68152)
  let {f32 arg_68158} = *_15756(a_68150, d_68153)
  let {f32 res_68159} = +_16553(arg_68157, arg_68158)
  in {res_68156, res_68159}
}

fun {f32, f32} *!_18436(f32 x_68160, f32 x_68161, f32 y_68162, f32 y_68163) = {
  let {f32 res_68164, f32 res_68165} = *_18441(x_68160, x_68161, y_68162,
                                               y_68163)
  in {res_68164, res_68165}
}

fun {f32, f32} /_18470(f32 a_68166, f32 b_68167, f32 c_68168, f32 d_68169) = {
  let {f32 arg_68170} = *_15756(a_68166, c_68168)
  let {f32 arg_68171} = *_15756(b_68167, d_68169)
  let {f32 arg_68172} = +_16553(arg_68170, arg_68171)
  let {f32 arg_68173} = *_15756(c_68168, c_68168)
  let {f32 arg_68174} = *_15756(d_68169, d_68169)
  let {f32 arg_68175} = +_16553(arg_68173, arg_68174)
  let {f32 res_68176} = /_15600(arg_68172, arg_68175)
  let {f32 arg_68177} = *_15756(b_68167, c_68168)
  let {f32 arg_68178} = *_15756(a_68166, d_68169)
  let {f32 arg_68179} = -_16513(arg_68177, arg_68178)
  let {f32 arg_68180} = *_15756(c_68168, c_68168)
  let {f32 arg_68181} = *_15756(d_68169, d_68169)
  let {f32 arg_68182} = +_16553(arg_68180, arg_68181)
  let {f32 res_68183} = /_15600(arg_68179, arg_68182)
  in {res_68176, res_68183}
}

fun {f32, f32} /!_18465(f32 x_68184, f32 x_68185, f32 y_68186, f32 y_68187) = {
  let {f32 res_68188, f32 res_68189} = /_18470(x_68184, x_68185, y_68186,
                                               y_68187)
  in {res_68188, res_68189}
}

fun {f32, f32} mk_im_18501(f32 b_68190) = {
  let {f32 res_68191} = i32_15734(0i32)
  in {res_68191, b_68190}
}

fun {bool, [?0]f32, f32, f32, [?1]i32, [?2]f32, [?2]f32, f32, f32, bool, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32} lifted_18598
(i32 size_68192, i32 size_68193, i32 size_68194, bool f_68195,
 [size_68192]f32 f_68196, f32 f_68197, f32 f_68198, [size_68193]i32 f_68199,
 [size_68194]f32 f_68200, [size_68194]f32 f_68201, f32 f_68202, f32 f_68203,
 bool f_68204, f32 f_68205, f32 f_68206, f32 f_68207, f32 f_68208, f32 f_68209,
 f32 f_68210, f32 f_68211, f32 f_68212, f32 f_68213, f32 f_68214, f32 f_68215,
 f32 f_68216, f32 f_68217, f32 f_68218, f32 f_68219, f32 f_68220, f32 f_68221,
 f32 f_68222, f32 f_68223, f32 f_68224, f32 f_68225, f32 f_68226, f32 f_68227,
 f32 f_68228, f32 f_68229, f32 f_68230, f32 f_68231, f32 f_68232, f32 f_68233,
 f32 f_68234, f32 f_68235, f32 f_68236, f32 f_68237, f32 f_68238, f32 f_68239,
 f32 f_68240, f32 f_68241, f32 f_68242, f32 f_68243, f32 f_68244,
 f32 f_68245) = {
  let {bool assert_arg_68246} = eq_i32(size_68192, size_68192)
  let {cert shape_cert_68247} = assert(assert_arg_68246,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68248 aliases f_68196
  let {[size_68192]f32 result_proper_shape_68248} = <shape_cert_68247>reshape((~size_68192),
                                                                              f_68196)
  let {bool assert_arg_68249} = eq_i32(size_68193, size_68193)
  let {cert shape_cert_68250} = assert(assert_arg_68249,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68251 aliases f_68199
  let {[size_68193]i32 result_proper_shape_68251} = <shape_cert_68250>reshape((~size_68193),
                                                                              f_68199)
  let {bool assert_arg_68252} = eq_i32(size_68194, size_68194)
  let {cert shape_cert_68253} = assert(assert_arg_68252,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68254 aliases f_68200
  let {[size_68194]f32 result_proper_shape_68254} = <shape_cert_68253>reshape((~size_68194),
                                                                              f_68200)
  let {bool assert_arg_68255} = eq_i32(size_68194, size_68194)
  let {cert shape_cert_68256} = assert(assert_arg_68255,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68257 aliases f_68201
  let {[size_68194]f32 result_proper_shape_68257} = <shape_cert_68256>reshape((~size_68194),
                                                                              f_68201)
  in {size_68192, size_68193, size_68194, f_68195, result_proper_shape_68248,
      f_68197, f_68198, result_proper_shape_68251, result_proper_shape_68254,
      result_proper_shape_68257, f_68202, f_68203, f_68204, f_68205, f_68206,
      f_68207, f_68208, f_68209, f_68210, f_68211, f_68212, f_68213, f_68214,
      f_68215, f_68216, f_68217, f_68218, f_68219, f_68220, f_68221, f_68222,
      f_68223, f_68224, f_68225, f_68226, f_68227, f_68228, f_68229, f_68230,
      f_68231, f_68232, f_68233, f_68234, f_68235, f_68236, f_68237, f_68238,
      f_68239, f_68240, f_68241, f_68242, f_68243, f_68244, f_68245}
}

fun {[?0]f32, bool, [?1]f32, f32, f32, [?2]i32, [?3]f32, [?3]f32, f32, f32,
     bool, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32} lifted_18734
(i32 n_68258, i32 size_68259, i32 size_68260, i32 size_68261, bool f_68262,
 [size_68259]f32 f_68263, f32 f_68264, f32 f_68265, [size_68260]i32 f_68266,
 [size_68261]f32 f_68267, [size_68261]f32 f_68268, f32 f_68269, f32 f_68270,
 bool f_68271, f32 f_68272, f32 f_68273, f32 f_68274, f32 f_68275, f32 f_68276,
 f32 f_68277, f32 f_68278, f32 f_68279, f32 f_68280, f32 f_68281, f32 f_68282,
 f32 f_68283, f32 f_68284, f32 f_68285, f32 f_68286, f32 f_68287, f32 f_68288,
 f32 f_68289, f32 f_68290, f32 f_68291, f32 f_68292, f32 f_68293, f32 f_68294,
 f32 f_68295, f32 f_68296, f32 f_68297, f32 f_68298, f32 f_68299, f32 f_68300,
 f32 f_68301, f32 f_68302, f32 f_68303, f32 f_68304, f32 f_68305, f32 f_68306,
 f32 f_68307, f32 f_68308, f32 f_68309, f32 f_68310, f32 f_68311, f32 f_68312,
 [n_68258]f32 as_68313) = {
  let {bool assert_arg_68314} = eq_i32(n_68258, n_68258)
  let {cert shape_cert_68315} = assert(assert_arg_68314,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68316 aliases as_68313
  let {[n_68258]f32 result_proper_shape_68316} = <shape_cert_68315>reshape((~n_68258),
                                                                           as_68313)
  let {bool assert_arg_68317} = eq_i32(size_68259, size_68259)
  let {cert shape_cert_68318} = assert(assert_arg_68317,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68319 aliases f_68263
  let {[size_68259]f32 result_proper_shape_68319} = <shape_cert_68318>reshape((~size_68259),
                                                                              f_68263)
  let {bool assert_arg_68320} = eq_i32(size_68260, size_68260)
  let {cert shape_cert_68321} = assert(assert_arg_68320,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68322 aliases f_68266
  let {[size_68260]i32 result_proper_shape_68322} = <shape_cert_68321>reshape((~size_68260),
                                                                              f_68266)
  let {bool assert_arg_68323} = eq_i32(size_68261, size_68261)
  let {cert shape_cert_68324} = assert(assert_arg_68323,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68325 aliases f_68267
  let {[size_68261]f32 result_proper_shape_68325} = <shape_cert_68324>reshape((~size_68261),
                                                                              f_68267)
  let {bool assert_arg_68326} = eq_i32(size_68261, size_68261)
  let {cert shape_cert_68327} = assert(assert_arg_68326,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68328 aliases f_68268
  let {[size_68261]f32 result_proper_shape_68328} = <shape_cert_68327>reshape((~size_68261),
                                                                              f_68268)
  in {n_68258, size_68259, size_68260, size_68261, result_proper_shape_68316,
      f_68262, result_proper_shape_68319, f_68264, f_68265,
      result_proper_shape_68322, result_proper_shape_68325,
      result_proper_shape_68328, f_68269, f_68270, f_68271, f_68272, f_68273,
      f_68274, f_68275, f_68276, f_68277, f_68278, f_68279, f_68280, f_68281,
      f_68282, f_68283, f_68284, f_68285, f_68286, f_68287, f_68288, f_68289,
      f_68290, f_68291, f_68292, f_68293, f_68294, f_68295, f_68296, f_68297,
      f_68298, f_68299, f_68300, f_68301, f_68302, f_68303, f_68304, f_68305,
      f_68306, f_68307, f_68308, f_68309, f_68310, f_68311, f_68312}
}

fun {bool, [?0]f32, f32, f32, [?1]i32, [?2]f32, [?2]f32, f32, f32, bool, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32} lifted_18960
(i32 size_68329, i32 size_68330, i32 size_68331, bool ap1_68332,
 [size_68329]f32 day_count_fractions_68333, f32 i_68334, f32 i_68335,
 [size_68330]i32 maturity_for_quote_68336, [size_68331]f32 minus_ik_68337,
 [size_68331]f32 minus_ik_68338, f32 psi_bs_68339, f32 psi_bs_68340,
 bool psi_bs_68341, f32 psi_bs_68342, f32 psi_bs_68343, f32 psi_bs_68344,
 f32 psi_bs_68345, f32 psi_bs_68346, f32 psi_bs_68347, f32 psi_bs_68348,
 f32 psi_bs_68349, f32 psi_bs_68350, f32 psi_bs_68351, f32 psi_bs_68352,
 f32 psi_bs_68353, f32 psi_bs_68354, f32 psi_bs_68355, f32 psi_bs_68356,
 f32 psi_bs_68357, f32 psi_bs_68358, f32 psi_bs_68359, f32 psi_bs_68360,
 f32 psi_bs_68361, f32 psi_bs_68362, f32 psi_bs_68363, f32 psi_h_68364,
 f32 psi_h_68365, f32 psi_h_68366, f32 psi_h_68367, f32 psi_h_68368,
 f32 psi_h_68369, f32 psi_h_68370, f32 psi_h_68371, f32 psi_h_68372,
 f32 psi_h_68373, f32 psi_h_68374, f32 psi_h_68375, f32 psi_h_68376,
 f32 psi_h_68377, f32 psi_h_68378, f32 psi_h_68379, f32 psi_h_68380,
 f32 psi_h_68381, f32 psi_h_68382, f32 xj_68383) = {
  let {bool assert_arg_68384} = eq_i32(size_68329, size_68329)
  let {cert shape_cert_68385} = assert(assert_arg_68384,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68386 aliases day_count_fractions_68333
  let {[size_68329]f32 result_proper_shape_68386} = <shape_cert_68385>reshape((~size_68329),
                                                                              day_count_fractions_68333)
  let {bool assert_arg_68387} = eq_i32(size_68330, size_68330)
  let {cert shape_cert_68388} = assert(assert_arg_68387,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68389 aliases maturity_for_quote_68336
  let {[size_68330]i32 result_proper_shape_68389} = <shape_cert_68388>reshape((~size_68330),
                                                                              maturity_for_quote_68336)
  let {bool assert_arg_68390} = eq_i32(size_68331, size_68331)
  let {cert shape_cert_68391} = assert(assert_arg_68390,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68392 aliases minus_ik_68337
  let {[size_68331]f32 result_proper_shape_68392} = <shape_cert_68391>reshape((~size_68331),
                                                                              minus_ik_68337)
  let {bool assert_arg_68393} = eq_i32(size_68331, size_68331)
  let {cert shape_cert_68394} = assert(assert_arg_68393,
                                       "shape of function result does not match shapes in return type",
                                       "unknown location")
  -- result_proper_shape_68395 aliases minus_ik_68338
  let {[size_68331]f32 result_proper_shape_68395} = <shape_cert_68394>reshape((~size_68331),
                                                                              minus_ik_68338)
  in {size_68329, size_68330, size_68331, ap1_68332, result_proper_shape_68386,
      i_68334, i_68335, result_proper_shape_68389, result_proper_shape_68392,
      result_proper_shape_68395, psi_bs_68339, psi_bs_68340, psi_bs_68341,
      psi_bs_68342, psi_bs_68343, psi_bs_68344, psi_bs_68345, psi_bs_68346,
      psi_bs_68347, psi_bs_68348, psi_bs_68349, psi_bs_68350, psi_bs_68351,
      psi_bs_68352, psi_bs_68353, psi_bs_68354, psi_bs_68355, psi_bs_68356,
      psi_bs_68357, psi_bs_68358, psi_bs_68359, psi_bs_68360, psi_bs_68361,
      psi_bs_68362, psi_bs_68363, psi_h_68364, psi_h_68365, psi_h_68366,
      psi_h_68367, psi_h_68368, psi_h_68369, psi_h_68370, psi_h_68371,
      psi_h_68372, psi_h_68373, psi_h_68374, psi_h_68375, psi_h_68376,
      psi_h_68377, psi_h_68378, psi_h_68379, psi_h_68380, psi_h_68381,
      psi_h_68382, xj_68383}
}

fun {f32} lifted_19117(i32 x_68396) = {
  let {f32 res_68397} = sitofp i32 x_68396 to f32
  in {res_68397}
}

fun {f32, f32} lifted_19115(f32 a_68398) = {
  let {f32 res_68399} = lifted_19117(0i32)
  in {a_68398, res_68399}
}

fun {f32, f32} lifted_19132(f32 x_68400, f32 x_68401) = {
  {x_68400, x_68401}
}

fun {f32} lifted_19139(f64 x_68402) = {
  let {f32 res_68403} = fpconv f64 x_68402 to f32
  in {res_68403}
}

fun {f32} lifted_19137(f64 x_68404) = {
  let {f32 res_68405} = lifted_19139(x_68404)
  in {res_68405}
}

fun {f32} lifted_19147(i32 x_68406) = {
  let {f32 res_68407} = sitofp i32 x_68406 to f32
  in {res_68407}
}

fun {f32, f32} lifted_19145(f32 b_68408) = {
  let {f32 res_68409} = lifted_19147(0i32)
  in {res_68409, b_68408}
}

fun {f32, f32} lifted_19163(f32 a_68410, f32 b_68411) = {
  {a_68410, b_68411}
}

fun {f32} lifted_19173(f32 x_68412) = {
  {x_68412}
}

fun {f32} lifted_19177(f32 x_68413, f32 y_68414) = {
  let {f32 res_68415} = fsub32(x_68413, y_68414)
  in {res_68415}
}

fun {f32} lifted_19181(f32 x_68416) = {
  {x_68416}
}

fun {f32} lifted_19185(f32 x_68417, f32 y_68418) = {
  let {f32 res_68419} = fsub32(x_68417, y_68418)
  in {res_68419}
}

fun {f32, f32} lifted_19171(f32 a_68420, f32 b_68421, f32 c_68422,
                            f32 d_68423) = {
  let {f32 arg_68424} = lifted_19173(a_68420)
  let {f32 res_68425} = lifted_19177(arg_68424, c_68422)
  let {f32 arg_68426} = lifted_19181(b_68421)
  let {f32 res_68427} = lifted_19185(arg_68426, d_68423)
  in {res_68425, res_68427}
}

fun {f32, f32} lifted_19159(f32 x_68428, f32 x_68429, f32 y_68430,
                            f32 y_68431) = {
  let {f32 arg_68432, f32 arg_68433} = lifted_19163(x_68428, x_68429)
  let {f32 res_68434, f32 res_68435} = lifted_19171(arg_68432, arg_68433,
                                                    y_68430, y_68431)
  in {res_68434, res_68435}
}

fun {f32} lifted_19196(f32 x_68436) = {
  {x_68436}
}

fun {f32} lifted_19202(f64 x_68437) = {
  let {f32 res_68438} = fpconv f64 x_68437 to f32
  in {res_68438}
}

fun {f32} lifted_19200(f64 x_68439) = {
  let {f32 res_68440} = lifted_19202(x_68439)
  in {res_68440}
}

fun {f32} lifted_19207(f32 x_68441) = {
  {x_68441}
}

fun {f32} lifted_19210(f32 x_68442) = {
  {x_68442}
}

fun {f32} lifted_19214(f32 x_68443, f32 y_68444) = {
  let {f32 res_68445} = fmul32(x_68443, y_68444)
  in {res_68445}
}

fun {f32} lifted_19219(f32 x_68446, f32 y_68447) = {
  let {f32 res_68448} = fadd32(x_68446, y_68447)
  in {res_68448}
}

fun {f32} lifted_19224(f32 x_68449, f32 y_68450) = {
  let {f32 res_68451} = fdiv32(x_68449, y_68450)
  in {res_68451}
}

fun {f32, f32, f32, bool, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32} lifted_19261
(f32 i_68452, f32 i_68453, bool sigma2_68454, f32 sigma2_68455,
 f32 sigma2_68456, f32 sigma2_68457, f32 sigma2_68458, f32 sigma2_68459,
 f32 sigma2_68460, f32 sigma2_68461, f32 sigma2_68462, f32 sigma2_68463,
 f32 sigma2_68464, f32 sigma2_68465, f32 sigma2_68466, f32 sigma2_68467,
 f32 sigma2_68468, f32 sigma2_68469, f32 sigma2_68470, f32 sigma2_68471,
 f32 sigma2_68472, f32 sigma2_68473, f32 sigma2_68474, f32 sigma2_68475,
 f32 sigma2_68476, f32 day_count_fraction_68477) = {
  {day_count_fraction_68477, i_68452, i_68453, sigma2_68454, sigma2_68455,
   sigma2_68456, sigma2_68457, sigma2_68458, sigma2_68459, sigma2_68460,
   sigma2_68461, sigma2_68462, sigma2_68463, sigma2_68464, sigma2_68465,
   sigma2_68466, sigma2_68467, sigma2_68468, sigma2_68469, sigma2_68470,
   sigma2_68471, sigma2_68472, sigma2_68473, sigma2_68474, sigma2_68475,
   sigma2_68476}
}

fun {f32} lifted_19331(f64 x_68478) = {
  let {f32 res_68479} = fpconv f64 x_68478 to f32
  in {res_68479}
}

fun {f32} lifted_19329(f64 x_68480) = {
  let {f32 res_68481} = lifted_19331(x_68480)
  in {res_68481}
}

fun {f32} lifted_19336(f32 x_68482) = {
  {x_68482}
}

fun {f32} lifted_19340(f32 x_68483, f32 y_68484) = {
  let {f32 res_68485} = fmul32(x_68483, y_68484)
  in {res_68485}
}

fun {f32} lifted_19344(f32 x_68486) = {
  {x_68486}
}

fun {f32} lifted_19390(i32 x_68487) = {
  let {f32 res_68488} = sitofp i32 x_68487 to f32
  in {res_68488}
}

fun {f32} lifted_19388(i32 x_68489) = {
  let {f32 res_68490} = lifted_19390(x_68489)
  in {res_68490}
}

fun {f32} lifted_19399(f64 x_68491) = {
  let {f32 res_68492} = fpconv f64 x_68491 to f32
  in {res_68492}
}

fun {f32} lifted_19397(f64 x_68493) = {
  let {f32 res_68494} = lifted_19399(x_68493)
  in {res_68494}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_19442(f32 coeff1_68495, f32 coeff1_68496,
                                           f32 coeff2_68497, f32 coeff2_68498,
                                           f32 etai2_68499, f32 etai2_68500,
                                           f32 etai_68501, f32 etai_68502,
                                           f32 i_68503, f32 i_68504,
                                           f32 kappai_68505, f32 kappai_68506,
                                           f32 one_68507, f32 one_68508,
                                           f32 rho_68509, f32 two_68510,
                                           f32 two_68511, f32 zero_68512,
                                           f32 zero_68513,
                                           f32 day_count_fraction_68514) = {
  {coeff1_68495, coeff1_68496, coeff2_68497, coeff2_68498,
   day_count_fraction_68514, etai2_68499, etai2_68500, etai_68501, etai_68502,
   i_68503, i_68504, kappai_68505, kappai_68506, one_68507, one_68508,
   rho_68509, two_68510, two_68511, zero_68512, zero_68513}
}

fun {f32} lifted_19464(f32 a_68515) = {
  {a_68515}
}

fun {f32, f32} lifted_19468(f32 a_68516, f32 b_68517) = {
  {a_68516, b_68517}
}

fun {f32} lifted_19517(i32 x_68518) = {
  let {f32 res_68519} = sitofp i32 x_68518 to f32
  in {res_68519}
}

fun {f32, f32} lifted_19515(f32 a_68520) = {
  let {f32 res_68521} = lifted_19517(0i32)
  in {a_68520, res_68521}
}

fun {f32, f32} lifted_19529(f32 x_68522, f32 x_68523) = {
  {x_68522, x_68523}
}

fun {f32} lifted_19536(i32 x_68524) = {
  let {f32 res_68525} = sitofp i32 x_68524 to f32
  in {res_68525}
}

fun {f32, f32} lifted_19534(f32 b_68526) = {
  let {f32 res_68527} = lifted_19536(0i32)
  in {res_68527, b_68526}
}

fun {f32, f32} lifted_19545(f32 x_68528, f32 x_68529) = {
  {x_68528, x_68529}
}

fun {f32, f32} lifted_19561(f32 a_68530, f32 b_68531) = {
  {a_68530, b_68531}
}

fun {f32} lifted_19573(f32 x_68532) = {
  {x_68532}
}

fun {f32} lifted_19577(f32 x_68533, f32 y_68534) = {
  let {f32 res_68535} = fmul32(x_68533, y_68534)
  in {res_68535}
}

fun {f32} lifted_19581(f32 x_68536) = {
  {x_68536}
}

fun {f32} lifted_19584(f32 x_68537) = {
  {x_68537}
}

fun {f32} lifted_19588(f32 x_68538, f32 y_68539) = {
  let {f32 res_68540} = fmul32(x_68538, y_68539)
  in {res_68540}
}

fun {f32} lifted_19593(f32 x_68541, f32 y_68542) = {
  let {f32 res_68543} = fsub32(x_68541, y_68542)
  in {res_68543}
}

fun {f32} lifted_19597(f32 x_68544) = {
  {x_68544}
}

fun {f32} lifted_19601(f32 x_68545, f32 y_68546) = {
  let {f32 res_68547} = fmul32(x_68545, y_68546)
  in {res_68547}
}

fun {f32} lifted_19605(f32 x_68548) = {
  {x_68548}
}

fun {f32} lifted_19608(f32 x_68549) = {
  {x_68549}
}

fun {f32} lifted_19612(f32 x_68550, f32 y_68551) = {
  let {f32 res_68552} = fmul32(x_68550, y_68551)
  in {res_68552}
}

fun {f32} lifted_19617(f32 x_68553, f32 y_68554) = {
  let {f32 res_68555} = fadd32(x_68553, y_68554)
  in {res_68555}
}

fun {f32, f32} lifted_19571(f32 a_68556, f32 b_68557, f32 c_68558,
                            f32 d_68559) = {
  let {f32 arg_68560} = lifted_19573(a_68556)
  let {f32 arg_68561} = lifted_19577(arg_68560, c_68558)
  let {f32 arg_68562} = lifted_19581(arg_68561)
  let {f32 arg_68563} = lifted_19584(b_68557)
  let {f32 arg_68564} = lifted_19588(arg_68563, d_68559)
  let {f32 res_68565} = lifted_19593(arg_68562, arg_68564)
  let {f32 arg_68566} = lifted_19597(b_68557)
  let {f32 arg_68567} = lifted_19601(arg_68566, c_68558)
  let {f32 arg_68568} = lifted_19605(arg_68567)
  let {f32 arg_68569} = lifted_19608(a_68556)
  let {f32 arg_68570} = lifted_19612(arg_68569, d_68559)
  let {f32 res_68571} = lifted_19617(arg_68568, arg_68570)
  in {res_68565, res_68571}
}

fun {f32, f32} lifted_19555(f32 x_68572, f32 x_68573, f32 y_68574,
                            f32 y_68575) = {
  let {f32 arg_68576, f32 arg_68577} = lifted_19561(x_68572, x_68573)
  let {f32 res_68578, f32 res_68579} = lifted_19571(arg_68576, arg_68577,
                                                    y_68574, y_68575)
  in {res_68578, res_68579}
}

fun {f32, f32} lifted_19628(f32 x_68580, f32 x_68581) = {
  {x_68580, x_68581}
}

fun {f32, f32} lifted_19644(f32 a_68582, f32 b_68583) = {
  {a_68582, b_68583}
}

fun {f32} lifted_19656(f32 x_68584) = {
  {x_68584}
}

fun {f32} lifted_19660(f32 x_68585, f32 y_68586) = {
  let {f32 res_68587} = fmul32(x_68585, y_68586)
  in {res_68587}
}

fun {f32} lifted_19664(f32 x_68588) = {
  {x_68588}
}

fun {f32} lifted_19667(f32 x_68589) = {
  {x_68589}
}

fun {f32} lifted_19671(f32 x_68590, f32 y_68591) = {
  let {f32 res_68592} = fmul32(x_68590, y_68591)
  in {res_68592}
}

fun {f32} lifted_19676(f32 x_68593, f32 y_68594) = {
  let {f32 res_68595} = fsub32(x_68593, y_68594)
  in {res_68595}
}

fun {f32} lifted_19680(f32 x_68596) = {
  {x_68596}
}

fun {f32} lifted_19684(f32 x_68597, f32 y_68598) = {
  let {f32 res_68599} = fmul32(x_68597, y_68598)
  in {res_68599}
}

fun {f32} lifted_19688(f32 x_68600) = {
  {x_68600}
}

fun {f32} lifted_19691(f32 x_68601) = {
  {x_68601}
}

fun {f32} lifted_19695(f32 x_68602, f32 y_68603) = {
  let {f32 res_68604} = fmul32(x_68602, y_68603)
  in {res_68604}
}

fun {f32} lifted_19700(f32 x_68605, f32 y_68606) = {
  let {f32 res_68607} = fadd32(x_68605, y_68606)
  in {res_68607}
}

fun {f32, f32} lifted_19654(f32 a_68608, f32 b_68609, f32 c_68610,
                            f32 d_68611) = {
  let {f32 arg_68612} = lifted_19656(a_68608)
  let {f32 arg_68613} = lifted_19660(arg_68612, c_68610)
  let {f32 arg_68614} = lifted_19664(arg_68613)
  let {f32 arg_68615} = lifted_19667(b_68609)
  let {f32 arg_68616} = lifted_19671(arg_68615, d_68611)
  let {f32 res_68617} = lifted_19676(arg_68614, arg_68616)
  let {f32 arg_68618} = lifted_19680(b_68609)
  let {f32 arg_68619} = lifted_19684(arg_68618, c_68610)
  let {f32 arg_68620} = lifted_19688(arg_68619)
  let {f32 arg_68621} = lifted_19691(a_68608)
  let {f32 arg_68622} = lifted_19695(arg_68621, d_68611)
  let {f32 res_68623} = lifted_19700(arg_68620, arg_68622)
  in {res_68617, res_68623}
}

fun {f32, f32} lifted_19638(f32 x_68624, f32 x_68625, f32 y_68626,
                            f32 y_68627) = {
  let {f32 arg_68628, f32 arg_68629} = lifted_19644(x_68624, x_68625)
  let {f32 res_68630, f32 res_68631} = lifted_19654(arg_68628, arg_68629,
                                                    y_68626, y_68627)
  in {res_68630, res_68631}
}

fun {f32, f32} lifted_19718(f32 a_68632, f32 b_68633) = {
  {a_68632, b_68633}
}

fun {f32} lifted_19728(f32 x_68634) = {
  {x_68634}
}

fun {f32} lifted_19732(f32 x_68635, f32 y_68636) = {
  let {f32 res_68637} = fsub32(x_68635, y_68636)
  in {res_68637}
}

fun {f32} lifted_19736(f32 x_68638) = {
  {x_68638}
}

fun {f32} lifted_19740(f32 x_68639, f32 y_68640) = {
  let {f32 res_68641} = fsub32(x_68639, y_68640)
  in {res_68641}
}

fun {f32, f32} lifted_19726(f32 a_68642, f32 b_68643, f32 c_68644,
                            f32 d_68645) = {
  let {f32 arg_68646} = lifted_19728(a_68642)
  let {f32 res_68647} = lifted_19732(arg_68646, c_68644)
  let {f32 arg_68648} = lifted_19736(b_68643)
  let {f32 res_68649} = lifted_19740(arg_68648, d_68645)
  in {res_68647, res_68649}
}

fun {f32, f32} lifted_19714(f32 x_68650, f32 x_68651, f32 y_68652,
                            f32 y_68653) = {
  let {f32 arg_68654, f32 arg_68655} = lifted_19718(x_68650, x_68651)
  let {f32 res_68656, f32 res_68657} = lifted_19726(arg_68654, arg_68655,
                                                    y_68652, y_68653)
  in {res_68656, res_68657}
}

fun {f32, f32} lifted_19754(f32 x_68658, f32 x_68659) = {
  {x_68658, x_68659}
}

fun {f32, f32} lifted_19770(f32 a_68660, f32 b_68661) = {
  {a_68660, b_68661}
}

fun {f32} lifted_19782(f32 x_68662) = {
  {x_68662}
}

fun {f32} lifted_19786(f32 x_68663, f32 y_68664) = {
  let {f32 res_68665} = fmul32(x_68663, y_68664)
  in {res_68665}
}

fun {f32} lifted_19790(f32 x_68666) = {
  {x_68666}
}

fun {f32} lifted_19793(f32 x_68667) = {
  {x_68667}
}

fun {f32} lifted_19797(f32 x_68668, f32 y_68669) = {
  let {f32 res_68670} = fmul32(x_68668, y_68669)
  in {res_68670}
}

fun {f32} lifted_19802(f32 x_68671, f32 y_68672) = {
  let {f32 res_68673} = fsub32(x_68671, y_68672)
  in {res_68673}
}

fun {f32} lifted_19806(f32 x_68674) = {
  {x_68674}
}

fun {f32} lifted_19810(f32 x_68675, f32 y_68676) = {
  let {f32 res_68677} = fmul32(x_68675, y_68676)
  in {res_68677}
}

fun {f32} lifted_19814(f32 x_68678) = {
  {x_68678}
}

fun {f32} lifted_19817(f32 x_68679) = {
  {x_68679}
}

fun {f32} lifted_19821(f32 x_68680, f32 y_68681) = {
  let {f32 res_68682} = fmul32(x_68680, y_68681)
  in {res_68682}
}

fun {f32} lifted_19826(f32 x_68683, f32 y_68684) = {
  let {f32 res_68685} = fadd32(x_68683, y_68684)
  in {res_68685}
}

fun {f32, f32} lifted_19780(f32 a_68686, f32 b_68687, f32 c_68688,
                            f32 d_68689) = {
  let {f32 arg_68690} = lifted_19782(a_68686)
  let {f32 arg_68691} = lifted_19786(arg_68690, c_68688)
  let {f32 arg_68692} = lifted_19790(arg_68691)
  let {f32 arg_68693} = lifted_19793(b_68687)
  let {f32 arg_68694} = lifted_19797(arg_68693, d_68689)
  let {f32 res_68695} = lifted_19802(arg_68692, arg_68694)
  let {f32 arg_68696} = lifted_19806(b_68687)
  let {f32 arg_68697} = lifted_19810(arg_68696, c_68688)
  let {f32 arg_68698} = lifted_19814(arg_68697)
  let {f32 arg_68699} = lifted_19817(a_68686)
  let {f32 arg_68700} = lifted_19821(arg_68699, d_68689)
  let {f32 res_68701} = lifted_19826(arg_68698, arg_68700)
  in {res_68695, res_68701}
}

fun {f32, f32} lifted_19764(f32 x_68702, f32 x_68703, f32 y_68704,
                            f32 y_68705) = {
  let {f32 arg_68706, f32 arg_68707} = lifted_19770(x_68702, x_68703)
  let {f32 res_68708, f32 res_68709} = lifted_19780(arg_68706, arg_68707,
                                                    y_68704, y_68705)
  in {res_68708, res_68709}
}

fun {f32, f32} lifted_19837(f32 x_68710, f32 x_68711) = {
  {x_68710, x_68711}
}

fun {f32, f32} lifted_19844(f32 x_68712, f32 x_68713) = {
  {x_68712, x_68713}
}

fun {f32, f32} lifted_19851(f32 x_68714, f32 x_68715) = {
  {x_68714, x_68715}
}

fun {f32, f32} lifted_19858(f32 x_68716, f32 x_68717) = {
  {x_68716, x_68717}
}

fun {f32, f32} lifted_19872(f32 a_68718, f32 b_68719) = {
  {a_68718, b_68719}
}

fun {f32} lifted_19882(f32 x_68720) = {
  {x_68720}
}

fun {f32} lifted_19886(f32 x_68721, f32 y_68722) = {
  let {f32 res_68723} = fadd32(x_68721, y_68722)
  in {res_68723}
}

fun {f32} lifted_19890(f32 x_68724) = {
  {x_68724}
}

fun {f32} lifted_19894(f32 x_68725, f32 y_68726) = {
  let {f32 res_68727} = fadd32(x_68725, y_68726)
  in {res_68727}
}

fun {f32, f32} lifted_19880(f32 a_68728, f32 b_68729, f32 c_68730,
                            f32 d_68731) = {
  let {f32 arg_68732} = lifted_19882(a_68728)
  let {f32 res_68733} = lifted_19886(arg_68732, c_68730)
  let {f32 arg_68734} = lifted_19890(b_68729)
  let {f32 res_68735} = lifted_19894(arg_68734, d_68731)
  in {res_68733, res_68735}
}

fun {f32, f32} lifted_19868(f32 x_68736, f32 x_68737, f32 y_68738,
                            f32 y_68739) = {
  let {f32 arg_68740, f32 arg_68741} = lifted_19872(x_68736, x_68737)
  let {f32 res_68742, f32 res_68743} = lifted_19880(arg_68740, arg_68741,
                                                    y_68738, y_68739)
  in {res_68742, res_68743}
}

fun {f32, f32} lifted_19914(f32 a_68744, f32 b_68745) = {
  {a_68744, b_68745}
}

fun {f32} lifted_19926(f32 x_68746) = {
  {x_68746}
}

fun {f32} lifted_19930(f32 x_68747, f32 y_68748) = {
  let {f32 res_68749} = fmul32(x_68747, y_68748)
  in {res_68749}
}

fun {f32} lifted_19934(f32 x_68750) = {
  {x_68750}
}

fun {f32} lifted_19937(f32 x_68751) = {
  {x_68751}
}

fun {f32} lifted_19941(f32 x_68752, f32 y_68753) = {
  let {f32 res_68754} = fmul32(x_68752, y_68753)
  in {res_68754}
}

fun {f32} lifted_19946(f32 x_68755, f32 y_68756) = {
  let {f32 res_68757} = fsub32(x_68755, y_68756)
  in {res_68757}
}

fun {f32} lifted_19950(f32 x_68758) = {
  {x_68758}
}

fun {f32} lifted_19954(f32 x_68759, f32 y_68760) = {
  let {f32 res_68761} = fmul32(x_68759, y_68760)
  in {res_68761}
}

fun {f32} lifted_19958(f32 x_68762) = {
  {x_68762}
}

fun {f32} lifted_19961(f32 x_68763) = {
  {x_68763}
}

fun {f32} lifted_19965(f32 x_68764, f32 y_68765) = {
  let {f32 res_68766} = fmul32(x_68764, y_68765)
  in {res_68766}
}

fun {f32} lifted_19970(f32 x_68767, f32 y_68768) = {
  let {f32 res_68769} = fadd32(x_68767, y_68768)
  in {res_68769}
}

fun {f32, f32} lifted_19924(f32 a_68770, f32 b_68771, f32 c_68772,
                            f32 d_68773) = {
  let {f32 arg_68774} = lifted_19926(a_68770)
  let {f32 arg_68775} = lifted_19930(arg_68774, c_68772)
  let {f32 arg_68776} = lifted_19934(arg_68775)
  let {f32 arg_68777} = lifted_19937(b_68771)
  let {f32 arg_68778} = lifted_19941(arg_68777, d_68773)
  let {f32 res_68779} = lifted_19946(arg_68776, arg_68778)
  let {f32 arg_68780} = lifted_19950(b_68771)
  let {f32 arg_68781} = lifted_19954(arg_68780, c_68772)
  let {f32 arg_68782} = lifted_19958(arg_68781)
  let {f32 arg_68783} = lifted_19961(a_68770)
  let {f32 arg_68784} = lifted_19965(arg_68783, d_68773)
  let {f32 res_68785} = lifted_19970(arg_68782, arg_68784)
  in {res_68779, res_68785}
}

fun {f32, f32} lifted_19908(f32 x_68786, f32 x_68787, f32 y_68788,
                            f32 y_68789) = {
  let {f32 arg_68790, f32 arg_68791} = lifted_19914(x_68786, x_68787)
  let {f32 res_68792, f32 res_68793} = lifted_19924(arg_68790, arg_68791,
                                                    y_68788, y_68789)
  in {res_68792, res_68793}
}

fun {f32, f32} lifted_19990(f32 a_68794, f32 b_68795) = {
  {a_68794, b_68795}
}

fun {f32} lifted_20002(f32 x_68796) = {
  {x_68796}
}

fun {f32} lifted_20006(f32 x_68797, f32 y_68798) = {
  let {f32 res_68799} = fmul32(x_68797, y_68798)
  in {res_68799}
}

fun {f32} lifted_20010(f32 x_68800) = {
  {x_68800}
}

fun {f32} lifted_20013(f32 x_68801) = {
  {x_68801}
}

fun {f32} lifted_20017(f32 x_68802, f32 y_68803) = {
  let {f32 res_68804} = fmul32(x_68802, y_68803)
  in {res_68804}
}

fun {f32} lifted_20022(f32 x_68805, f32 y_68806) = {
  let {f32 res_68807} = fsub32(x_68805, y_68806)
  in {res_68807}
}

fun {f32} lifted_20026(f32 x_68808) = {
  {x_68808}
}

fun {f32} lifted_20030(f32 x_68809, f32 y_68810) = {
  let {f32 res_68811} = fmul32(x_68809, y_68810)
  in {res_68811}
}

fun {f32} lifted_20034(f32 x_68812) = {
  {x_68812}
}

fun {f32} lifted_20037(f32 x_68813) = {
  {x_68813}
}

fun {f32} lifted_20041(f32 x_68814, f32 y_68815) = {
  let {f32 res_68816} = fmul32(x_68814, y_68815)
  in {res_68816}
}

fun {f32} lifted_20046(f32 x_68817, f32 y_68818) = {
  let {f32 res_68819} = fadd32(x_68817, y_68818)
  in {res_68819}
}

fun {f32, f32} lifted_20000(f32 a_68820, f32 b_68821, f32 c_68822,
                            f32 d_68823) = {
  let {f32 arg_68824} = lifted_20002(a_68820)
  let {f32 arg_68825} = lifted_20006(arg_68824, c_68822)
  let {f32 arg_68826} = lifted_20010(arg_68825)
  let {f32 arg_68827} = lifted_20013(b_68821)
  let {f32 arg_68828} = lifted_20017(arg_68827, d_68823)
  let {f32 res_68829} = lifted_20022(arg_68826, arg_68828)
  let {f32 arg_68830} = lifted_20026(b_68821)
  let {f32 arg_68831} = lifted_20030(arg_68830, c_68822)
  let {f32 arg_68832} = lifted_20034(arg_68831)
  let {f32 arg_68833} = lifted_20037(a_68820)
  let {f32 arg_68834} = lifted_20041(arg_68833, d_68823)
  let {f32 res_68835} = lifted_20046(arg_68832, arg_68834)
  in {res_68829, res_68835}
}

fun {f32, f32} lifted_19984(f32 x_68836, f32 x_68837, f32 y_68838,
                            f32 y_68839) = {
  let {f32 arg_68840, f32 arg_68841} = lifted_19990(x_68836, x_68837)
  let {f32 res_68842, f32 res_68843} = lifted_20000(arg_68840, arg_68841,
                                                    y_68838, y_68839)
  in {res_68842, res_68843}
}

fun {f32, f32} lifted_20064(f32 a_68844, f32 b_68845) = {
  {a_68844, b_68845}
}

fun {f32} lifted_20074(f32 x_68846) = {
  {x_68846}
}

fun {f32} lifted_20078(f32 x_68847, f32 y_68848) = {
  let {f32 res_68849} = fadd32(x_68847, y_68848)
  in {res_68849}
}

fun {f32} lifted_20082(f32 x_68850) = {
  {x_68850}
}

fun {f32} lifted_20086(f32 x_68851, f32 y_68852) = {
  let {f32 res_68853} = fadd32(x_68851, y_68852)
  in {res_68853}
}

fun {f32, f32} lifted_20072(f32 a_68854, f32 b_68855, f32 c_68856,
                            f32 d_68857) = {
  let {f32 arg_68858} = lifted_20074(a_68854)
  let {f32 res_68859} = lifted_20078(arg_68858, c_68856)
  let {f32 arg_68860} = lifted_20082(b_68855)
  let {f32 res_68861} = lifted_20086(arg_68860, d_68857)
  in {res_68859, res_68861}
}

fun {f32, f32} lifted_20060(f32 x_68862, f32 x_68863, f32 y_68864,
                            f32 y_68865) = {
  let {f32 arg_68866, f32 arg_68867} = lifted_20064(x_68862, x_68863)
  let {f32 res_68868, f32 res_68869} = lifted_20072(arg_68866, arg_68867,
                                                    y_68864, y_68865)
  in {res_68868, res_68869}
}

fun {f32} lifted_20105(f32 x_68870) = {
  {x_68870}
}

fun {f32} lifted_20108(f32 x_68871) = {
  {x_68871}
}

fun {f32} lifted_20112(f32 x_68872, f32 y_68873) = {
  let {f32 res_68874} = fmul32(x_68872, y_68873)
  in {res_68874}
}

fun {f32} lifted_20116(f32 x_68875) = {
  {x_68875}
}

fun {f32} lifted_20119(f32 x_68876) = {
  {x_68876}
}

fun {f32} lifted_20123(f32 x_68877, f32 y_68878) = {
  let {f32 res_68879} = fmul32(x_68877, y_68878)
  in {res_68879}
}

fun {f32} lifted_20128(f32 x_68880, f32 y_68881) = {
  let {f32 res_68882} = fadd32(x_68880, y_68881)
  in {res_68882}
}

fun {f32} lifted_20132(f32 x_68883) = {
  let {f32 res_68884} = sqrt32(x_68883)
  in {res_68884}
}

fun {f32} lifted_20137(f32 x_68885, f32 y_68886) = {
  let {f32 res_68887} = fadd32(x_68885, y_68886)
  in {res_68887}
}

fun {f32} lifted_20141(f32 x_68888) = {
  {x_68888}
}

fun {f32} lifted_20144(i32 x_68889) = {
  let {f32 res_68890} = sitofp i32 x_68889 to f32
  in {res_68890}
}

fun {f32} lifted_20149(f32 x_68891, f32 y_68892) = {
  let {f32 res_68893} = fdiv32(x_68891, y_68892)
  in {res_68893}
}

fun {f32} lifted_20153(f32 x_68894) = {
  let {f32 res_68895} = sqrt32(x_68894)
  in {res_68895}
}

fun {f32} lifted_20162(f32 x_68896) = {
  {x_68896}
}

fun {bool} lifted_20166(f32 x_68897, f32 y_68898) = {
  let {bool res_68899} = lt32(x_68897, y_68898)
  in {res_68899}
}

fun {f32} lifted_20171(f32 x_68900) = {
  {x_68900}
}

fun {bool} lifted_20175(f32 x_68901, f32 y_68902) = {
  let {bool res_68903} = eq_f32(x_68901, y_68902)
  in {res_68903}
}

fun {f32} lifted_20160(f32 x_68904) = {
  let {f32 arg_68905} = lifted_20162(x_68904)
  let {bool cond_68906} = lifted_20166(arg_68905, 0.0f32)
  let {f32 res_68907} =
    -- Branch returns: {f32}
    if cond_68906
    then {
      let {f32 res_68908} = fsub32(0.0f32, 1.0f32)
      in {res_68908}
    } else {
      let {f32 arg_68909} = lifted_20171(x_68904)
      let {bool cond_68910} = lifted_20175(arg_68909, 0.0f32)
      let {f32 res_68911} =
        -- Branch returns: {f32}
        if cond_68910
        then {0.0f32} else {1.0f32}
      in {res_68911}
    }
  in {res_68907}
}

fun {i32} lifted_20182(f32 x_68912) = {
  let {i32 res_68913} = fptosi f32 x_68912 to i32
  in {res_68913}
}

fun {f32} lifted_20186(i32 x_68914) = {
  let {f32 res_68915} = sitofp i32 x_68914 to f32
  in {res_68915}
}

fun {f32} lifted_20190(f32 x_68916) = {
  {x_68916}
}

fun {f32} lifted_20193(i32 x_68917) = {
  let {f32 res_68918} = sitofp i32 x_68917 to f32
  in {res_68918}
}

fun {f32} lifted_20197(f32 x_68919) = {
  {x_68919}
}

fun {f32} lifted_20201(f32 x_68920, f32 y_68921) = {
  let {f32 res_68922} = fsub32(x_68920, y_68921)
  in {res_68922}
}

fun {f32} lifted_20205(f32 x_68923) = {
  {x_68923}
}

fun {f32} lifted_20208(f32 x_68924) = {
  {x_68924}
}

fun {f32} lifted_20212(f32 x_68925, f32 y_68926) = {
  let {f32 res_68927} = fmul32(x_68925, y_68926)
  in {res_68927}
}

fun {f32} lifted_20216(f32 x_68928) = {
  {x_68928}
}

fun {f32} lifted_20219(f32 x_68929) = {
  {x_68929}
}

fun {f32} lifted_20223(f32 x_68930, f32 y_68931) = {
  let {f32 res_68932} = fmul32(x_68930, y_68931)
  in {res_68932}
}

fun {f32} lifted_20228(f32 x_68933, f32 y_68934) = {
  let {f32 res_68935} = fadd32(x_68933, y_68934)
  in {res_68935}
}

fun {f32} lifted_20232(f32 x_68936) = {
  let {f32 res_68937} = sqrt32(x_68936)
  in {res_68937}
}

fun {f32} lifted_20237(f32 x_68938, f32 y_68939) = {
  let {f32 res_68940} = fadd32(x_68938, y_68939)
  in {res_68940}
}

fun {f32} lifted_20241(f32 x_68941) = {
  {x_68941}
}

fun {f32} lifted_20244(i32 x_68942) = {
  let {f32 res_68943} = sitofp i32 x_68942 to f32
  in {res_68943}
}

fun {f32} lifted_20249(f32 x_68944, f32 y_68945) = {
  let {f32 res_68946} = fdiv32(x_68944, y_68945)
  in {res_68946}
}

fun {f32} lifted_20253(f32 x_68947) = {
  let {f32 res_68948} = sqrt32(x_68947)
  in {res_68948}
}

fun {f32} lifted_20258(f32 x_68949, f32 y_68950) = {
  let {f32 res_68951} = fmul32(x_68949, y_68950)
  in {res_68951}
}

fun {f32, f32} lifted_20103(f32 a_68952, f32 b_68953) = {
  let {f32 arg_68954} = lifted_20105(a_68952)
  let {f32 arg_68955} = lifted_20108(a_68952)
  let {f32 arg_68956} = lifted_20112(arg_68955, a_68952)
  let {f32 arg_68957} = lifted_20116(arg_68956)
  let {f32 arg_68958} = lifted_20119(b_68953)
  let {f32 arg_68959} = lifted_20123(arg_68958, b_68953)
  let {f32 arg_68960} = lifted_20128(arg_68957, arg_68959)
  let {f32 arg_68961} = lifted_20132(arg_68960)
  let {f32 arg_68962} = lifted_20137(arg_68954, arg_68961)
  let {f32 arg_68963} = lifted_20141(arg_68962)
  let {f32 arg_68964} = lifted_20144(2i32)
  let {f32 arg_68965} = lifted_20149(arg_68963, arg_68964)
  let {f32 res_68966} = lifted_20153(arg_68965)
  let {f32 gamma_68967} = res_68966
  let {f32 arg_68968} = lifted_20160(b_68953)
  let {i32 arg_68969} = lifted_20182(arg_68968)
  let {f32 arg_68970} = lifted_20186(arg_68969)
  let {f32 arg_68971} = lifted_20190(arg_68970)
  let {f32 arg_68972} = lifted_20193(0i32)
  let {f32 arg_68973} = lifted_20197(arg_68972)
  let {f32 arg_68974} = lifted_20201(arg_68973, a_68952)
  let {f32 arg_68975} = lifted_20205(arg_68974)
  let {f32 arg_68976} = lifted_20208(a_68952)
  let {f32 arg_68977} = lifted_20212(arg_68976, a_68952)
  let {f32 arg_68978} = lifted_20216(arg_68977)
  let {f32 arg_68979} = lifted_20219(b_68953)
  let {f32 arg_68980} = lifted_20223(arg_68979, b_68953)
  let {f32 arg_68981} = lifted_20228(arg_68978, arg_68980)
  let {f32 arg_68982} = lifted_20232(arg_68981)
  let {f32 arg_68983} = lifted_20237(arg_68975, arg_68982)
  let {f32 arg_68984} = lifted_20241(arg_68983)
  let {f32 arg_68985} = lifted_20244(2i32)
  let {f32 arg_68986} = lifted_20249(arg_68984, arg_68985)
  let {f32 arg_68987} = lifted_20253(arg_68986)
  let {f32 res_68988} = lifted_20258(arg_68971, arg_68987)
  let {f32 delta_68989} = res_68988
  in {gamma_68967, delta_68989}
}

fun {f32, f32} lifted_20271(f32 x_68990, f32 x_68991) = {
  {x_68990, x_68991}
}

fun {f32, f32} lifted_20285(f32 a_68992, f32 b_68993) = {
  {a_68992, b_68993}
}

fun {f32} lifted_20295(f32 x_68994) = {
  {x_68994}
}

fun {f32} lifted_20299(f32 x_68995, f32 y_68996) = {
  let {f32 res_68997} = fsub32(x_68995, y_68996)
  in {res_68997}
}

fun {f32} lifted_20303(f32 x_68998) = {
  {x_68998}
}

fun {f32} lifted_20307(f32 x_68999, f32 y_69000) = {
  let {f32 res_69001} = fsub32(x_68999, y_69000)
  in {res_69001}
}

fun {f32, f32} lifted_20293(f32 a_69002, f32 b_69003, f32 c_69004,
                            f32 d_69005) = {
  let {f32 arg_69006} = lifted_20295(a_69002)
  let {f32 res_69007} = lifted_20299(arg_69006, c_69004)
  let {f32 arg_69008} = lifted_20303(b_69003)
  let {f32 res_69009} = lifted_20307(arg_69008, d_69005)
  in {res_69007, res_69009}
}

fun {f32, f32} lifted_20281(f32 x_69010, f32 x_69011, f32 y_69012,
                            f32 y_69013) = {
  let {f32 arg_69014, f32 arg_69015} = lifted_20285(x_69010, x_69011)
  let {f32 res_69016, f32 res_69017} = lifted_20293(arg_69014, arg_69015,
                                                    y_69012, y_69013)
  in {res_69016, res_69017}
}

fun {f32, f32} lifted_20321(f32 x_69018, f32 x_69019) = {
  {x_69018, x_69019}
}

fun {f32, f32} lifted_20328(f32 x_69020, f32 x_69021) = {
  {x_69020, x_69021}
}

fun {f32, f32} lifted_20342(f32 a_69022, f32 b_69023) = {
  {a_69022, b_69023}
}

fun {f32} lifted_20352(f32 x_69024) = {
  {x_69024}
}

fun {f32} lifted_20356(f32 x_69025, f32 y_69026) = {
  let {f32 res_69027} = fadd32(x_69025, y_69026)
  in {res_69027}
}

fun {f32} lifted_20360(f32 x_69028) = {
  {x_69028}
}

fun {f32} lifted_20364(f32 x_69029, f32 y_69030) = {
  let {f32 res_69031} = fadd32(x_69029, y_69030)
  in {res_69031}
}

fun {f32, f32} lifted_20350(f32 a_69032, f32 b_69033, f32 c_69034,
                            f32 d_69035) = {
  let {f32 arg_69036} = lifted_20352(a_69032)
  let {f32 res_69037} = lifted_20356(arg_69036, c_69034)
  let {f32 arg_69038} = lifted_20360(b_69033)
  let {f32 res_69039} = lifted_20364(arg_69038, d_69035)
  in {res_69037, res_69039}
}

fun {f32, f32} lifted_20338(f32 x_69040, f32 x_69041, f32 y_69042,
                            f32 y_69043) = {
  let {f32 arg_69044, f32 arg_69045} = lifted_20342(x_69040, x_69041)
  let {f32 res_69046, f32 res_69047} = lifted_20350(arg_69044, arg_69045,
                                                    y_69042, y_69043)
  in {res_69046, res_69047}
}

fun {f32, f32} lifted_20385(f32 a_69048, f32 b_69049) = {
  {a_69048, b_69049}
}

fun {f32} lifted_20398(f32 x_69050) = {
  {x_69050}
}

fun {f32} lifted_20402(f32 x_69051, f32 y_69052) = {
  let {f32 res_69053} = fmul32(x_69051, y_69052)
  in {res_69053}
}

fun {f32} lifted_20406(f32 x_69054) = {
  {x_69054}
}

fun {f32} lifted_20409(f32 x_69055) = {
  {x_69055}
}

fun {f32} lifted_20413(f32 x_69056, f32 y_69057) = {
  let {f32 res_69058} = fmul32(x_69056, y_69057)
  in {res_69058}
}

fun {f32} lifted_20418(f32 x_69059, f32 y_69060) = {
  let {f32 res_69061} = fadd32(x_69059, y_69060)
  in {res_69061}
}

fun {f32} lifted_20422(f32 x_69062) = {
  {x_69062}
}

fun {f32} lifted_20425(f32 x_69063) = {
  {x_69063}
}

fun {f32} lifted_20429(f32 x_69064, f32 y_69065) = {
  let {f32 res_69066} = fmul32(x_69064, y_69065)
  in {res_69066}
}

fun {f32} lifted_20433(f32 x_69067) = {
  {x_69067}
}

fun {f32} lifted_20436(f32 x_69068) = {
  {x_69068}
}

fun {f32} lifted_20440(f32 x_69069, f32 y_69070) = {
  let {f32 res_69071} = fmul32(x_69069, y_69070)
  in {res_69071}
}

fun {f32} lifted_20445(f32 x_69072, f32 y_69073) = {
  let {f32 res_69074} = fadd32(x_69072, y_69073)
  in {res_69074}
}

fun {f32} lifted_20450(f32 x_69075, f32 y_69076) = {
  let {f32 res_69077} = fdiv32(x_69075, y_69076)
  in {res_69077}
}

fun {f32} lifted_20454(f32 x_69078) = {
  {x_69078}
}

fun {f32} lifted_20458(f32 x_69079, f32 y_69080) = {
  let {f32 res_69081} = fmul32(x_69079, y_69080)
  in {res_69081}
}

fun {f32} lifted_20462(f32 x_69082) = {
  {x_69082}
}

fun {f32} lifted_20465(f32 x_69083) = {
  {x_69083}
}

fun {f32} lifted_20469(f32 x_69084, f32 y_69085) = {
  let {f32 res_69086} = fmul32(x_69084, y_69085)
  in {res_69086}
}

fun {f32} lifted_20474(f32 x_69087, f32 y_69088) = {
  let {f32 res_69089} = fsub32(x_69087, y_69088)
  in {res_69089}
}

fun {f32} lifted_20478(f32 x_69090) = {
  {x_69090}
}

fun {f32} lifted_20481(f32 x_69091) = {
  {x_69091}
}

fun {f32} lifted_20485(f32 x_69092, f32 y_69093) = {
  let {f32 res_69094} = fmul32(x_69092, y_69093)
  in {res_69094}
}

fun {f32} lifted_20489(f32 x_69095) = {
  {x_69095}
}

fun {f32} lifted_20492(f32 x_69096) = {
  {x_69096}
}

fun {f32} lifted_20496(f32 x_69097, f32 y_69098) = {
  let {f32 res_69099} = fmul32(x_69097, y_69098)
  in {res_69099}
}

fun {f32} lifted_20501(f32 x_69100, f32 y_69101) = {
  let {f32 res_69102} = fadd32(x_69100, y_69101)
  in {res_69102}
}

fun {f32} lifted_20506(f32 x_69103, f32 y_69104) = {
  let {f32 res_69105} = fdiv32(x_69103, y_69104)
  in {res_69105}
}

fun {f32, f32} lifted_20396(f32 a_69106, f32 b_69107, f32 c_69108,
                            f32 d_69109) = {
  let {f32 arg_69110} = lifted_20398(a_69106)
  let {f32 arg_69111} = lifted_20402(arg_69110, c_69108)
  let {f32 arg_69112} = lifted_20406(arg_69111)
  let {f32 arg_69113} = lifted_20409(b_69107)
  let {f32 arg_69114} = lifted_20413(arg_69113, d_69109)
  let {f32 arg_69115} = lifted_20418(arg_69112, arg_69114)
  let {f32 arg_69116} = lifted_20422(arg_69115)
  let {f32 arg_69117} = lifted_20425(c_69108)
  let {f32 arg_69118} = lifted_20429(arg_69117, c_69108)
  let {f32 arg_69119} = lifted_20433(arg_69118)
  let {f32 arg_69120} = lifted_20436(d_69109)
  let {f32 arg_69121} = lifted_20440(arg_69120, d_69109)
  let {f32 arg_69122} = lifted_20445(arg_69119, arg_69121)
  let {f32 res_69123} = lifted_20450(arg_69116, arg_69122)
  let {f32 arg_69124} = lifted_20454(b_69107)
  let {f32 arg_69125} = lifted_20458(arg_69124, c_69108)
  let {f32 arg_69126} = lifted_20462(arg_69125)
  let {f32 arg_69127} = lifted_20465(a_69106)
  let {f32 arg_69128} = lifted_20469(arg_69127, d_69109)
  let {f32 arg_69129} = lifted_20474(arg_69126, arg_69128)
  let {f32 arg_69130} = lifted_20478(arg_69129)
  let {f32 arg_69131} = lifted_20481(c_69108)
  let {f32 arg_69132} = lifted_20485(arg_69131, c_69108)
  let {f32 arg_69133} = lifted_20489(arg_69132)
  let {f32 arg_69134} = lifted_20492(d_69109)
  let {f32 arg_69135} = lifted_20496(arg_69134, d_69109)
  let {f32 arg_69136} = lifted_20501(arg_69133, arg_69135)
  let {f32 res_69137} = lifted_20506(arg_69130, arg_69136)
  in {res_69123, res_69137}
}

fun {f32, f32} lifted_20378(f32 x_69138, f32 x_69139, f32 y_69140,
                            f32 y_69141) = {
  let {f32 arg_69142, f32 arg_69143} = lifted_20385(x_69138, x_69139)
  let {f32 res_69144, f32 res_69145} = lifted_20396(arg_69142, arg_69143,
                                                    y_69140, y_69141)
  in {res_69144, res_69145}
}

fun {f32, f32} lifted_20520(f32 x_69146, f32 x_69147) = {
  {x_69146, x_69147}
}

fun {f32, f32} lifted_20527(f32 x_69148, f32 x_69149) = {
  {x_69148, x_69149}
}

fun {f32, f32} lifted_20543(f32 a_69150, f32 b_69151) = {
  {a_69150, b_69151}
}

fun {f32} lifted_20555(f32 x_69152) = {
  {x_69152}
}

fun {f32} lifted_20559(f32 x_69153, f32 y_69154) = {
  let {f32 res_69155} = fmul32(x_69153, y_69154)
  in {res_69155}
}

fun {f32} lifted_20563(f32 x_69156) = {
  {x_69156}
}

fun {f32} lifted_20566(f32 x_69157) = {
  {x_69157}
}

fun {f32} lifted_20570(f32 x_69158, f32 y_69159) = {
  let {f32 res_69160} = fmul32(x_69158, y_69159)
  in {res_69160}
}

fun {f32} lifted_20575(f32 x_69161, f32 y_69162) = {
  let {f32 res_69163} = fsub32(x_69161, y_69162)
  in {res_69163}
}

fun {f32} lifted_20579(f32 x_69164) = {
  {x_69164}
}

fun {f32} lifted_20583(f32 x_69165, f32 y_69166) = {
  let {f32 res_69167} = fmul32(x_69165, y_69166)
  in {res_69167}
}

fun {f32} lifted_20587(f32 x_69168) = {
  {x_69168}
}

fun {f32} lifted_20590(f32 x_69169) = {
  {x_69169}
}

fun {f32} lifted_20594(f32 x_69170, f32 y_69171) = {
  let {f32 res_69172} = fmul32(x_69170, y_69171)
  in {res_69172}
}

fun {f32} lifted_20599(f32 x_69173, f32 y_69174) = {
  let {f32 res_69175} = fadd32(x_69173, y_69174)
  in {res_69175}
}

fun {f32, f32} lifted_20553(f32 a_69176, f32 b_69177, f32 c_69178,
                            f32 d_69179) = {
  let {f32 arg_69180} = lifted_20555(a_69176)
  let {f32 arg_69181} = lifted_20559(arg_69180, c_69178)
  let {f32 arg_69182} = lifted_20563(arg_69181)
  let {f32 arg_69183} = lifted_20566(b_69177)
  let {f32 arg_69184} = lifted_20570(arg_69183, d_69179)
  let {f32 res_69185} = lifted_20575(arg_69182, arg_69184)
  let {f32 arg_69186} = lifted_20579(b_69177)
  let {f32 arg_69187} = lifted_20583(arg_69186, c_69178)
  let {f32 arg_69188} = lifted_20587(arg_69187)
  let {f32 arg_69189} = lifted_20590(a_69176)
  let {f32 arg_69190} = lifted_20594(arg_69189, d_69179)
  let {f32 res_69191} = lifted_20599(arg_69188, arg_69190)
  in {res_69185, res_69191}
}

fun {f32, f32} lifted_20537(f32 x_69192, f32 x_69193, f32 y_69194,
                            f32 y_69195) = {
  let {f32 arg_69196, f32 arg_69197} = lifted_20543(x_69192, x_69193)
  let {f32 res_69198, f32 res_69199} = lifted_20553(arg_69196, arg_69197,
                                                    y_69194, y_69195)
  in {res_69198, res_69199}
}

fun {f32, f32} lifted_20617(f32 a_69200, f32 b_69201) = {
  {a_69200, b_69201}
}

fun {f32} lifted_20627(f32 x_69202) = {
  {x_69202}
}

fun {f32} lifted_20631(f32 x_69203, f32 y_69204) = {
  let {f32 res_69205} = fsub32(x_69203, y_69204)
  in {res_69205}
}

fun {f32} lifted_20635(f32 x_69206) = {
  {x_69206}
}

fun {f32} lifted_20639(f32 x_69207, f32 y_69208) = {
  let {f32 res_69209} = fsub32(x_69207, y_69208)
  in {res_69209}
}

fun {f32, f32} lifted_20625(f32 a_69210, f32 b_69211, f32 c_69212,
                            f32 d_69213) = {
  let {f32 arg_69214} = lifted_20627(a_69210)
  let {f32 res_69215} = lifted_20631(arg_69214, c_69212)
  let {f32 arg_69216} = lifted_20635(b_69211)
  let {f32 res_69217} = lifted_20639(arg_69216, d_69213)
  in {res_69215, res_69217}
}

fun {f32, f32} lifted_20613(f32 x_69218, f32 x_69219, f32 y_69220,
                            f32 y_69221) = {
  let {f32 arg_69222, f32 arg_69223} = lifted_20617(x_69218, x_69219)
  let {f32 res_69224, f32 res_69225} = lifted_20625(arg_69222, arg_69223,
                                                    y_69220, y_69221)
  in {res_69224, res_69225}
}

fun {f32} lifted_20655(f32 x_69226) = {
  let {f32 res_69227} = exp32(x_69226)
  in {res_69227}
}

fun {f32} lifted_20660(f32 x_69228) = {
  {x_69228}
}

fun {f32} lifted_20663(f32 x_69229) = {
  let {f32 res_69230} = cos32(x_69229)
  in {res_69230}
}

fun {f32} lifted_20668(f32 x_69231, f32 y_69232) = {
  let {f32 res_69233} = fmul32(x_69231, y_69232)
  in {res_69233}
}

fun {f32} lifted_20672(f32 a_69234) = {
  {a_69234}
}

fun {f32} lifted_20675(f32 x_69235) = {
  {x_69235}
}

fun {f32} lifted_20678(f32 x_69236) = {
  let {f32 res_69237} = sin32(x_69236)
  in {res_69237}
}

fun {f32} lifted_20683(f32 x_69238, f32 y_69239) = {
  let {f32 res_69240} = fmul32(x_69238, y_69239)
  in {res_69240}
}

fun {f32, f32} lifted_20688(f32 a_69241, f32 b_69242) = {
  {a_69241, b_69242}
}

fun {f32, f32} lifted_20653(f32 a_69243, f32 b_69244) = {
  let {f32 res_69245} = lifted_20655(a_69243)
  let {f32 expx_69246} = res_69245
  let {f32 arg_69247} = lifted_20660(expx_69246)
  let {f32 arg_69248} = lifted_20663(b_69244)
  let {f32 arg_69249} = lifted_20668(arg_69247, arg_69248)
  let {f32 arg_69250} = lifted_20672(arg_69249)
  let {f32 arg_69251} = lifted_20675(expx_69246)
  let {f32 arg_69252} = lifted_20678(b_69244)
  let {f32 arg_69253} = lifted_20683(arg_69251, arg_69252)
  let {f32 res_69254, f32 res_69255} = lifted_20688(arg_69250, arg_69253)
  in {res_69254, res_69255}
}

fun {f32, f32} lifted_20700(f32 x_69256, f32 x_69257) = {
  {x_69256, x_69257}
}

fun {f32, f32} lifted_20707(f32 x_69258, f32 x_69259) = {
  {x_69258, x_69259}
}

fun {f32, f32} lifted_20723(f32 a_69260, f32 b_69261) = {
  {a_69260, b_69261}
}

fun {f32} lifted_20735(f32 x_69262) = {
  {x_69262}
}

fun {f32} lifted_20739(f32 x_69263, f32 y_69264) = {
  let {f32 res_69265} = fmul32(x_69263, y_69264)
  in {res_69265}
}

fun {f32} lifted_20743(f32 x_69266) = {
  {x_69266}
}

fun {f32} lifted_20746(f32 x_69267) = {
  {x_69267}
}

fun {f32} lifted_20750(f32 x_69268, f32 y_69269) = {
  let {f32 res_69270} = fmul32(x_69268, y_69269)
  in {res_69270}
}

fun {f32} lifted_20755(f32 x_69271, f32 y_69272) = {
  let {f32 res_69273} = fsub32(x_69271, y_69272)
  in {res_69273}
}

fun {f32} lifted_20759(f32 x_69274) = {
  {x_69274}
}

fun {f32} lifted_20763(f32 x_69275, f32 y_69276) = {
  let {f32 res_69277} = fmul32(x_69275, y_69276)
  in {res_69277}
}

fun {f32} lifted_20767(f32 x_69278) = {
  {x_69278}
}

fun {f32} lifted_20770(f32 x_69279) = {
  {x_69279}
}

fun {f32} lifted_20774(f32 x_69280, f32 y_69281) = {
  let {f32 res_69282} = fmul32(x_69280, y_69281)
  in {res_69282}
}

fun {f32} lifted_20779(f32 x_69283, f32 y_69284) = {
  let {f32 res_69285} = fadd32(x_69283, y_69284)
  in {res_69285}
}

fun {f32, f32} lifted_20733(f32 a_69286, f32 b_69287, f32 c_69288,
                            f32 d_69289) = {
  let {f32 arg_69290} = lifted_20735(a_69286)
  let {f32 arg_69291} = lifted_20739(arg_69290, c_69288)
  let {f32 arg_69292} = lifted_20743(arg_69291)
  let {f32 arg_69293} = lifted_20746(b_69287)
  let {f32 arg_69294} = lifted_20750(arg_69293, d_69289)
  let {f32 res_69295} = lifted_20755(arg_69292, arg_69294)
  let {f32 arg_69296} = lifted_20759(b_69287)
  let {f32 arg_69297} = lifted_20763(arg_69296, c_69288)
  let {f32 arg_69298} = lifted_20767(arg_69297)
  let {f32 arg_69299} = lifted_20770(a_69286)
  let {f32 arg_69300} = lifted_20774(arg_69299, d_69289)
  let {f32 res_69301} = lifted_20779(arg_69298, arg_69300)
  in {res_69295, res_69301}
}

fun {f32, f32} lifted_20717(f32 x_69302, f32 x_69303, f32 y_69304,
                            f32 y_69305) = {
  let {f32 arg_69306, f32 arg_69307} = lifted_20723(x_69302, x_69303)
  let {f32 res_69308, f32 res_69309} = lifted_20733(arg_69306, arg_69307,
                                                    y_69304, y_69305)
  in {res_69308, res_69309}
}

fun {f32, f32} lifted_20790(f32 x_69310, f32 x_69311) = {
  {x_69310, x_69311}
}

fun {f32, f32} lifted_20797(f32 x_69312, f32 x_69313) = {
  {x_69312, x_69313}
}

fun {f32, f32} lifted_20804(f32 x_69314, f32 x_69315) = {
  {x_69314, x_69315}
}

fun {f32, f32} lifted_20811(f32 x_69316, f32 x_69317) = {
  {x_69316, x_69317}
}

fun {f32, f32} lifted_20827(f32 a_69318, f32 b_69319) = {
  {a_69318, b_69319}
}

fun {f32} lifted_20839(f32 x_69320) = {
  {x_69320}
}

fun {f32} lifted_20843(f32 x_69321, f32 y_69322) = {
  let {f32 res_69323} = fmul32(x_69321, y_69322)
  in {res_69323}
}

fun {f32} lifted_20847(f32 x_69324) = {
  {x_69324}
}

fun {f32} lifted_20850(f32 x_69325) = {
  {x_69325}
}

fun {f32} lifted_20854(f32 x_69326, f32 y_69327) = {
  let {f32 res_69328} = fmul32(x_69326, y_69327)
  in {res_69328}
}

fun {f32} lifted_20859(f32 x_69329, f32 y_69330) = {
  let {f32 res_69331} = fsub32(x_69329, y_69330)
  in {res_69331}
}

fun {f32} lifted_20863(f32 x_69332) = {
  {x_69332}
}

fun {f32} lifted_20867(f32 x_69333, f32 y_69334) = {
  let {f32 res_69335} = fmul32(x_69333, y_69334)
  in {res_69335}
}

fun {f32} lifted_20871(f32 x_69336) = {
  {x_69336}
}

fun {f32} lifted_20874(f32 x_69337) = {
  {x_69337}
}

fun {f32} lifted_20878(f32 x_69338, f32 y_69339) = {
  let {f32 res_69340} = fmul32(x_69338, y_69339)
  in {res_69340}
}

fun {f32} lifted_20883(f32 x_69341, f32 y_69342) = {
  let {f32 res_69343} = fadd32(x_69341, y_69342)
  in {res_69343}
}

fun {f32, f32} lifted_20837(f32 a_69344, f32 b_69345, f32 c_69346,
                            f32 d_69347) = {
  let {f32 arg_69348} = lifted_20839(a_69344)
  let {f32 arg_69349} = lifted_20843(arg_69348, c_69346)
  let {f32 arg_69350} = lifted_20847(arg_69349)
  let {f32 arg_69351} = lifted_20850(b_69345)
  let {f32 arg_69352} = lifted_20854(arg_69351, d_69347)
  let {f32 res_69353} = lifted_20859(arg_69350, arg_69352)
  let {f32 arg_69354} = lifted_20863(b_69345)
  let {f32 arg_69355} = lifted_20867(arg_69354, c_69346)
  let {f32 arg_69356} = lifted_20871(arg_69355)
  let {f32 arg_69357} = lifted_20874(a_69344)
  let {f32 arg_69358} = lifted_20878(arg_69357, d_69347)
  let {f32 res_69359} = lifted_20883(arg_69356, arg_69358)
  in {res_69353, res_69359}
}

fun {f32, f32} lifted_20821(f32 x_69360, f32 x_69361, f32 y_69362,
                            f32 y_69363) = {
  let {f32 arg_69364, f32 arg_69365} = lifted_20827(x_69360, x_69361)
  let {f32 res_69366, f32 res_69367} = lifted_20837(arg_69364, arg_69365,
                                                    y_69362, y_69363)
  in {res_69366, res_69367}
}

fun {f32, f32} lifted_20901(f32 a_69368, f32 b_69369) = {
  {a_69368, b_69369}
}

fun {f32} lifted_20911(f32 x_69370) = {
  {x_69370}
}

fun {f32} lifted_20915(f32 x_69371, f32 y_69372) = {
  let {f32 res_69373} = fsub32(x_69371, y_69372)
  in {res_69373}
}

fun {f32} lifted_20919(f32 x_69374) = {
  {x_69374}
}

fun {f32} lifted_20923(f32 x_69375, f32 y_69376) = {
  let {f32 res_69377} = fsub32(x_69375, y_69376)
  in {res_69377}
}

fun {f32, f32} lifted_20909(f32 a_69378, f32 b_69379, f32 c_69380,
                            f32 d_69381) = {
  let {f32 arg_69382} = lifted_20911(a_69378)
  let {f32 res_69383} = lifted_20915(arg_69382, c_69380)
  let {f32 arg_69384} = lifted_20919(b_69379)
  let {f32 res_69385} = lifted_20923(arg_69384, d_69381)
  in {res_69383, res_69385}
}

fun {f32, f32} lifted_20897(f32 x_69386, f32 x_69387, f32 y_69388,
                            f32 y_69389) = {
  let {f32 arg_69390, f32 arg_69391} = lifted_20901(x_69386, x_69387)
  let {f32 res_69392, f32 res_69393} = lifted_20909(arg_69390, arg_69391,
                                                    y_69388, y_69389)
  in {res_69392, res_69393}
}

fun {f32, f32} lifted_20934(f32 x_69394, f32 x_69395) = {
  {x_69394, x_69395}
}

fun {f32, f32} lifted_20941(f32 x_69396, f32 x_69397) = {
  {x_69396, x_69397}
}

fun {f32, f32} lifted_20955(f32 a_69398, f32 b_69399) = {
  {a_69398, b_69399}
}

fun {f32} lifted_20965(f32 x_69400) = {
  {x_69400}
}

fun {f32} lifted_20969(f32 x_69401, f32 y_69402) = {
  let {f32 res_69403} = fsub32(x_69401, y_69402)
  in {res_69403}
}

fun {f32} lifted_20973(f32 x_69404) = {
  {x_69404}
}

fun {f32} lifted_20977(f32 x_69405, f32 y_69406) = {
  let {f32 res_69407} = fsub32(x_69405, y_69406)
  in {res_69407}
}

fun {f32, f32} lifted_20963(f32 a_69408, f32 b_69409, f32 c_69410,
                            f32 d_69411) = {
  let {f32 arg_69412} = lifted_20965(a_69408)
  let {f32 res_69413} = lifted_20969(arg_69412, c_69410)
  let {f32 arg_69414} = lifted_20973(b_69409)
  let {f32 res_69415} = lifted_20977(arg_69414, d_69411)
  in {res_69413, res_69415}
}

fun {f32, f32} lifted_20951(f32 x_69416, f32 x_69417, f32 y_69418,
                            f32 y_69419) = {
  let {f32 arg_69420, f32 arg_69421} = lifted_20955(x_69416, x_69417)
  let {f32 res_69422, f32 res_69423} = lifted_20963(arg_69420, arg_69421,
                                                    y_69418, y_69419)
  in {res_69422, res_69423}
}

fun {f32, f32} lifted_20998(f32 a_69424, f32 b_69425) = {
  {a_69424, b_69425}
}

fun {f32} lifted_21011(f32 x_69426) = {
  {x_69426}
}

fun {f32} lifted_21015(f32 x_69427, f32 y_69428) = {
  let {f32 res_69429} = fmul32(x_69427, y_69428)
  in {res_69429}
}

fun {f32} lifted_21019(f32 x_69430) = {
  {x_69430}
}

fun {f32} lifted_21022(f32 x_69431) = {
  {x_69431}
}

fun {f32} lifted_21026(f32 x_69432, f32 y_69433) = {
  let {f32 res_69434} = fmul32(x_69432, y_69433)
  in {res_69434}
}

fun {f32} lifted_21031(f32 x_69435, f32 y_69436) = {
  let {f32 res_69437} = fadd32(x_69435, y_69436)
  in {res_69437}
}

fun {f32} lifted_21035(f32 x_69438) = {
  {x_69438}
}

fun {f32} lifted_21038(f32 x_69439) = {
  {x_69439}
}

fun {f32} lifted_21042(f32 x_69440, f32 y_69441) = {
  let {f32 res_69442} = fmul32(x_69440, y_69441)
  in {res_69442}
}

fun {f32} lifted_21046(f32 x_69443) = {
  {x_69443}
}

fun {f32} lifted_21049(f32 x_69444) = {
  {x_69444}
}

fun {f32} lifted_21053(f32 x_69445, f32 y_69446) = {
  let {f32 res_69447} = fmul32(x_69445, y_69446)
  in {res_69447}
}

fun {f32} lifted_21058(f32 x_69448, f32 y_69449) = {
  let {f32 res_69450} = fadd32(x_69448, y_69449)
  in {res_69450}
}

fun {f32} lifted_21063(f32 x_69451, f32 y_69452) = {
  let {f32 res_69453} = fdiv32(x_69451, y_69452)
  in {res_69453}
}

fun {f32} lifted_21067(f32 x_69454) = {
  {x_69454}
}

fun {f32} lifted_21071(f32 x_69455, f32 y_69456) = {
  let {f32 res_69457} = fmul32(x_69455, y_69456)
  in {res_69457}
}

fun {f32} lifted_21075(f32 x_69458) = {
  {x_69458}
}

fun {f32} lifted_21078(f32 x_69459) = {
  {x_69459}
}

fun {f32} lifted_21082(f32 x_69460, f32 y_69461) = {
  let {f32 res_69462} = fmul32(x_69460, y_69461)
  in {res_69462}
}

fun {f32} lifted_21087(f32 x_69463, f32 y_69464) = {
  let {f32 res_69465} = fsub32(x_69463, y_69464)
  in {res_69465}
}

fun {f32} lifted_21091(f32 x_69466) = {
  {x_69466}
}

fun {f32} lifted_21094(f32 x_69467) = {
  {x_69467}
}

fun {f32} lifted_21098(f32 x_69468, f32 y_69469) = {
  let {f32 res_69470} = fmul32(x_69468, y_69469)
  in {res_69470}
}

fun {f32} lifted_21102(f32 x_69471) = {
  {x_69471}
}

fun {f32} lifted_21105(f32 x_69472) = {
  {x_69472}
}

fun {f32} lifted_21109(f32 x_69473, f32 y_69474) = {
  let {f32 res_69475} = fmul32(x_69473, y_69474)
  in {res_69475}
}

fun {f32} lifted_21114(f32 x_69476, f32 y_69477) = {
  let {f32 res_69478} = fadd32(x_69476, y_69477)
  in {res_69478}
}

fun {f32} lifted_21119(f32 x_69479, f32 y_69480) = {
  let {f32 res_69481} = fdiv32(x_69479, y_69480)
  in {res_69481}
}

fun {f32, f32} lifted_21009(f32 a_69482, f32 b_69483, f32 c_69484,
                            f32 d_69485) = {
  let {f32 arg_69486} = lifted_21011(a_69482)
  let {f32 arg_69487} = lifted_21015(arg_69486, c_69484)
  let {f32 arg_69488} = lifted_21019(arg_69487)
  let {f32 arg_69489} = lifted_21022(b_69483)
  let {f32 arg_69490} = lifted_21026(arg_69489, d_69485)
  let {f32 arg_69491} = lifted_21031(arg_69488, arg_69490)
  let {f32 arg_69492} = lifted_21035(arg_69491)
  let {f32 arg_69493} = lifted_21038(c_69484)
  let {f32 arg_69494} = lifted_21042(arg_69493, c_69484)
  let {f32 arg_69495} = lifted_21046(arg_69494)
  let {f32 arg_69496} = lifted_21049(d_69485)
  let {f32 arg_69497} = lifted_21053(arg_69496, d_69485)
  let {f32 arg_69498} = lifted_21058(arg_69495, arg_69497)
  let {f32 res_69499} = lifted_21063(arg_69492, arg_69498)
  let {f32 arg_69500} = lifted_21067(b_69483)
  let {f32 arg_69501} = lifted_21071(arg_69500, c_69484)
  let {f32 arg_69502} = lifted_21075(arg_69501)
  let {f32 arg_69503} = lifted_21078(a_69482)
  let {f32 arg_69504} = lifted_21082(arg_69503, d_69485)
  let {f32 arg_69505} = lifted_21087(arg_69502, arg_69504)
  let {f32 arg_69506} = lifted_21091(arg_69505)
  let {f32 arg_69507} = lifted_21094(c_69484)
  let {f32 arg_69508} = lifted_21098(arg_69507, c_69484)
  let {f32 arg_69509} = lifted_21102(arg_69508)
  let {f32 arg_69510} = lifted_21105(d_69485)
  let {f32 arg_69511} = lifted_21109(arg_69510, d_69485)
  let {f32 arg_69512} = lifted_21114(arg_69509, arg_69511)
  let {f32 res_69513} = lifted_21119(arg_69506, arg_69512)
  in {res_69499, res_69513}
}

fun {f32, f32} lifted_20991(f32 x_69514, f32 x_69515, f32 y_69516,
                            f32 y_69517) = {
  let {f32 arg_69518, f32 arg_69519} = lifted_20998(x_69514, x_69515)
  let {f32 res_69520, f32 res_69521} = lifted_21009(arg_69518, arg_69519,
                                                    y_69516, y_69517)
  in {res_69520, res_69521}
}

fun {f32} lifted_21141(f32 x_69522) = {
  {x_69522}
}

fun {f32} lifted_21145(f32 x_69523, f32 y_69524) = {
  let {f32 res_69525} = fmul32(x_69523, y_69524)
  in {res_69525}
}

fun {f32} lifted_21149(f32 x_69526) = {
  {x_69526}
}

fun {f32} lifted_21152(f32 x_69527) = {
  {x_69527}
}

fun {f32} lifted_21156(f32 x_69528, f32 y_69529) = {
  let {f32 res_69530} = fmul32(x_69528, y_69529)
  in {res_69530}
}

fun {f32} lifted_21161(f32 x_69531, f32 y_69532) = {
  let {f32 res_69533} = fadd32(x_69531, y_69532)
  in {res_69533}
}

fun {f32} lifted_21165(f32 x_69534) = {
  let {f32 res_69535} = sqrt32(x_69534)
  in {res_69535}
}

fun {f32} lifted_21139(f32 a_69536, f32 b_69537) = {
  let {f32 arg_69538} = lifted_21141(a_69536)
  let {f32 arg_69539} = lifted_21145(arg_69538, a_69536)
  let {f32 arg_69540} = lifted_21149(arg_69539)
  let {f32 arg_69541} = lifted_21152(b_69537)
  let {f32 arg_69542} = lifted_21156(arg_69541, b_69537)
  let {f32 arg_69543} = lifted_21161(arg_69540, arg_69542)
  let {f32 res_69544} = lifted_21165(arg_69543)
  in {res_69544}
}

fun {f32} lifted_21170(f32 x_69545) = {
  let {f32 res_69546} = log32(x_69545)
  in {res_69546}
}

fun {f32} lifted_21174(f32 a_69547) = {
  {a_69547}
}

fun {f32} lifted_21181(f32 x_69548) = {
  {x_69548}
}

fun {f32} lifted_21185(f32 x_69549, f32 y_69550) = {
  let {f32 res_69551} = atan2_32(x_69549, y_69550)
  in {res_69551}
}

fun {f32} lifted_21179(f32 a_69552, f32 b_69553) = {
  let {f32 arg_69554} = lifted_21181(b_69553)
  let {f32 res_69555} = lifted_21185(arg_69554, a_69552)
  in {res_69555}
}

fun {f32, f32} lifted_21191(f32 a_69556, f32 b_69557) = {
  {a_69556, b_69557}
}

fun {f32, f32} lifted_21133(f32 z_69558, f32 z_69559) = {
  let {f32 arg_69560} = lifted_21139(z_69558, z_69559)
  let {f32 arg_69561} = lifted_21170(arg_69560)
  let {f32 arg_69562} = lifted_21174(arg_69561)
  let {f32 arg_69563} = lifted_21179(z_69558, z_69559)
  let {f32 res_69564, f32 res_69565} = lifted_21191(arg_69562, arg_69563)
  in {res_69564, res_69565}
}

fun {f32, f32} lifted_21209(f32 a_69566, f32 b_69567) = {
  {a_69566, b_69567}
}

fun {f32} lifted_21221(f32 x_69568) = {
  {x_69568}
}

fun {f32} lifted_21225(f32 x_69569, f32 y_69570) = {
  let {f32 res_69571} = fmul32(x_69569, y_69570)
  in {res_69571}
}

fun {f32} lifted_21229(f32 x_69572) = {
  {x_69572}
}

fun {f32} lifted_21232(f32 x_69573) = {
  {x_69573}
}

fun {f32} lifted_21236(f32 x_69574, f32 y_69575) = {
  let {f32 res_69576} = fmul32(x_69574, y_69575)
  in {res_69576}
}

fun {f32} lifted_21241(f32 x_69577, f32 y_69578) = {
  let {f32 res_69579} = fsub32(x_69577, y_69578)
  in {res_69579}
}

fun {f32} lifted_21245(f32 x_69580) = {
  {x_69580}
}

fun {f32} lifted_21249(f32 x_69581, f32 y_69582) = {
  let {f32 res_69583} = fmul32(x_69581, y_69582)
  in {res_69583}
}

fun {f32} lifted_21253(f32 x_69584) = {
  {x_69584}
}

fun {f32} lifted_21256(f32 x_69585) = {
  {x_69585}
}

fun {f32} lifted_21260(f32 x_69586, f32 y_69587) = {
  let {f32 res_69588} = fmul32(x_69586, y_69587)
  in {res_69588}
}

fun {f32} lifted_21265(f32 x_69589, f32 y_69590) = {
  let {f32 res_69591} = fadd32(x_69589, y_69590)
  in {res_69591}
}

fun {f32, f32} lifted_21219(f32 a_69592, f32 b_69593, f32 c_69594,
                            f32 d_69595) = {
  let {f32 arg_69596} = lifted_21221(a_69592)
  let {f32 arg_69597} = lifted_21225(arg_69596, c_69594)
  let {f32 arg_69598} = lifted_21229(arg_69597)
  let {f32 arg_69599} = lifted_21232(b_69593)
  let {f32 arg_69600} = lifted_21236(arg_69599, d_69595)
  let {f32 res_69601} = lifted_21241(arg_69598, arg_69600)
  let {f32 arg_69602} = lifted_21245(b_69593)
  let {f32 arg_69603} = lifted_21249(arg_69602, c_69594)
  let {f32 arg_69604} = lifted_21253(arg_69603)
  let {f32 arg_69605} = lifted_21256(a_69592)
  let {f32 arg_69606} = lifted_21260(arg_69605, d_69595)
  let {f32 res_69607} = lifted_21265(arg_69604, arg_69606)
  in {res_69601, res_69607}
}

fun {f32, f32} lifted_21203(f32 x_69608, f32 x_69609, f32 y_69610,
                            f32 y_69611) = {
  let {f32 arg_69612, f32 arg_69613} = lifted_21209(x_69608, x_69609)
  let {f32 res_69614, f32 res_69615} = lifted_21219(arg_69612, arg_69613,
                                                    y_69610, y_69611)
  in {res_69614, res_69615}
}

fun {f32, f32} lifted_21283(f32 a_69616, f32 b_69617) = {
  {a_69616, b_69617}
}

fun {f32} lifted_21293(f32 x_69618) = {
  {x_69618}
}

fun {f32} lifted_21297(f32 x_69619, f32 y_69620) = {
  let {f32 res_69621} = fsub32(x_69619, y_69620)
  in {res_69621}
}

fun {f32} lifted_21301(f32 x_69622) = {
  {x_69622}
}

fun {f32} lifted_21305(f32 x_69623, f32 y_69624) = {
  let {f32 res_69625} = fsub32(x_69623, y_69624)
  in {res_69625}
}

fun {f32, f32} lifted_21291(f32 a_69626, f32 b_69627, f32 c_69628,
                            f32 d_69629) = {
  let {f32 arg_69630} = lifted_21293(a_69626)
  let {f32 res_69631} = lifted_21297(arg_69630, c_69628)
  let {f32 arg_69632} = lifted_21301(b_69627)
  let {f32 res_69633} = lifted_21305(arg_69632, d_69629)
  in {res_69631, res_69633}
}

fun {f32, f32} lifted_21279(f32 x_69634, f32 x_69635, f32 y_69636,
                            f32 y_69637) = {
  let {f32 arg_69638, f32 arg_69639} = lifted_21283(x_69634, x_69635)
  let {f32 res_69640, f32 res_69641} = lifted_21291(arg_69638, arg_69639,
                                                    y_69636, y_69637)
  in {res_69640, res_69641}
}

fun {f32, f32} lifted_21325(f32 a_69642, f32 b_69643) = {
  {a_69642, b_69643}
}

fun {f32} lifted_21337(f32 x_69644) = {
  {x_69644}
}

fun {f32} lifted_21341(f32 x_69645, f32 y_69646) = {
  let {f32 res_69647} = fmul32(x_69645, y_69646)
  in {res_69647}
}

fun {f32} lifted_21345(f32 x_69648) = {
  {x_69648}
}

fun {f32} lifted_21348(f32 x_69649) = {
  {x_69649}
}

fun {f32} lifted_21352(f32 x_69650, f32 y_69651) = {
  let {f32 res_69652} = fmul32(x_69650, y_69651)
  in {res_69652}
}

fun {f32} lifted_21357(f32 x_69653, f32 y_69654) = {
  let {f32 res_69655} = fsub32(x_69653, y_69654)
  in {res_69655}
}

fun {f32} lifted_21361(f32 x_69656) = {
  {x_69656}
}

fun {f32} lifted_21365(f32 x_69657, f32 y_69658) = {
  let {f32 res_69659} = fmul32(x_69657, y_69658)
  in {res_69659}
}

fun {f32} lifted_21369(f32 x_69660) = {
  {x_69660}
}

fun {f32} lifted_21372(f32 x_69661) = {
  {x_69661}
}

fun {f32} lifted_21376(f32 x_69662, f32 y_69663) = {
  let {f32 res_69664} = fmul32(x_69662, y_69663)
  in {res_69664}
}

fun {f32} lifted_21381(f32 x_69665, f32 y_69666) = {
  let {f32 res_69667} = fadd32(x_69665, y_69666)
  in {res_69667}
}

fun {f32, f32} lifted_21335(f32 a_69668, f32 b_69669, f32 c_69670,
                            f32 d_69671) = {
  let {f32 arg_69672} = lifted_21337(a_69668)
  let {f32 arg_69673} = lifted_21341(arg_69672, c_69670)
  let {f32 arg_69674} = lifted_21345(arg_69673)
  let {f32 arg_69675} = lifted_21348(b_69669)
  let {f32 arg_69676} = lifted_21352(arg_69675, d_69671)
  let {f32 res_69677} = lifted_21357(arg_69674, arg_69676)
  let {f32 arg_69678} = lifted_21361(b_69669)
  let {f32 arg_69679} = lifted_21365(arg_69678, c_69670)
  let {f32 arg_69680} = lifted_21369(arg_69679)
  let {f32 arg_69681} = lifted_21372(a_69668)
  let {f32 arg_69682} = lifted_21376(arg_69681, d_69671)
  let {f32 res_69683} = lifted_21381(arg_69680, arg_69682)
  in {res_69677, res_69683}
}

fun {f32, f32} lifted_21319(f32 x_69684, f32 x_69685, f32 y_69686,
                            f32 y_69687) = {
  let {f32 arg_69688, f32 arg_69689} = lifted_21325(x_69684, x_69685)
  let {f32 res_69690, f32 res_69691} = lifted_21335(arg_69688, arg_69689,
                                                    y_69686, y_69687)
  in {res_69690, res_69691}
}

fun {f32, f32} lifted_21392(f32 x_69692, f32 x_69693) = {
  {x_69692, x_69693}
}

fun {f32, f32} lifted_21399(f32 x_69694, f32 x_69695) = {
  {x_69694, x_69695}
}

fun {f32, f32} lifted_21415(f32 a_69696, f32 b_69697) = {
  {a_69696, b_69697}
}

fun {f32} lifted_21427(f32 x_69698) = {
  {x_69698}
}

fun {f32} lifted_21431(f32 x_69699, f32 y_69700) = {
  let {f32 res_69701} = fmul32(x_69699, y_69700)
  in {res_69701}
}

fun {f32} lifted_21435(f32 x_69702) = {
  {x_69702}
}

fun {f32} lifted_21438(f32 x_69703) = {
  {x_69703}
}

fun {f32} lifted_21442(f32 x_69704, f32 y_69705) = {
  let {f32 res_69706} = fmul32(x_69704, y_69705)
  in {res_69706}
}

fun {f32} lifted_21447(f32 x_69707, f32 y_69708) = {
  let {f32 res_69709} = fsub32(x_69707, y_69708)
  in {res_69709}
}

fun {f32} lifted_21451(f32 x_69710) = {
  {x_69710}
}

fun {f32} lifted_21455(f32 x_69711, f32 y_69712) = {
  let {f32 res_69713} = fmul32(x_69711, y_69712)
  in {res_69713}
}

fun {f32} lifted_21459(f32 x_69714) = {
  {x_69714}
}

fun {f32} lifted_21462(f32 x_69715) = {
  {x_69715}
}

fun {f32} lifted_21466(f32 x_69716, f32 y_69717) = {
  let {f32 res_69718} = fmul32(x_69716, y_69717)
  in {res_69718}
}

fun {f32} lifted_21471(f32 x_69719, f32 y_69720) = {
  let {f32 res_69721} = fadd32(x_69719, y_69720)
  in {res_69721}
}

fun {f32, f32} lifted_21425(f32 a_69722, f32 b_69723, f32 c_69724,
                            f32 d_69725) = {
  let {f32 arg_69726} = lifted_21427(a_69722)
  let {f32 arg_69727} = lifted_21431(arg_69726, c_69724)
  let {f32 arg_69728} = lifted_21435(arg_69727)
  let {f32 arg_69729} = lifted_21438(b_69723)
  let {f32 arg_69730} = lifted_21442(arg_69729, d_69725)
  let {f32 res_69731} = lifted_21447(arg_69728, arg_69730)
  let {f32 arg_69732} = lifted_21451(b_69723)
  let {f32 arg_69733} = lifted_21455(arg_69732, c_69724)
  let {f32 arg_69734} = lifted_21459(arg_69733)
  let {f32 arg_69735} = lifted_21462(a_69722)
  let {f32 arg_69736} = lifted_21466(arg_69735, d_69725)
  let {f32 res_69737} = lifted_21471(arg_69734, arg_69736)
  in {res_69731, res_69737}
}

fun {f32, f32} lifted_21409(f32 x_69738, f32 x_69739, f32 y_69740,
                            f32 y_69741) = {
  let {f32 arg_69742, f32 arg_69743} = lifted_21415(x_69738, x_69739)
  let {f32 res_69744, f32 res_69745} = lifted_21425(arg_69742, arg_69743,
                                                    y_69740, y_69741)
  in {res_69744, res_69745}
}

fun {f32, f32} lifted_21482(f32 x_69746, f32 x_69747) = {
  {x_69746, x_69747}
}

fun {f32, f32} lifted_21489(f32 x_69748, f32 x_69749) = {
  {x_69748, x_69749}
}

fun {f32, f32} lifted_21503(f32 a_69750, f32 b_69751) = {
  {a_69750, b_69751}
}

fun {f32} lifted_21513(f32 x_69752) = {
  {x_69752}
}

fun {f32} lifted_21517(f32 x_69753, f32 y_69754) = {
  let {f32 res_69755} = fsub32(x_69753, y_69754)
  in {res_69755}
}

fun {f32} lifted_21521(f32 x_69756) = {
  {x_69756}
}

fun {f32} lifted_21525(f32 x_69757, f32 y_69758) = {
  let {f32 res_69759} = fsub32(x_69757, y_69758)
  in {res_69759}
}

fun {f32, f32} lifted_21511(f32 a_69760, f32 b_69761, f32 c_69762,
                            f32 d_69763) = {
  let {f32 arg_69764} = lifted_21513(a_69760)
  let {f32 res_69765} = lifted_21517(arg_69764, c_69762)
  let {f32 arg_69766} = lifted_21521(b_69761)
  let {f32 res_69767} = lifted_21525(arg_69766, d_69763)
  in {res_69765, res_69767}
}

fun {f32, f32} lifted_21499(f32 x_69768, f32 x_69769, f32 y_69770,
                            f32 y_69771) = {
  let {f32 arg_69772, f32 arg_69773} = lifted_21503(x_69768, x_69769)
  let {f32 res_69774, f32 res_69775} = lifted_21511(arg_69772, arg_69773,
                                                    y_69770, y_69771)
  in {res_69774, res_69775}
}

fun {f32, f32} lifted_21545(f32 a_69776, f32 b_69777) = {
  {a_69776, b_69777}
}

fun {f32} lifted_21557(f32 x_69778) = {
  {x_69778}
}

fun {f32} lifted_21561(f32 x_69779, f32 y_69780) = {
  let {f32 res_69781} = fmul32(x_69779, y_69780)
  in {res_69781}
}

fun {f32} lifted_21565(f32 x_69782) = {
  {x_69782}
}

fun {f32} lifted_21568(f32 x_69783) = {
  {x_69783}
}

fun {f32} lifted_21572(f32 x_69784, f32 y_69785) = {
  let {f32 res_69786} = fmul32(x_69784, y_69785)
  in {res_69786}
}

fun {f32} lifted_21577(f32 x_69787, f32 y_69788) = {
  let {f32 res_69789} = fsub32(x_69787, y_69788)
  in {res_69789}
}

fun {f32} lifted_21581(f32 x_69790) = {
  {x_69790}
}

fun {f32} lifted_21585(f32 x_69791, f32 y_69792) = {
  let {f32 res_69793} = fmul32(x_69791, y_69792)
  in {res_69793}
}

fun {f32} lifted_21589(f32 x_69794) = {
  {x_69794}
}

fun {f32} lifted_21592(f32 x_69795) = {
  {x_69795}
}

fun {f32} lifted_21596(f32 x_69796, f32 y_69797) = {
  let {f32 res_69798} = fmul32(x_69796, y_69797)
  in {res_69798}
}

fun {f32} lifted_21601(f32 x_69799, f32 y_69800) = {
  let {f32 res_69801} = fadd32(x_69799, y_69800)
  in {res_69801}
}

fun {f32, f32} lifted_21555(f32 a_69802, f32 b_69803, f32 c_69804,
                            f32 d_69805) = {
  let {f32 arg_69806} = lifted_21557(a_69802)
  let {f32 arg_69807} = lifted_21561(arg_69806, c_69804)
  let {f32 arg_69808} = lifted_21565(arg_69807)
  let {f32 arg_69809} = lifted_21568(b_69803)
  let {f32 arg_69810} = lifted_21572(arg_69809, d_69805)
  let {f32 res_69811} = lifted_21577(arg_69808, arg_69810)
  let {f32 arg_69812} = lifted_21581(b_69803)
  let {f32 arg_69813} = lifted_21585(arg_69812, c_69804)
  let {f32 arg_69814} = lifted_21589(arg_69813)
  let {f32 arg_69815} = lifted_21592(a_69802)
  let {f32 arg_69816} = lifted_21596(arg_69815, d_69805)
  let {f32 res_69817} = lifted_21601(arg_69814, arg_69816)
  in {res_69811, res_69817}
}

fun {f32, f32} lifted_21539(f32 x_69818, f32 x_69819, f32 y_69820,
                            f32 y_69821) = {
  let {f32 arg_69822, f32 arg_69823} = lifted_21545(x_69818, x_69819)
  let {f32 res_69824, f32 res_69825} = lifted_21555(arg_69822, arg_69823,
                                                    y_69820, y_69821)
  in {res_69824, res_69825}
}

fun {f32, f32} lifted_21612(f32 x_69826, f32 x_69827) = {
  {x_69826, x_69827}
}

fun {f32, f32} lifted_21619(f32 x_69828, f32 x_69829) = {
  {x_69828, x_69829}
}

fun {f32, f32} lifted_21626(f32 x_69830, f32 x_69831) = {
  {x_69830, x_69831}
}

fun {f32, f32} lifted_21642(f32 a_69832, f32 b_69833) = {
  {a_69832, b_69833}
}

fun {f32} lifted_21654(f32 x_69834) = {
  {x_69834}
}

fun {f32} lifted_21658(f32 x_69835, f32 y_69836) = {
  let {f32 res_69837} = fmul32(x_69835, y_69836)
  in {res_69837}
}

fun {f32} lifted_21662(f32 x_69838) = {
  {x_69838}
}

fun {f32} lifted_21665(f32 x_69839) = {
  {x_69839}
}

fun {f32} lifted_21669(f32 x_69840, f32 y_69841) = {
  let {f32 res_69842} = fmul32(x_69840, y_69841)
  in {res_69842}
}

fun {f32} lifted_21674(f32 x_69843, f32 y_69844) = {
  let {f32 res_69845} = fsub32(x_69843, y_69844)
  in {res_69845}
}

fun {f32} lifted_21678(f32 x_69846) = {
  {x_69846}
}

fun {f32} lifted_21682(f32 x_69847, f32 y_69848) = {
  let {f32 res_69849} = fmul32(x_69847, y_69848)
  in {res_69849}
}

fun {f32} lifted_21686(f32 x_69850) = {
  {x_69850}
}

fun {f32} lifted_21689(f32 x_69851) = {
  {x_69851}
}

fun {f32} lifted_21693(f32 x_69852, f32 y_69853) = {
  let {f32 res_69854} = fmul32(x_69852, y_69853)
  in {res_69854}
}

fun {f32} lifted_21698(f32 x_69855, f32 y_69856) = {
  let {f32 res_69857} = fadd32(x_69855, y_69856)
  in {res_69857}
}

fun {f32, f32} lifted_21652(f32 a_69858, f32 b_69859, f32 c_69860,
                            f32 d_69861) = {
  let {f32 arg_69862} = lifted_21654(a_69858)
  let {f32 arg_69863} = lifted_21658(arg_69862, c_69860)
  let {f32 arg_69864} = lifted_21662(arg_69863)
  let {f32 arg_69865} = lifted_21665(b_69859)
  let {f32 arg_69866} = lifted_21669(arg_69865, d_69861)
  let {f32 res_69867} = lifted_21674(arg_69864, arg_69866)
  let {f32 arg_69868} = lifted_21678(b_69859)
  let {f32 arg_69869} = lifted_21682(arg_69868, c_69860)
  let {f32 arg_69870} = lifted_21686(arg_69869)
  let {f32 arg_69871} = lifted_21689(a_69858)
  let {f32 arg_69872} = lifted_21693(arg_69871, d_69861)
  let {f32 res_69873} = lifted_21698(arg_69870, arg_69872)
  in {res_69867, res_69873}
}

fun {f32, f32} lifted_21636(f32 x_69874, f32 x_69875, f32 y_69876,
                            f32 y_69877) = {
  let {f32 arg_69878, f32 arg_69879} = lifted_21642(x_69874, x_69875)
  let {f32 res_69880, f32 res_69881} = lifted_21652(arg_69878, arg_69879,
                                                    y_69876, y_69877)
  in {res_69880, res_69881}
}

fun {f32, f32} lifted_21716(f32 a_69882, f32 b_69883) = {
  {a_69882, b_69883}
}

fun {f32} lifted_21726(f32 x_69884) = {
  {x_69884}
}

fun {f32} lifted_21730(f32 x_69885, f32 y_69886) = {
  let {f32 res_69887} = fsub32(x_69885, y_69886)
  in {res_69887}
}

fun {f32} lifted_21734(f32 x_69888) = {
  {x_69888}
}

fun {f32} lifted_21738(f32 x_69889, f32 y_69890) = {
  let {f32 res_69891} = fsub32(x_69889, y_69890)
  in {res_69891}
}

fun {f32, f32} lifted_21724(f32 a_69892, f32 b_69893, f32 c_69894,
                            f32 d_69895) = {
  let {f32 arg_69896} = lifted_21726(a_69892)
  let {f32 res_69897} = lifted_21730(arg_69896, c_69894)
  let {f32 arg_69898} = lifted_21734(b_69893)
  let {f32 res_69899} = lifted_21738(arg_69898, d_69895)
  in {res_69897, res_69899}
}

fun {f32, f32} lifted_21712(f32 x_69900, f32 x_69901, f32 y_69902,
                            f32 y_69903) = {
  let {f32 arg_69904, f32 arg_69905} = lifted_21716(x_69900, x_69901)
  let {f32 res_69906, f32 res_69907} = lifted_21724(arg_69904, arg_69905,
                                                    y_69902, y_69903)
  in {res_69906, res_69907}
}

fun {f32, f32} lifted_21759(f32 a_69908, f32 b_69909) = {
  {a_69908, b_69909}
}

fun {f32} lifted_21772(f32 x_69910) = {
  {x_69910}
}

fun {f32} lifted_21776(f32 x_69911, f32 y_69912) = {
  let {f32 res_69913} = fmul32(x_69911, y_69912)
  in {res_69913}
}

fun {f32} lifted_21780(f32 x_69914) = {
  {x_69914}
}

fun {f32} lifted_21783(f32 x_69915) = {
  {x_69915}
}

fun {f32} lifted_21787(f32 x_69916, f32 y_69917) = {
  let {f32 res_69918} = fmul32(x_69916, y_69917)
  in {res_69918}
}

fun {f32} lifted_21792(f32 x_69919, f32 y_69920) = {
  let {f32 res_69921} = fadd32(x_69919, y_69920)
  in {res_69921}
}

fun {f32} lifted_21796(f32 x_69922) = {
  {x_69922}
}

fun {f32} lifted_21799(f32 x_69923) = {
  {x_69923}
}

fun {f32} lifted_21803(f32 x_69924, f32 y_69925) = {
  let {f32 res_69926} = fmul32(x_69924, y_69925)
  in {res_69926}
}

fun {f32} lifted_21807(f32 x_69927) = {
  {x_69927}
}

fun {f32} lifted_21810(f32 x_69928) = {
  {x_69928}
}

fun {f32} lifted_21814(f32 x_69929, f32 y_69930) = {
  let {f32 res_69931} = fmul32(x_69929, y_69930)
  in {res_69931}
}

fun {f32} lifted_21819(f32 x_69932, f32 y_69933) = {
  let {f32 res_69934} = fadd32(x_69932, y_69933)
  in {res_69934}
}

fun {f32} lifted_21824(f32 x_69935, f32 y_69936) = {
  let {f32 res_69937} = fdiv32(x_69935, y_69936)
  in {res_69937}
}

fun {f32} lifted_21828(f32 x_69938) = {
  {x_69938}
}

fun {f32} lifted_21832(f32 x_69939, f32 y_69940) = {
  let {f32 res_69941} = fmul32(x_69939, y_69940)
  in {res_69941}
}

fun {f32} lifted_21836(f32 x_69942) = {
  {x_69942}
}

fun {f32} lifted_21839(f32 x_69943) = {
  {x_69943}
}

fun {f32} lifted_21843(f32 x_69944, f32 y_69945) = {
  let {f32 res_69946} = fmul32(x_69944, y_69945)
  in {res_69946}
}

fun {f32} lifted_21848(f32 x_69947, f32 y_69948) = {
  let {f32 res_69949} = fsub32(x_69947, y_69948)
  in {res_69949}
}

fun {f32} lifted_21852(f32 x_69950) = {
  {x_69950}
}

fun {f32} lifted_21855(f32 x_69951) = {
  {x_69951}
}

fun {f32} lifted_21859(f32 x_69952, f32 y_69953) = {
  let {f32 res_69954} = fmul32(x_69952, y_69953)
  in {res_69954}
}

fun {f32} lifted_21863(f32 x_69955) = {
  {x_69955}
}

fun {f32} lifted_21866(f32 x_69956) = {
  {x_69956}
}

fun {f32} lifted_21870(f32 x_69957, f32 y_69958) = {
  let {f32 res_69959} = fmul32(x_69957, y_69958)
  in {res_69959}
}

fun {f32} lifted_21875(f32 x_69960, f32 y_69961) = {
  let {f32 res_69962} = fadd32(x_69960, y_69961)
  in {res_69962}
}

fun {f32} lifted_21880(f32 x_69963, f32 y_69964) = {
  let {f32 res_69965} = fdiv32(x_69963, y_69964)
  in {res_69965}
}

fun {f32, f32} lifted_21770(f32 a_69966, f32 b_69967, f32 c_69968,
                            f32 d_69969) = {
  let {f32 arg_69970} = lifted_21772(a_69966)
  let {f32 arg_69971} = lifted_21776(arg_69970, c_69968)
  let {f32 arg_69972} = lifted_21780(arg_69971)
  let {f32 arg_69973} = lifted_21783(b_69967)
  let {f32 arg_69974} = lifted_21787(arg_69973, d_69969)
  let {f32 arg_69975} = lifted_21792(arg_69972, arg_69974)
  let {f32 arg_69976} = lifted_21796(arg_69975)
  let {f32 arg_69977} = lifted_21799(c_69968)
  let {f32 arg_69978} = lifted_21803(arg_69977, c_69968)
  let {f32 arg_69979} = lifted_21807(arg_69978)
  let {f32 arg_69980} = lifted_21810(d_69969)
  let {f32 arg_69981} = lifted_21814(arg_69980, d_69969)
  let {f32 arg_69982} = lifted_21819(arg_69979, arg_69981)
  let {f32 res_69983} = lifted_21824(arg_69976, arg_69982)
  let {f32 arg_69984} = lifted_21828(b_69967)
  let {f32 arg_69985} = lifted_21832(arg_69984, c_69968)
  let {f32 arg_69986} = lifted_21836(arg_69985)
  let {f32 arg_69987} = lifted_21839(a_69966)
  let {f32 arg_69988} = lifted_21843(arg_69987, d_69969)
  let {f32 arg_69989} = lifted_21848(arg_69986, arg_69988)
  let {f32 arg_69990} = lifted_21852(arg_69989)
  let {f32 arg_69991} = lifted_21855(c_69968)
  let {f32 arg_69992} = lifted_21859(arg_69991, c_69968)
  let {f32 arg_69993} = lifted_21863(arg_69992)
  let {f32 arg_69994} = lifted_21866(d_69969)
  let {f32 arg_69995} = lifted_21870(arg_69994, d_69969)
  let {f32 arg_69996} = lifted_21875(arg_69993, arg_69995)
  let {f32 res_69997} = lifted_21880(arg_69990, arg_69996)
  in {res_69983, res_69997}
}

fun {f32, f32} lifted_21752(f32 x_69998, f32 x_69999, f32 y_70000,
                            f32 y_70001) = {
  let {f32 arg_70002, f32 arg_70003} = lifted_21759(x_69998, x_69999)
  let {f32 res_70004, f32 res_70005} = lifted_21770(arg_70002, arg_70003,
                                                    y_70000, y_70001)
  in {res_70004, res_70005}
}

fun {f32, f32} lifted_21898(f32 a_70006, f32 b_70007) = {
  {a_70006, b_70007}
}

fun {f32} lifted_21908(f32 x_70008) = {
  {x_70008}
}

fun {f32} lifted_21912(f32 x_70009, f32 y_70010) = {
  let {f32 res_70011} = fadd32(x_70009, y_70010)
  in {res_70011}
}

fun {f32} lifted_21916(f32 x_70012) = {
  {x_70012}
}

fun {f32} lifted_21920(f32 x_70013, f32 y_70014) = {
  let {f32 res_70015} = fadd32(x_70013, y_70014)
  in {res_70015}
}

fun {f32, f32} lifted_21906(f32 a_70016, f32 b_70017, f32 c_70018,
                            f32 d_70019) = {
  let {f32 arg_70020} = lifted_21908(a_70016)
  let {f32 res_70021} = lifted_21912(arg_70020, c_70018)
  let {f32 arg_70022} = lifted_21916(b_70017)
  let {f32 res_70023} = lifted_21920(arg_70022, d_70019)
  in {res_70021, res_70023}
}

fun {f32, f32} lifted_21894(f32 x_70024, f32 x_70025, f32 y_70026,
                            f32 y_70027) = {
  let {f32 arg_70028, f32 arg_70029} = lifted_21898(x_70024, x_70025)
  let {f32 res_70030, f32 res_70031} = lifted_21906(arg_70028, arg_70029,
                                                    y_70026, y_70027)
  in {res_70030, res_70031}
}

fun {f32} lifted_21936(f32 x_70032) = {
  let {f32 res_70033} = exp32(x_70032)
  in {res_70033}
}

fun {f32} lifted_21941(f32 x_70034) = {
  {x_70034}
}

fun {f32} lifted_21944(f32 x_70035) = {
  let {f32 res_70036} = cos32(x_70035)
  in {res_70036}
}

fun {f32} lifted_21949(f32 x_70037, f32 y_70038) = {
  let {f32 res_70039} = fmul32(x_70037, y_70038)
  in {res_70039}
}

fun {f32} lifted_21953(f32 a_70040) = {
  {a_70040}
}

fun {f32} lifted_21956(f32 x_70041) = {
  {x_70041}
}

fun {f32} lifted_21959(f32 x_70042) = {
  let {f32 res_70043} = sin32(x_70042)
  in {res_70043}
}

fun {f32} lifted_21964(f32 x_70044, f32 y_70045) = {
  let {f32 res_70046} = fmul32(x_70044, y_70045)
  in {res_70046}
}

fun {f32, f32} lifted_21969(f32 a_70047, f32 b_70048) = {
  {a_70047, b_70048}
}

fun {f32, f32} lifted_21934(f32 a_70049, f32 b_70050) = {
  let {f32 res_70051} = lifted_21936(a_70049)
  let {f32 expx_70052} = res_70051
  let {f32 arg_70053} = lifted_21941(expx_70052)
  let {f32 arg_70054} = lifted_21944(b_70050)
  let {f32 arg_70055} = lifted_21949(arg_70053, arg_70054)
  let {f32 arg_70056} = lifted_21953(arg_70055)
  let {f32 arg_70057} = lifted_21956(expx_70052)
  let {f32 arg_70058} = lifted_21959(b_70050)
  let {f32 arg_70059} = lifted_21964(arg_70057, arg_70058)
  let {f32 res_70060, f32 res_70061} = lifted_21969(arg_70056, arg_70059)
  in {res_70060, res_70061}
}

fun {f32, f32} lifted_19512(f32 coeff1_70062, f32 coeff1_70063,
                            f32 coeff2_70064, f32 coeff2_70065,
                            f32 day_count_fraction_70066, f32 etai2_70067,
                            f32 etai2_70068, f32 etai_70069, f32 etai_70070,
                            f32 i_70071, f32 i_70072, f32 kappai_70073,
                            f32 kappai_70074, f32 one_70075, f32 one_70076,
                            f32 rho_70077, f32 two_70078, f32 two_70079,
                            f32 zero_70080, f32 zero_70081, f32 xi_70082,
                            f32 xi_70083) = {
  let {f32 res_70084, f32 res_70085} = lifted_19515(day_count_fraction_70066)
  let {f32 ti_70086} = res_70084
  let {f32 ti_70087} = res_70085
  let {f32 arg_70088, f32 arg_70089} = lifted_19529(kappai_70073, kappai_70074)
  let {f32 arg_70090, f32 arg_70091} = lifted_19534(rho_70077)
  let {f32 arg_70092, f32 arg_70093} = lifted_19545(arg_70090, arg_70091)
  let {f32 arg_70094, f32 arg_70095} = lifted_19555(arg_70092, arg_70093,
                                                    etai_70069, etai_70070)
  let {f32 arg_70096, f32 arg_70097} = lifted_19628(arg_70094, arg_70095)
  let {f32 arg_70098, f32 arg_70099} = lifted_19638(arg_70096, arg_70097,
                                                    xi_70082, xi_70083)
  let {f32 res_70100, f32 res_70101} = lifted_19714(arg_70088, arg_70089,
                                                    arg_70098, arg_70099)
  let {f32 d0_70102} = res_70100
  let {f32 d0_70103} = res_70101
  let {f32 arg_70104, f32 arg_70105} = lifted_19754(d0_70102, d0_70103)
  let {f32 arg_70106, f32 arg_70107} = lifted_19764(arg_70104, arg_70105,
                                                    d0_70102, d0_70103)
  let {f32 arg_70108, f32 arg_70109} = lifted_19837(arg_70106, arg_70107)
  let {f32 arg_70110, f32 arg_70111} = lifted_19844(etai2_70067, etai2_70068)
  let {f32 arg_70112, f32 arg_70113} = lifted_19851(xi_70082, xi_70083)
  let {f32 arg_70114, f32 arg_70115} = lifted_19858(i_70071, i_70072)
  let {f32 arg_70116, f32 arg_70117} = lifted_19868(arg_70114, arg_70115,
                                                    xi_70082, xi_70083)
  let {f32 arg_70118, f32 arg_70119} = lifted_19908(arg_70112, arg_70113,
                                                    arg_70116, arg_70117)
  let {f32 arg_70120, f32 arg_70121} = lifted_19984(arg_70110, arg_70111,
                                                    arg_70118, arg_70119)
  let {f32 arg_70122, f32 arg_70123} = lifted_20060(arg_70108, arg_70109,
                                                    arg_70120, arg_70121)
  let {f32 res_70124, f32 res_70125} = lifted_20103(arg_70122, arg_70123)
  let {f32 d_70126} = res_70124
  let {f32 d_70127} = res_70125
  let {f32 arg_70128, f32 arg_70129} = lifted_20271(d0_70102, d0_70103)
  let {f32 res_70130, f32 res_70131} = lifted_20281(arg_70128, arg_70129,
                                                    d_70126, d_70127)
  let {f32 a_minus_70132} = res_70130
  let {f32 a_minus_70133} = res_70131
  let {f32 arg_70134, f32 arg_70135} = lifted_20321(a_minus_70132,
                                                    a_minus_70133)
  let {f32 arg_70136, f32 arg_70137} = lifted_20328(d0_70102, d0_70103)
  let {f32 arg_70138, f32 arg_70139} = lifted_20338(arg_70136, arg_70137,
                                                    d_70126, d_70127)
  let {f32 res_70140, f32 res_70141} = lifted_20378(arg_70134, arg_70135,
                                                    arg_70138, arg_70139)
  let {f32 g_70142} = res_70140
  let {f32 g_70143} = res_70141
  let {f32 arg_70144, f32 arg_70145} = lifted_20520(zero_70080, zero_70081)
  let {f32 arg_70146, f32 arg_70147} = lifted_20527(d_70126, d_70127)
  let {f32 arg_70148, f32 arg_70149} = lifted_20537(arg_70146, arg_70147,
                                                    ti_70086, ti_70087)
  let {f32 arg_70150, f32 arg_70151} = lifted_20613(arg_70144, arg_70145,
                                                    arg_70148, arg_70149)
  let {f32 res_70152, f32 res_70153} = lifted_20653(arg_70150, arg_70151)
  let {f32 e_70154} = res_70152
  let {f32 e_70155} = res_70153
  let {f32 arg_70156, f32 arg_70157} = lifted_20700(coeff1_70062, coeff1_70063)
  let {f32 arg_70158, f32 arg_70159} = lifted_20707(a_minus_70132,
                                                    a_minus_70133)
  let {f32 arg_70160, f32 arg_70161} = lifted_20717(arg_70158, arg_70159,
                                                    ti_70086, ti_70087)
  let {f32 arg_70162, f32 arg_70163} = lifted_20790(arg_70160, arg_70161)
  let {f32 arg_70164, f32 arg_70165} = lifted_20797(two_70078, two_70079)
  let {f32 arg_70166, f32 arg_70167} = lifted_20804(one_70075, one_70076)
  let {f32 arg_70168, f32 arg_70169} = lifted_20811(g_70142, g_70143)
  let {f32 arg_70170, f32 arg_70171} = lifted_20821(arg_70168, arg_70169,
                                                    e_70154, e_70155)
  let {f32 arg_70172, f32 arg_70173} = lifted_20897(arg_70166, arg_70167,
                                                    arg_70170, arg_70171)
  let {f32 arg_70174, f32 arg_70175} = lifted_20934(arg_70172, arg_70173)
  let {f32 arg_70176, f32 arg_70177} = lifted_20941(one_70075, one_70076)
  let {f32 arg_70178, f32 arg_70179} = lifted_20951(arg_70176, arg_70177,
                                                    g_70142, g_70143)
  let {f32 arg_70180, f32 arg_70181} = lifted_20991(arg_70174, arg_70175,
                                                    arg_70178, arg_70179)
  let {f32 arg_70182, f32 arg_70183} = lifted_21133(arg_70180, arg_70181)
  let {f32 arg_70184, f32 arg_70185} = lifted_21203(arg_70164, arg_70165,
                                                    arg_70182, arg_70183)
  let {f32 arg_70186, f32 arg_70187} = lifted_21279(arg_70162, arg_70163,
                                                    arg_70184, arg_70185)
  let {f32 arg_70188, f32 arg_70189} = lifted_21319(arg_70156, arg_70157,
                                                    arg_70186, arg_70187)
  let {f32 arg_70190, f32 arg_70191} = lifted_21392(arg_70188, arg_70189)
  let {f32 arg_70192, f32 arg_70193} = lifted_21399(coeff2_70064, coeff2_70065)
  let {f32 arg_70194, f32 arg_70195} = lifted_21409(arg_70192, arg_70193,
                                                    a_minus_70132,
                                                    a_minus_70133)
  let {f32 arg_70196, f32 arg_70197} = lifted_21482(arg_70194, arg_70195)
  let {f32 arg_70198, f32 arg_70199} = lifted_21489(one_70075, one_70076)
  let {f32 arg_70200, f32 arg_70201} = lifted_21499(arg_70198, arg_70199,
                                                    e_70154, e_70155)
  let {f32 arg_70202, f32 arg_70203} = lifted_21539(arg_70196, arg_70197,
                                                    arg_70200, arg_70201)
  let {f32 arg_70204, f32 arg_70205} = lifted_21612(arg_70202, arg_70203)
  let {f32 arg_70206, f32 arg_70207} = lifted_21619(one_70075, one_70076)
  let {f32 arg_70208, f32 arg_70209} = lifted_21626(g_70142, g_70143)
  let {f32 arg_70210, f32 arg_70211} = lifted_21636(arg_70208, arg_70209,
                                                    e_70154, e_70155)
  let {f32 arg_70212, f32 arg_70213} = lifted_21712(arg_70206, arg_70207,
                                                    arg_70210, arg_70211)
  let {f32 arg_70214, f32 arg_70215} = lifted_21752(arg_70204, arg_70205,
                                                    arg_70212, arg_70213)
  let {f32 arg_70216, f32 arg_70217} = lifted_21894(arg_70190, arg_70191,
                                                    arg_70214, arg_70215)
  let {f32 res_70218, f32 res_70219} = lifted_21934(arg_70216, arg_70217)
  in {res_70218, res_70219}
}

fun {f32, f32} lifted_21980(f32 x_70220, f32 x_70221) = {
  {x_70220, x_70221}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_22021(f32 coeff1_70222, f32 coeff1_70223,
                                           f32 coeff2_70224, f32 coeff2_70225,
                                           f32 etai2_70226, f32 etai2_70227,
                                           f32 etai_70228, f32 etai_70229,
                                           f32 i_70230, f32 i_70231,
                                           f32 kappai_70232, f32 kappai_70233,
                                           f32 one_70234, f32 one_70235,
                                           f32 rho_70236, f32 two_70237,
                                           f32 two_70238, f32 zero_70239,
                                           f32 zero_70240,
                                           f32 day_count_fraction_70241) = {
  {coeff1_70222, coeff1_70223, coeff2_70224, coeff2_70225,
   day_count_fraction_70241, etai2_70226, etai2_70227, etai_70228, etai_70229,
   i_70230, i_70231, kappai_70232, kappai_70233, one_70234, one_70235,
   rho_70236, two_70237, two_70238, zero_70239, zero_70240}
}

fun {f32} lifted_22043(f32 x_70242) = {
  let {f32 res_70243} = fsub32(0.0f32, x_70242)
  in {res_70243}
}

fun {f32} lifted_22047(f32 a_70244) = {
  {a_70244}
}

fun {f32, f32} lifted_22051(f32 a_70245, f32 b_70246) = {
  {a_70245, b_70246}
}

fun {f32} lifted_22100(i32 x_70247) = {
  let {f32 res_70248} = sitofp i32 x_70247 to f32
  in {res_70248}
}

fun {f32, f32} lifted_22098(f32 a_70249) = {
  let {f32 res_70250} = lifted_22100(0i32)
  in {a_70249, res_70250}
}

fun {f32, f32} lifted_22112(f32 x_70251, f32 x_70252) = {
  {x_70251, x_70252}
}

fun {f32} lifted_22119(i32 x_70253) = {
  let {f32 res_70254} = sitofp i32 x_70253 to f32
  in {res_70254}
}

fun {f32, f32} lifted_22117(f32 b_70255) = {
  let {f32 res_70256} = lifted_22119(0i32)
  in {res_70256, b_70255}
}

fun {f32, f32} lifted_22128(f32 x_70257, f32 x_70258) = {
  {x_70257, x_70258}
}

fun {f32, f32} lifted_22144(f32 a_70259, f32 b_70260) = {
  {a_70259, b_70260}
}

fun {f32} lifted_22156(f32 x_70261) = {
  {x_70261}
}

fun {f32} lifted_22160(f32 x_70262, f32 y_70263) = {
  let {f32 res_70264} = fmul32(x_70262, y_70263)
  in {res_70264}
}

fun {f32} lifted_22164(f32 x_70265) = {
  {x_70265}
}

fun {f32} lifted_22167(f32 x_70266) = {
  {x_70266}
}

fun {f32} lifted_22171(f32 x_70267, f32 y_70268) = {
  let {f32 res_70269} = fmul32(x_70267, y_70268)
  in {res_70269}
}

fun {f32} lifted_22176(f32 x_70270, f32 y_70271) = {
  let {f32 res_70272} = fsub32(x_70270, y_70271)
  in {res_70272}
}

fun {f32} lifted_22180(f32 x_70273) = {
  {x_70273}
}

fun {f32} lifted_22184(f32 x_70274, f32 y_70275) = {
  let {f32 res_70276} = fmul32(x_70274, y_70275)
  in {res_70276}
}

fun {f32} lifted_22188(f32 x_70277) = {
  {x_70277}
}

fun {f32} lifted_22191(f32 x_70278) = {
  {x_70278}
}

fun {f32} lifted_22195(f32 x_70279, f32 y_70280) = {
  let {f32 res_70281} = fmul32(x_70279, y_70280)
  in {res_70281}
}

fun {f32} lifted_22200(f32 x_70282, f32 y_70283) = {
  let {f32 res_70284} = fadd32(x_70282, y_70283)
  in {res_70284}
}

fun {f32, f32} lifted_22154(f32 a_70285, f32 b_70286, f32 c_70287,
                            f32 d_70288) = {
  let {f32 arg_70289} = lifted_22156(a_70285)
  let {f32 arg_70290} = lifted_22160(arg_70289, c_70287)
  let {f32 arg_70291} = lifted_22164(arg_70290)
  let {f32 arg_70292} = lifted_22167(b_70286)
  let {f32 arg_70293} = lifted_22171(arg_70292, d_70288)
  let {f32 res_70294} = lifted_22176(arg_70291, arg_70293)
  let {f32 arg_70295} = lifted_22180(b_70286)
  let {f32 arg_70296} = lifted_22184(arg_70295, c_70287)
  let {f32 arg_70297} = lifted_22188(arg_70296)
  let {f32 arg_70298} = lifted_22191(a_70285)
  let {f32 arg_70299} = lifted_22195(arg_70298, d_70288)
  let {f32 res_70300} = lifted_22200(arg_70297, arg_70299)
  in {res_70294, res_70300}
}

fun {f32, f32} lifted_22138(f32 x_70301, f32 x_70302, f32 y_70303,
                            f32 y_70304) = {
  let {f32 arg_70305, f32 arg_70306} = lifted_22144(x_70301, x_70302)
  let {f32 res_70307, f32 res_70308} = lifted_22154(arg_70305, arg_70306,
                                                    y_70303, y_70304)
  in {res_70307, res_70308}
}

fun {f32, f32} lifted_22211(f32 x_70309, f32 x_70310) = {
  {x_70309, x_70310}
}

fun {f32, f32} lifted_22227(f32 a_70311, f32 b_70312) = {
  {a_70311, b_70312}
}

fun {f32} lifted_22239(f32 x_70313) = {
  {x_70313}
}

fun {f32} lifted_22243(f32 x_70314, f32 y_70315) = {
  let {f32 res_70316} = fmul32(x_70314, y_70315)
  in {res_70316}
}

fun {f32} lifted_22247(f32 x_70317) = {
  {x_70317}
}

fun {f32} lifted_22250(f32 x_70318) = {
  {x_70318}
}

fun {f32} lifted_22254(f32 x_70319, f32 y_70320) = {
  let {f32 res_70321} = fmul32(x_70319, y_70320)
  in {res_70321}
}

fun {f32} lifted_22259(f32 x_70322, f32 y_70323) = {
  let {f32 res_70324} = fsub32(x_70322, y_70323)
  in {res_70324}
}

fun {f32} lifted_22263(f32 x_70325) = {
  {x_70325}
}

fun {f32} lifted_22267(f32 x_70326, f32 y_70327) = {
  let {f32 res_70328} = fmul32(x_70326, y_70327)
  in {res_70328}
}

fun {f32} lifted_22271(f32 x_70329) = {
  {x_70329}
}

fun {f32} lifted_22274(f32 x_70330) = {
  {x_70330}
}

fun {f32} lifted_22278(f32 x_70331, f32 y_70332) = {
  let {f32 res_70333} = fmul32(x_70331, y_70332)
  in {res_70333}
}

fun {f32} lifted_22283(f32 x_70334, f32 y_70335) = {
  let {f32 res_70336} = fadd32(x_70334, y_70335)
  in {res_70336}
}

fun {f32, f32} lifted_22237(f32 a_70337, f32 b_70338, f32 c_70339,
                            f32 d_70340) = {
  let {f32 arg_70341} = lifted_22239(a_70337)
  let {f32 arg_70342} = lifted_22243(arg_70341, c_70339)
  let {f32 arg_70343} = lifted_22247(arg_70342)
  let {f32 arg_70344} = lifted_22250(b_70338)
  let {f32 arg_70345} = lifted_22254(arg_70344, d_70340)
  let {f32 res_70346} = lifted_22259(arg_70343, arg_70345)
  let {f32 arg_70347} = lifted_22263(b_70338)
  let {f32 arg_70348} = lifted_22267(arg_70347, c_70339)
  let {f32 arg_70349} = lifted_22271(arg_70348)
  let {f32 arg_70350} = lifted_22274(a_70337)
  let {f32 arg_70351} = lifted_22278(arg_70350, d_70340)
  let {f32 res_70352} = lifted_22283(arg_70349, arg_70351)
  in {res_70346, res_70352}
}

fun {f32, f32} lifted_22221(f32 x_70353, f32 x_70354, f32 y_70355,
                            f32 y_70356) = {
  let {f32 arg_70357, f32 arg_70358} = lifted_22227(x_70353, x_70354)
  let {f32 res_70359, f32 res_70360} = lifted_22237(arg_70357, arg_70358,
                                                    y_70355, y_70356)
  in {res_70359, res_70360}
}

fun {f32, f32} lifted_22301(f32 a_70361, f32 b_70362) = {
  {a_70361, b_70362}
}

fun {f32} lifted_22311(f32 x_70363) = {
  {x_70363}
}

fun {f32} lifted_22315(f32 x_70364, f32 y_70365) = {
  let {f32 res_70366} = fsub32(x_70364, y_70365)
  in {res_70366}
}

fun {f32} lifted_22319(f32 x_70367) = {
  {x_70367}
}

fun {f32} lifted_22323(f32 x_70368, f32 y_70369) = {
  let {f32 res_70370} = fsub32(x_70368, y_70369)
  in {res_70370}
}

fun {f32, f32} lifted_22309(f32 a_70371, f32 b_70372, f32 c_70373,
                            f32 d_70374) = {
  let {f32 arg_70375} = lifted_22311(a_70371)
  let {f32 res_70376} = lifted_22315(arg_70375, c_70373)
  let {f32 arg_70377} = lifted_22319(b_70372)
  let {f32 res_70378} = lifted_22323(arg_70377, d_70374)
  in {res_70376, res_70378}
}

fun {f32, f32} lifted_22297(f32 x_70379, f32 x_70380, f32 y_70381,
                            f32 y_70382) = {
  let {f32 arg_70383, f32 arg_70384} = lifted_22301(x_70379, x_70380)
  let {f32 res_70385, f32 res_70386} = lifted_22309(arg_70383, arg_70384,
                                                    y_70381, y_70382)
  in {res_70385, res_70386}
}

fun {f32, f32} lifted_22337(f32 x_70387, f32 x_70388) = {
  {x_70387, x_70388}
}

fun {f32, f32} lifted_22353(f32 a_70389, f32 b_70390) = {
  {a_70389, b_70390}
}

fun {f32} lifted_22365(f32 x_70391) = {
  {x_70391}
}

fun {f32} lifted_22369(f32 x_70392, f32 y_70393) = {
  let {f32 res_70394} = fmul32(x_70392, y_70393)
  in {res_70394}
}

fun {f32} lifted_22373(f32 x_70395) = {
  {x_70395}
}

fun {f32} lifted_22376(f32 x_70396) = {
  {x_70396}
}

fun {f32} lifted_22380(f32 x_70397, f32 y_70398) = {
  let {f32 res_70399} = fmul32(x_70397, y_70398)
  in {res_70399}
}

fun {f32} lifted_22385(f32 x_70400, f32 y_70401) = {
  let {f32 res_70402} = fsub32(x_70400, y_70401)
  in {res_70402}
}

fun {f32} lifted_22389(f32 x_70403) = {
  {x_70403}
}

fun {f32} lifted_22393(f32 x_70404, f32 y_70405) = {
  let {f32 res_70406} = fmul32(x_70404, y_70405)
  in {res_70406}
}

fun {f32} lifted_22397(f32 x_70407) = {
  {x_70407}
}

fun {f32} lifted_22400(f32 x_70408) = {
  {x_70408}
}

fun {f32} lifted_22404(f32 x_70409, f32 y_70410) = {
  let {f32 res_70411} = fmul32(x_70409, y_70410)
  in {res_70411}
}

fun {f32} lifted_22409(f32 x_70412, f32 y_70413) = {
  let {f32 res_70414} = fadd32(x_70412, y_70413)
  in {res_70414}
}

fun {f32, f32} lifted_22363(f32 a_70415, f32 b_70416, f32 c_70417,
                            f32 d_70418) = {
  let {f32 arg_70419} = lifted_22365(a_70415)
  let {f32 arg_70420} = lifted_22369(arg_70419, c_70417)
  let {f32 arg_70421} = lifted_22373(arg_70420)
  let {f32 arg_70422} = lifted_22376(b_70416)
  let {f32 arg_70423} = lifted_22380(arg_70422, d_70418)
  let {f32 res_70424} = lifted_22385(arg_70421, arg_70423)
  let {f32 arg_70425} = lifted_22389(b_70416)
  let {f32 arg_70426} = lifted_22393(arg_70425, c_70417)
  let {f32 arg_70427} = lifted_22397(arg_70426)
  let {f32 arg_70428} = lifted_22400(a_70415)
  let {f32 arg_70429} = lifted_22404(arg_70428, d_70418)
  let {f32 res_70430} = lifted_22409(arg_70427, arg_70429)
  in {res_70424, res_70430}
}

fun {f32, f32} lifted_22347(f32 x_70431, f32 x_70432, f32 y_70433,
                            f32 y_70434) = {
  let {f32 arg_70435, f32 arg_70436} = lifted_22353(x_70431, x_70432)
  let {f32 res_70437, f32 res_70438} = lifted_22363(arg_70435, arg_70436,
                                                    y_70433, y_70434)
  in {res_70437, res_70438}
}

fun {f32, f32} lifted_22420(f32 x_70439, f32 x_70440) = {
  {x_70439, x_70440}
}

fun {f32, f32} lifted_22427(f32 x_70441, f32 x_70442) = {
  {x_70441, x_70442}
}

fun {f32, f32} lifted_22434(f32 x_70443, f32 x_70444) = {
  {x_70443, x_70444}
}

fun {f32, f32} lifted_22441(f32 x_70445, f32 x_70446) = {
  {x_70445, x_70446}
}

fun {f32, f32} lifted_22455(f32 a_70447, f32 b_70448) = {
  {a_70447, b_70448}
}

fun {f32} lifted_22465(f32 x_70449) = {
  {x_70449}
}

fun {f32} lifted_22469(f32 x_70450, f32 y_70451) = {
  let {f32 res_70452} = fadd32(x_70450, y_70451)
  in {res_70452}
}

fun {f32} lifted_22473(f32 x_70453) = {
  {x_70453}
}

fun {f32} lifted_22477(f32 x_70454, f32 y_70455) = {
  let {f32 res_70456} = fadd32(x_70454, y_70455)
  in {res_70456}
}

fun {f32, f32} lifted_22463(f32 a_70457, f32 b_70458, f32 c_70459,
                            f32 d_70460) = {
  let {f32 arg_70461} = lifted_22465(a_70457)
  let {f32 res_70462} = lifted_22469(arg_70461, c_70459)
  let {f32 arg_70463} = lifted_22473(b_70458)
  let {f32 res_70464} = lifted_22477(arg_70463, d_70460)
  in {res_70462, res_70464}
}

fun {f32, f32} lifted_22451(f32 x_70465, f32 x_70466, f32 y_70467,
                            f32 y_70468) = {
  let {f32 arg_70469, f32 arg_70470} = lifted_22455(x_70465, x_70466)
  let {f32 res_70471, f32 res_70472} = lifted_22463(arg_70469, arg_70470,
                                                    y_70467, y_70468)
  in {res_70471, res_70472}
}

fun {f32, f32} lifted_22497(f32 a_70473, f32 b_70474) = {
  {a_70473, b_70474}
}

fun {f32} lifted_22509(f32 x_70475) = {
  {x_70475}
}

fun {f32} lifted_22513(f32 x_70476, f32 y_70477) = {
  let {f32 res_70478} = fmul32(x_70476, y_70477)
  in {res_70478}
}

fun {f32} lifted_22517(f32 x_70479) = {
  {x_70479}
}

fun {f32} lifted_22520(f32 x_70480) = {
  {x_70480}
}

fun {f32} lifted_22524(f32 x_70481, f32 y_70482) = {
  let {f32 res_70483} = fmul32(x_70481, y_70482)
  in {res_70483}
}

fun {f32} lifted_22529(f32 x_70484, f32 y_70485) = {
  let {f32 res_70486} = fsub32(x_70484, y_70485)
  in {res_70486}
}

fun {f32} lifted_22533(f32 x_70487) = {
  {x_70487}
}

fun {f32} lifted_22537(f32 x_70488, f32 y_70489) = {
  let {f32 res_70490} = fmul32(x_70488, y_70489)
  in {res_70490}
}

fun {f32} lifted_22541(f32 x_70491) = {
  {x_70491}
}

fun {f32} lifted_22544(f32 x_70492) = {
  {x_70492}
}

fun {f32} lifted_22548(f32 x_70493, f32 y_70494) = {
  let {f32 res_70495} = fmul32(x_70493, y_70494)
  in {res_70495}
}

fun {f32} lifted_22553(f32 x_70496, f32 y_70497) = {
  let {f32 res_70498} = fadd32(x_70496, y_70497)
  in {res_70498}
}

fun {f32, f32} lifted_22507(f32 a_70499, f32 b_70500, f32 c_70501,
                            f32 d_70502) = {
  let {f32 arg_70503} = lifted_22509(a_70499)
  let {f32 arg_70504} = lifted_22513(arg_70503, c_70501)
  let {f32 arg_70505} = lifted_22517(arg_70504)
  let {f32 arg_70506} = lifted_22520(b_70500)
  let {f32 arg_70507} = lifted_22524(arg_70506, d_70502)
  let {f32 res_70508} = lifted_22529(arg_70505, arg_70507)
  let {f32 arg_70509} = lifted_22533(b_70500)
  let {f32 arg_70510} = lifted_22537(arg_70509, c_70501)
  let {f32 arg_70511} = lifted_22541(arg_70510)
  let {f32 arg_70512} = lifted_22544(a_70499)
  let {f32 arg_70513} = lifted_22548(arg_70512, d_70502)
  let {f32 res_70514} = lifted_22553(arg_70511, arg_70513)
  in {res_70508, res_70514}
}

fun {f32, f32} lifted_22491(f32 x_70515, f32 x_70516, f32 y_70517,
                            f32 y_70518) = {
  let {f32 arg_70519, f32 arg_70520} = lifted_22497(x_70515, x_70516)
  let {f32 res_70521, f32 res_70522} = lifted_22507(arg_70519, arg_70520,
                                                    y_70517, y_70518)
  in {res_70521, res_70522}
}

fun {f32, f32} lifted_22573(f32 a_70523, f32 b_70524) = {
  {a_70523, b_70524}
}

fun {f32} lifted_22585(f32 x_70525) = {
  {x_70525}
}

fun {f32} lifted_22589(f32 x_70526, f32 y_70527) = {
  let {f32 res_70528} = fmul32(x_70526, y_70527)
  in {res_70528}
}

fun {f32} lifted_22593(f32 x_70529) = {
  {x_70529}
}

fun {f32} lifted_22596(f32 x_70530) = {
  {x_70530}
}

fun {f32} lifted_22600(f32 x_70531, f32 y_70532) = {
  let {f32 res_70533} = fmul32(x_70531, y_70532)
  in {res_70533}
}

fun {f32} lifted_22605(f32 x_70534, f32 y_70535) = {
  let {f32 res_70536} = fsub32(x_70534, y_70535)
  in {res_70536}
}

fun {f32} lifted_22609(f32 x_70537) = {
  {x_70537}
}

fun {f32} lifted_22613(f32 x_70538, f32 y_70539) = {
  let {f32 res_70540} = fmul32(x_70538, y_70539)
  in {res_70540}
}

fun {f32} lifted_22617(f32 x_70541) = {
  {x_70541}
}

fun {f32} lifted_22620(f32 x_70542) = {
  {x_70542}
}

fun {f32} lifted_22624(f32 x_70543, f32 y_70544) = {
  let {f32 res_70545} = fmul32(x_70543, y_70544)
  in {res_70545}
}

fun {f32} lifted_22629(f32 x_70546, f32 y_70547) = {
  let {f32 res_70548} = fadd32(x_70546, y_70547)
  in {res_70548}
}

fun {f32, f32} lifted_22583(f32 a_70549, f32 b_70550, f32 c_70551,
                            f32 d_70552) = {
  let {f32 arg_70553} = lifted_22585(a_70549)
  let {f32 arg_70554} = lifted_22589(arg_70553, c_70551)
  let {f32 arg_70555} = lifted_22593(arg_70554)
  let {f32 arg_70556} = lifted_22596(b_70550)
  let {f32 arg_70557} = lifted_22600(arg_70556, d_70552)
  let {f32 res_70558} = lifted_22605(arg_70555, arg_70557)
  let {f32 arg_70559} = lifted_22609(b_70550)
  let {f32 arg_70560} = lifted_22613(arg_70559, c_70551)
  let {f32 arg_70561} = lifted_22617(arg_70560)
  let {f32 arg_70562} = lifted_22620(a_70549)
  let {f32 arg_70563} = lifted_22624(arg_70562, d_70552)
  let {f32 res_70564} = lifted_22629(arg_70561, arg_70563)
  in {res_70558, res_70564}
}

fun {f32, f32} lifted_22567(f32 x_70565, f32 x_70566, f32 y_70567,
                            f32 y_70568) = {
  let {f32 arg_70569, f32 arg_70570} = lifted_22573(x_70565, x_70566)
  let {f32 res_70571, f32 res_70572} = lifted_22583(arg_70569, arg_70570,
                                                    y_70567, y_70568)
  in {res_70571, res_70572}
}

fun {f32, f32} lifted_22647(f32 a_70573, f32 b_70574) = {
  {a_70573, b_70574}
}

fun {f32} lifted_22657(f32 x_70575) = {
  {x_70575}
}

fun {f32} lifted_22661(f32 x_70576, f32 y_70577) = {
  let {f32 res_70578} = fadd32(x_70576, y_70577)
  in {res_70578}
}

fun {f32} lifted_22665(f32 x_70579) = {
  {x_70579}
}

fun {f32} lifted_22669(f32 x_70580, f32 y_70581) = {
  let {f32 res_70582} = fadd32(x_70580, y_70581)
  in {res_70582}
}

fun {f32, f32} lifted_22655(f32 a_70583, f32 b_70584, f32 c_70585,
                            f32 d_70586) = {
  let {f32 arg_70587} = lifted_22657(a_70583)
  let {f32 res_70588} = lifted_22661(arg_70587, c_70585)
  let {f32 arg_70589} = lifted_22665(b_70584)
  let {f32 res_70590} = lifted_22669(arg_70589, d_70586)
  in {res_70588, res_70590}
}

fun {f32, f32} lifted_22643(f32 x_70591, f32 x_70592, f32 y_70593,
                            f32 y_70594) = {
  let {f32 arg_70595, f32 arg_70596} = lifted_22647(x_70591, x_70592)
  let {f32 res_70597, f32 res_70598} = lifted_22655(arg_70595, arg_70596,
                                                    y_70593, y_70594)
  in {res_70597, res_70598}
}

fun {f32} lifted_22688(f32 x_70599) = {
  {x_70599}
}

fun {f32} lifted_22691(f32 x_70600) = {
  {x_70600}
}

fun {f32} lifted_22695(f32 x_70601, f32 y_70602) = {
  let {f32 res_70603} = fmul32(x_70601, y_70602)
  in {res_70603}
}

fun {f32} lifted_22699(f32 x_70604) = {
  {x_70604}
}

fun {f32} lifted_22702(f32 x_70605) = {
  {x_70605}
}

fun {f32} lifted_22706(f32 x_70606, f32 y_70607) = {
  let {f32 res_70608} = fmul32(x_70606, y_70607)
  in {res_70608}
}

fun {f32} lifted_22711(f32 x_70609, f32 y_70610) = {
  let {f32 res_70611} = fadd32(x_70609, y_70610)
  in {res_70611}
}

fun {f32} lifted_22715(f32 x_70612) = {
  let {f32 res_70613} = sqrt32(x_70612)
  in {res_70613}
}

fun {f32} lifted_22720(f32 x_70614, f32 y_70615) = {
  let {f32 res_70616} = fadd32(x_70614, y_70615)
  in {res_70616}
}

fun {f32} lifted_22724(f32 x_70617) = {
  {x_70617}
}

fun {f32} lifted_22727(i32 x_70618) = {
  let {f32 res_70619} = sitofp i32 x_70618 to f32
  in {res_70619}
}

fun {f32} lifted_22732(f32 x_70620, f32 y_70621) = {
  let {f32 res_70622} = fdiv32(x_70620, y_70621)
  in {res_70622}
}

fun {f32} lifted_22736(f32 x_70623) = {
  let {f32 res_70624} = sqrt32(x_70623)
  in {res_70624}
}

fun {f32} lifted_22745(f32 x_70625) = {
  {x_70625}
}

fun {bool} lifted_22749(f32 x_70626, f32 y_70627) = {
  let {bool res_70628} = lt32(x_70626, y_70627)
  in {res_70628}
}

fun {f32} lifted_22754(f32 x_70629) = {
  {x_70629}
}

fun {bool} lifted_22758(f32 x_70630, f32 y_70631) = {
  let {bool res_70632} = eq_f32(x_70630, y_70631)
  in {res_70632}
}

fun {f32} lifted_22743(f32 x_70633) = {
  let {f32 arg_70634} = lifted_22745(x_70633)
  let {bool cond_70635} = lifted_22749(arg_70634, 0.0f32)
  let {f32 res_70636} =
    -- Branch returns: {f32}
    if cond_70635
    then {
      let {f32 res_70637} = fsub32(0.0f32, 1.0f32)
      in {res_70637}
    } else {
      let {f32 arg_70638} = lifted_22754(x_70633)
      let {bool cond_70639} = lifted_22758(arg_70638, 0.0f32)
      let {f32 res_70640} =
        -- Branch returns: {f32}
        if cond_70639
        then {0.0f32} else {1.0f32}
      in {res_70640}
    }
  in {res_70636}
}

fun {i32} lifted_22765(f32 x_70641) = {
  let {i32 res_70642} = fptosi f32 x_70641 to i32
  in {res_70642}
}

fun {f32} lifted_22769(i32 x_70643) = {
  let {f32 res_70644} = sitofp i32 x_70643 to f32
  in {res_70644}
}

fun {f32} lifted_22773(f32 x_70645) = {
  {x_70645}
}

fun {f32} lifted_22776(i32 x_70646) = {
  let {f32 res_70647} = sitofp i32 x_70646 to f32
  in {res_70647}
}

fun {f32} lifted_22780(f32 x_70648) = {
  {x_70648}
}

fun {f32} lifted_22784(f32 x_70649, f32 y_70650) = {
  let {f32 res_70651} = fsub32(x_70649, y_70650)
  in {res_70651}
}

fun {f32} lifted_22788(f32 x_70652) = {
  {x_70652}
}

fun {f32} lifted_22791(f32 x_70653) = {
  {x_70653}
}

fun {f32} lifted_22795(f32 x_70654, f32 y_70655) = {
  let {f32 res_70656} = fmul32(x_70654, y_70655)
  in {res_70656}
}

fun {f32} lifted_22799(f32 x_70657) = {
  {x_70657}
}

fun {f32} lifted_22802(f32 x_70658) = {
  {x_70658}
}

fun {f32} lifted_22806(f32 x_70659, f32 y_70660) = {
  let {f32 res_70661} = fmul32(x_70659, y_70660)
  in {res_70661}
}

fun {f32} lifted_22811(f32 x_70662, f32 y_70663) = {
  let {f32 res_70664} = fadd32(x_70662, y_70663)
  in {res_70664}
}

fun {f32} lifted_22815(f32 x_70665) = {
  let {f32 res_70666} = sqrt32(x_70665)
  in {res_70666}
}

fun {f32} lifted_22820(f32 x_70667, f32 y_70668) = {
  let {f32 res_70669} = fadd32(x_70667, y_70668)
  in {res_70669}
}

fun {f32} lifted_22824(f32 x_70670) = {
  {x_70670}
}

fun {f32} lifted_22827(i32 x_70671) = {
  let {f32 res_70672} = sitofp i32 x_70671 to f32
  in {res_70672}
}

fun {f32} lifted_22832(f32 x_70673, f32 y_70674) = {
  let {f32 res_70675} = fdiv32(x_70673, y_70674)
  in {res_70675}
}

fun {f32} lifted_22836(f32 x_70676) = {
  let {f32 res_70677} = sqrt32(x_70676)
  in {res_70677}
}

fun {f32} lifted_22841(f32 x_70678, f32 y_70679) = {
  let {f32 res_70680} = fmul32(x_70678, y_70679)
  in {res_70680}
}

fun {f32, f32} lifted_22686(f32 a_70681, f32 b_70682) = {
  let {f32 arg_70683} = lifted_22688(a_70681)
  let {f32 arg_70684} = lifted_22691(a_70681)
  let {f32 arg_70685} = lifted_22695(arg_70684, a_70681)
  let {f32 arg_70686} = lifted_22699(arg_70685)
  let {f32 arg_70687} = lifted_22702(b_70682)
  let {f32 arg_70688} = lifted_22706(arg_70687, b_70682)
  let {f32 arg_70689} = lifted_22711(arg_70686, arg_70688)
  let {f32 arg_70690} = lifted_22715(arg_70689)
  let {f32 arg_70691} = lifted_22720(arg_70683, arg_70690)
  let {f32 arg_70692} = lifted_22724(arg_70691)
  let {f32 arg_70693} = lifted_22727(2i32)
  let {f32 arg_70694} = lifted_22732(arg_70692, arg_70693)
  let {f32 res_70695} = lifted_22736(arg_70694)
  let {f32 gamma_70696} = res_70695
  let {f32 arg_70697} = lifted_22743(b_70682)
  let {i32 arg_70698} = lifted_22765(arg_70697)
  let {f32 arg_70699} = lifted_22769(arg_70698)
  let {f32 arg_70700} = lifted_22773(arg_70699)
  let {f32 arg_70701} = lifted_22776(0i32)
  let {f32 arg_70702} = lifted_22780(arg_70701)
  let {f32 arg_70703} = lifted_22784(arg_70702, a_70681)
  let {f32 arg_70704} = lifted_22788(arg_70703)
  let {f32 arg_70705} = lifted_22791(a_70681)
  let {f32 arg_70706} = lifted_22795(arg_70705, a_70681)
  let {f32 arg_70707} = lifted_22799(arg_70706)
  let {f32 arg_70708} = lifted_22802(b_70682)
  let {f32 arg_70709} = lifted_22806(arg_70708, b_70682)
  let {f32 arg_70710} = lifted_22811(arg_70707, arg_70709)
  let {f32 arg_70711} = lifted_22815(arg_70710)
  let {f32 arg_70712} = lifted_22820(arg_70704, arg_70711)
  let {f32 arg_70713} = lifted_22824(arg_70712)
  let {f32 arg_70714} = lifted_22827(2i32)
  let {f32 arg_70715} = lifted_22832(arg_70713, arg_70714)
  let {f32 arg_70716} = lifted_22836(arg_70715)
  let {f32 res_70717} = lifted_22841(arg_70700, arg_70716)
  let {f32 delta_70718} = res_70717
  in {gamma_70696, delta_70718}
}

fun {f32, f32} lifted_22854(f32 x_70719, f32 x_70720) = {
  {x_70719, x_70720}
}

fun {f32, f32} lifted_22868(f32 a_70721, f32 b_70722) = {
  {a_70721, b_70722}
}

fun {f32} lifted_22878(f32 x_70723) = {
  {x_70723}
}

fun {f32} lifted_22882(f32 x_70724, f32 y_70725) = {
  let {f32 res_70726} = fsub32(x_70724, y_70725)
  in {res_70726}
}

fun {f32} lifted_22886(f32 x_70727) = {
  {x_70727}
}

fun {f32} lifted_22890(f32 x_70728, f32 y_70729) = {
  let {f32 res_70730} = fsub32(x_70728, y_70729)
  in {res_70730}
}

fun {f32, f32} lifted_22876(f32 a_70731, f32 b_70732, f32 c_70733,
                            f32 d_70734) = {
  let {f32 arg_70735} = lifted_22878(a_70731)
  let {f32 res_70736} = lifted_22882(arg_70735, c_70733)
  let {f32 arg_70737} = lifted_22886(b_70732)
  let {f32 res_70738} = lifted_22890(arg_70737, d_70734)
  in {res_70736, res_70738}
}

fun {f32, f32} lifted_22864(f32 x_70739, f32 x_70740, f32 y_70741,
                            f32 y_70742) = {
  let {f32 arg_70743, f32 arg_70744} = lifted_22868(x_70739, x_70740)
  let {f32 res_70745, f32 res_70746} = lifted_22876(arg_70743, arg_70744,
                                                    y_70741, y_70742)
  in {res_70745, res_70746}
}

fun {f32, f32} lifted_22904(f32 x_70747, f32 x_70748) = {
  {x_70747, x_70748}
}

fun {f32, f32} lifted_22911(f32 x_70749, f32 x_70750) = {
  {x_70749, x_70750}
}

fun {f32, f32} lifted_22925(f32 a_70751, f32 b_70752) = {
  {a_70751, b_70752}
}

fun {f32} lifted_22935(f32 x_70753) = {
  {x_70753}
}

fun {f32} lifted_22939(f32 x_70754, f32 y_70755) = {
  let {f32 res_70756} = fadd32(x_70754, y_70755)
  in {res_70756}
}

fun {f32} lifted_22943(f32 x_70757) = {
  {x_70757}
}

fun {f32} lifted_22947(f32 x_70758, f32 y_70759) = {
  let {f32 res_70760} = fadd32(x_70758, y_70759)
  in {res_70760}
}

fun {f32, f32} lifted_22933(f32 a_70761, f32 b_70762, f32 c_70763,
                            f32 d_70764) = {
  let {f32 arg_70765} = lifted_22935(a_70761)
  let {f32 res_70766} = lifted_22939(arg_70765, c_70763)
  let {f32 arg_70767} = lifted_22943(b_70762)
  let {f32 res_70768} = lifted_22947(arg_70767, d_70764)
  in {res_70766, res_70768}
}

fun {f32, f32} lifted_22921(f32 x_70769, f32 x_70770, f32 y_70771,
                            f32 y_70772) = {
  let {f32 arg_70773, f32 arg_70774} = lifted_22925(x_70769, x_70770)
  let {f32 res_70775, f32 res_70776} = lifted_22933(arg_70773, arg_70774,
                                                    y_70771, y_70772)
  in {res_70775, res_70776}
}

fun {f32, f32} lifted_22968(f32 a_70777, f32 b_70778) = {
  {a_70777, b_70778}
}

fun {f32} lifted_22981(f32 x_70779) = {
  {x_70779}
}

fun {f32} lifted_22985(f32 x_70780, f32 y_70781) = {
  let {f32 res_70782} = fmul32(x_70780, y_70781)
  in {res_70782}
}

fun {f32} lifted_22989(f32 x_70783) = {
  {x_70783}
}

fun {f32} lifted_22992(f32 x_70784) = {
  {x_70784}
}

fun {f32} lifted_22996(f32 x_70785, f32 y_70786) = {
  let {f32 res_70787} = fmul32(x_70785, y_70786)
  in {res_70787}
}

fun {f32} lifted_23001(f32 x_70788, f32 y_70789) = {
  let {f32 res_70790} = fadd32(x_70788, y_70789)
  in {res_70790}
}

fun {f32} lifted_23005(f32 x_70791) = {
  {x_70791}
}

fun {f32} lifted_23008(f32 x_70792) = {
  {x_70792}
}

fun {f32} lifted_23012(f32 x_70793, f32 y_70794) = {
  let {f32 res_70795} = fmul32(x_70793, y_70794)
  in {res_70795}
}

fun {f32} lifted_23016(f32 x_70796) = {
  {x_70796}
}

fun {f32} lifted_23019(f32 x_70797) = {
  {x_70797}
}

fun {f32} lifted_23023(f32 x_70798, f32 y_70799) = {
  let {f32 res_70800} = fmul32(x_70798, y_70799)
  in {res_70800}
}

fun {f32} lifted_23028(f32 x_70801, f32 y_70802) = {
  let {f32 res_70803} = fadd32(x_70801, y_70802)
  in {res_70803}
}

fun {f32} lifted_23033(f32 x_70804, f32 y_70805) = {
  let {f32 res_70806} = fdiv32(x_70804, y_70805)
  in {res_70806}
}

fun {f32} lifted_23037(f32 x_70807) = {
  {x_70807}
}

fun {f32} lifted_23041(f32 x_70808, f32 y_70809) = {
  let {f32 res_70810} = fmul32(x_70808, y_70809)
  in {res_70810}
}

fun {f32} lifted_23045(f32 x_70811) = {
  {x_70811}
}

fun {f32} lifted_23048(f32 x_70812) = {
  {x_70812}
}

fun {f32} lifted_23052(f32 x_70813, f32 y_70814) = {
  let {f32 res_70815} = fmul32(x_70813, y_70814)
  in {res_70815}
}

fun {f32} lifted_23057(f32 x_70816, f32 y_70817) = {
  let {f32 res_70818} = fsub32(x_70816, y_70817)
  in {res_70818}
}

fun {f32} lifted_23061(f32 x_70819) = {
  {x_70819}
}

fun {f32} lifted_23064(f32 x_70820) = {
  {x_70820}
}

fun {f32} lifted_23068(f32 x_70821, f32 y_70822) = {
  let {f32 res_70823} = fmul32(x_70821, y_70822)
  in {res_70823}
}

fun {f32} lifted_23072(f32 x_70824) = {
  {x_70824}
}

fun {f32} lifted_23075(f32 x_70825) = {
  {x_70825}
}

fun {f32} lifted_23079(f32 x_70826, f32 y_70827) = {
  let {f32 res_70828} = fmul32(x_70826, y_70827)
  in {res_70828}
}

fun {f32} lifted_23084(f32 x_70829, f32 y_70830) = {
  let {f32 res_70831} = fadd32(x_70829, y_70830)
  in {res_70831}
}

fun {f32} lifted_23089(f32 x_70832, f32 y_70833) = {
  let {f32 res_70834} = fdiv32(x_70832, y_70833)
  in {res_70834}
}

fun {f32, f32} lifted_22979(f32 a_70835, f32 b_70836, f32 c_70837,
                            f32 d_70838) = {
  let {f32 arg_70839} = lifted_22981(a_70835)
  let {f32 arg_70840} = lifted_22985(arg_70839, c_70837)
  let {f32 arg_70841} = lifted_22989(arg_70840)
  let {f32 arg_70842} = lifted_22992(b_70836)
  let {f32 arg_70843} = lifted_22996(arg_70842, d_70838)
  let {f32 arg_70844} = lifted_23001(arg_70841, arg_70843)
  let {f32 arg_70845} = lifted_23005(arg_70844)
  let {f32 arg_70846} = lifted_23008(c_70837)
  let {f32 arg_70847} = lifted_23012(arg_70846, c_70837)
  let {f32 arg_70848} = lifted_23016(arg_70847)
  let {f32 arg_70849} = lifted_23019(d_70838)
  let {f32 arg_70850} = lifted_23023(arg_70849, d_70838)
  let {f32 arg_70851} = lifted_23028(arg_70848, arg_70850)
  let {f32 res_70852} = lifted_23033(arg_70845, arg_70851)
  let {f32 arg_70853} = lifted_23037(b_70836)
  let {f32 arg_70854} = lifted_23041(arg_70853, c_70837)
  let {f32 arg_70855} = lifted_23045(arg_70854)
  let {f32 arg_70856} = lifted_23048(a_70835)
  let {f32 arg_70857} = lifted_23052(arg_70856, d_70838)
  let {f32 arg_70858} = lifted_23057(arg_70855, arg_70857)
  let {f32 arg_70859} = lifted_23061(arg_70858)
  let {f32 arg_70860} = lifted_23064(c_70837)
  let {f32 arg_70861} = lifted_23068(arg_70860, c_70837)
  let {f32 arg_70862} = lifted_23072(arg_70861)
  let {f32 arg_70863} = lifted_23075(d_70838)
  let {f32 arg_70864} = lifted_23079(arg_70863, d_70838)
  let {f32 arg_70865} = lifted_23084(arg_70862, arg_70864)
  let {f32 res_70866} = lifted_23089(arg_70859, arg_70865)
  in {res_70852, res_70866}
}

fun {f32, f32} lifted_22961(f32 x_70867, f32 x_70868, f32 y_70869,
                            f32 y_70870) = {
  let {f32 arg_70871, f32 arg_70872} = lifted_22968(x_70867, x_70868)
  let {f32 res_70873, f32 res_70874} = lifted_22979(arg_70871, arg_70872,
                                                    y_70869, y_70870)
  in {res_70873, res_70874}
}

fun {f32, f32} lifted_23103(f32 x_70875, f32 x_70876) = {
  {x_70875, x_70876}
}

fun {f32, f32} lifted_23110(f32 x_70877, f32 x_70878) = {
  {x_70877, x_70878}
}

fun {f32, f32} lifted_23126(f32 a_70879, f32 b_70880) = {
  {a_70879, b_70880}
}

fun {f32} lifted_23138(f32 x_70881) = {
  {x_70881}
}

fun {f32} lifted_23142(f32 x_70882, f32 y_70883) = {
  let {f32 res_70884} = fmul32(x_70882, y_70883)
  in {res_70884}
}

fun {f32} lifted_23146(f32 x_70885) = {
  {x_70885}
}

fun {f32} lifted_23149(f32 x_70886) = {
  {x_70886}
}

fun {f32} lifted_23153(f32 x_70887, f32 y_70888) = {
  let {f32 res_70889} = fmul32(x_70887, y_70888)
  in {res_70889}
}

fun {f32} lifted_23158(f32 x_70890, f32 y_70891) = {
  let {f32 res_70892} = fsub32(x_70890, y_70891)
  in {res_70892}
}

fun {f32} lifted_23162(f32 x_70893) = {
  {x_70893}
}

fun {f32} lifted_23166(f32 x_70894, f32 y_70895) = {
  let {f32 res_70896} = fmul32(x_70894, y_70895)
  in {res_70896}
}

fun {f32} lifted_23170(f32 x_70897) = {
  {x_70897}
}

fun {f32} lifted_23173(f32 x_70898) = {
  {x_70898}
}

fun {f32} lifted_23177(f32 x_70899, f32 y_70900) = {
  let {f32 res_70901} = fmul32(x_70899, y_70900)
  in {res_70901}
}

fun {f32} lifted_23182(f32 x_70902, f32 y_70903) = {
  let {f32 res_70904} = fadd32(x_70902, y_70903)
  in {res_70904}
}

fun {f32, f32} lifted_23136(f32 a_70905, f32 b_70906, f32 c_70907,
                            f32 d_70908) = {
  let {f32 arg_70909} = lifted_23138(a_70905)
  let {f32 arg_70910} = lifted_23142(arg_70909, c_70907)
  let {f32 arg_70911} = lifted_23146(arg_70910)
  let {f32 arg_70912} = lifted_23149(b_70906)
  let {f32 arg_70913} = lifted_23153(arg_70912, d_70908)
  let {f32 res_70914} = lifted_23158(arg_70911, arg_70913)
  let {f32 arg_70915} = lifted_23162(b_70906)
  let {f32 arg_70916} = lifted_23166(arg_70915, c_70907)
  let {f32 arg_70917} = lifted_23170(arg_70916)
  let {f32 arg_70918} = lifted_23173(a_70905)
  let {f32 arg_70919} = lifted_23177(arg_70918, d_70908)
  let {f32 res_70920} = lifted_23182(arg_70917, arg_70919)
  in {res_70914, res_70920}
}

fun {f32, f32} lifted_23120(f32 x_70921, f32 x_70922, f32 y_70923,
                            f32 y_70924) = {
  let {f32 arg_70925, f32 arg_70926} = lifted_23126(x_70921, x_70922)
  let {f32 res_70927, f32 res_70928} = lifted_23136(arg_70925, arg_70926,
                                                    y_70923, y_70924)
  in {res_70927, res_70928}
}

fun {f32, f32} lifted_23200(f32 a_70929, f32 b_70930) = {
  {a_70929, b_70930}
}

fun {f32} lifted_23210(f32 x_70931) = {
  {x_70931}
}

fun {f32} lifted_23214(f32 x_70932, f32 y_70933) = {
  let {f32 res_70934} = fsub32(x_70932, y_70933)
  in {res_70934}
}

fun {f32} lifted_23218(f32 x_70935) = {
  {x_70935}
}

fun {f32} lifted_23222(f32 x_70936, f32 y_70937) = {
  let {f32 res_70938} = fsub32(x_70936, y_70937)
  in {res_70938}
}

fun {f32, f32} lifted_23208(f32 a_70939, f32 b_70940, f32 c_70941,
                            f32 d_70942) = {
  let {f32 arg_70943} = lifted_23210(a_70939)
  let {f32 res_70944} = lifted_23214(arg_70943, c_70941)
  let {f32 arg_70945} = lifted_23218(b_70940)
  let {f32 res_70946} = lifted_23222(arg_70945, d_70942)
  in {res_70944, res_70946}
}

fun {f32, f32} lifted_23196(f32 x_70947, f32 x_70948, f32 y_70949,
                            f32 y_70950) = {
  let {f32 arg_70951, f32 arg_70952} = lifted_23200(x_70947, x_70948)
  let {f32 res_70953, f32 res_70954} = lifted_23208(arg_70951, arg_70952,
                                                    y_70949, y_70950)
  in {res_70953, res_70954}
}

fun {f32} lifted_23238(f32 x_70955) = {
  let {f32 res_70956} = exp32(x_70955)
  in {res_70956}
}

fun {f32} lifted_23243(f32 x_70957) = {
  {x_70957}
}

fun {f32} lifted_23246(f32 x_70958) = {
  let {f32 res_70959} = cos32(x_70958)
  in {res_70959}
}

fun {f32} lifted_23251(f32 x_70960, f32 y_70961) = {
  let {f32 res_70962} = fmul32(x_70960, y_70961)
  in {res_70962}
}

fun {f32} lifted_23255(f32 a_70963) = {
  {a_70963}
}

fun {f32} lifted_23258(f32 x_70964) = {
  {x_70964}
}

fun {f32} lifted_23261(f32 x_70965) = {
  let {f32 res_70966} = sin32(x_70965)
  in {res_70966}
}

fun {f32} lifted_23266(f32 x_70967, f32 y_70968) = {
  let {f32 res_70969} = fmul32(x_70967, y_70968)
  in {res_70969}
}

fun {f32, f32} lifted_23271(f32 a_70970, f32 b_70971) = {
  {a_70970, b_70971}
}

fun {f32, f32} lifted_23236(f32 a_70972, f32 b_70973) = {
  let {f32 res_70974} = lifted_23238(a_70972)
  let {f32 expx_70975} = res_70974
  let {f32 arg_70976} = lifted_23243(expx_70975)
  let {f32 arg_70977} = lifted_23246(b_70973)
  let {f32 arg_70978} = lifted_23251(arg_70976, arg_70977)
  let {f32 arg_70979} = lifted_23255(arg_70978)
  let {f32 arg_70980} = lifted_23258(expx_70975)
  let {f32 arg_70981} = lifted_23261(b_70973)
  let {f32 arg_70982} = lifted_23266(arg_70980, arg_70981)
  let {f32 res_70983, f32 res_70984} = lifted_23271(arg_70979, arg_70982)
  in {res_70983, res_70984}
}

fun {f32, f32} lifted_23283(f32 x_70985, f32 x_70986) = {
  {x_70985, x_70986}
}

fun {f32, f32} lifted_23290(f32 x_70987, f32 x_70988) = {
  {x_70987, x_70988}
}

fun {f32, f32} lifted_23306(f32 a_70989, f32 b_70990) = {
  {a_70989, b_70990}
}

fun {f32} lifted_23318(f32 x_70991) = {
  {x_70991}
}

fun {f32} lifted_23322(f32 x_70992, f32 y_70993) = {
  let {f32 res_70994} = fmul32(x_70992, y_70993)
  in {res_70994}
}

fun {f32} lifted_23326(f32 x_70995) = {
  {x_70995}
}

fun {f32} lifted_23329(f32 x_70996) = {
  {x_70996}
}

fun {f32} lifted_23333(f32 x_70997, f32 y_70998) = {
  let {f32 res_70999} = fmul32(x_70997, y_70998)
  in {res_70999}
}

fun {f32} lifted_23338(f32 x_71000, f32 y_71001) = {
  let {f32 res_71002} = fsub32(x_71000, y_71001)
  in {res_71002}
}

fun {f32} lifted_23342(f32 x_71003) = {
  {x_71003}
}

fun {f32} lifted_23346(f32 x_71004, f32 y_71005) = {
  let {f32 res_71006} = fmul32(x_71004, y_71005)
  in {res_71006}
}

fun {f32} lifted_23350(f32 x_71007) = {
  {x_71007}
}

fun {f32} lifted_23353(f32 x_71008) = {
  {x_71008}
}

fun {f32} lifted_23357(f32 x_71009, f32 y_71010) = {
  let {f32 res_71011} = fmul32(x_71009, y_71010)
  in {res_71011}
}

fun {f32} lifted_23362(f32 x_71012, f32 y_71013) = {
  let {f32 res_71014} = fadd32(x_71012, y_71013)
  in {res_71014}
}

fun {f32, f32} lifted_23316(f32 a_71015, f32 b_71016, f32 c_71017,
                            f32 d_71018) = {
  let {f32 arg_71019} = lifted_23318(a_71015)
  let {f32 arg_71020} = lifted_23322(arg_71019, c_71017)
  let {f32 arg_71021} = lifted_23326(arg_71020)
  let {f32 arg_71022} = lifted_23329(b_71016)
  let {f32 arg_71023} = lifted_23333(arg_71022, d_71018)
  let {f32 res_71024} = lifted_23338(arg_71021, arg_71023)
  let {f32 arg_71025} = lifted_23342(b_71016)
  let {f32 arg_71026} = lifted_23346(arg_71025, c_71017)
  let {f32 arg_71027} = lifted_23350(arg_71026)
  let {f32 arg_71028} = lifted_23353(a_71015)
  let {f32 arg_71029} = lifted_23357(arg_71028, d_71018)
  let {f32 res_71030} = lifted_23362(arg_71027, arg_71029)
  in {res_71024, res_71030}
}

fun {f32, f32} lifted_23300(f32 x_71031, f32 x_71032, f32 y_71033,
                            f32 y_71034) = {
  let {f32 arg_71035, f32 arg_71036} = lifted_23306(x_71031, x_71032)
  let {f32 res_71037, f32 res_71038} = lifted_23316(arg_71035, arg_71036,
                                                    y_71033, y_71034)
  in {res_71037, res_71038}
}

fun {f32, f32} lifted_23373(f32 x_71039, f32 x_71040) = {
  {x_71039, x_71040}
}

fun {f32, f32} lifted_23380(f32 x_71041, f32 x_71042) = {
  {x_71041, x_71042}
}

fun {f32, f32} lifted_23387(f32 x_71043, f32 x_71044) = {
  {x_71043, x_71044}
}

fun {f32, f32} lifted_23394(f32 x_71045, f32 x_71046) = {
  {x_71045, x_71046}
}

fun {f32, f32} lifted_23410(f32 a_71047, f32 b_71048) = {
  {a_71047, b_71048}
}

fun {f32} lifted_23422(f32 x_71049) = {
  {x_71049}
}

fun {f32} lifted_23426(f32 x_71050, f32 y_71051) = {
  let {f32 res_71052} = fmul32(x_71050, y_71051)
  in {res_71052}
}

fun {f32} lifted_23430(f32 x_71053) = {
  {x_71053}
}

fun {f32} lifted_23433(f32 x_71054) = {
  {x_71054}
}

fun {f32} lifted_23437(f32 x_71055, f32 y_71056) = {
  let {f32 res_71057} = fmul32(x_71055, y_71056)
  in {res_71057}
}

fun {f32} lifted_23442(f32 x_71058, f32 y_71059) = {
  let {f32 res_71060} = fsub32(x_71058, y_71059)
  in {res_71060}
}

fun {f32} lifted_23446(f32 x_71061) = {
  {x_71061}
}

fun {f32} lifted_23450(f32 x_71062, f32 y_71063) = {
  let {f32 res_71064} = fmul32(x_71062, y_71063)
  in {res_71064}
}

fun {f32} lifted_23454(f32 x_71065) = {
  {x_71065}
}

fun {f32} lifted_23457(f32 x_71066) = {
  {x_71066}
}

fun {f32} lifted_23461(f32 x_71067, f32 y_71068) = {
  let {f32 res_71069} = fmul32(x_71067, y_71068)
  in {res_71069}
}

fun {f32} lifted_23466(f32 x_71070, f32 y_71071) = {
  let {f32 res_71072} = fadd32(x_71070, y_71071)
  in {res_71072}
}

fun {f32, f32} lifted_23420(f32 a_71073, f32 b_71074, f32 c_71075,
                            f32 d_71076) = {
  let {f32 arg_71077} = lifted_23422(a_71073)
  let {f32 arg_71078} = lifted_23426(arg_71077, c_71075)
  let {f32 arg_71079} = lifted_23430(arg_71078)
  let {f32 arg_71080} = lifted_23433(b_71074)
  let {f32 arg_71081} = lifted_23437(arg_71080, d_71076)
  let {f32 res_71082} = lifted_23442(arg_71079, arg_71081)
  let {f32 arg_71083} = lifted_23446(b_71074)
  let {f32 arg_71084} = lifted_23450(arg_71083, c_71075)
  let {f32 arg_71085} = lifted_23454(arg_71084)
  let {f32 arg_71086} = lifted_23457(a_71073)
  let {f32 arg_71087} = lifted_23461(arg_71086, d_71076)
  let {f32 res_71088} = lifted_23466(arg_71085, arg_71087)
  in {res_71082, res_71088}
}

fun {f32, f32} lifted_23404(f32 x_71089, f32 x_71090, f32 y_71091,
                            f32 y_71092) = {
  let {f32 arg_71093, f32 arg_71094} = lifted_23410(x_71089, x_71090)
  let {f32 res_71095, f32 res_71096} = lifted_23420(arg_71093, arg_71094,
                                                    y_71091, y_71092)
  in {res_71095, res_71096}
}

fun {f32, f32} lifted_23484(f32 a_71097, f32 b_71098) = {
  {a_71097, b_71098}
}

fun {f32} lifted_23494(f32 x_71099) = {
  {x_71099}
}

fun {f32} lifted_23498(f32 x_71100, f32 y_71101) = {
  let {f32 res_71102} = fsub32(x_71100, y_71101)
  in {res_71102}
}

fun {f32} lifted_23502(f32 x_71103) = {
  {x_71103}
}

fun {f32} lifted_23506(f32 x_71104, f32 y_71105) = {
  let {f32 res_71106} = fsub32(x_71104, y_71105)
  in {res_71106}
}

fun {f32, f32} lifted_23492(f32 a_71107, f32 b_71108, f32 c_71109,
                            f32 d_71110) = {
  let {f32 arg_71111} = lifted_23494(a_71107)
  let {f32 res_71112} = lifted_23498(arg_71111, c_71109)
  let {f32 arg_71113} = lifted_23502(b_71108)
  let {f32 res_71114} = lifted_23506(arg_71113, d_71110)
  in {res_71112, res_71114}
}

fun {f32, f32} lifted_23480(f32 x_71115, f32 x_71116, f32 y_71117,
                            f32 y_71118) = {
  let {f32 arg_71119, f32 arg_71120} = lifted_23484(x_71115, x_71116)
  let {f32 res_71121, f32 res_71122} = lifted_23492(arg_71119, arg_71120,
                                                    y_71117, y_71118)
  in {res_71121, res_71122}
}

fun {f32, f32} lifted_23517(f32 x_71123, f32 x_71124) = {
  {x_71123, x_71124}
}

fun {f32, f32} lifted_23524(f32 x_71125, f32 x_71126) = {
  {x_71125, x_71126}
}

fun {f32, f32} lifted_23538(f32 a_71127, f32 b_71128) = {
  {a_71127, b_71128}
}

fun {f32} lifted_23548(f32 x_71129) = {
  {x_71129}
}

fun {f32} lifted_23552(f32 x_71130, f32 y_71131) = {
  let {f32 res_71132} = fsub32(x_71130, y_71131)
  in {res_71132}
}

fun {f32} lifted_23556(f32 x_71133) = {
  {x_71133}
}

fun {f32} lifted_23560(f32 x_71134, f32 y_71135) = {
  let {f32 res_71136} = fsub32(x_71134, y_71135)
  in {res_71136}
}

fun {f32, f32} lifted_23546(f32 a_71137, f32 b_71138, f32 c_71139,
                            f32 d_71140) = {
  let {f32 arg_71141} = lifted_23548(a_71137)
  let {f32 res_71142} = lifted_23552(arg_71141, c_71139)
  let {f32 arg_71143} = lifted_23556(b_71138)
  let {f32 res_71144} = lifted_23560(arg_71143, d_71140)
  in {res_71142, res_71144}
}

fun {f32, f32} lifted_23534(f32 x_71145, f32 x_71146, f32 y_71147,
                            f32 y_71148) = {
  let {f32 arg_71149, f32 arg_71150} = lifted_23538(x_71145, x_71146)
  let {f32 res_71151, f32 res_71152} = lifted_23546(arg_71149, arg_71150,
                                                    y_71147, y_71148)
  in {res_71151, res_71152}
}

fun {f32, f32} lifted_23581(f32 a_71153, f32 b_71154) = {
  {a_71153, b_71154}
}

fun {f32} lifted_23594(f32 x_71155) = {
  {x_71155}
}

fun {f32} lifted_23598(f32 x_71156, f32 y_71157) = {
  let {f32 res_71158} = fmul32(x_71156, y_71157)
  in {res_71158}
}

fun {f32} lifted_23602(f32 x_71159) = {
  {x_71159}
}

fun {f32} lifted_23605(f32 x_71160) = {
  {x_71160}
}

fun {f32} lifted_23609(f32 x_71161, f32 y_71162) = {
  let {f32 res_71163} = fmul32(x_71161, y_71162)
  in {res_71163}
}

fun {f32} lifted_23614(f32 x_71164, f32 y_71165) = {
  let {f32 res_71166} = fadd32(x_71164, y_71165)
  in {res_71166}
}

fun {f32} lifted_23618(f32 x_71167) = {
  {x_71167}
}

fun {f32} lifted_23621(f32 x_71168) = {
  {x_71168}
}

fun {f32} lifted_23625(f32 x_71169, f32 y_71170) = {
  let {f32 res_71171} = fmul32(x_71169, y_71170)
  in {res_71171}
}

fun {f32} lifted_23629(f32 x_71172) = {
  {x_71172}
}

fun {f32} lifted_23632(f32 x_71173) = {
  {x_71173}
}

fun {f32} lifted_23636(f32 x_71174, f32 y_71175) = {
  let {f32 res_71176} = fmul32(x_71174, y_71175)
  in {res_71176}
}

fun {f32} lifted_23641(f32 x_71177, f32 y_71178) = {
  let {f32 res_71179} = fadd32(x_71177, y_71178)
  in {res_71179}
}

fun {f32} lifted_23646(f32 x_71180, f32 y_71181) = {
  let {f32 res_71182} = fdiv32(x_71180, y_71181)
  in {res_71182}
}

fun {f32} lifted_23650(f32 x_71183) = {
  {x_71183}
}

fun {f32} lifted_23654(f32 x_71184, f32 y_71185) = {
  let {f32 res_71186} = fmul32(x_71184, y_71185)
  in {res_71186}
}

fun {f32} lifted_23658(f32 x_71187) = {
  {x_71187}
}

fun {f32} lifted_23661(f32 x_71188) = {
  {x_71188}
}

fun {f32} lifted_23665(f32 x_71189, f32 y_71190) = {
  let {f32 res_71191} = fmul32(x_71189, y_71190)
  in {res_71191}
}

fun {f32} lifted_23670(f32 x_71192, f32 y_71193) = {
  let {f32 res_71194} = fsub32(x_71192, y_71193)
  in {res_71194}
}

fun {f32} lifted_23674(f32 x_71195) = {
  {x_71195}
}

fun {f32} lifted_23677(f32 x_71196) = {
  {x_71196}
}

fun {f32} lifted_23681(f32 x_71197, f32 y_71198) = {
  let {f32 res_71199} = fmul32(x_71197, y_71198)
  in {res_71199}
}

fun {f32} lifted_23685(f32 x_71200) = {
  {x_71200}
}

fun {f32} lifted_23688(f32 x_71201) = {
  {x_71201}
}

fun {f32} lifted_23692(f32 x_71202, f32 y_71203) = {
  let {f32 res_71204} = fmul32(x_71202, y_71203)
  in {res_71204}
}

fun {f32} lifted_23697(f32 x_71205, f32 y_71206) = {
  let {f32 res_71207} = fadd32(x_71205, y_71206)
  in {res_71207}
}

fun {f32} lifted_23702(f32 x_71208, f32 y_71209) = {
  let {f32 res_71210} = fdiv32(x_71208, y_71209)
  in {res_71210}
}

fun {f32, f32} lifted_23592(f32 a_71211, f32 b_71212, f32 c_71213,
                            f32 d_71214) = {
  let {f32 arg_71215} = lifted_23594(a_71211)
  let {f32 arg_71216} = lifted_23598(arg_71215, c_71213)
  let {f32 arg_71217} = lifted_23602(arg_71216)
  let {f32 arg_71218} = lifted_23605(b_71212)
  let {f32 arg_71219} = lifted_23609(arg_71218, d_71214)
  let {f32 arg_71220} = lifted_23614(arg_71217, arg_71219)
  let {f32 arg_71221} = lifted_23618(arg_71220)
  let {f32 arg_71222} = lifted_23621(c_71213)
  let {f32 arg_71223} = lifted_23625(arg_71222, c_71213)
  let {f32 arg_71224} = lifted_23629(arg_71223)
  let {f32 arg_71225} = lifted_23632(d_71214)
  let {f32 arg_71226} = lifted_23636(arg_71225, d_71214)
  let {f32 arg_71227} = lifted_23641(arg_71224, arg_71226)
  let {f32 res_71228} = lifted_23646(arg_71221, arg_71227)
  let {f32 arg_71229} = lifted_23650(b_71212)
  let {f32 arg_71230} = lifted_23654(arg_71229, c_71213)
  let {f32 arg_71231} = lifted_23658(arg_71230)
  let {f32 arg_71232} = lifted_23661(a_71211)
  let {f32 arg_71233} = lifted_23665(arg_71232, d_71214)
  let {f32 arg_71234} = lifted_23670(arg_71231, arg_71233)
  let {f32 arg_71235} = lifted_23674(arg_71234)
  let {f32 arg_71236} = lifted_23677(c_71213)
  let {f32 arg_71237} = lifted_23681(arg_71236, c_71213)
  let {f32 arg_71238} = lifted_23685(arg_71237)
  let {f32 arg_71239} = lifted_23688(d_71214)
  let {f32 arg_71240} = lifted_23692(arg_71239, d_71214)
  let {f32 arg_71241} = lifted_23697(arg_71238, arg_71240)
  let {f32 res_71242} = lifted_23702(arg_71235, arg_71241)
  in {res_71228, res_71242}
}

fun {f32, f32} lifted_23574(f32 x_71243, f32 x_71244, f32 y_71245,
                            f32 y_71246) = {
  let {f32 arg_71247, f32 arg_71248} = lifted_23581(x_71243, x_71244)
  let {f32 res_71249, f32 res_71250} = lifted_23592(arg_71247, arg_71248,
                                                    y_71245, y_71246)
  in {res_71249, res_71250}
}

fun {f32} lifted_23724(f32 x_71251) = {
  {x_71251}
}

fun {f32} lifted_23728(f32 x_71252, f32 y_71253) = {
  let {f32 res_71254} = fmul32(x_71252, y_71253)
  in {res_71254}
}

fun {f32} lifted_23732(f32 x_71255) = {
  {x_71255}
}

fun {f32} lifted_23735(f32 x_71256) = {
  {x_71256}
}

fun {f32} lifted_23739(f32 x_71257, f32 y_71258) = {
  let {f32 res_71259} = fmul32(x_71257, y_71258)
  in {res_71259}
}

fun {f32} lifted_23744(f32 x_71260, f32 y_71261) = {
  let {f32 res_71262} = fadd32(x_71260, y_71261)
  in {res_71262}
}

fun {f32} lifted_23748(f32 x_71263) = {
  let {f32 res_71264} = sqrt32(x_71263)
  in {res_71264}
}

fun {f32} lifted_23722(f32 a_71265, f32 b_71266) = {
  let {f32 arg_71267} = lifted_23724(a_71265)
  let {f32 arg_71268} = lifted_23728(arg_71267, a_71265)
  let {f32 arg_71269} = lifted_23732(arg_71268)
  let {f32 arg_71270} = lifted_23735(b_71266)
  let {f32 arg_71271} = lifted_23739(arg_71270, b_71266)
  let {f32 arg_71272} = lifted_23744(arg_71269, arg_71271)
  let {f32 res_71273} = lifted_23748(arg_71272)
  in {res_71273}
}

fun {f32} lifted_23753(f32 x_71274) = {
  let {f32 res_71275} = log32(x_71274)
  in {res_71275}
}

fun {f32} lifted_23757(f32 a_71276) = {
  {a_71276}
}

fun {f32} lifted_23764(f32 x_71277) = {
  {x_71277}
}

fun {f32} lifted_23768(f32 x_71278, f32 y_71279) = {
  let {f32 res_71280} = atan2_32(x_71278, y_71279)
  in {res_71280}
}

fun {f32} lifted_23762(f32 a_71281, f32 b_71282) = {
  let {f32 arg_71283} = lifted_23764(b_71282)
  let {f32 res_71284} = lifted_23768(arg_71283, a_71281)
  in {res_71284}
}

fun {f32, f32} lifted_23774(f32 a_71285, f32 b_71286) = {
  {a_71285, b_71286}
}

fun {f32, f32} lifted_23716(f32 z_71287, f32 z_71288) = {
  let {f32 arg_71289} = lifted_23722(z_71287, z_71288)
  let {f32 arg_71290} = lifted_23753(arg_71289)
  let {f32 arg_71291} = lifted_23757(arg_71290)
  let {f32 arg_71292} = lifted_23762(z_71287, z_71288)
  let {f32 res_71293, f32 res_71294} = lifted_23774(arg_71291, arg_71292)
  in {res_71293, res_71294}
}

fun {f32, f32} lifted_23792(f32 a_71295, f32 b_71296) = {
  {a_71295, b_71296}
}

fun {f32} lifted_23804(f32 x_71297) = {
  {x_71297}
}

fun {f32} lifted_23808(f32 x_71298, f32 y_71299) = {
  let {f32 res_71300} = fmul32(x_71298, y_71299)
  in {res_71300}
}

fun {f32} lifted_23812(f32 x_71301) = {
  {x_71301}
}

fun {f32} lifted_23815(f32 x_71302) = {
  {x_71302}
}

fun {f32} lifted_23819(f32 x_71303, f32 y_71304) = {
  let {f32 res_71305} = fmul32(x_71303, y_71304)
  in {res_71305}
}

fun {f32} lifted_23824(f32 x_71306, f32 y_71307) = {
  let {f32 res_71308} = fsub32(x_71306, y_71307)
  in {res_71308}
}

fun {f32} lifted_23828(f32 x_71309) = {
  {x_71309}
}

fun {f32} lifted_23832(f32 x_71310, f32 y_71311) = {
  let {f32 res_71312} = fmul32(x_71310, y_71311)
  in {res_71312}
}

fun {f32} lifted_23836(f32 x_71313) = {
  {x_71313}
}

fun {f32} lifted_23839(f32 x_71314) = {
  {x_71314}
}

fun {f32} lifted_23843(f32 x_71315, f32 y_71316) = {
  let {f32 res_71317} = fmul32(x_71315, y_71316)
  in {res_71317}
}

fun {f32} lifted_23848(f32 x_71318, f32 y_71319) = {
  let {f32 res_71320} = fadd32(x_71318, y_71319)
  in {res_71320}
}

fun {f32, f32} lifted_23802(f32 a_71321, f32 b_71322, f32 c_71323,
                            f32 d_71324) = {
  let {f32 arg_71325} = lifted_23804(a_71321)
  let {f32 arg_71326} = lifted_23808(arg_71325, c_71323)
  let {f32 arg_71327} = lifted_23812(arg_71326)
  let {f32 arg_71328} = lifted_23815(b_71322)
  let {f32 arg_71329} = lifted_23819(arg_71328, d_71324)
  let {f32 res_71330} = lifted_23824(arg_71327, arg_71329)
  let {f32 arg_71331} = lifted_23828(b_71322)
  let {f32 arg_71332} = lifted_23832(arg_71331, c_71323)
  let {f32 arg_71333} = lifted_23836(arg_71332)
  let {f32 arg_71334} = lifted_23839(a_71321)
  let {f32 arg_71335} = lifted_23843(arg_71334, d_71324)
  let {f32 res_71336} = lifted_23848(arg_71333, arg_71335)
  in {res_71330, res_71336}
}

fun {f32, f32} lifted_23786(f32 x_71337, f32 x_71338, f32 y_71339,
                            f32 y_71340) = {
  let {f32 arg_71341, f32 arg_71342} = lifted_23792(x_71337, x_71338)
  let {f32 res_71343, f32 res_71344} = lifted_23802(arg_71341, arg_71342,
                                                    y_71339, y_71340)
  in {res_71343, res_71344}
}

fun {f32, f32} lifted_23866(f32 a_71345, f32 b_71346) = {
  {a_71345, b_71346}
}

fun {f32} lifted_23876(f32 x_71347) = {
  {x_71347}
}

fun {f32} lifted_23880(f32 x_71348, f32 y_71349) = {
  let {f32 res_71350} = fsub32(x_71348, y_71349)
  in {res_71350}
}

fun {f32} lifted_23884(f32 x_71351) = {
  {x_71351}
}

fun {f32} lifted_23888(f32 x_71352, f32 y_71353) = {
  let {f32 res_71354} = fsub32(x_71352, y_71353)
  in {res_71354}
}

fun {f32, f32} lifted_23874(f32 a_71355, f32 b_71356, f32 c_71357,
                            f32 d_71358) = {
  let {f32 arg_71359} = lifted_23876(a_71355)
  let {f32 res_71360} = lifted_23880(arg_71359, c_71357)
  let {f32 arg_71361} = lifted_23884(b_71356)
  let {f32 res_71362} = lifted_23888(arg_71361, d_71358)
  in {res_71360, res_71362}
}

fun {f32, f32} lifted_23862(f32 x_71363, f32 x_71364, f32 y_71365,
                            f32 y_71366) = {
  let {f32 arg_71367, f32 arg_71368} = lifted_23866(x_71363, x_71364)
  let {f32 res_71369, f32 res_71370} = lifted_23874(arg_71367, arg_71368,
                                                    y_71365, y_71366)
  in {res_71369, res_71370}
}

fun {f32, f32} lifted_23908(f32 a_71371, f32 b_71372) = {
  {a_71371, b_71372}
}

fun {f32} lifted_23920(f32 x_71373) = {
  {x_71373}
}

fun {f32} lifted_23924(f32 x_71374, f32 y_71375) = {
  let {f32 res_71376} = fmul32(x_71374, y_71375)
  in {res_71376}
}

fun {f32} lifted_23928(f32 x_71377) = {
  {x_71377}
}

fun {f32} lifted_23931(f32 x_71378) = {
  {x_71378}
}

fun {f32} lifted_23935(f32 x_71379, f32 y_71380) = {
  let {f32 res_71381} = fmul32(x_71379, y_71380)
  in {res_71381}
}

fun {f32} lifted_23940(f32 x_71382, f32 y_71383) = {
  let {f32 res_71384} = fsub32(x_71382, y_71383)
  in {res_71384}
}

fun {f32} lifted_23944(f32 x_71385) = {
  {x_71385}
}

fun {f32} lifted_23948(f32 x_71386, f32 y_71387) = {
  let {f32 res_71388} = fmul32(x_71386, y_71387)
  in {res_71388}
}

fun {f32} lifted_23952(f32 x_71389) = {
  {x_71389}
}

fun {f32} lifted_23955(f32 x_71390) = {
  {x_71390}
}

fun {f32} lifted_23959(f32 x_71391, f32 y_71392) = {
  let {f32 res_71393} = fmul32(x_71391, y_71392)
  in {res_71393}
}

fun {f32} lifted_23964(f32 x_71394, f32 y_71395) = {
  let {f32 res_71396} = fadd32(x_71394, y_71395)
  in {res_71396}
}

fun {f32, f32} lifted_23918(f32 a_71397, f32 b_71398, f32 c_71399,
                            f32 d_71400) = {
  let {f32 arg_71401} = lifted_23920(a_71397)
  let {f32 arg_71402} = lifted_23924(arg_71401, c_71399)
  let {f32 arg_71403} = lifted_23928(arg_71402)
  let {f32 arg_71404} = lifted_23931(b_71398)
  let {f32 arg_71405} = lifted_23935(arg_71404, d_71400)
  let {f32 res_71406} = lifted_23940(arg_71403, arg_71405)
  let {f32 arg_71407} = lifted_23944(b_71398)
  let {f32 arg_71408} = lifted_23948(arg_71407, c_71399)
  let {f32 arg_71409} = lifted_23952(arg_71408)
  let {f32 arg_71410} = lifted_23955(a_71397)
  let {f32 arg_71411} = lifted_23959(arg_71410, d_71400)
  let {f32 res_71412} = lifted_23964(arg_71409, arg_71411)
  in {res_71406, res_71412}
}

fun {f32, f32} lifted_23902(f32 x_71413, f32 x_71414, f32 y_71415,
                            f32 y_71416) = {
  let {f32 arg_71417, f32 arg_71418} = lifted_23908(x_71413, x_71414)
  let {f32 res_71419, f32 res_71420} = lifted_23918(arg_71417, arg_71418,
                                                    y_71415, y_71416)
  in {res_71419, res_71420}
}

fun {f32, f32} lifted_23975(f32 x_71421, f32 x_71422) = {
  {x_71421, x_71422}
}

fun {f32, f32} lifted_23982(f32 x_71423, f32 x_71424) = {
  {x_71423, x_71424}
}

fun {f32, f32} lifted_23998(f32 a_71425, f32 b_71426) = {
  {a_71425, b_71426}
}

fun {f32} lifted_24010(f32 x_71427) = {
  {x_71427}
}

fun {f32} lifted_24014(f32 x_71428, f32 y_71429) = {
  let {f32 res_71430} = fmul32(x_71428, y_71429)
  in {res_71430}
}

fun {f32} lifted_24018(f32 x_71431) = {
  {x_71431}
}

fun {f32} lifted_24021(f32 x_71432) = {
  {x_71432}
}

fun {f32} lifted_24025(f32 x_71433, f32 y_71434) = {
  let {f32 res_71435} = fmul32(x_71433, y_71434)
  in {res_71435}
}

fun {f32} lifted_24030(f32 x_71436, f32 y_71437) = {
  let {f32 res_71438} = fsub32(x_71436, y_71437)
  in {res_71438}
}

fun {f32} lifted_24034(f32 x_71439) = {
  {x_71439}
}

fun {f32} lifted_24038(f32 x_71440, f32 y_71441) = {
  let {f32 res_71442} = fmul32(x_71440, y_71441)
  in {res_71442}
}

fun {f32} lifted_24042(f32 x_71443) = {
  {x_71443}
}

fun {f32} lifted_24045(f32 x_71444) = {
  {x_71444}
}

fun {f32} lifted_24049(f32 x_71445, f32 y_71446) = {
  let {f32 res_71447} = fmul32(x_71445, y_71446)
  in {res_71447}
}

fun {f32} lifted_24054(f32 x_71448, f32 y_71449) = {
  let {f32 res_71450} = fadd32(x_71448, y_71449)
  in {res_71450}
}

fun {f32, f32} lifted_24008(f32 a_71451, f32 b_71452, f32 c_71453,
                            f32 d_71454) = {
  let {f32 arg_71455} = lifted_24010(a_71451)
  let {f32 arg_71456} = lifted_24014(arg_71455, c_71453)
  let {f32 arg_71457} = lifted_24018(arg_71456)
  let {f32 arg_71458} = lifted_24021(b_71452)
  let {f32 arg_71459} = lifted_24025(arg_71458, d_71454)
  let {f32 res_71460} = lifted_24030(arg_71457, arg_71459)
  let {f32 arg_71461} = lifted_24034(b_71452)
  let {f32 arg_71462} = lifted_24038(arg_71461, c_71453)
  let {f32 arg_71463} = lifted_24042(arg_71462)
  let {f32 arg_71464} = lifted_24045(a_71451)
  let {f32 arg_71465} = lifted_24049(arg_71464, d_71454)
  let {f32 res_71466} = lifted_24054(arg_71463, arg_71465)
  in {res_71460, res_71466}
}

fun {f32, f32} lifted_23992(f32 x_71467, f32 x_71468, f32 y_71469,
                            f32 y_71470) = {
  let {f32 arg_71471, f32 arg_71472} = lifted_23998(x_71467, x_71468)
  let {f32 res_71473, f32 res_71474} = lifted_24008(arg_71471, arg_71472,
                                                    y_71469, y_71470)
  in {res_71473, res_71474}
}

fun {f32, f32} lifted_24065(f32 x_71475, f32 x_71476) = {
  {x_71475, x_71476}
}

fun {f32, f32} lifted_24072(f32 x_71477, f32 x_71478) = {
  {x_71477, x_71478}
}

fun {f32, f32} lifted_24086(f32 a_71479, f32 b_71480) = {
  {a_71479, b_71480}
}

fun {f32} lifted_24096(f32 x_71481) = {
  {x_71481}
}

fun {f32} lifted_24100(f32 x_71482, f32 y_71483) = {
  let {f32 res_71484} = fsub32(x_71482, y_71483)
  in {res_71484}
}

fun {f32} lifted_24104(f32 x_71485) = {
  {x_71485}
}

fun {f32} lifted_24108(f32 x_71486, f32 y_71487) = {
  let {f32 res_71488} = fsub32(x_71486, y_71487)
  in {res_71488}
}

fun {f32, f32} lifted_24094(f32 a_71489, f32 b_71490, f32 c_71491,
                            f32 d_71492) = {
  let {f32 arg_71493} = lifted_24096(a_71489)
  let {f32 res_71494} = lifted_24100(arg_71493, c_71491)
  let {f32 arg_71495} = lifted_24104(b_71490)
  let {f32 res_71496} = lifted_24108(arg_71495, d_71492)
  in {res_71494, res_71496}
}

fun {f32, f32} lifted_24082(f32 x_71497, f32 x_71498, f32 y_71499,
                            f32 y_71500) = {
  let {f32 arg_71501, f32 arg_71502} = lifted_24086(x_71497, x_71498)
  let {f32 res_71503, f32 res_71504} = lifted_24094(arg_71501, arg_71502,
                                                    y_71499, y_71500)
  in {res_71503, res_71504}
}

fun {f32, f32} lifted_24128(f32 a_71505, f32 b_71506) = {
  {a_71505, b_71506}
}

fun {f32} lifted_24140(f32 x_71507) = {
  {x_71507}
}

fun {f32} lifted_24144(f32 x_71508, f32 y_71509) = {
  let {f32 res_71510} = fmul32(x_71508, y_71509)
  in {res_71510}
}

fun {f32} lifted_24148(f32 x_71511) = {
  {x_71511}
}

fun {f32} lifted_24151(f32 x_71512) = {
  {x_71512}
}

fun {f32} lifted_24155(f32 x_71513, f32 y_71514) = {
  let {f32 res_71515} = fmul32(x_71513, y_71514)
  in {res_71515}
}

fun {f32} lifted_24160(f32 x_71516, f32 y_71517) = {
  let {f32 res_71518} = fsub32(x_71516, y_71517)
  in {res_71518}
}

fun {f32} lifted_24164(f32 x_71519) = {
  {x_71519}
}

fun {f32} lifted_24168(f32 x_71520, f32 y_71521) = {
  let {f32 res_71522} = fmul32(x_71520, y_71521)
  in {res_71522}
}

fun {f32} lifted_24172(f32 x_71523) = {
  {x_71523}
}

fun {f32} lifted_24175(f32 x_71524) = {
  {x_71524}
}

fun {f32} lifted_24179(f32 x_71525, f32 y_71526) = {
  let {f32 res_71527} = fmul32(x_71525, y_71526)
  in {res_71527}
}

fun {f32} lifted_24184(f32 x_71528, f32 y_71529) = {
  let {f32 res_71530} = fadd32(x_71528, y_71529)
  in {res_71530}
}

fun {f32, f32} lifted_24138(f32 a_71531, f32 b_71532, f32 c_71533,
                            f32 d_71534) = {
  let {f32 arg_71535} = lifted_24140(a_71531)
  let {f32 arg_71536} = lifted_24144(arg_71535, c_71533)
  let {f32 arg_71537} = lifted_24148(arg_71536)
  let {f32 arg_71538} = lifted_24151(b_71532)
  let {f32 arg_71539} = lifted_24155(arg_71538, d_71534)
  let {f32 res_71540} = lifted_24160(arg_71537, arg_71539)
  let {f32 arg_71541} = lifted_24164(b_71532)
  let {f32 arg_71542} = lifted_24168(arg_71541, c_71533)
  let {f32 arg_71543} = lifted_24172(arg_71542)
  let {f32 arg_71544} = lifted_24175(a_71531)
  let {f32 arg_71545} = lifted_24179(arg_71544, d_71534)
  let {f32 res_71546} = lifted_24184(arg_71543, arg_71545)
  in {res_71540, res_71546}
}

fun {f32, f32} lifted_24122(f32 x_71547, f32 x_71548, f32 y_71549,
                            f32 y_71550) = {
  let {f32 arg_71551, f32 arg_71552} = lifted_24128(x_71547, x_71548)
  let {f32 res_71553, f32 res_71554} = lifted_24138(arg_71551, arg_71552,
                                                    y_71549, y_71550)
  in {res_71553, res_71554}
}

fun {f32, f32} lifted_24195(f32 x_71555, f32 x_71556) = {
  {x_71555, x_71556}
}

fun {f32, f32} lifted_24202(f32 x_71557, f32 x_71558) = {
  {x_71557, x_71558}
}

fun {f32, f32} lifted_24209(f32 x_71559, f32 x_71560) = {
  {x_71559, x_71560}
}

fun {f32, f32} lifted_24225(f32 a_71561, f32 b_71562) = {
  {a_71561, b_71562}
}

fun {f32} lifted_24237(f32 x_71563) = {
  {x_71563}
}

fun {f32} lifted_24241(f32 x_71564, f32 y_71565) = {
  let {f32 res_71566} = fmul32(x_71564, y_71565)
  in {res_71566}
}

fun {f32} lifted_24245(f32 x_71567) = {
  {x_71567}
}

fun {f32} lifted_24248(f32 x_71568) = {
  {x_71568}
}

fun {f32} lifted_24252(f32 x_71569, f32 y_71570) = {
  let {f32 res_71571} = fmul32(x_71569, y_71570)
  in {res_71571}
}

fun {f32} lifted_24257(f32 x_71572, f32 y_71573) = {
  let {f32 res_71574} = fsub32(x_71572, y_71573)
  in {res_71574}
}

fun {f32} lifted_24261(f32 x_71575) = {
  {x_71575}
}

fun {f32} lifted_24265(f32 x_71576, f32 y_71577) = {
  let {f32 res_71578} = fmul32(x_71576, y_71577)
  in {res_71578}
}

fun {f32} lifted_24269(f32 x_71579) = {
  {x_71579}
}

fun {f32} lifted_24272(f32 x_71580) = {
  {x_71580}
}

fun {f32} lifted_24276(f32 x_71581, f32 y_71582) = {
  let {f32 res_71583} = fmul32(x_71581, y_71582)
  in {res_71583}
}

fun {f32} lifted_24281(f32 x_71584, f32 y_71585) = {
  let {f32 res_71586} = fadd32(x_71584, y_71585)
  in {res_71586}
}

fun {f32, f32} lifted_24235(f32 a_71587, f32 b_71588, f32 c_71589,
                            f32 d_71590) = {
  let {f32 arg_71591} = lifted_24237(a_71587)
  let {f32 arg_71592} = lifted_24241(arg_71591, c_71589)
  let {f32 arg_71593} = lifted_24245(arg_71592)
  let {f32 arg_71594} = lifted_24248(b_71588)
  let {f32 arg_71595} = lifted_24252(arg_71594, d_71590)
  let {f32 res_71596} = lifted_24257(arg_71593, arg_71595)
  let {f32 arg_71597} = lifted_24261(b_71588)
  let {f32 arg_71598} = lifted_24265(arg_71597, c_71589)
  let {f32 arg_71599} = lifted_24269(arg_71598)
  let {f32 arg_71600} = lifted_24272(a_71587)
  let {f32 arg_71601} = lifted_24276(arg_71600, d_71590)
  let {f32 res_71602} = lifted_24281(arg_71599, arg_71601)
  in {res_71596, res_71602}
}

fun {f32, f32} lifted_24219(f32 x_71603, f32 x_71604, f32 y_71605,
                            f32 y_71606) = {
  let {f32 arg_71607, f32 arg_71608} = lifted_24225(x_71603, x_71604)
  let {f32 res_71609, f32 res_71610} = lifted_24235(arg_71607, arg_71608,
                                                    y_71605, y_71606)
  in {res_71609, res_71610}
}

fun {f32, f32} lifted_24299(f32 a_71611, f32 b_71612) = {
  {a_71611, b_71612}
}

fun {f32} lifted_24309(f32 x_71613) = {
  {x_71613}
}

fun {f32} lifted_24313(f32 x_71614, f32 y_71615) = {
  let {f32 res_71616} = fsub32(x_71614, y_71615)
  in {res_71616}
}

fun {f32} lifted_24317(f32 x_71617) = {
  {x_71617}
}

fun {f32} lifted_24321(f32 x_71618, f32 y_71619) = {
  let {f32 res_71620} = fsub32(x_71618, y_71619)
  in {res_71620}
}

fun {f32, f32} lifted_24307(f32 a_71621, f32 b_71622, f32 c_71623,
                            f32 d_71624) = {
  let {f32 arg_71625} = lifted_24309(a_71621)
  let {f32 res_71626} = lifted_24313(arg_71625, c_71623)
  let {f32 arg_71627} = lifted_24317(b_71622)
  let {f32 res_71628} = lifted_24321(arg_71627, d_71624)
  in {res_71626, res_71628}
}

fun {f32, f32} lifted_24295(f32 x_71629, f32 x_71630, f32 y_71631,
                            f32 y_71632) = {
  let {f32 arg_71633, f32 arg_71634} = lifted_24299(x_71629, x_71630)
  let {f32 res_71635, f32 res_71636} = lifted_24307(arg_71633, arg_71634,
                                                    y_71631, y_71632)
  in {res_71635, res_71636}
}

fun {f32, f32} lifted_24342(f32 a_71637, f32 b_71638) = {
  {a_71637, b_71638}
}

fun {f32} lifted_24355(f32 x_71639) = {
  {x_71639}
}

fun {f32} lifted_24359(f32 x_71640, f32 y_71641) = {
  let {f32 res_71642} = fmul32(x_71640, y_71641)
  in {res_71642}
}

fun {f32} lifted_24363(f32 x_71643) = {
  {x_71643}
}

fun {f32} lifted_24366(f32 x_71644) = {
  {x_71644}
}

fun {f32} lifted_24370(f32 x_71645, f32 y_71646) = {
  let {f32 res_71647} = fmul32(x_71645, y_71646)
  in {res_71647}
}

fun {f32} lifted_24375(f32 x_71648, f32 y_71649) = {
  let {f32 res_71650} = fadd32(x_71648, y_71649)
  in {res_71650}
}

fun {f32} lifted_24379(f32 x_71651) = {
  {x_71651}
}

fun {f32} lifted_24382(f32 x_71652) = {
  {x_71652}
}

fun {f32} lifted_24386(f32 x_71653, f32 y_71654) = {
  let {f32 res_71655} = fmul32(x_71653, y_71654)
  in {res_71655}
}

fun {f32} lifted_24390(f32 x_71656) = {
  {x_71656}
}

fun {f32} lifted_24393(f32 x_71657) = {
  {x_71657}
}

fun {f32} lifted_24397(f32 x_71658, f32 y_71659) = {
  let {f32 res_71660} = fmul32(x_71658, y_71659)
  in {res_71660}
}

fun {f32} lifted_24402(f32 x_71661, f32 y_71662) = {
  let {f32 res_71663} = fadd32(x_71661, y_71662)
  in {res_71663}
}

fun {f32} lifted_24407(f32 x_71664, f32 y_71665) = {
  let {f32 res_71666} = fdiv32(x_71664, y_71665)
  in {res_71666}
}

fun {f32} lifted_24411(f32 x_71667) = {
  {x_71667}
}

fun {f32} lifted_24415(f32 x_71668, f32 y_71669) = {
  let {f32 res_71670} = fmul32(x_71668, y_71669)
  in {res_71670}
}

fun {f32} lifted_24419(f32 x_71671) = {
  {x_71671}
}

fun {f32} lifted_24422(f32 x_71672) = {
  {x_71672}
}

fun {f32} lifted_24426(f32 x_71673, f32 y_71674) = {
  let {f32 res_71675} = fmul32(x_71673, y_71674)
  in {res_71675}
}

fun {f32} lifted_24431(f32 x_71676, f32 y_71677) = {
  let {f32 res_71678} = fsub32(x_71676, y_71677)
  in {res_71678}
}

fun {f32} lifted_24435(f32 x_71679) = {
  {x_71679}
}

fun {f32} lifted_24438(f32 x_71680) = {
  {x_71680}
}

fun {f32} lifted_24442(f32 x_71681, f32 y_71682) = {
  let {f32 res_71683} = fmul32(x_71681, y_71682)
  in {res_71683}
}

fun {f32} lifted_24446(f32 x_71684) = {
  {x_71684}
}

fun {f32} lifted_24449(f32 x_71685) = {
  {x_71685}
}

fun {f32} lifted_24453(f32 x_71686, f32 y_71687) = {
  let {f32 res_71688} = fmul32(x_71686, y_71687)
  in {res_71688}
}

fun {f32} lifted_24458(f32 x_71689, f32 y_71690) = {
  let {f32 res_71691} = fadd32(x_71689, y_71690)
  in {res_71691}
}

fun {f32} lifted_24463(f32 x_71692, f32 y_71693) = {
  let {f32 res_71694} = fdiv32(x_71692, y_71693)
  in {res_71694}
}

fun {f32, f32} lifted_24353(f32 a_71695, f32 b_71696, f32 c_71697,
                            f32 d_71698) = {
  let {f32 arg_71699} = lifted_24355(a_71695)
  let {f32 arg_71700} = lifted_24359(arg_71699, c_71697)
  let {f32 arg_71701} = lifted_24363(arg_71700)
  let {f32 arg_71702} = lifted_24366(b_71696)
  let {f32 arg_71703} = lifted_24370(arg_71702, d_71698)
  let {f32 arg_71704} = lifted_24375(arg_71701, arg_71703)
  let {f32 arg_71705} = lifted_24379(arg_71704)
  let {f32 arg_71706} = lifted_24382(c_71697)
  let {f32 arg_71707} = lifted_24386(arg_71706, c_71697)
  let {f32 arg_71708} = lifted_24390(arg_71707)
  let {f32 arg_71709} = lifted_24393(d_71698)
  let {f32 arg_71710} = lifted_24397(arg_71709, d_71698)
  let {f32 arg_71711} = lifted_24402(arg_71708, arg_71710)
  let {f32 res_71712} = lifted_24407(arg_71705, arg_71711)
  let {f32 arg_71713} = lifted_24411(b_71696)
  let {f32 arg_71714} = lifted_24415(arg_71713, c_71697)
  let {f32 arg_71715} = lifted_24419(arg_71714)
  let {f32 arg_71716} = lifted_24422(a_71695)
  let {f32 arg_71717} = lifted_24426(arg_71716, d_71698)
  let {f32 arg_71718} = lifted_24431(arg_71715, arg_71717)
  let {f32 arg_71719} = lifted_24435(arg_71718)
  let {f32 arg_71720} = lifted_24438(c_71697)
  let {f32 arg_71721} = lifted_24442(arg_71720, c_71697)
  let {f32 arg_71722} = lifted_24446(arg_71721)
  let {f32 arg_71723} = lifted_24449(d_71698)
  let {f32 arg_71724} = lifted_24453(arg_71723, d_71698)
  let {f32 arg_71725} = lifted_24458(arg_71722, arg_71724)
  let {f32 res_71726} = lifted_24463(arg_71719, arg_71725)
  in {res_71712, res_71726}
}

fun {f32, f32} lifted_24335(f32 x_71727, f32 x_71728, f32 y_71729,
                            f32 y_71730) = {
  let {f32 arg_71731, f32 arg_71732} = lifted_24342(x_71727, x_71728)
  let {f32 res_71733, f32 res_71734} = lifted_24353(arg_71731, arg_71732,
                                                    y_71729, y_71730)
  in {res_71733, res_71734}
}

fun {f32, f32} lifted_24481(f32 a_71735, f32 b_71736) = {
  {a_71735, b_71736}
}

fun {f32} lifted_24491(f32 x_71737) = {
  {x_71737}
}

fun {f32} lifted_24495(f32 x_71738, f32 y_71739) = {
  let {f32 res_71740} = fadd32(x_71738, y_71739)
  in {res_71740}
}

fun {f32} lifted_24499(f32 x_71741) = {
  {x_71741}
}

fun {f32} lifted_24503(f32 x_71742, f32 y_71743) = {
  let {f32 res_71744} = fadd32(x_71742, y_71743)
  in {res_71744}
}

fun {f32, f32} lifted_24489(f32 a_71745, f32 b_71746, f32 c_71747,
                            f32 d_71748) = {
  let {f32 arg_71749} = lifted_24491(a_71745)
  let {f32 res_71750} = lifted_24495(arg_71749, c_71747)
  let {f32 arg_71751} = lifted_24499(b_71746)
  let {f32 res_71752} = lifted_24503(arg_71751, d_71748)
  in {res_71750, res_71752}
}

fun {f32, f32} lifted_24477(f32 x_71753, f32 x_71754, f32 y_71755,
                            f32 y_71756) = {
  let {f32 arg_71757, f32 arg_71758} = lifted_24481(x_71753, x_71754)
  let {f32 res_71759, f32 res_71760} = lifted_24489(arg_71757, arg_71758,
                                                    y_71755, y_71756)
  in {res_71759, res_71760}
}

fun {f32} lifted_24519(f32 x_71761) = {
  let {f32 res_71762} = exp32(x_71761)
  in {res_71762}
}

fun {f32} lifted_24524(f32 x_71763) = {
  {x_71763}
}

fun {f32} lifted_24527(f32 x_71764) = {
  let {f32 res_71765} = cos32(x_71764)
  in {res_71765}
}

fun {f32} lifted_24532(f32 x_71766, f32 y_71767) = {
  let {f32 res_71768} = fmul32(x_71766, y_71767)
  in {res_71768}
}

fun {f32} lifted_24536(f32 a_71769) = {
  {a_71769}
}

fun {f32} lifted_24539(f32 x_71770) = {
  {x_71770}
}

fun {f32} lifted_24542(f32 x_71771) = {
  let {f32 res_71772} = sin32(x_71771)
  in {res_71772}
}

fun {f32} lifted_24547(f32 x_71773, f32 y_71774) = {
  let {f32 res_71775} = fmul32(x_71773, y_71774)
  in {res_71775}
}

fun {f32, f32} lifted_24552(f32 a_71776, f32 b_71777) = {
  {a_71776, b_71777}
}

fun {f32, f32} lifted_24517(f32 a_71778, f32 b_71779) = {
  let {f32 res_71780} = lifted_24519(a_71778)
  let {f32 expx_71781} = res_71780
  let {f32 arg_71782} = lifted_24524(expx_71781)
  let {f32 arg_71783} = lifted_24527(b_71779)
  let {f32 arg_71784} = lifted_24532(arg_71782, arg_71783)
  let {f32 arg_71785} = lifted_24536(arg_71784)
  let {f32 arg_71786} = lifted_24539(expx_71781)
  let {f32 arg_71787} = lifted_24542(b_71779)
  let {f32 arg_71788} = lifted_24547(arg_71786, arg_71787)
  let {f32 res_71789, f32 res_71790} = lifted_24552(arg_71785, arg_71788)
  in {res_71789, res_71790}
}

fun {f32, f32} lifted_22095(f32 coeff1_71791, f32 coeff1_71792,
                            f32 coeff2_71793, f32 coeff2_71794,
                            f32 day_count_fraction_71795, f32 etai2_71796,
                            f32 etai2_71797, f32 etai_71798, f32 etai_71799,
                            f32 i_71800, f32 i_71801, f32 kappai_71802,
                            f32 kappai_71803, f32 one_71804, f32 one_71805,
                            f32 rho_71806, f32 two_71807, f32 two_71808,
                            f32 zero_71809, f32 zero_71810, f32 xi_71811,
                            f32 xi_71812) = {
  let {f32 res_71813, f32 res_71814} = lifted_22098(day_count_fraction_71795)
  let {f32 ti_71815} = res_71813
  let {f32 ti_71816} = res_71814
  let {f32 arg_71817, f32 arg_71818} = lifted_22112(kappai_71802, kappai_71803)
  let {f32 arg_71819, f32 arg_71820} = lifted_22117(rho_71806)
  let {f32 arg_71821, f32 arg_71822} = lifted_22128(arg_71819, arg_71820)
  let {f32 arg_71823, f32 arg_71824} = lifted_22138(arg_71821, arg_71822,
                                                    etai_71798, etai_71799)
  let {f32 arg_71825, f32 arg_71826} = lifted_22211(arg_71823, arg_71824)
  let {f32 arg_71827, f32 arg_71828} = lifted_22221(arg_71825, arg_71826,
                                                    xi_71811, xi_71812)
  let {f32 res_71829, f32 res_71830} = lifted_22297(arg_71817, arg_71818,
                                                    arg_71827, arg_71828)
  let {f32 d0_71831} = res_71829
  let {f32 d0_71832} = res_71830
  let {f32 arg_71833, f32 arg_71834} = lifted_22337(d0_71831, d0_71832)
  let {f32 arg_71835, f32 arg_71836} = lifted_22347(arg_71833, arg_71834,
                                                    d0_71831, d0_71832)
  let {f32 arg_71837, f32 arg_71838} = lifted_22420(arg_71835, arg_71836)
  let {f32 arg_71839, f32 arg_71840} = lifted_22427(etai2_71796, etai2_71797)
  let {f32 arg_71841, f32 arg_71842} = lifted_22434(xi_71811, xi_71812)
  let {f32 arg_71843, f32 arg_71844} = lifted_22441(i_71800, i_71801)
  let {f32 arg_71845, f32 arg_71846} = lifted_22451(arg_71843, arg_71844,
                                                    xi_71811, xi_71812)
  let {f32 arg_71847, f32 arg_71848} = lifted_22491(arg_71841, arg_71842,
                                                    arg_71845, arg_71846)
  let {f32 arg_71849, f32 arg_71850} = lifted_22567(arg_71839, arg_71840,
                                                    arg_71847, arg_71848)
  let {f32 arg_71851, f32 arg_71852} = lifted_22643(arg_71837, arg_71838,
                                                    arg_71849, arg_71850)
  let {f32 res_71853, f32 res_71854} = lifted_22686(arg_71851, arg_71852)
  let {f32 d_71855} = res_71853
  let {f32 d_71856} = res_71854
  let {f32 arg_71857, f32 arg_71858} = lifted_22854(d0_71831, d0_71832)
  let {f32 res_71859, f32 res_71860} = lifted_22864(arg_71857, arg_71858,
                                                    d_71855, d_71856)
  let {f32 a_minus_71861} = res_71859
  let {f32 a_minus_71862} = res_71860
  let {f32 arg_71863, f32 arg_71864} = lifted_22904(a_minus_71861,
                                                    a_minus_71862)
  let {f32 arg_71865, f32 arg_71866} = lifted_22911(d0_71831, d0_71832)
  let {f32 arg_71867, f32 arg_71868} = lifted_22921(arg_71865, arg_71866,
                                                    d_71855, d_71856)
  let {f32 res_71869, f32 res_71870} = lifted_22961(arg_71863, arg_71864,
                                                    arg_71867, arg_71868)
  let {f32 g_71871} = res_71869
  let {f32 g_71872} = res_71870
  let {f32 arg_71873, f32 arg_71874} = lifted_23103(zero_71809, zero_71810)
  let {f32 arg_71875, f32 arg_71876} = lifted_23110(d_71855, d_71856)
  let {f32 arg_71877, f32 arg_71878} = lifted_23120(arg_71875, arg_71876,
                                                    ti_71815, ti_71816)
  let {f32 arg_71879, f32 arg_71880} = lifted_23196(arg_71873, arg_71874,
                                                    arg_71877, arg_71878)
  let {f32 res_71881, f32 res_71882} = lifted_23236(arg_71879, arg_71880)
  let {f32 e_71883} = res_71881
  let {f32 e_71884} = res_71882
  let {f32 arg_71885, f32 arg_71886} = lifted_23283(coeff1_71791, coeff1_71792)
  let {f32 arg_71887, f32 arg_71888} = lifted_23290(a_minus_71861,
                                                    a_minus_71862)
  let {f32 arg_71889, f32 arg_71890} = lifted_23300(arg_71887, arg_71888,
                                                    ti_71815, ti_71816)
  let {f32 arg_71891, f32 arg_71892} = lifted_23373(arg_71889, arg_71890)
  let {f32 arg_71893, f32 arg_71894} = lifted_23380(two_71807, two_71808)
  let {f32 arg_71895, f32 arg_71896} = lifted_23387(one_71804, one_71805)
  let {f32 arg_71897, f32 arg_71898} = lifted_23394(g_71871, g_71872)
  let {f32 arg_71899, f32 arg_71900} = lifted_23404(arg_71897, arg_71898,
                                                    e_71883, e_71884)
  let {f32 arg_71901, f32 arg_71902} = lifted_23480(arg_71895, arg_71896,
                                                    arg_71899, arg_71900)
  let {f32 arg_71903, f32 arg_71904} = lifted_23517(arg_71901, arg_71902)
  let {f32 arg_71905, f32 arg_71906} = lifted_23524(one_71804, one_71805)
  let {f32 arg_71907, f32 arg_71908} = lifted_23534(arg_71905, arg_71906,
                                                    g_71871, g_71872)
  let {f32 arg_71909, f32 arg_71910} = lifted_23574(arg_71903, arg_71904,
                                                    arg_71907, arg_71908)
  let {f32 arg_71911, f32 arg_71912} = lifted_23716(arg_71909, arg_71910)
  let {f32 arg_71913, f32 arg_71914} = lifted_23786(arg_71893, arg_71894,
                                                    arg_71911, arg_71912)
  let {f32 arg_71915, f32 arg_71916} = lifted_23862(arg_71891, arg_71892,
                                                    arg_71913, arg_71914)
  let {f32 arg_71917, f32 arg_71918} = lifted_23902(arg_71885, arg_71886,
                                                    arg_71915, arg_71916)
  let {f32 arg_71919, f32 arg_71920} = lifted_23975(arg_71917, arg_71918)
  let {f32 arg_71921, f32 arg_71922} = lifted_23982(coeff2_71793, coeff2_71794)
  let {f32 arg_71923, f32 arg_71924} = lifted_23992(arg_71921, arg_71922,
                                                    a_minus_71861,
                                                    a_minus_71862)
  let {f32 arg_71925, f32 arg_71926} = lifted_24065(arg_71923, arg_71924)
  let {f32 arg_71927, f32 arg_71928} = lifted_24072(one_71804, one_71805)
  let {f32 arg_71929, f32 arg_71930} = lifted_24082(arg_71927, arg_71928,
                                                    e_71883, e_71884)
  let {f32 arg_71931, f32 arg_71932} = lifted_24122(arg_71925, arg_71926,
                                                    arg_71929, arg_71930)
  let {f32 arg_71933, f32 arg_71934} = lifted_24195(arg_71931, arg_71932)
  let {f32 arg_71935, f32 arg_71936} = lifted_24202(one_71804, one_71805)
  let {f32 arg_71937, f32 arg_71938} = lifted_24209(g_71871, g_71872)
  let {f32 arg_71939, f32 arg_71940} = lifted_24219(arg_71937, arg_71938,
                                                    e_71883, e_71884)
  let {f32 arg_71941, f32 arg_71942} = lifted_24295(arg_71935, arg_71936,
                                                    arg_71939, arg_71940)
  let {f32 arg_71943, f32 arg_71944} = lifted_24335(arg_71933, arg_71934,
                                                    arg_71941, arg_71942)
  let {f32 arg_71945, f32 arg_71946} = lifted_24477(arg_71919, arg_71920,
                                                    arg_71943, arg_71944)
  let {f32 res_71947, f32 res_71948} = lifted_24517(arg_71945, arg_71946)
  in {res_71947, res_71948}
}

fun {f32, f32} lifted_24570(f32 a_71949, f32 b_71950) = {
  {a_71949, b_71950}
}

fun {f32} lifted_24580(f32 x_71951) = {
  {x_71951}
}

fun {f32} lifted_24584(f32 x_71952, f32 y_71953) = {
  let {f32 res_71954} = fsub32(x_71952, y_71953)
  in {res_71954}
}

fun {f32} lifted_24588(f32 x_71955) = {
  {x_71955}
}

fun {f32} lifted_24592(f32 x_71956, f32 y_71957) = {
  let {f32 res_71958} = fsub32(x_71956, y_71957)
  in {res_71958}
}

fun {f32, f32} lifted_24578(f32 a_71959, f32 b_71960, f32 c_71961,
                            f32 d_71962) = {
  let {f32 arg_71963} = lifted_24580(a_71959)
  let {f32 res_71964} = lifted_24584(arg_71963, c_71961)
  let {f32 arg_71965} = lifted_24588(b_71960)
  let {f32 res_71966} = lifted_24592(arg_71965, d_71962)
  in {res_71964, res_71966}
}

fun {f32, f32} lifted_24566(f32 x_71967, f32 x_71968, f32 y_71969,
                            f32 y_71970) = {
  let {f32 arg_71971, f32 arg_71972} = lifted_24570(x_71967, x_71968)
  let {f32 res_71973, f32 res_71974} = lifted_24578(arg_71971, arg_71972,
                                                    y_71969, y_71970)
  in {res_71973, res_71974}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_24640(f32 coeff1_71975, f32 coeff1_71976,
                                           f32 coeff2_71977, f32 coeff2_71978,
                                           f32 etai2_71979, f32 etai2_71980,
                                           f32 etai_71981, f32 etai_71982,
                                           f32 i_71983, f32 i_71984,
                                           f32 kappai_71985, f32 kappai_71986,
                                           f32 one_71987, f32 one_71988,
                                           f32 rho_71989, f32 two_71990,
                                           f32 two_71991, f32 zero_71992,
                                           f32 zero_71993,
                                           f32 day_count_fraction_71994) = {
  {coeff1_71975, coeff1_71976, coeff2_71977, coeff2_71978,
   day_count_fraction_71994, etai2_71979, etai2_71980, etai_71981, etai_71982,
   i_71983, i_71984, kappai_71985, kappai_71986, one_71987, one_71988,
   rho_71989, two_71990, two_71991, zero_71992, zero_71993}
}

fun {f32} lifted_24662(f32 x_71995) = {
  {x_71995}
}

fun {f32} lifted_24666(f32 x_71996, f32 y_71997) = {
  let {f32 res_71998} = fadd32(x_71996, y_71997)
  in {res_71998}
}

fun {f32} lifted_24673(i32 x_71999) = {
  let {f32 res_72000} = sitofp i32 x_71999 to f32
  in {res_72000}
}

fun {f32, f32} lifted_24671(f32 b_72001) = {
  let {f32 res_72002} = lifted_24673(0i32)
  in {res_72002, b_72001}
}

fun {f32} lifted_24724(i32 x_72003) = {
  let {f32 res_72004} = sitofp i32 x_72003 to f32
  in {res_72004}
}

fun {f32, f32} lifted_24722(f32 a_72005) = {
  let {f32 res_72006} = lifted_24724(0i32)
  in {a_72005, res_72006}
}

fun {f32, f32} lifted_24736(f32 x_72007, f32 x_72008) = {
  {x_72007, x_72008}
}

fun {f32} lifted_24743(i32 x_72009) = {
  let {f32 res_72010} = sitofp i32 x_72009 to f32
  in {res_72010}
}

fun {f32, f32} lifted_24741(f32 b_72011) = {
  let {f32 res_72012} = lifted_24743(0i32)
  in {res_72012, b_72011}
}

fun {f32, f32} lifted_24752(f32 x_72013, f32 x_72014) = {
  {x_72013, x_72014}
}

fun {f32, f32} lifted_24768(f32 a_72015, f32 b_72016) = {
  {a_72015, b_72016}
}

fun {f32} lifted_24780(f32 x_72017) = {
  {x_72017}
}

fun {f32} lifted_24784(f32 x_72018, f32 y_72019) = {
  let {f32 res_72020} = fmul32(x_72018, y_72019)
  in {res_72020}
}

fun {f32} lifted_24788(f32 x_72021) = {
  {x_72021}
}

fun {f32} lifted_24791(f32 x_72022) = {
  {x_72022}
}

fun {f32} lifted_24795(f32 x_72023, f32 y_72024) = {
  let {f32 res_72025} = fmul32(x_72023, y_72024)
  in {res_72025}
}

fun {f32} lifted_24800(f32 x_72026, f32 y_72027) = {
  let {f32 res_72028} = fsub32(x_72026, y_72027)
  in {res_72028}
}

fun {f32} lifted_24804(f32 x_72029) = {
  {x_72029}
}

fun {f32} lifted_24808(f32 x_72030, f32 y_72031) = {
  let {f32 res_72032} = fmul32(x_72030, y_72031)
  in {res_72032}
}

fun {f32} lifted_24812(f32 x_72033) = {
  {x_72033}
}

fun {f32} lifted_24815(f32 x_72034) = {
  {x_72034}
}

fun {f32} lifted_24819(f32 x_72035, f32 y_72036) = {
  let {f32 res_72037} = fmul32(x_72035, y_72036)
  in {res_72037}
}

fun {f32} lifted_24824(f32 x_72038, f32 y_72039) = {
  let {f32 res_72040} = fadd32(x_72038, y_72039)
  in {res_72040}
}

fun {f32, f32} lifted_24778(f32 a_72041, f32 b_72042, f32 c_72043,
                            f32 d_72044) = {
  let {f32 arg_72045} = lifted_24780(a_72041)
  let {f32 arg_72046} = lifted_24784(arg_72045, c_72043)
  let {f32 arg_72047} = lifted_24788(arg_72046)
  let {f32 arg_72048} = lifted_24791(b_72042)
  let {f32 arg_72049} = lifted_24795(arg_72048, d_72044)
  let {f32 res_72050} = lifted_24800(arg_72047, arg_72049)
  let {f32 arg_72051} = lifted_24804(b_72042)
  let {f32 arg_72052} = lifted_24808(arg_72051, c_72043)
  let {f32 arg_72053} = lifted_24812(arg_72052)
  let {f32 arg_72054} = lifted_24815(a_72041)
  let {f32 arg_72055} = lifted_24819(arg_72054, d_72044)
  let {f32 res_72056} = lifted_24824(arg_72053, arg_72055)
  in {res_72050, res_72056}
}

fun {f32, f32} lifted_24762(f32 x_72057, f32 x_72058, f32 y_72059,
                            f32 y_72060) = {
  let {f32 arg_72061, f32 arg_72062} = lifted_24768(x_72057, x_72058)
  let {f32 res_72063, f32 res_72064} = lifted_24778(arg_72061, arg_72062,
                                                    y_72059, y_72060)
  in {res_72063, res_72064}
}

fun {f32, f32} lifted_24835(f32 x_72065, f32 x_72066) = {
  {x_72065, x_72066}
}

fun {f32, f32} lifted_24851(f32 a_72067, f32 b_72068) = {
  {a_72067, b_72068}
}

fun {f32} lifted_24863(f32 x_72069) = {
  {x_72069}
}

fun {f32} lifted_24867(f32 x_72070, f32 y_72071) = {
  let {f32 res_72072} = fmul32(x_72070, y_72071)
  in {res_72072}
}

fun {f32} lifted_24871(f32 x_72073) = {
  {x_72073}
}

fun {f32} lifted_24874(f32 x_72074) = {
  {x_72074}
}

fun {f32} lifted_24878(f32 x_72075, f32 y_72076) = {
  let {f32 res_72077} = fmul32(x_72075, y_72076)
  in {res_72077}
}

fun {f32} lifted_24883(f32 x_72078, f32 y_72079) = {
  let {f32 res_72080} = fsub32(x_72078, y_72079)
  in {res_72080}
}

fun {f32} lifted_24887(f32 x_72081) = {
  {x_72081}
}

fun {f32} lifted_24891(f32 x_72082, f32 y_72083) = {
  let {f32 res_72084} = fmul32(x_72082, y_72083)
  in {res_72084}
}

fun {f32} lifted_24895(f32 x_72085) = {
  {x_72085}
}

fun {f32} lifted_24898(f32 x_72086) = {
  {x_72086}
}

fun {f32} lifted_24902(f32 x_72087, f32 y_72088) = {
  let {f32 res_72089} = fmul32(x_72087, y_72088)
  in {res_72089}
}

fun {f32} lifted_24907(f32 x_72090, f32 y_72091) = {
  let {f32 res_72092} = fadd32(x_72090, y_72091)
  in {res_72092}
}

fun {f32, f32} lifted_24861(f32 a_72093, f32 b_72094, f32 c_72095,
                            f32 d_72096) = {
  let {f32 arg_72097} = lifted_24863(a_72093)
  let {f32 arg_72098} = lifted_24867(arg_72097, c_72095)
  let {f32 arg_72099} = lifted_24871(arg_72098)
  let {f32 arg_72100} = lifted_24874(b_72094)
  let {f32 arg_72101} = lifted_24878(arg_72100, d_72096)
  let {f32 res_72102} = lifted_24883(arg_72099, arg_72101)
  let {f32 arg_72103} = lifted_24887(b_72094)
  let {f32 arg_72104} = lifted_24891(arg_72103, c_72095)
  let {f32 arg_72105} = lifted_24895(arg_72104)
  let {f32 arg_72106} = lifted_24898(a_72093)
  let {f32 arg_72107} = lifted_24902(arg_72106, d_72096)
  let {f32 res_72108} = lifted_24907(arg_72105, arg_72107)
  in {res_72102, res_72108}
}

fun {f32, f32} lifted_24845(f32 x_72109, f32 x_72110, f32 y_72111,
                            f32 y_72112) = {
  let {f32 arg_72113, f32 arg_72114} = lifted_24851(x_72109, x_72110)
  let {f32 res_72115, f32 res_72116} = lifted_24861(arg_72113, arg_72114,
                                                    y_72111, y_72112)
  in {res_72115, res_72116}
}

fun {f32, f32} lifted_24925(f32 a_72117, f32 b_72118) = {
  {a_72117, b_72118}
}

fun {f32} lifted_24935(f32 x_72119) = {
  {x_72119}
}

fun {f32} lifted_24939(f32 x_72120, f32 y_72121) = {
  let {f32 res_72122} = fsub32(x_72120, y_72121)
  in {res_72122}
}

fun {f32} lifted_24943(f32 x_72123) = {
  {x_72123}
}

fun {f32} lifted_24947(f32 x_72124, f32 y_72125) = {
  let {f32 res_72126} = fsub32(x_72124, y_72125)
  in {res_72126}
}

fun {f32, f32} lifted_24933(f32 a_72127, f32 b_72128, f32 c_72129,
                            f32 d_72130) = {
  let {f32 arg_72131} = lifted_24935(a_72127)
  let {f32 res_72132} = lifted_24939(arg_72131, c_72129)
  let {f32 arg_72133} = lifted_24943(b_72128)
  let {f32 res_72134} = lifted_24947(arg_72133, d_72130)
  in {res_72132, res_72134}
}

fun {f32, f32} lifted_24921(f32 x_72135, f32 x_72136, f32 y_72137,
                            f32 y_72138) = {
  let {f32 arg_72139, f32 arg_72140} = lifted_24925(x_72135, x_72136)
  let {f32 res_72141, f32 res_72142} = lifted_24933(arg_72139, arg_72140,
                                                    y_72137, y_72138)
  in {res_72141, res_72142}
}

fun {f32, f32} lifted_24961(f32 x_72143, f32 x_72144) = {
  {x_72143, x_72144}
}

fun {f32, f32} lifted_24977(f32 a_72145, f32 b_72146) = {
  {a_72145, b_72146}
}

fun {f32} lifted_24989(f32 x_72147) = {
  {x_72147}
}

fun {f32} lifted_24993(f32 x_72148, f32 y_72149) = {
  let {f32 res_72150} = fmul32(x_72148, y_72149)
  in {res_72150}
}

fun {f32} lifted_24997(f32 x_72151) = {
  {x_72151}
}

fun {f32} lifted_25000(f32 x_72152) = {
  {x_72152}
}

fun {f32} lifted_25004(f32 x_72153, f32 y_72154) = {
  let {f32 res_72155} = fmul32(x_72153, y_72154)
  in {res_72155}
}

fun {f32} lifted_25009(f32 x_72156, f32 y_72157) = {
  let {f32 res_72158} = fsub32(x_72156, y_72157)
  in {res_72158}
}

fun {f32} lifted_25013(f32 x_72159) = {
  {x_72159}
}

fun {f32} lifted_25017(f32 x_72160, f32 y_72161) = {
  let {f32 res_72162} = fmul32(x_72160, y_72161)
  in {res_72162}
}

fun {f32} lifted_25021(f32 x_72163) = {
  {x_72163}
}

fun {f32} lifted_25024(f32 x_72164) = {
  {x_72164}
}

fun {f32} lifted_25028(f32 x_72165, f32 y_72166) = {
  let {f32 res_72167} = fmul32(x_72165, y_72166)
  in {res_72167}
}

fun {f32} lifted_25033(f32 x_72168, f32 y_72169) = {
  let {f32 res_72170} = fadd32(x_72168, y_72169)
  in {res_72170}
}

fun {f32, f32} lifted_24987(f32 a_72171, f32 b_72172, f32 c_72173,
                            f32 d_72174) = {
  let {f32 arg_72175} = lifted_24989(a_72171)
  let {f32 arg_72176} = lifted_24993(arg_72175, c_72173)
  let {f32 arg_72177} = lifted_24997(arg_72176)
  let {f32 arg_72178} = lifted_25000(b_72172)
  let {f32 arg_72179} = lifted_25004(arg_72178, d_72174)
  let {f32 res_72180} = lifted_25009(arg_72177, arg_72179)
  let {f32 arg_72181} = lifted_25013(b_72172)
  let {f32 arg_72182} = lifted_25017(arg_72181, c_72173)
  let {f32 arg_72183} = lifted_25021(arg_72182)
  let {f32 arg_72184} = lifted_25024(a_72171)
  let {f32 arg_72185} = lifted_25028(arg_72184, d_72174)
  let {f32 res_72186} = lifted_25033(arg_72183, arg_72185)
  in {res_72180, res_72186}
}

fun {f32, f32} lifted_24971(f32 x_72187, f32 x_72188, f32 y_72189,
                            f32 y_72190) = {
  let {f32 arg_72191, f32 arg_72192} = lifted_24977(x_72187, x_72188)
  let {f32 res_72193, f32 res_72194} = lifted_24987(arg_72191, arg_72192,
                                                    y_72189, y_72190)
  in {res_72193, res_72194}
}

fun {f32, f32} lifted_25044(f32 x_72195, f32 x_72196) = {
  {x_72195, x_72196}
}

fun {f32, f32} lifted_25051(f32 x_72197, f32 x_72198) = {
  {x_72197, x_72198}
}

fun {f32, f32} lifted_25058(f32 x_72199, f32 x_72200) = {
  {x_72199, x_72200}
}

fun {f32, f32} lifted_25065(f32 x_72201, f32 x_72202) = {
  {x_72201, x_72202}
}

fun {f32, f32} lifted_25079(f32 a_72203, f32 b_72204) = {
  {a_72203, b_72204}
}

fun {f32} lifted_25089(f32 x_72205) = {
  {x_72205}
}

fun {f32} lifted_25093(f32 x_72206, f32 y_72207) = {
  let {f32 res_72208} = fadd32(x_72206, y_72207)
  in {res_72208}
}

fun {f32} lifted_25097(f32 x_72209) = {
  {x_72209}
}

fun {f32} lifted_25101(f32 x_72210, f32 y_72211) = {
  let {f32 res_72212} = fadd32(x_72210, y_72211)
  in {res_72212}
}

fun {f32, f32} lifted_25087(f32 a_72213, f32 b_72214, f32 c_72215,
                            f32 d_72216) = {
  let {f32 arg_72217} = lifted_25089(a_72213)
  let {f32 res_72218} = lifted_25093(arg_72217, c_72215)
  let {f32 arg_72219} = lifted_25097(b_72214)
  let {f32 res_72220} = lifted_25101(arg_72219, d_72216)
  in {res_72218, res_72220}
}

fun {f32, f32} lifted_25075(f32 x_72221, f32 x_72222, f32 y_72223,
                            f32 y_72224) = {
  let {f32 arg_72225, f32 arg_72226} = lifted_25079(x_72221, x_72222)
  let {f32 res_72227, f32 res_72228} = lifted_25087(arg_72225, arg_72226,
                                                    y_72223, y_72224)
  in {res_72227, res_72228}
}

fun {f32, f32} lifted_25121(f32 a_72229, f32 b_72230) = {
  {a_72229, b_72230}
}

fun {f32} lifted_25133(f32 x_72231) = {
  {x_72231}
}

fun {f32} lifted_25137(f32 x_72232, f32 y_72233) = {
  let {f32 res_72234} = fmul32(x_72232, y_72233)
  in {res_72234}
}

fun {f32} lifted_25141(f32 x_72235) = {
  {x_72235}
}

fun {f32} lifted_25144(f32 x_72236) = {
  {x_72236}
}

fun {f32} lifted_25148(f32 x_72237, f32 y_72238) = {
  let {f32 res_72239} = fmul32(x_72237, y_72238)
  in {res_72239}
}

fun {f32} lifted_25153(f32 x_72240, f32 y_72241) = {
  let {f32 res_72242} = fsub32(x_72240, y_72241)
  in {res_72242}
}

fun {f32} lifted_25157(f32 x_72243) = {
  {x_72243}
}

fun {f32} lifted_25161(f32 x_72244, f32 y_72245) = {
  let {f32 res_72246} = fmul32(x_72244, y_72245)
  in {res_72246}
}

fun {f32} lifted_25165(f32 x_72247) = {
  {x_72247}
}

fun {f32} lifted_25168(f32 x_72248) = {
  {x_72248}
}

fun {f32} lifted_25172(f32 x_72249, f32 y_72250) = {
  let {f32 res_72251} = fmul32(x_72249, y_72250)
  in {res_72251}
}

fun {f32} lifted_25177(f32 x_72252, f32 y_72253) = {
  let {f32 res_72254} = fadd32(x_72252, y_72253)
  in {res_72254}
}

fun {f32, f32} lifted_25131(f32 a_72255, f32 b_72256, f32 c_72257,
                            f32 d_72258) = {
  let {f32 arg_72259} = lifted_25133(a_72255)
  let {f32 arg_72260} = lifted_25137(arg_72259, c_72257)
  let {f32 arg_72261} = lifted_25141(arg_72260)
  let {f32 arg_72262} = lifted_25144(b_72256)
  let {f32 arg_72263} = lifted_25148(arg_72262, d_72258)
  let {f32 res_72264} = lifted_25153(arg_72261, arg_72263)
  let {f32 arg_72265} = lifted_25157(b_72256)
  let {f32 arg_72266} = lifted_25161(arg_72265, c_72257)
  let {f32 arg_72267} = lifted_25165(arg_72266)
  let {f32 arg_72268} = lifted_25168(a_72255)
  let {f32 arg_72269} = lifted_25172(arg_72268, d_72258)
  let {f32 res_72270} = lifted_25177(arg_72267, arg_72269)
  in {res_72264, res_72270}
}

fun {f32, f32} lifted_25115(f32 x_72271, f32 x_72272, f32 y_72273,
                            f32 y_72274) = {
  let {f32 arg_72275, f32 arg_72276} = lifted_25121(x_72271, x_72272)
  let {f32 res_72277, f32 res_72278} = lifted_25131(arg_72275, arg_72276,
                                                    y_72273, y_72274)
  in {res_72277, res_72278}
}

fun {f32, f32} lifted_25197(f32 a_72279, f32 b_72280) = {
  {a_72279, b_72280}
}

fun {f32} lifted_25209(f32 x_72281) = {
  {x_72281}
}

fun {f32} lifted_25213(f32 x_72282, f32 y_72283) = {
  let {f32 res_72284} = fmul32(x_72282, y_72283)
  in {res_72284}
}

fun {f32} lifted_25217(f32 x_72285) = {
  {x_72285}
}

fun {f32} lifted_25220(f32 x_72286) = {
  {x_72286}
}

fun {f32} lifted_25224(f32 x_72287, f32 y_72288) = {
  let {f32 res_72289} = fmul32(x_72287, y_72288)
  in {res_72289}
}

fun {f32} lifted_25229(f32 x_72290, f32 y_72291) = {
  let {f32 res_72292} = fsub32(x_72290, y_72291)
  in {res_72292}
}

fun {f32} lifted_25233(f32 x_72293) = {
  {x_72293}
}

fun {f32} lifted_25237(f32 x_72294, f32 y_72295) = {
  let {f32 res_72296} = fmul32(x_72294, y_72295)
  in {res_72296}
}

fun {f32} lifted_25241(f32 x_72297) = {
  {x_72297}
}

fun {f32} lifted_25244(f32 x_72298) = {
  {x_72298}
}

fun {f32} lifted_25248(f32 x_72299, f32 y_72300) = {
  let {f32 res_72301} = fmul32(x_72299, y_72300)
  in {res_72301}
}

fun {f32} lifted_25253(f32 x_72302, f32 y_72303) = {
  let {f32 res_72304} = fadd32(x_72302, y_72303)
  in {res_72304}
}

fun {f32, f32} lifted_25207(f32 a_72305, f32 b_72306, f32 c_72307,
                            f32 d_72308) = {
  let {f32 arg_72309} = lifted_25209(a_72305)
  let {f32 arg_72310} = lifted_25213(arg_72309, c_72307)
  let {f32 arg_72311} = lifted_25217(arg_72310)
  let {f32 arg_72312} = lifted_25220(b_72306)
  let {f32 arg_72313} = lifted_25224(arg_72312, d_72308)
  let {f32 res_72314} = lifted_25229(arg_72311, arg_72313)
  let {f32 arg_72315} = lifted_25233(b_72306)
  let {f32 arg_72316} = lifted_25237(arg_72315, c_72307)
  let {f32 arg_72317} = lifted_25241(arg_72316)
  let {f32 arg_72318} = lifted_25244(a_72305)
  let {f32 arg_72319} = lifted_25248(arg_72318, d_72308)
  let {f32 res_72320} = lifted_25253(arg_72317, arg_72319)
  in {res_72314, res_72320}
}

fun {f32, f32} lifted_25191(f32 x_72321, f32 x_72322, f32 y_72323,
                            f32 y_72324) = {
  let {f32 arg_72325, f32 arg_72326} = lifted_25197(x_72321, x_72322)
  let {f32 res_72327, f32 res_72328} = lifted_25207(arg_72325, arg_72326,
                                                    y_72323, y_72324)
  in {res_72327, res_72328}
}

fun {f32, f32} lifted_25271(f32 a_72329, f32 b_72330) = {
  {a_72329, b_72330}
}

fun {f32} lifted_25281(f32 x_72331) = {
  {x_72331}
}

fun {f32} lifted_25285(f32 x_72332, f32 y_72333) = {
  let {f32 res_72334} = fadd32(x_72332, y_72333)
  in {res_72334}
}

fun {f32} lifted_25289(f32 x_72335) = {
  {x_72335}
}

fun {f32} lifted_25293(f32 x_72336, f32 y_72337) = {
  let {f32 res_72338} = fadd32(x_72336, y_72337)
  in {res_72338}
}

fun {f32, f32} lifted_25279(f32 a_72339, f32 b_72340, f32 c_72341,
                            f32 d_72342) = {
  let {f32 arg_72343} = lifted_25281(a_72339)
  let {f32 res_72344} = lifted_25285(arg_72343, c_72341)
  let {f32 arg_72345} = lifted_25289(b_72340)
  let {f32 res_72346} = lifted_25293(arg_72345, d_72342)
  in {res_72344, res_72346}
}

fun {f32, f32} lifted_25267(f32 x_72347, f32 x_72348, f32 y_72349,
                            f32 y_72350) = {
  let {f32 arg_72351, f32 arg_72352} = lifted_25271(x_72347, x_72348)
  let {f32 res_72353, f32 res_72354} = lifted_25279(arg_72351, arg_72352,
                                                    y_72349, y_72350)
  in {res_72353, res_72354}
}

fun {f32} lifted_25312(f32 x_72355) = {
  {x_72355}
}

fun {f32} lifted_25315(f32 x_72356) = {
  {x_72356}
}

fun {f32} lifted_25319(f32 x_72357, f32 y_72358) = {
  let {f32 res_72359} = fmul32(x_72357, y_72358)
  in {res_72359}
}

fun {f32} lifted_25323(f32 x_72360) = {
  {x_72360}
}

fun {f32} lifted_25326(f32 x_72361) = {
  {x_72361}
}

fun {f32} lifted_25330(f32 x_72362, f32 y_72363) = {
  let {f32 res_72364} = fmul32(x_72362, y_72363)
  in {res_72364}
}

fun {f32} lifted_25335(f32 x_72365, f32 y_72366) = {
  let {f32 res_72367} = fadd32(x_72365, y_72366)
  in {res_72367}
}

fun {f32} lifted_25339(f32 x_72368) = {
  let {f32 res_72369} = sqrt32(x_72368)
  in {res_72369}
}

fun {f32} lifted_25344(f32 x_72370, f32 y_72371) = {
  let {f32 res_72372} = fadd32(x_72370, y_72371)
  in {res_72372}
}

fun {f32} lifted_25348(f32 x_72373) = {
  {x_72373}
}

fun {f32} lifted_25351(i32 x_72374) = {
  let {f32 res_72375} = sitofp i32 x_72374 to f32
  in {res_72375}
}

fun {f32} lifted_25356(f32 x_72376, f32 y_72377) = {
  let {f32 res_72378} = fdiv32(x_72376, y_72377)
  in {res_72378}
}

fun {f32} lifted_25360(f32 x_72379) = {
  let {f32 res_72380} = sqrt32(x_72379)
  in {res_72380}
}

fun {f32} lifted_25369(f32 x_72381) = {
  {x_72381}
}

fun {bool} lifted_25373(f32 x_72382, f32 y_72383) = {
  let {bool res_72384} = lt32(x_72382, y_72383)
  in {res_72384}
}

fun {f32} lifted_25378(f32 x_72385) = {
  {x_72385}
}

fun {bool} lifted_25382(f32 x_72386, f32 y_72387) = {
  let {bool res_72388} = eq_f32(x_72386, y_72387)
  in {res_72388}
}

fun {f32} lifted_25367(f32 x_72389) = {
  let {f32 arg_72390} = lifted_25369(x_72389)
  let {bool cond_72391} = lifted_25373(arg_72390, 0.0f32)
  let {f32 res_72392} =
    -- Branch returns: {f32}
    if cond_72391
    then {
      let {f32 res_72393} = fsub32(0.0f32, 1.0f32)
      in {res_72393}
    } else {
      let {f32 arg_72394} = lifted_25378(x_72389)
      let {bool cond_72395} = lifted_25382(arg_72394, 0.0f32)
      let {f32 res_72396} =
        -- Branch returns: {f32}
        if cond_72395
        then {0.0f32} else {1.0f32}
      in {res_72396}
    }
  in {res_72392}
}

fun {i32} lifted_25389(f32 x_72397) = {
  let {i32 res_72398} = fptosi f32 x_72397 to i32
  in {res_72398}
}

fun {f32} lifted_25393(i32 x_72399) = {
  let {f32 res_72400} = sitofp i32 x_72399 to f32
  in {res_72400}
}

fun {f32} lifted_25397(f32 x_72401) = {
  {x_72401}
}

fun {f32} lifted_25400(i32 x_72402) = {
  let {f32 res_72403} = sitofp i32 x_72402 to f32
  in {res_72403}
}

fun {f32} lifted_25404(f32 x_72404) = {
  {x_72404}
}

fun {f32} lifted_25408(f32 x_72405, f32 y_72406) = {
  let {f32 res_72407} = fsub32(x_72405, y_72406)
  in {res_72407}
}

fun {f32} lifted_25412(f32 x_72408) = {
  {x_72408}
}

fun {f32} lifted_25415(f32 x_72409) = {
  {x_72409}
}

fun {f32} lifted_25419(f32 x_72410, f32 y_72411) = {
  let {f32 res_72412} = fmul32(x_72410, y_72411)
  in {res_72412}
}

fun {f32} lifted_25423(f32 x_72413) = {
  {x_72413}
}

fun {f32} lifted_25426(f32 x_72414) = {
  {x_72414}
}

fun {f32} lifted_25430(f32 x_72415, f32 y_72416) = {
  let {f32 res_72417} = fmul32(x_72415, y_72416)
  in {res_72417}
}

fun {f32} lifted_25435(f32 x_72418, f32 y_72419) = {
  let {f32 res_72420} = fadd32(x_72418, y_72419)
  in {res_72420}
}

fun {f32} lifted_25439(f32 x_72421) = {
  let {f32 res_72422} = sqrt32(x_72421)
  in {res_72422}
}

fun {f32} lifted_25444(f32 x_72423, f32 y_72424) = {
  let {f32 res_72425} = fadd32(x_72423, y_72424)
  in {res_72425}
}

fun {f32} lifted_25448(f32 x_72426) = {
  {x_72426}
}

fun {f32} lifted_25451(i32 x_72427) = {
  let {f32 res_72428} = sitofp i32 x_72427 to f32
  in {res_72428}
}

fun {f32} lifted_25456(f32 x_72429, f32 y_72430) = {
  let {f32 res_72431} = fdiv32(x_72429, y_72430)
  in {res_72431}
}

fun {f32} lifted_25460(f32 x_72432) = {
  let {f32 res_72433} = sqrt32(x_72432)
  in {res_72433}
}

fun {f32} lifted_25465(f32 x_72434, f32 y_72435) = {
  let {f32 res_72436} = fmul32(x_72434, y_72435)
  in {res_72436}
}

fun {f32, f32} lifted_25310(f32 a_72437, f32 b_72438) = {
  let {f32 arg_72439} = lifted_25312(a_72437)
  let {f32 arg_72440} = lifted_25315(a_72437)
  let {f32 arg_72441} = lifted_25319(arg_72440, a_72437)
  let {f32 arg_72442} = lifted_25323(arg_72441)
  let {f32 arg_72443} = lifted_25326(b_72438)
  let {f32 arg_72444} = lifted_25330(arg_72443, b_72438)
  let {f32 arg_72445} = lifted_25335(arg_72442, arg_72444)
  let {f32 arg_72446} = lifted_25339(arg_72445)
  let {f32 arg_72447} = lifted_25344(arg_72439, arg_72446)
  let {f32 arg_72448} = lifted_25348(arg_72447)
  let {f32 arg_72449} = lifted_25351(2i32)
  let {f32 arg_72450} = lifted_25356(arg_72448, arg_72449)
  let {f32 res_72451} = lifted_25360(arg_72450)
  let {f32 gamma_72452} = res_72451
  let {f32 arg_72453} = lifted_25367(b_72438)
  let {i32 arg_72454} = lifted_25389(arg_72453)
  let {f32 arg_72455} = lifted_25393(arg_72454)
  let {f32 arg_72456} = lifted_25397(arg_72455)
  let {f32 arg_72457} = lifted_25400(0i32)
  let {f32 arg_72458} = lifted_25404(arg_72457)
  let {f32 arg_72459} = lifted_25408(arg_72458, a_72437)
  let {f32 arg_72460} = lifted_25412(arg_72459)
  let {f32 arg_72461} = lifted_25415(a_72437)
  let {f32 arg_72462} = lifted_25419(arg_72461, a_72437)
  let {f32 arg_72463} = lifted_25423(arg_72462)
  let {f32 arg_72464} = lifted_25426(b_72438)
  let {f32 arg_72465} = lifted_25430(arg_72464, b_72438)
  let {f32 arg_72466} = lifted_25435(arg_72463, arg_72465)
  let {f32 arg_72467} = lifted_25439(arg_72466)
  let {f32 arg_72468} = lifted_25444(arg_72460, arg_72467)
  let {f32 arg_72469} = lifted_25448(arg_72468)
  let {f32 arg_72470} = lifted_25451(2i32)
  let {f32 arg_72471} = lifted_25456(arg_72469, arg_72470)
  let {f32 arg_72472} = lifted_25460(arg_72471)
  let {f32 res_72473} = lifted_25465(arg_72456, arg_72472)
  let {f32 delta_72474} = res_72473
  in {gamma_72452, delta_72474}
}

fun {f32, f32} lifted_25478(f32 x_72475, f32 x_72476) = {
  {x_72475, x_72476}
}

fun {f32, f32} lifted_25492(f32 a_72477, f32 b_72478) = {
  {a_72477, b_72478}
}

fun {f32} lifted_25502(f32 x_72479) = {
  {x_72479}
}

fun {f32} lifted_25506(f32 x_72480, f32 y_72481) = {
  let {f32 res_72482} = fsub32(x_72480, y_72481)
  in {res_72482}
}

fun {f32} lifted_25510(f32 x_72483) = {
  {x_72483}
}

fun {f32} lifted_25514(f32 x_72484, f32 y_72485) = {
  let {f32 res_72486} = fsub32(x_72484, y_72485)
  in {res_72486}
}

fun {f32, f32} lifted_25500(f32 a_72487, f32 b_72488, f32 c_72489,
                            f32 d_72490) = {
  let {f32 arg_72491} = lifted_25502(a_72487)
  let {f32 res_72492} = lifted_25506(arg_72491, c_72489)
  let {f32 arg_72493} = lifted_25510(b_72488)
  let {f32 res_72494} = lifted_25514(arg_72493, d_72490)
  in {res_72492, res_72494}
}

fun {f32, f32} lifted_25488(f32 x_72495, f32 x_72496, f32 y_72497,
                            f32 y_72498) = {
  let {f32 arg_72499, f32 arg_72500} = lifted_25492(x_72495, x_72496)
  let {f32 res_72501, f32 res_72502} = lifted_25500(arg_72499, arg_72500,
                                                    y_72497, y_72498)
  in {res_72501, res_72502}
}

fun {f32, f32} lifted_25528(f32 x_72503, f32 x_72504) = {
  {x_72503, x_72504}
}

fun {f32, f32} lifted_25535(f32 x_72505, f32 x_72506) = {
  {x_72505, x_72506}
}

fun {f32, f32} lifted_25549(f32 a_72507, f32 b_72508) = {
  {a_72507, b_72508}
}

fun {f32} lifted_25559(f32 x_72509) = {
  {x_72509}
}

fun {f32} lifted_25563(f32 x_72510, f32 y_72511) = {
  let {f32 res_72512} = fadd32(x_72510, y_72511)
  in {res_72512}
}

fun {f32} lifted_25567(f32 x_72513) = {
  {x_72513}
}

fun {f32} lifted_25571(f32 x_72514, f32 y_72515) = {
  let {f32 res_72516} = fadd32(x_72514, y_72515)
  in {res_72516}
}

fun {f32, f32} lifted_25557(f32 a_72517, f32 b_72518, f32 c_72519,
                            f32 d_72520) = {
  let {f32 arg_72521} = lifted_25559(a_72517)
  let {f32 res_72522} = lifted_25563(arg_72521, c_72519)
  let {f32 arg_72523} = lifted_25567(b_72518)
  let {f32 res_72524} = lifted_25571(arg_72523, d_72520)
  in {res_72522, res_72524}
}

fun {f32, f32} lifted_25545(f32 x_72525, f32 x_72526, f32 y_72527,
                            f32 y_72528) = {
  let {f32 arg_72529, f32 arg_72530} = lifted_25549(x_72525, x_72526)
  let {f32 res_72531, f32 res_72532} = lifted_25557(arg_72529, arg_72530,
                                                    y_72527, y_72528)
  in {res_72531, res_72532}
}

fun {f32, f32} lifted_25592(f32 a_72533, f32 b_72534) = {
  {a_72533, b_72534}
}

fun {f32} lifted_25605(f32 x_72535) = {
  {x_72535}
}

fun {f32} lifted_25609(f32 x_72536, f32 y_72537) = {
  let {f32 res_72538} = fmul32(x_72536, y_72537)
  in {res_72538}
}

fun {f32} lifted_25613(f32 x_72539) = {
  {x_72539}
}

fun {f32} lifted_25616(f32 x_72540) = {
  {x_72540}
}

fun {f32} lifted_25620(f32 x_72541, f32 y_72542) = {
  let {f32 res_72543} = fmul32(x_72541, y_72542)
  in {res_72543}
}

fun {f32} lifted_25625(f32 x_72544, f32 y_72545) = {
  let {f32 res_72546} = fadd32(x_72544, y_72545)
  in {res_72546}
}

fun {f32} lifted_25629(f32 x_72547) = {
  {x_72547}
}

fun {f32} lifted_25632(f32 x_72548) = {
  {x_72548}
}

fun {f32} lifted_25636(f32 x_72549, f32 y_72550) = {
  let {f32 res_72551} = fmul32(x_72549, y_72550)
  in {res_72551}
}

fun {f32} lifted_25640(f32 x_72552) = {
  {x_72552}
}

fun {f32} lifted_25643(f32 x_72553) = {
  {x_72553}
}

fun {f32} lifted_25647(f32 x_72554, f32 y_72555) = {
  let {f32 res_72556} = fmul32(x_72554, y_72555)
  in {res_72556}
}

fun {f32} lifted_25652(f32 x_72557, f32 y_72558) = {
  let {f32 res_72559} = fadd32(x_72557, y_72558)
  in {res_72559}
}

fun {f32} lifted_25657(f32 x_72560, f32 y_72561) = {
  let {f32 res_72562} = fdiv32(x_72560, y_72561)
  in {res_72562}
}

fun {f32} lifted_25661(f32 x_72563) = {
  {x_72563}
}

fun {f32} lifted_25665(f32 x_72564, f32 y_72565) = {
  let {f32 res_72566} = fmul32(x_72564, y_72565)
  in {res_72566}
}

fun {f32} lifted_25669(f32 x_72567) = {
  {x_72567}
}

fun {f32} lifted_25672(f32 x_72568) = {
  {x_72568}
}

fun {f32} lifted_25676(f32 x_72569, f32 y_72570) = {
  let {f32 res_72571} = fmul32(x_72569, y_72570)
  in {res_72571}
}

fun {f32} lifted_25681(f32 x_72572, f32 y_72573) = {
  let {f32 res_72574} = fsub32(x_72572, y_72573)
  in {res_72574}
}

fun {f32} lifted_25685(f32 x_72575) = {
  {x_72575}
}

fun {f32} lifted_25688(f32 x_72576) = {
  {x_72576}
}

fun {f32} lifted_25692(f32 x_72577, f32 y_72578) = {
  let {f32 res_72579} = fmul32(x_72577, y_72578)
  in {res_72579}
}

fun {f32} lifted_25696(f32 x_72580) = {
  {x_72580}
}

fun {f32} lifted_25699(f32 x_72581) = {
  {x_72581}
}

fun {f32} lifted_25703(f32 x_72582, f32 y_72583) = {
  let {f32 res_72584} = fmul32(x_72582, y_72583)
  in {res_72584}
}

fun {f32} lifted_25708(f32 x_72585, f32 y_72586) = {
  let {f32 res_72587} = fadd32(x_72585, y_72586)
  in {res_72587}
}

fun {f32} lifted_25713(f32 x_72588, f32 y_72589) = {
  let {f32 res_72590} = fdiv32(x_72588, y_72589)
  in {res_72590}
}

fun {f32, f32} lifted_25603(f32 a_72591, f32 b_72592, f32 c_72593,
                            f32 d_72594) = {
  let {f32 arg_72595} = lifted_25605(a_72591)
  let {f32 arg_72596} = lifted_25609(arg_72595, c_72593)
  let {f32 arg_72597} = lifted_25613(arg_72596)
  let {f32 arg_72598} = lifted_25616(b_72592)
  let {f32 arg_72599} = lifted_25620(arg_72598, d_72594)
  let {f32 arg_72600} = lifted_25625(arg_72597, arg_72599)
  let {f32 arg_72601} = lifted_25629(arg_72600)
  let {f32 arg_72602} = lifted_25632(c_72593)
  let {f32 arg_72603} = lifted_25636(arg_72602, c_72593)
  let {f32 arg_72604} = lifted_25640(arg_72603)
  let {f32 arg_72605} = lifted_25643(d_72594)
  let {f32 arg_72606} = lifted_25647(arg_72605, d_72594)
  let {f32 arg_72607} = lifted_25652(arg_72604, arg_72606)
  let {f32 res_72608} = lifted_25657(arg_72601, arg_72607)
  let {f32 arg_72609} = lifted_25661(b_72592)
  let {f32 arg_72610} = lifted_25665(arg_72609, c_72593)
  let {f32 arg_72611} = lifted_25669(arg_72610)
  let {f32 arg_72612} = lifted_25672(a_72591)
  let {f32 arg_72613} = lifted_25676(arg_72612, d_72594)
  let {f32 arg_72614} = lifted_25681(arg_72611, arg_72613)
  let {f32 arg_72615} = lifted_25685(arg_72614)
  let {f32 arg_72616} = lifted_25688(c_72593)
  let {f32 arg_72617} = lifted_25692(arg_72616, c_72593)
  let {f32 arg_72618} = lifted_25696(arg_72617)
  let {f32 arg_72619} = lifted_25699(d_72594)
  let {f32 arg_72620} = lifted_25703(arg_72619, d_72594)
  let {f32 arg_72621} = lifted_25708(arg_72618, arg_72620)
  let {f32 res_72622} = lifted_25713(arg_72615, arg_72621)
  in {res_72608, res_72622}
}

fun {f32, f32} lifted_25585(f32 x_72623, f32 x_72624, f32 y_72625,
                            f32 y_72626) = {
  let {f32 arg_72627, f32 arg_72628} = lifted_25592(x_72623, x_72624)
  let {f32 res_72629, f32 res_72630} = lifted_25603(arg_72627, arg_72628,
                                                    y_72625, y_72626)
  in {res_72629, res_72630}
}

fun {f32, f32} lifted_25727(f32 x_72631, f32 x_72632) = {
  {x_72631, x_72632}
}

fun {f32, f32} lifted_25734(f32 x_72633, f32 x_72634) = {
  {x_72633, x_72634}
}

fun {f32, f32} lifted_25750(f32 a_72635, f32 b_72636) = {
  {a_72635, b_72636}
}

fun {f32} lifted_25762(f32 x_72637) = {
  {x_72637}
}

fun {f32} lifted_25766(f32 x_72638, f32 y_72639) = {
  let {f32 res_72640} = fmul32(x_72638, y_72639)
  in {res_72640}
}

fun {f32} lifted_25770(f32 x_72641) = {
  {x_72641}
}

fun {f32} lifted_25773(f32 x_72642) = {
  {x_72642}
}

fun {f32} lifted_25777(f32 x_72643, f32 y_72644) = {
  let {f32 res_72645} = fmul32(x_72643, y_72644)
  in {res_72645}
}

fun {f32} lifted_25782(f32 x_72646, f32 y_72647) = {
  let {f32 res_72648} = fsub32(x_72646, y_72647)
  in {res_72648}
}

fun {f32} lifted_25786(f32 x_72649) = {
  {x_72649}
}

fun {f32} lifted_25790(f32 x_72650, f32 y_72651) = {
  let {f32 res_72652} = fmul32(x_72650, y_72651)
  in {res_72652}
}

fun {f32} lifted_25794(f32 x_72653) = {
  {x_72653}
}

fun {f32} lifted_25797(f32 x_72654) = {
  {x_72654}
}

fun {f32} lifted_25801(f32 x_72655, f32 y_72656) = {
  let {f32 res_72657} = fmul32(x_72655, y_72656)
  in {res_72657}
}

fun {f32} lifted_25806(f32 x_72658, f32 y_72659) = {
  let {f32 res_72660} = fadd32(x_72658, y_72659)
  in {res_72660}
}

fun {f32, f32} lifted_25760(f32 a_72661, f32 b_72662, f32 c_72663,
                            f32 d_72664) = {
  let {f32 arg_72665} = lifted_25762(a_72661)
  let {f32 arg_72666} = lifted_25766(arg_72665, c_72663)
  let {f32 arg_72667} = lifted_25770(arg_72666)
  let {f32 arg_72668} = lifted_25773(b_72662)
  let {f32 arg_72669} = lifted_25777(arg_72668, d_72664)
  let {f32 res_72670} = lifted_25782(arg_72667, arg_72669)
  let {f32 arg_72671} = lifted_25786(b_72662)
  let {f32 arg_72672} = lifted_25790(arg_72671, c_72663)
  let {f32 arg_72673} = lifted_25794(arg_72672)
  let {f32 arg_72674} = lifted_25797(a_72661)
  let {f32 arg_72675} = lifted_25801(arg_72674, d_72664)
  let {f32 res_72676} = lifted_25806(arg_72673, arg_72675)
  in {res_72670, res_72676}
}

fun {f32, f32} lifted_25744(f32 x_72677, f32 x_72678, f32 y_72679,
                            f32 y_72680) = {
  let {f32 arg_72681, f32 arg_72682} = lifted_25750(x_72677, x_72678)
  let {f32 res_72683, f32 res_72684} = lifted_25760(arg_72681, arg_72682,
                                                    y_72679, y_72680)
  in {res_72683, res_72684}
}

fun {f32, f32} lifted_25824(f32 a_72685, f32 b_72686) = {
  {a_72685, b_72686}
}

fun {f32} lifted_25834(f32 x_72687) = {
  {x_72687}
}

fun {f32} lifted_25838(f32 x_72688, f32 y_72689) = {
  let {f32 res_72690} = fsub32(x_72688, y_72689)
  in {res_72690}
}

fun {f32} lifted_25842(f32 x_72691) = {
  {x_72691}
}

fun {f32} lifted_25846(f32 x_72692, f32 y_72693) = {
  let {f32 res_72694} = fsub32(x_72692, y_72693)
  in {res_72694}
}

fun {f32, f32} lifted_25832(f32 a_72695, f32 b_72696, f32 c_72697,
                            f32 d_72698) = {
  let {f32 arg_72699} = lifted_25834(a_72695)
  let {f32 res_72700} = lifted_25838(arg_72699, c_72697)
  let {f32 arg_72701} = lifted_25842(b_72696)
  let {f32 res_72702} = lifted_25846(arg_72701, d_72698)
  in {res_72700, res_72702}
}

fun {f32, f32} lifted_25820(f32 x_72703, f32 x_72704, f32 y_72705,
                            f32 y_72706) = {
  let {f32 arg_72707, f32 arg_72708} = lifted_25824(x_72703, x_72704)
  let {f32 res_72709, f32 res_72710} = lifted_25832(arg_72707, arg_72708,
                                                    y_72705, y_72706)
  in {res_72709, res_72710}
}

fun {f32} lifted_25862(f32 x_72711) = {
  let {f32 res_72712} = exp32(x_72711)
  in {res_72712}
}

fun {f32} lifted_25867(f32 x_72713) = {
  {x_72713}
}

fun {f32} lifted_25870(f32 x_72714) = {
  let {f32 res_72715} = cos32(x_72714)
  in {res_72715}
}

fun {f32} lifted_25875(f32 x_72716, f32 y_72717) = {
  let {f32 res_72718} = fmul32(x_72716, y_72717)
  in {res_72718}
}

fun {f32} lifted_25879(f32 a_72719) = {
  {a_72719}
}

fun {f32} lifted_25882(f32 x_72720) = {
  {x_72720}
}

fun {f32} lifted_25885(f32 x_72721) = {
  let {f32 res_72722} = sin32(x_72721)
  in {res_72722}
}

fun {f32} lifted_25890(f32 x_72723, f32 y_72724) = {
  let {f32 res_72725} = fmul32(x_72723, y_72724)
  in {res_72725}
}

fun {f32, f32} lifted_25895(f32 a_72726, f32 b_72727) = {
  {a_72726, b_72727}
}

fun {f32, f32} lifted_25860(f32 a_72728, f32 b_72729) = {
  let {f32 res_72730} = lifted_25862(a_72728)
  let {f32 expx_72731} = res_72730
  let {f32 arg_72732} = lifted_25867(expx_72731)
  let {f32 arg_72733} = lifted_25870(b_72729)
  let {f32 arg_72734} = lifted_25875(arg_72732, arg_72733)
  let {f32 arg_72735} = lifted_25879(arg_72734)
  let {f32 arg_72736} = lifted_25882(expx_72731)
  let {f32 arg_72737} = lifted_25885(b_72729)
  let {f32 arg_72738} = lifted_25890(arg_72736, arg_72737)
  let {f32 res_72739, f32 res_72740} = lifted_25895(arg_72735, arg_72738)
  in {res_72739, res_72740}
}

fun {f32, f32} lifted_25907(f32 x_72741, f32 x_72742) = {
  {x_72741, x_72742}
}

fun {f32, f32} lifted_25914(f32 x_72743, f32 x_72744) = {
  {x_72743, x_72744}
}

fun {f32, f32} lifted_25930(f32 a_72745, f32 b_72746) = {
  {a_72745, b_72746}
}

fun {f32} lifted_25942(f32 x_72747) = {
  {x_72747}
}

fun {f32} lifted_25946(f32 x_72748, f32 y_72749) = {
  let {f32 res_72750} = fmul32(x_72748, y_72749)
  in {res_72750}
}

fun {f32} lifted_25950(f32 x_72751) = {
  {x_72751}
}

fun {f32} lifted_25953(f32 x_72752) = {
  {x_72752}
}

fun {f32} lifted_25957(f32 x_72753, f32 y_72754) = {
  let {f32 res_72755} = fmul32(x_72753, y_72754)
  in {res_72755}
}

fun {f32} lifted_25962(f32 x_72756, f32 y_72757) = {
  let {f32 res_72758} = fsub32(x_72756, y_72757)
  in {res_72758}
}

fun {f32} lifted_25966(f32 x_72759) = {
  {x_72759}
}

fun {f32} lifted_25970(f32 x_72760, f32 y_72761) = {
  let {f32 res_72762} = fmul32(x_72760, y_72761)
  in {res_72762}
}

fun {f32} lifted_25974(f32 x_72763) = {
  {x_72763}
}

fun {f32} lifted_25977(f32 x_72764) = {
  {x_72764}
}

fun {f32} lifted_25981(f32 x_72765, f32 y_72766) = {
  let {f32 res_72767} = fmul32(x_72765, y_72766)
  in {res_72767}
}

fun {f32} lifted_25986(f32 x_72768, f32 y_72769) = {
  let {f32 res_72770} = fadd32(x_72768, y_72769)
  in {res_72770}
}

fun {f32, f32} lifted_25940(f32 a_72771, f32 b_72772, f32 c_72773,
                            f32 d_72774) = {
  let {f32 arg_72775} = lifted_25942(a_72771)
  let {f32 arg_72776} = lifted_25946(arg_72775, c_72773)
  let {f32 arg_72777} = lifted_25950(arg_72776)
  let {f32 arg_72778} = lifted_25953(b_72772)
  let {f32 arg_72779} = lifted_25957(arg_72778, d_72774)
  let {f32 res_72780} = lifted_25962(arg_72777, arg_72779)
  let {f32 arg_72781} = lifted_25966(b_72772)
  let {f32 arg_72782} = lifted_25970(arg_72781, c_72773)
  let {f32 arg_72783} = lifted_25974(arg_72782)
  let {f32 arg_72784} = lifted_25977(a_72771)
  let {f32 arg_72785} = lifted_25981(arg_72784, d_72774)
  let {f32 res_72786} = lifted_25986(arg_72783, arg_72785)
  in {res_72780, res_72786}
}

fun {f32, f32} lifted_25924(f32 x_72787, f32 x_72788, f32 y_72789,
                            f32 y_72790) = {
  let {f32 arg_72791, f32 arg_72792} = lifted_25930(x_72787, x_72788)
  let {f32 res_72793, f32 res_72794} = lifted_25940(arg_72791, arg_72792,
                                                    y_72789, y_72790)
  in {res_72793, res_72794}
}

fun {f32, f32} lifted_25997(f32 x_72795, f32 x_72796) = {
  {x_72795, x_72796}
}

fun {f32, f32} lifted_26004(f32 x_72797, f32 x_72798) = {
  {x_72797, x_72798}
}

fun {f32, f32} lifted_26011(f32 x_72799, f32 x_72800) = {
  {x_72799, x_72800}
}

fun {f32, f32} lifted_26018(f32 x_72801, f32 x_72802) = {
  {x_72801, x_72802}
}

fun {f32, f32} lifted_26034(f32 a_72803, f32 b_72804) = {
  {a_72803, b_72804}
}

fun {f32} lifted_26046(f32 x_72805) = {
  {x_72805}
}

fun {f32} lifted_26050(f32 x_72806, f32 y_72807) = {
  let {f32 res_72808} = fmul32(x_72806, y_72807)
  in {res_72808}
}

fun {f32} lifted_26054(f32 x_72809) = {
  {x_72809}
}

fun {f32} lifted_26057(f32 x_72810) = {
  {x_72810}
}

fun {f32} lifted_26061(f32 x_72811, f32 y_72812) = {
  let {f32 res_72813} = fmul32(x_72811, y_72812)
  in {res_72813}
}

fun {f32} lifted_26066(f32 x_72814, f32 y_72815) = {
  let {f32 res_72816} = fsub32(x_72814, y_72815)
  in {res_72816}
}

fun {f32} lifted_26070(f32 x_72817) = {
  {x_72817}
}

fun {f32} lifted_26074(f32 x_72818, f32 y_72819) = {
  let {f32 res_72820} = fmul32(x_72818, y_72819)
  in {res_72820}
}

fun {f32} lifted_26078(f32 x_72821) = {
  {x_72821}
}

fun {f32} lifted_26081(f32 x_72822) = {
  {x_72822}
}

fun {f32} lifted_26085(f32 x_72823, f32 y_72824) = {
  let {f32 res_72825} = fmul32(x_72823, y_72824)
  in {res_72825}
}

fun {f32} lifted_26090(f32 x_72826, f32 y_72827) = {
  let {f32 res_72828} = fadd32(x_72826, y_72827)
  in {res_72828}
}

fun {f32, f32} lifted_26044(f32 a_72829, f32 b_72830, f32 c_72831,
                            f32 d_72832) = {
  let {f32 arg_72833} = lifted_26046(a_72829)
  let {f32 arg_72834} = lifted_26050(arg_72833, c_72831)
  let {f32 arg_72835} = lifted_26054(arg_72834)
  let {f32 arg_72836} = lifted_26057(b_72830)
  let {f32 arg_72837} = lifted_26061(arg_72836, d_72832)
  let {f32 res_72838} = lifted_26066(arg_72835, arg_72837)
  let {f32 arg_72839} = lifted_26070(b_72830)
  let {f32 arg_72840} = lifted_26074(arg_72839, c_72831)
  let {f32 arg_72841} = lifted_26078(arg_72840)
  let {f32 arg_72842} = lifted_26081(a_72829)
  let {f32 arg_72843} = lifted_26085(arg_72842, d_72832)
  let {f32 res_72844} = lifted_26090(arg_72841, arg_72843)
  in {res_72838, res_72844}
}

fun {f32, f32} lifted_26028(f32 x_72845, f32 x_72846, f32 y_72847,
                            f32 y_72848) = {
  let {f32 arg_72849, f32 arg_72850} = lifted_26034(x_72845, x_72846)
  let {f32 res_72851, f32 res_72852} = lifted_26044(arg_72849, arg_72850,
                                                    y_72847, y_72848)
  in {res_72851, res_72852}
}

fun {f32, f32} lifted_26108(f32 a_72853, f32 b_72854) = {
  {a_72853, b_72854}
}

fun {f32} lifted_26118(f32 x_72855) = {
  {x_72855}
}

fun {f32} lifted_26122(f32 x_72856, f32 y_72857) = {
  let {f32 res_72858} = fsub32(x_72856, y_72857)
  in {res_72858}
}

fun {f32} lifted_26126(f32 x_72859) = {
  {x_72859}
}

fun {f32} lifted_26130(f32 x_72860, f32 y_72861) = {
  let {f32 res_72862} = fsub32(x_72860, y_72861)
  in {res_72862}
}

fun {f32, f32} lifted_26116(f32 a_72863, f32 b_72864, f32 c_72865,
                            f32 d_72866) = {
  let {f32 arg_72867} = lifted_26118(a_72863)
  let {f32 res_72868} = lifted_26122(arg_72867, c_72865)
  let {f32 arg_72869} = lifted_26126(b_72864)
  let {f32 res_72870} = lifted_26130(arg_72869, d_72866)
  in {res_72868, res_72870}
}

fun {f32, f32} lifted_26104(f32 x_72871, f32 x_72872, f32 y_72873,
                            f32 y_72874) = {
  let {f32 arg_72875, f32 arg_72876} = lifted_26108(x_72871, x_72872)
  let {f32 res_72877, f32 res_72878} = lifted_26116(arg_72875, arg_72876,
                                                    y_72873, y_72874)
  in {res_72877, res_72878}
}

fun {f32, f32} lifted_26141(f32 x_72879, f32 x_72880) = {
  {x_72879, x_72880}
}

fun {f32, f32} lifted_26148(f32 x_72881, f32 x_72882) = {
  {x_72881, x_72882}
}

fun {f32, f32} lifted_26162(f32 a_72883, f32 b_72884) = {
  {a_72883, b_72884}
}

fun {f32} lifted_26172(f32 x_72885) = {
  {x_72885}
}

fun {f32} lifted_26176(f32 x_72886, f32 y_72887) = {
  let {f32 res_72888} = fsub32(x_72886, y_72887)
  in {res_72888}
}

fun {f32} lifted_26180(f32 x_72889) = {
  {x_72889}
}

fun {f32} lifted_26184(f32 x_72890, f32 y_72891) = {
  let {f32 res_72892} = fsub32(x_72890, y_72891)
  in {res_72892}
}

fun {f32, f32} lifted_26170(f32 a_72893, f32 b_72894, f32 c_72895,
                            f32 d_72896) = {
  let {f32 arg_72897} = lifted_26172(a_72893)
  let {f32 res_72898} = lifted_26176(arg_72897, c_72895)
  let {f32 arg_72899} = lifted_26180(b_72894)
  let {f32 res_72900} = lifted_26184(arg_72899, d_72896)
  in {res_72898, res_72900}
}

fun {f32, f32} lifted_26158(f32 x_72901, f32 x_72902, f32 y_72903,
                            f32 y_72904) = {
  let {f32 arg_72905, f32 arg_72906} = lifted_26162(x_72901, x_72902)
  let {f32 res_72907, f32 res_72908} = lifted_26170(arg_72905, arg_72906,
                                                    y_72903, y_72904)
  in {res_72907, res_72908}
}

fun {f32, f32} lifted_26205(f32 a_72909, f32 b_72910) = {
  {a_72909, b_72910}
}

fun {f32} lifted_26218(f32 x_72911) = {
  {x_72911}
}

fun {f32} lifted_26222(f32 x_72912, f32 y_72913) = {
  let {f32 res_72914} = fmul32(x_72912, y_72913)
  in {res_72914}
}

fun {f32} lifted_26226(f32 x_72915) = {
  {x_72915}
}

fun {f32} lifted_26229(f32 x_72916) = {
  {x_72916}
}

fun {f32} lifted_26233(f32 x_72917, f32 y_72918) = {
  let {f32 res_72919} = fmul32(x_72917, y_72918)
  in {res_72919}
}

fun {f32} lifted_26238(f32 x_72920, f32 y_72921) = {
  let {f32 res_72922} = fadd32(x_72920, y_72921)
  in {res_72922}
}

fun {f32} lifted_26242(f32 x_72923) = {
  {x_72923}
}

fun {f32} lifted_26245(f32 x_72924) = {
  {x_72924}
}

fun {f32} lifted_26249(f32 x_72925, f32 y_72926) = {
  let {f32 res_72927} = fmul32(x_72925, y_72926)
  in {res_72927}
}

fun {f32} lifted_26253(f32 x_72928) = {
  {x_72928}
}

fun {f32} lifted_26256(f32 x_72929) = {
  {x_72929}
}

fun {f32} lifted_26260(f32 x_72930, f32 y_72931) = {
  let {f32 res_72932} = fmul32(x_72930, y_72931)
  in {res_72932}
}

fun {f32} lifted_26265(f32 x_72933, f32 y_72934) = {
  let {f32 res_72935} = fadd32(x_72933, y_72934)
  in {res_72935}
}

fun {f32} lifted_26270(f32 x_72936, f32 y_72937) = {
  let {f32 res_72938} = fdiv32(x_72936, y_72937)
  in {res_72938}
}

fun {f32} lifted_26274(f32 x_72939) = {
  {x_72939}
}

fun {f32} lifted_26278(f32 x_72940, f32 y_72941) = {
  let {f32 res_72942} = fmul32(x_72940, y_72941)
  in {res_72942}
}

fun {f32} lifted_26282(f32 x_72943) = {
  {x_72943}
}

fun {f32} lifted_26285(f32 x_72944) = {
  {x_72944}
}

fun {f32} lifted_26289(f32 x_72945, f32 y_72946) = {
  let {f32 res_72947} = fmul32(x_72945, y_72946)
  in {res_72947}
}

fun {f32} lifted_26294(f32 x_72948, f32 y_72949) = {
  let {f32 res_72950} = fsub32(x_72948, y_72949)
  in {res_72950}
}

fun {f32} lifted_26298(f32 x_72951) = {
  {x_72951}
}

fun {f32} lifted_26301(f32 x_72952) = {
  {x_72952}
}

fun {f32} lifted_26305(f32 x_72953, f32 y_72954) = {
  let {f32 res_72955} = fmul32(x_72953, y_72954)
  in {res_72955}
}

fun {f32} lifted_26309(f32 x_72956) = {
  {x_72956}
}

fun {f32} lifted_26312(f32 x_72957) = {
  {x_72957}
}

fun {f32} lifted_26316(f32 x_72958, f32 y_72959) = {
  let {f32 res_72960} = fmul32(x_72958, y_72959)
  in {res_72960}
}

fun {f32} lifted_26321(f32 x_72961, f32 y_72962) = {
  let {f32 res_72963} = fadd32(x_72961, y_72962)
  in {res_72963}
}

fun {f32} lifted_26326(f32 x_72964, f32 y_72965) = {
  let {f32 res_72966} = fdiv32(x_72964, y_72965)
  in {res_72966}
}

fun {f32, f32} lifted_26216(f32 a_72967, f32 b_72968, f32 c_72969,
                            f32 d_72970) = {
  let {f32 arg_72971} = lifted_26218(a_72967)
  let {f32 arg_72972} = lifted_26222(arg_72971, c_72969)
  let {f32 arg_72973} = lifted_26226(arg_72972)
  let {f32 arg_72974} = lifted_26229(b_72968)
  let {f32 arg_72975} = lifted_26233(arg_72974, d_72970)
  let {f32 arg_72976} = lifted_26238(arg_72973, arg_72975)
  let {f32 arg_72977} = lifted_26242(arg_72976)
  let {f32 arg_72978} = lifted_26245(c_72969)
  let {f32 arg_72979} = lifted_26249(arg_72978, c_72969)
  let {f32 arg_72980} = lifted_26253(arg_72979)
  let {f32 arg_72981} = lifted_26256(d_72970)
  let {f32 arg_72982} = lifted_26260(arg_72981, d_72970)
  let {f32 arg_72983} = lifted_26265(arg_72980, arg_72982)
  let {f32 res_72984} = lifted_26270(arg_72977, arg_72983)
  let {f32 arg_72985} = lifted_26274(b_72968)
  let {f32 arg_72986} = lifted_26278(arg_72985, c_72969)
  let {f32 arg_72987} = lifted_26282(arg_72986)
  let {f32 arg_72988} = lifted_26285(a_72967)
  let {f32 arg_72989} = lifted_26289(arg_72988, d_72970)
  let {f32 arg_72990} = lifted_26294(arg_72987, arg_72989)
  let {f32 arg_72991} = lifted_26298(arg_72990)
  let {f32 arg_72992} = lifted_26301(c_72969)
  let {f32 arg_72993} = lifted_26305(arg_72992, c_72969)
  let {f32 arg_72994} = lifted_26309(arg_72993)
  let {f32 arg_72995} = lifted_26312(d_72970)
  let {f32 arg_72996} = lifted_26316(arg_72995, d_72970)
  let {f32 arg_72997} = lifted_26321(arg_72994, arg_72996)
  let {f32 res_72998} = lifted_26326(arg_72991, arg_72997)
  in {res_72984, res_72998}
}

fun {f32, f32} lifted_26198(f32 x_72999, f32 x_73000, f32 y_73001,
                            f32 y_73002) = {
  let {f32 arg_73003, f32 arg_73004} = lifted_26205(x_72999, x_73000)
  let {f32 res_73005, f32 res_73006} = lifted_26216(arg_73003, arg_73004,
                                                    y_73001, y_73002)
  in {res_73005, res_73006}
}

fun {f32} lifted_26348(f32 x_73007) = {
  {x_73007}
}

fun {f32} lifted_26352(f32 x_73008, f32 y_73009) = {
  let {f32 res_73010} = fmul32(x_73008, y_73009)
  in {res_73010}
}

fun {f32} lifted_26356(f32 x_73011) = {
  {x_73011}
}

fun {f32} lifted_26359(f32 x_73012) = {
  {x_73012}
}

fun {f32} lifted_26363(f32 x_73013, f32 y_73014) = {
  let {f32 res_73015} = fmul32(x_73013, y_73014)
  in {res_73015}
}

fun {f32} lifted_26368(f32 x_73016, f32 y_73017) = {
  let {f32 res_73018} = fadd32(x_73016, y_73017)
  in {res_73018}
}

fun {f32} lifted_26372(f32 x_73019) = {
  let {f32 res_73020} = sqrt32(x_73019)
  in {res_73020}
}

fun {f32} lifted_26346(f32 a_73021, f32 b_73022) = {
  let {f32 arg_73023} = lifted_26348(a_73021)
  let {f32 arg_73024} = lifted_26352(arg_73023, a_73021)
  let {f32 arg_73025} = lifted_26356(arg_73024)
  let {f32 arg_73026} = lifted_26359(b_73022)
  let {f32 arg_73027} = lifted_26363(arg_73026, b_73022)
  let {f32 arg_73028} = lifted_26368(arg_73025, arg_73027)
  let {f32 res_73029} = lifted_26372(arg_73028)
  in {res_73029}
}

fun {f32} lifted_26377(f32 x_73030) = {
  let {f32 res_73031} = log32(x_73030)
  in {res_73031}
}

fun {f32} lifted_26381(f32 a_73032) = {
  {a_73032}
}

fun {f32} lifted_26388(f32 x_73033) = {
  {x_73033}
}

fun {f32} lifted_26392(f32 x_73034, f32 y_73035) = {
  let {f32 res_73036} = atan2_32(x_73034, y_73035)
  in {res_73036}
}

fun {f32} lifted_26386(f32 a_73037, f32 b_73038) = {
  let {f32 arg_73039} = lifted_26388(b_73038)
  let {f32 res_73040} = lifted_26392(arg_73039, a_73037)
  in {res_73040}
}

fun {f32, f32} lifted_26398(f32 a_73041, f32 b_73042) = {
  {a_73041, b_73042}
}

fun {f32, f32} lifted_26340(f32 z_73043, f32 z_73044) = {
  let {f32 arg_73045} = lifted_26346(z_73043, z_73044)
  let {f32 arg_73046} = lifted_26377(arg_73045)
  let {f32 arg_73047} = lifted_26381(arg_73046)
  let {f32 arg_73048} = lifted_26386(z_73043, z_73044)
  let {f32 res_73049, f32 res_73050} = lifted_26398(arg_73047, arg_73048)
  in {res_73049, res_73050}
}

fun {f32, f32} lifted_26416(f32 a_73051, f32 b_73052) = {
  {a_73051, b_73052}
}

fun {f32} lifted_26428(f32 x_73053) = {
  {x_73053}
}

fun {f32} lifted_26432(f32 x_73054, f32 y_73055) = {
  let {f32 res_73056} = fmul32(x_73054, y_73055)
  in {res_73056}
}

fun {f32} lifted_26436(f32 x_73057) = {
  {x_73057}
}

fun {f32} lifted_26439(f32 x_73058) = {
  {x_73058}
}

fun {f32} lifted_26443(f32 x_73059, f32 y_73060) = {
  let {f32 res_73061} = fmul32(x_73059, y_73060)
  in {res_73061}
}

fun {f32} lifted_26448(f32 x_73062, f32 y_73063) = {
  let {f32 res_73064} = fsub32(x_73062, y_73063)
  in {res_73064}
}

fun {f32} lifted_26452(f32 x_73065) = {
  {x_73065}
}

fun {f32} lifted_26456(f32 x_73066, f32 y_73067) = {
  let {f32 res_73068} = fmul32(x_73066, y_73067)
  in {res_73068}
}

fun {f32} lifted_26460(f32 x_73069) = {
  {x_73069}
}

fun {f32} lifted_26463(f32 x_73070) = {
  {x_73070}
}

fun {f32} lifted_26467(f32 x_73071, f32 y_73072) = {
  let {f32 res_73073} = fmul32(x_73071, y_73072)
  in {res_73073}
}

fun {f32} lifted_26472(f32 x_73074, f32 y_73075) = {
  let {f32 res_73076} = fadd32(x_73074, y_73075)
  in {res_73076}
}

fun {f32, f32} lifted_26426(f32 a_73077, f32 b_73078, f32 c_73079,
                            f32 d_73080) = {
  let {f32 arg_73081} = lifted_26428(a_73077)
  let {f32 arg_73082} = lifted_26432(arg_73081, c_73079)
  let {f32 arg_73083} = lifted_26436(arg_73082)
  let {f32 arg_73084} = lifted_26439(b_73078)
  let {f32 arg_73085} = lifted_26443(arg_73084, d_73080)
  let {f32 res_73086} = lifted_26448(arg_73083, arg_73085)
  let {f32 arg_73087} = lifted_26452(b_73078)
  let {f32 arg_73088} = lifted_26456(arg_73087, c_73079)
  let {f32 arg_73089} = lifted_26460(arg_73088)
  let {f32 arg_73090} = lifted_26463(a_73077)
  let {f32 arg_73091} = lifted_26467(arg_73090, d_73080)
  let {f32 res_73092} = lifted_26472(arg_73089, arg_73091)
  in {res_73086, res_73092}
}

fun {f32, f32} lifted_26410(f32 x_73093, f32 x_73094, f32 y_73095,
                            f32 y_73096) = {
  let {f32 arg_73097, f32 arg_73098} = lifted_26416(x_73093, x_73094)
  let {f32 res_73099, f32 res_73100} = lifted_26426(arg_73097, arg_73098,
                                                    y_73095, y_73096)
  in {res_73099, res_73100}
}

fun {f32, f32} lifted_26490(f32 a_73101, f32 b_73102) = {
  {a_73101, b_73102}
}

fun {f32} lifted_26500(f32 x_73103) = {
  {x_73103}
}

fun {f32} lifted_26504(f32 x_73104, f32 y_73105) = {
  let {f32 res_73106} = fsub32(x_73104, y_73105)
  in {res_73106}
}

fun {f32} lifted_26508(f32 x_73107) = {
  {x_73107}
}

fun {f32} lifted_26512(f32 x_73108, f32 y_73109) = {
  let {f32 res_73110} = fsub32(x_73108, y_73109)
  in {res_73110}
}

fun {f32, f32} lifted_26498(f32 a_73111, f32 b_73112, f32 c_73113,
                            f32 d_73114) = {
  let {f32 arg_73115} = lifted_26500(a_73111)
  let {f32 res_73116} = lifted_26504(arg_73115, c_73113)
  let {f32 arg_73117} = lifted_26508(b_73112)
  let {f32 res_73118} = lifted_26512(arg_73117, d_73114)
  in {res_73116, res_73118}
}

fun {f32, f32} lifted_26486(f32 x_73119, f32 x_73120, f32 y_73121,
                            f32 y_73122) = {
  let {f32 arg_73123, f32 arg_73124} = lifted_26490(x_73119, x_73120)
  let {f32 res_73125, f32 res_73126} = lifted_26498(arg_73123, arg_73124,
                                                    y_73121, y_73122)
  in {res_73125, res_73126}
}

fun {f32, f32} lifted_26532(f32 a_73127, f32 b_73128) = {
  {a_73127, b_73128}
}

fun {f32} lifted_26544(f32 x_73129) = {
  {x_73129}
}

fun {f32} lifted_26548(f32 x_73130, f32 y_73131) = {
  let {f32 res_73132} = fmul32(x_73130, y_73131)
  in {res_73132}
}

fun {f32} lifted_26552(f32 x_73133) = {
  {x_73133}
}

fun {f32} lifted_26555(f32 x_73134) = {
  {x_73134}
}

fun {f32} lifted_26559(f32 x_73135, f32 y_73136) = {
  let {f32 res_73137} = fmul32(x_73135, y_73136)
  in {res_73137}
}

fun {f32} lifted_26564(f32 x_73138, f32 y_73139) = {
  let {f32 res_73140} = fsub32(x_73138, y_73139)
  in {res_73140}
}

fun {f32} lifted_26568(f32 x_73141) = {
  {x_73141}
}

fun {f32} lifted_26572(f32 x_73142, f32 y_73143) = {
  let {f32 res_73144} = fmul32(x_73142, y_73143)
  in {res_73144}
}

fun {f32} lifted_26576(f32 x_73145) = {
  {x_73145}
}

fun {f32} lifted_26579(f32 x_73146) = {
  {x_73146}
}

fun {f32} lifted_26583(f32 x_73147, f32 y_73148) = {
  let {f32 res_73149} = fmul32(x_73147, y_73148)
  in {res_73149}
}

fun {f32} lifted_26588(f32 x_73150, f32 y_73151) = {
  let {f32 res_73152} = fadd32(x_73150, y_73151)
  in {res_73152}
}

fun {f32, f32} lifted_26542(f32 a_73153, f32 b_73154, f32 c_73155,
                            f32 d_73156) = {
  let {f32 arg_73157} = lifted_26544(a_73153)
  let {f32 arg_73158} = lifted_26548(arg_73157, c_73155)
  let {f32 arg_73159} = lifted_26552(arg_73158)
  let {f32 arg_73160} = lifted_26555(b_73154)
  let {f32 arg_73161} = lifted_26559(arg_73160, d_73156)
  let {f32 res_73162} = lifted_26564(arg_73159, arg_73161)
  let {f32 arg_73163} = lifted_26568(b_73154)
  let {f32 arg_73164} = lifted_26572(arg_73163, c_73155)
  let {f32 arg_73165} = lifted_26576(arg_73164)
  let {f32 arg_73166} = lifted_26579(a_73153)
  let {f32 arg_73167} = lifted_26583(arg_73166, d_73156)
  let {f32 res_73168} = lifted_26588(arg_73165, arg_73167)
  in {res_73162, res_73168}
}

fun {f32, f32} lifted_26526(f32 x_73169, f32 x_73170, f32 y_73171,
                            f32 y_73172) = {
  let {f32 arg_73173, f32 arg_73174} = lifted_26532(x_73169, x_73170)
  let {f32 res_73175, f32 res_73176} = lifted_26542(arg_73173, arg_73174,
                                                    y_73171, y_73172)
  in {res_73175, res_73176}
}

fun {f32, f32} lifted_26599(f32 x_73177, f32 x_73178) = {
  {x_73177, x_73178}
}

fun {f32, f32} lifted_26606(f32 x_73179, f32 x_73180) = {
  {x_73179, x_73180}
}

fun {f32, f32} lifted_26622(f32 a_73181, f32 b_73182) = {
  {a_73181, b_73182}
}

fun {f32} lifted_26634(f32 x_73183) = {
  {x_73183}
}

fun {f32} lifted_26638(f32 x_73184, f32 y_73185) = {
  let {f32 res_73186} = fmul32(x_73184, y_73185)
  in {res_73186}
}

fun {f32} lifted_26642(f32 x_73187) = {
  {x_73187}
}

fun {f32} lifted_26645(f32 x_73188) = {
  {x_73188}
}

fun {f32} lifted_26649(f32 x_73189, f32 y_73190) = {
  let {f32 res_73191} = fmul32(x_73189, y_73190)
  in {res_73191}
}

fun {f32} lifted_26654(f32 x_73192, f32 y_73193) = {
  let {f32 res_73194} = fsub32(x_73192, y_73193)
  in {res_73194}
}

fun {f32} lifted_26658(f32 x_73195) = {
  {x_73195}
}

fun {f32} lifted_26662(f32 x_73196, f32 y_73197) = {
  let {f32 res_73198} = fmul32(x_73196, y_73197)
  in {res_73198}
}

fun {f32} lifted_26666(f32 x_73199) = {
  {x_73199}
}

fun {f32} lifted_26669(f32 x_73200) = {
  {x_73200}
}

fun {f32} lifted_26673(f32 x_73201, f32 y_73202) = {
  let {f32 res_73203} = fmul32(x_73201, y_73202)
  in {res_73203}
}

fun {f32} lifted_26678(f32 x_73204, f32 y_73205) = {
  let {f32 res_73206} = fadd32(x_73204, y_73205)
  in {res_73206}
}

fun {f32, f32} lifted_26632(f32 a_73207, f32 b_73208, f32 c_73209,
                            f32 d_73210) = {
  let {f32 arg_73211} = lifted_26634(a_73207)
  let {f32 arg_73212} = lifted_26638(arg_73211, c_73209)
  let {f32 arg_73213} = lifted_26642(arg_73212)
  let {f32 arg_73214} = lifted_26645(b_73208)
  let {f32 arg_73215} = lifted_26649(arg_73214, d_73210)
  let {f32 res_73216} = lifted_26654(arg_73213, arg_73215)
  let {f32 arg_73217} = lifted_26658(b_73208)
  let {f32 arg_73218} = lifted_26662(arg_73217, c_73209)
  let {f32 arg_73219} = lifted_26666(arg_73218)
  let {f32 arg_73220} = lifted_26669(a_73207)
  let {f32 arg_73221} = lifted_26673(arg_73220, d_73210)
  let {f32 res_73222} = lifted_26678(arg_73219, arg_73221)
  in {res_73216, res_73222}
}

fun {f32, f32} lifted_26616(f32 x_73223, f32 x_73224, f32 y_73225,
                            f32 y_73226) = {
  let {f32 arg_73227, f32 arg_73228} = lifted_26622(x_73223, x_73224)
  let {f32 res_73229, f32 res_73230} = lifted_26632(arg_73227, arg_73228,
                                                    y_73225, y_73226)
  in {res_73229, res_73230}
}

fun {f32, f32} lifted_26689(f32 x_73231, f32 x_73232) = {
  {x_73231, x_73232}
}

fun {f32, f32} lifted_26696(f32 x_73233, f32 x_73234) = {
  {x_73233, x_73234}
}

fun {f32, f32} lifted_26710(f32 a_73235, f32 b_73236) = {
  {a_73235, b_73236}
}

fun {f32} lifted_26720(f32 x_73237) = {
  {x_73237}
}

fun {f32} lifted_26724(f32 x_73238, f32 y_73239) = {
  let {f32 res_73240} = fsub32(x_73238, y_73239)
  in {res_73240}
}

fun {f32} lifted_26728(f32 x_73241) = {
  {x_73241}
}

fun {f32} lifted_26732(f32 x_73242, f32 y_73243) = {
  let {f32 res_73244} = fsub32(x_73242, y_73243)
  in {res_73244}
}

fun {f32, f32} lifted_26718(f32 a_73245, f32 b_73246, f32 c_73247,
                            f32 d_73248) = {
  let {f32 arg_73249} = lifted_26720(a_73245)
  let {f32 res_73250} = lifted_26724(arg_73249, c_73247)
  let {f32 arg_73251} = lifted_26728(b_73246)
  let {f32 res_73252} = lifted_26732(arg_73251, d_73248)
  in {res_73250, res_73252}
}

fun {f32, f32} lifted_26706(f32 x_73253, f32 x_73254, f32 y_73255,
                            f32 y_73256) = {
  let {f32 arg_73257, f32 arg_73258} = lifted_26710(x_73253, x_73254)
  let {f32 res_73259, f32 res_73260} = lifted_26718(arg_73257, arg_73258,
                                                    y_73255, y_73256)
  in {res_73259, res_73260}
}

fun {f32, f32} lifted_26752(f32 a_73261, f32 b_73262) = {
  {a_73261, b_73262}
}

fun {f32} lifted_26764(f32 x_73263) = {
  {x_73263}
}

fun {f32} lifted_26768(f32 x_73264, f32 y_73265) = {
  let {f32 res_73266} = fmul32(x_73264, y_73265)
  in {res_73266}
}

fun {f32} lifted_26772(f32 x_73267) = {
  {x_73267}
}

fun {f32} lifted_26775(f32 x_73268) = {
  {x_73268}
}

fun {f32} lifted_26779(f32 x_73269, f32 y_73270) = {
  let {f32 res_73271} = fmul32(x_73269, y_73270)
  in {res_73271}
}

fun {f32} lifted_26784(f32 x_73272, f32 y_73273) = {
  let {f32 res_73274} = fsub32(x_73272, y_73273)
  in {res_73274}
}

fun {f32} lifted_26788(f32 x_73275) = {
  {x_73275}
}

fun {f32} lifted_26792(f32 x_73276, f32 y_73277) = {
  let {f32 res_73278} = fmul32(x_73276, y_73277)
  in {res_73278}
}

fun {f32} lifted_26796(f32 x_73279) = {
  {x_73279}
}

fun {f32} lifted_26799(f32 x_73280) = {
  {x_73280}
}

fun {f32} lifted_26803(f32 x_73281, f32 y_73282) = {
  let {f32 res_73283} = fmul32(x_73281, y_73282)
  in {res_73283}
}

fun {f32} lifted_26808(f32 x_73284, f32 y_73285) = {
  let {f32 res_73286} = fadd32(x_73284, y_73285)
  in {res_73286}
}

fun {f32, f32} lifted_26762(f32 a_73287, f32 b_73288, f32 c_73289,
                            f32 d_73290) = {
  let {f32 arg_73291} = lifted_26764(a_73287)
  let {f32 arg_73292} = lifted_26768(arg_73291, c_73289)
  let {f32 arg_73293} = lifted_26772(arg_73292)
  let {f32 arg_73294} = lifted_26775(b_73288)
  let {f32 arg_73295} = lifted_26779(arg_73294, d_73290)
  let {f32 res_73296} = lifted_26784(arg_73293, arg_73295)
  let {f32 arg_73297} = lifted_26788(b_73288)
  let {f32 arg_73298} = lifted_26792(arg_73297, c_73289)
  let {f32 arg_73299} = lifted_26796(arg_73298)
  let {f32 arg_73300} = lifted_26799(a_73287)
  let {f32 arg_73301} = lifted_26803(arg_73300, d_73290)
  let {f32 res_73302} = lifted_26808(arg_73299, arg_73301)
  in {res_73296, res_73302}
}

fun {f32, f32} lifted_26746(f32 x_73303, f32 x_73304, f32 y_73305,
                            f32 y_73306) = {
  let {f32 arg_73307, f32 arg_73308} = lifted_26752(x_73303, x_73304)
  let {f32 res_73309, f32 res_73310} = lifted_26762(arg_73307, arg_73308,
                                                    y_73305, y_73306)
  in {res_73309, res_73310}
}

fun {f32, f32} lifted_26819(f32 x_73311, f32 x_73312) = {
  {x_73311, x_73312}
}

fun {f32, f32} lifted_26826(f32 x_73313, f32 x_73314) = {
  {x_73313, x_73314}
}

fun {f32, f32} lifted_26833(f32 x_73315, f32 x_73316) = {
  {x_73315, x_73316}
}

fun {f32, f32} lifted_26849(f32 a_73317, f32 b_73318) = {
  {a_73317, b_73318}
}

fun {f32} lifted_26861(f32 x_73319) = {
  {x_73319}
}

fun {f32} lifted_26865(f32 x_73320, f32 y_73321) = {
  let {f32 res_73322} = fmul32(x_73320, y_73321)
  in {res_73322}
}

fun {f32} lifted_26869(f32 x_73323) = {
  {x_73323}
}

fun {f32} lifted_26872(f32 x_73324) = {
  {x_73324}
}

fun {f32} lifted_26876(f32 x_73325, f32 y_73326) = {
  let {f32 res_73327} = fmul32(x_73325, y_73326)
  in {res_73327}
}

fun {f32} lifted_26881(f32 x_73328, f32 y_73329) = {
  let {f32 res_73330} = fsub32(x_73328, y_73329)
  in {res_73330}
}

fun {f32} lifted_26885(f32 x_73331) = {
  {x_73331}
}

fun {f32} lifted_26889(f32 x_73332, f32 y_73333) = {
  let {f32 res_73334} = fmul32(x_73332, y_73333)
  in {res_73334}
}

fun {f32} lifted_26893(f32 x_73335) = {
  {x_73335}
}

fun {f32} lifted_26896(f32 x_73336) = {
  {x_73336}
}

fun {f32} lifted_26900(f32 x_73337, f32 y_73338) = {
  let {f32 res_73339} = fmul32(x_73337, y_73338)
  in {res_73339}
}

fun {f32} lifted_26905(f32 x_73340, f32 y_73341) = {
  let {f32 res_73342} = fadd32(x_73340, y_73341)
  in {res_73342}
}

fun {f32, f32} lifted_26859(f32 a_73343, f32 b_73344, f32 c_73345,
                            f32 d_73346) = {
  let {f32 arg_73347} = lifted_26861(a_73343)
  let {f32 arg_73348} = lifted_26865(arg_73347, c_73345)
  let {f32 arg_73349} = lifted_26869(arg_73348)
  let {f32 arg_73350} = lifted_26872(b_73344)
  let {f32 arg_73351} = lifted_26876(arg_73350, d_73346)
  let {f32 res_73352} = lifted_26881(arg_73349, arg_73351)
  let {f32 arg_73353} = lifted_26885(b_73344)
  let {f32 arg_73354} = lifted_26889(arg_73353, c_73345)
  let {f32 arg_73355} = lifted_26893(arg_73354)
  let {f32 arg_73356} = lifted_26896(a_73343)
  let {f32 arg_73357} = lifted_26900(arg_73356, d_73346)
  let {f32 res_73358} = lifted_26905(arg_73355, arg_73357)
  in {res_73352, res_73358}
}

fun {f32, f32} lifted_26843(f32 x_73359, f32 x_73360, f32 y_73361,
                            f32 y_73362) = {
  let {f32 arg_73363, f32 arg_73364} = lifted_26849(x_73359, x_73360)
  let {f32 res_73365, f32 res_73366} = lifted_26859(arg_73363, arg_73364,
                                                    y_73361, y_73362)
  in {res_73365, res_73366}
}

fun {f32, f32} lifted_26923(f32 a_73367, f32 b_73368) = {
  {a_73367, b_73368}
}

fun {f32} lifted_26933(f32 x_73369) = {
  {x_73369}
}

fun {f32} lifted_26937(f32 x_73370, f32 y_73371) = {
  let {f32 res_73372} = fsub32(x_73370, y_73371)
  in {res_73372}
}

fun {f32} lifted_26941(f32 x_73373) = {
  {x_73373}
}

fun {f32} lifted_26945(f32 x_73374, f32 y_73375) = {
  let {f32 res_73376} = fsub32(x_73374, y_73375)
  in {res_73376}
}

fun {f32, f32} lifted_26931(f32 a_73377, f32 b_73378, f32 c_73379,
                            f32 d_73380) = {
  let {f32 arg_73381} = lifted_26933(a_73377)
  let {f32 res_73382} = lifted_26937(arg_73381, c_73379)
  let {f32 arg_73383} = lifted_26941(b_73378)
  let {f32 res_73384} = lifted_26945(arg_73383, d_73380)
  in {res_73382, res_73384}
}

fun {f32, f32} lifted_26919(f32 x_73385, f32 x_73386, f32 y_73387,
                            f32 y_73388) = {
  let {f32 arg_73389, f32 arg_73390} = lifted_26923(x_73385, x_73386)
  let {f32 res_73391, f32 res_73392} = lifted_26931(arg_73389, arg_73390,
                                                    y_73387, y_73388)
  in {res_73391, res_73392}
}

fun {f32, f32} lifted_26966(f32 a_73393, f32 b_73394) = {
  {a_73393, b_73394}
}

fun {f32} lifted_26979(f32 x_73395) = {
  {x_73395}
}

fun {f32} lifted_26983(f32 x_73396, f32 y_73397) = {
  let {f32 res_73398} = fmul32(x_73396, y_73397)
  in {res_73398}
}

fun {f32} lifted_26987(f32 x_73399) = {
  {x_73399}
}

fun {f32} lifted_26990(f32 x_73400) = {
  {x_73400}
}

fun {f32} lifted_26994(f32 x_73401, f32 y_73402) = {
  let {f32 res_73403} = fmul32(x_73401, y_73402)
  in {res_73403}
}

fun {f32} lifted_26999(f32 x_73404, f32 y_73405) = {
  let {f32 res_73406} = fadd32(x_73404, y_73405)
  in {res_73406}
}

fun {f32} lifted_27003(f32 x_73407) = {
  {x_73407}
}

fun {f32} lifted_27006(f32 x_73408) = {
  {x_73408}
}

fun {f32} lifted_27010(f32 x_73409, f32 y_73410) = {
  let {f32 res_73411} = fmul32(x_73409, y_73410)
  in {res_73411}
}

fun {f32} lifted_27014(f32 x_73412) = {
  {x_73412}
}

fun {f32} lifted_27017(f32 x_73413) = {
  {x_73413}
}

fun {f32} lifted_27021(f32 x_73414, f32 y_73415) = {
  let {f32 res_73416} = fmul32(x_73414, y_73415)
  in {res_73416}
}

fun {f32} lifted_27026(f32 x_73417, f32 y_73418) = {
  let {f32 res_73419} = fadd32(x_73417, y_73418)
  in {res_73419}
}

fun {f32} lifted_27031(f32 x_73420, f32 y_73421) = {
  let {f32 res_73422} = fdiv32(x_73420, y_73421)
  in {res_73422}
}

fun {f32} lifted_27035(f32 x_73423) = {
  {x_73423}
}

fun {f32} lifted_27039(f32 x_73424, f32 y_73425) = {
  let {f32 res_73426} = fmul32(x_73424, y_73425)
  in {res_73426}
}

fun {f32} lifted_27043(f32 x_73427) = {
  {x_73427}
}

fun {f32} lifted_27046(f32 x_73428) = {
  {x_73428}
}

fun {f32} lifted_27050(f32 x_73429, f32 y_73430) = {
  let {f32 res_73431} = fmul32(x_73429, y_73430)
  in {res_73431}
}

fun {f32} lifted_27055(f32 x_73432, f32 y_73433) = {
  let {f32 res_73434} = fsub32(x_73432, y_73433)
  in {res_73434}
}

fun {f32} lifted_27059(f32 x_73435) = {
  {x_73435}
}

fun {f32} lifted_27062(f32 x_73436) = {
  {x_73436}
}

fun {f32} lifted_27066(f32 x_73437, f32 y_73438) = {
  let {f32 res_73439} = fmul32(x_73437, y_73438)
  in {res_73439}
}

fun {f32} lifted_27070(f32 x_73440) = {
  {x_73440}
}

fun {f32} lifted_27073(f32 x_73441) = {
  {x_73441}
}

fun {f32} lifted_27077(f32 x_73442, f32 y_73443) = {
  let {f32 res_73444} = fmul32(x_73442, y_73443)
  in {res_73444}
}

fun {f32} lifted_27082(f32 x_73445, f32 y_73446) = {
  let {f32 res_73447} = fadd32(x_73445, y_73446)
  in {res_73447}
}

fun {f32} lifted_27087(f32 x_73448, f32 y_73449) = {
  let {f32 res_73450} = fdiv32(x_73448, y_73449)
  in {res_73450}
}

fun {f32, f32} lifted_26977(f32 a_73451, f32 b_73452, f32 c_73453,
                            f32 d_73454) = {
  let {f32 arg_73455} = lifted_26979(a_73451)
  let {f32 arg_73456} = lifted_26983(arg_73455, c_73453)
  let {f32 arg_73457} = lifted_26987(arg_73456)
  let {f32 arg_73458} = lifted_26990(b_73452)
  let {f32 arg_73459} = lifted_26994(arg_73458, d_73454)
  let {f32 arg_73460} = lifted_26999(arg_73457, arg_73459)
  let {f32 arg_73461} = lifted_27003(arg_73460)
  let {f32 arg_73462} = lifted_27006(c_73453)
  let {f32 arg_73463} = lifted_27010(arg_73462, c_73453)
  let {f32 arg_73464} = lifted_27014(arg_73463)
  let {f32 arg_73465} = lifted_27017(d_73454)
  let {f32 arg_73466} = lifted_27021(arg_73465, d_73454)
  let {f32 arg_73467} = lifted_27026(arg_73464, arg_73466)
  let {f32 res_73468} = lifted_27031(arg_73461, arg_73467)
  let {f32 arg_73469} = lifted_27035(b_73452)
  let {f32 arg_73470} = lifted_27039(arg_73469, c_73453)
  let {f32 arg_73471} = lifted_27043(arg_73470)
  let {f32 arg_73472} = lifted_27046(a_73451)
  let {f32 arg_73473} = lifted_27050(arg_73472, d_73454)
  let {f32 arg_73474} = lifted_27055(arg_73471, arg_73473)
  let {f32 arg_73475} = lifted_27059(arg_73474)
  let {f32 arg_73476} = lifted_27062(c_73453)
  let {f32 arg_73477} = lifted_27066(arg_73476, c_73453)
  let {f32 arg_73478} = lifted_27070(arg_73477)
  let {f32 arg_73479} = lifted_27073(d_73454)
  let {f32 arg_73480} = lifted_27077(arg_73479, d_73454)
  let {f32 arg_73481} = lifted_27082(arg_73478, arg_73480)
  let {f32 res_73482} = lifted_27087(arg_73475, arg_73481)
  in {res_73468, res_73482}
}

fun {f32, f32} lifted_26959(f32 x_73483, f32 x_73484, f32 y_73485,
                            f32 y_73486) = {
  let {f32 arg_73487, f32 arg_73488} = lifted_26966(x_73483, x_73484)
  let {f32 res_73489, f32 res_73490} = lifted_26977(arg_73487, arg_73488,
                                                    y_73485, y_73486)
  in {res_73489, res_73490}
}

fun {f32, f32} lifted_27105(f32 a_73491, f32 b_73492) = {
  {a_73491, b_73492}
}

fun {f32} lifted_27115(f32 x_73493) = {
  {x_73493}
}

fun {f32} lifted_27119(f32 x_73494, f32 y_73495) = {
  let {f32 res_73496} = fadd32(x_73494, y_73495)
  in {res_73496}
}

fun {f32} lifted_27123(f32 x_73497) = {
  {x_73497}
}

fun {f32} lifted_27127(f32 x_73498, f32 y_73499) = {
  let {f32 res_73500} = fadd32(x_73498, y_73499)
  in {res_73500}
}

fun {f32, f32} lifted_27113(f32 a_73501, f32 b_73502, f32 c_73503,
                            f32 d_73504) = {
  let {f32 arg_73505} = lifted_27115(a_73501)
  let {f32 res_73506} = lifted_27119(arg_73505, c_73503)
  let {f32 arg_73507} = lifted_27123(b_73502)
  let {f32 res_73508} = lifted_27127(arg_73507, d_73504)
  in {res_73506, res_73508}
}

fun {f32, f32} lifted_27101(f32 x_73509, f32 x_73510, f32 y_73511,
                            f32 y_73512) = {
  let {f32 arg_73513, f32 arg_73514} = lifted_27105(x_73509, x_73510)
  let {f32 res_73515, f32 res_73516} = lifted_27113(arg_73513, arg_73514,
                                                    y_73511, y_73512)
  in {res_73515, res_73516}
}

fun {f32} lifted_27143(f32 x_73517) = {
  let {f32 res_73518} = exp32(x_73517)
  in {res_73518}
}

fun {f32} lifted_27148(f32 x_73519) = {
  {x_73519}
}

fun {f32} lifted_27151(f32 x_73520) = {
  let {f32 res_73521} = cos32(x_73520)
  in {res_73521}
}

fun {f32} lifted_27156(f32 x_73522, f32 y_73523) = {
  let {f32 res_73524} = fmul32(x_73522, y_73523)
  in {res_73524}
}

fun {f32} lifted_27160(f32 a_73525) = {
  {a_73525}
}

fun {f32} lifted_27163(f32 x_73526) = {
  {x_73526}
}

fun {f32} lifted_27166(f32 x_73527) = {
  let {f32 res_73528} = sin32(x_73527)
  in {res_73528}
}

fun {f32} lifted_27171(f32 x_73529, f32 y_73530) = {
  let {f32 res_73531} = fmul32(x_73529, y_73530)
  in {res_73531}
}

fun {f32, f32} lifted_27176(f32 a_73532, f32 b_73533) = {
  {a_73532, b_73533}
}

fun {f32, f32} lifted_27141(f32 a_73534, f32 b_73535) = {
  let {f32 res_73536} = lifted_27143(a_73534)
  let {f32 expx_73537} = res_73536
  let {f32 arg_73538} = lifted_27148(expx_73537)
  let {f32 arg_73539} = lifted_27151(b_73535)
  let {f32 arg_73540} = lifted_27156(arg_73538, arg_73539)
  let {f32 arg_73541} = lifted_27160(arg_73540)
  let {f32 arg_73542} = lifted_27163(expx_73537)
  let {f32 arg_73543} = lifted_27166(b_73535)
  let {f32 arg_73544} = lifted_27171(arg_73542, arg_73543)
  let {f32 res_73545, f32 res_73546} = lifted_27176(arg_73541, arg_73544)
  in {res_73545, res_73546}
}

fun {f32, f32} lifted_24719(f32 coeff1_73547, f32 coeff1_73548,
                            f32 coeff2_73549, f32 coeff2_73550,
                            f32 day_count_fraction_73551, f32 etai2_73552,
                            f32 etai2_73553, f32 etai_73554, f32 etai_73555,
                            f32 i_73556, f32 i_73557, f32 kappai_73558,
                            f32 kappai_73559, f32 one_73560, f32 one_73561,
                            f32 rho_73562, f32 two_73563, f32 two_73564,
                            f32 zero_73565, f32 zero_73566, f32 xi_73567,
                            f32 xi_73568) = {
  let {f32 res_73569, f32 res_73570} = lifted_24722(day_count_fraction_73551)
  let {f32 ti_73571} = res_73569
  let {f32 ti_73572} = res_73570
  let {f32 arg_73573, f32 arg_73574} = lifted_24736(kappai_73558, kappai_73559)
  let {f32 arg_73575, f32 arg_73576} = lifted_24741(rho_73562)
  let {f32 arg_73577, f32 arg_73578} = lifted_24752(arg_73575, arg_73576)
  let {f32 arg_73579, f32 arg_73580} = lifted_24762(arg_73577, arg_73578,
                                                    etai_73554, etai_73555)
  let {f32 arg_73581, f32 arg_73582} = lifted_24835(arg_73579, arg_73580)
  let {f32 arg_73583, f32 arg_73584} = lifted_24845(arg_73581, arg_73582,
                                                    xi_73567, xi_73568)
  let {f32 res_73585, f32 res_73586} = lifted_24921(arg_73573, arg_73574,
                                                    arg_73583, arg_73584)
  let {f32 d0_73587} = res_73585
  let {f32 d0_73588} = res_73586
  let {f32 arg_73589, f32 arg_73590} = lifted_24961(d0_73587, d0_73588)
  let {f32 arg_73591, f32 arg_73592} = lifted_24971(arg_73589, arg_73590,
                                                    d0_73587, d0_73588)
  let {f32 arg_73593, f32 arg_73594} = lifted_25044(arg_73591, arg_73592)
  let {f32 arg_73595, f32 arg_73596} = lifted_25051(etai2_73552, etai2_73553)
  let {f32 arg_73597, f32 arg_73598} = lifted_25058(xi_73567, xi_73568)
  let {f32 arg_73599, f32 arg_73600} = lifted_25065(i_73556, i_73557)
  let {f32 arg_73601, f32 arg_73602} = lifted_25075(arg_73599, arg_73600,
                                                    xi_73567, xi_73568)
  let {f32 arg_73603, f32 arg_73604} = lifted_25115(arg_73597, arg_73598,
                                                    arg_73601, arg_73602)
  let {f32 arg_73605, f32 arg_73606} = lifted_25191(arg_73595, arg_73596,
                                                    arg_73603, arg_73604)
  let {f32 arg_73607, f32 arg_73608} = lifted_25267(arg_73593, arg_73594,
                                                    arg_73605, arg_73606)
  let {f32 res_73609, f32 res_73610} = lifted_25310(arg_73607, arg_73608)
  let {f32 d_73611} = res_73609
  let {f32 d_73612} = res_73610
  let {f32 arg_73613, f32 arg_73614} = lifted_25478(d0_73587, d0_73588)
  let {f32 res_73615, f32 res_73616} = lifted_25488(arg_73613, arg_73614,
                                                    d_73611, d_73612)
  let {f32 a_minus_73617} = res_73615
  let {f32 a_minus_73618} = res_73616
  let {f32 arg_73619, f32 arg_73620} = lifted_25528(a_minus_73617,
                                                    a_minus_73618)
  let {f32 arg_73621, f32 arg_73622} = lifted_25535(d0_73587, d0_73588)
  let {f32 arg_73623, f32 arg_73624} = lifted_25545(arg_73621, arg_73622,
                                                    d_73611, d_73612)
  let {f32 res_73625, f32 res_73626} = lifted_25585(arg_73619, arg_73620,
                                                    arg_73623, arg_73624)
  let {f32 g_73627} = res_73625
  let {f32 g_73628} = res_73626
  let {f32 arg_73629, f32 arg_73630} = lifted_25727(zero_73565, zero_73566)
  let {f32 arg_73631, f32 arg_73632} = lifted_25734(d_73611, d_73612)
  let {f32 arg_73633, f32 arg_73634} = lifted_25744(arg_73631, arg_73632,
                                                    ti_73571, ti_73572)
  let {f32 arg_73635, f32 arg_73636} = lifted_25820(arg_73629, arg_73630,
                                                    arg_73633, arg_73634)
  let {f32 res_73637, f32 res_73638} = lifted_25860(arg_73635, arg_73636)
  let {f32 e_73639} = res_73637
  let {f32 e_73640} = res_73638
  let {f32 arg_73641, f32 arg_73642} = lifted_25907(coeff1_73547, coeff1_73548)
  let {f32 arg_73643, f32 arg_73644} = lifted_25914(a_minus_73617,
                                                    a_minus_73618)
  let {f32 arg_73645, f32 arg_73646} = lifted_25924(arg_73643, arg_73644,
                                                    ti_73571, ti_73572)
  let {f32 arg_73647, f32 arg_73648} = lifted_25997(arg_73645, arg_73646)
  let {f32 arg_73649, f32 arg_73650} = lifted_26004(two_73563, two_73564)
  let {f32 arg_73651, f32 arg_73652} = lifted_26011(one_73560, one_73561)
  let {f32 arg_73653, f32 arg_73654} = lifted_26018(g_73627, g_73628)
  let {f32 arg_73655, f32 arg_73656} = lifted_26028(arg_73653, arg_73654,
                                                    e_73639, e_73640)
  let {f32 arg_73657, f32 arg_73658} = lifted_26104(arg_73651, arg_73652,
                                                    arg_73655, arg_73656)
  let {f32 arg_73659, f32 arg_73660} = lifted_26141(arg_73657, arg_73658)
  let {f32 arg_73661, f32 arg_73662} = lifted_26148(one_73560, one_73561)
  let {f32 arg_73663, f32 arg_73664} = lifted_26158(arg_73661, arg_73662,
                                                    g_73627, g_73628)
  let {f32 arg_73665, f32 arg_73666} = lifted_26198(arg_73659, arg_73660,
                                                    arg_73663, arg_73664)
  let {f32 arg_73667, f32 arg_73668} = lifted_26340(arg_73665, arg_73666)
  let {f32 arg_73669, f32 arg_73670} = lifted_26410(arg_73649, arg_73650,
                                                    arg_73667, arg_73668)
  let {f32 arg_73671, f32 arg_73672} = lifted_26486(arg_73647, arg_73648,
                                                    arg_73669, arg_73670)
  let {f32 arg_73673, f32 arg_73674} = lifted_26526(arg_73641, arg_73642,
                                                    arg_73671, arg_73672)
  let {f32 arg_73675, f32 arg_73676} = lifted_26599(arg_73673, arg_73674)
  let {f32 arg_73677, f32 arg_73678} = lifted_26606(coeff2_73549, coeff2_73550)
  let {f32 arg_73679, f32 arg_73680} = lifted_26616(arg_73677, arg_73678,
                                                    a_minus_73617,
                                                    a_minus_73618)
  let {f32 arg_73681, f32 arg_73682} = lifted_26689(arg_73679, arg_73680)
  let {f32 arg_73683, f32 arg_73684} = lifted_26696(one_73560, one_73561)
  let {f32 arg_73685, f32 arg_73686} = lifted_26706(arg_73683, arg_73684,
                                                    e_73639, e_73640)
  let {f32 arg_73687, f32 arg_73688} = lifted_26746(arg_73681, arg_73682,
                                                    arg_73685, arg_73686)
  let {f32 arg_73689, f32 arg_73690} = lifted_26819(arg_73687, arg_73688)
  let {f32 arg_73691, f32 arg_73692} = lifted_26826(one_73560, one_73561)
  let {f32 arg_73693, f32 arg_73694} = lifted_26833(g_73627, g_73628)
  let {f32 arg_73695, f32 arg_73696} = lifted_26843(arg_73693, arg_73694,
                                                    e_73639, e_73640)
  let {f32 arg_73697, f32 arg_73698} = lifted_26919(arg_73691, arg_73692,
                                                    arg_73695, arg_73696)
  let {f32 arg_73699, f32 arg_73700} = lifted_26959(arg_73689, arg_73690,
                                                    arg_73697, arg_73698)
  let {f32 arg_73701, f32 arg_73702} = lifted_27101(arg_73675, arg_73676,
                                                    arg_73699, arg_73700)
  let {f32 res_73703, f32 res_73704} = lifted_27141(arg_73701, arg_73702)
  in {res_73703, res_73704}
}

fun {f32, f32} lifted_27187(f32 x_73705, f32 x_73706) = {
  {x_73705, x_73706}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_27228(f32 coeff1_73707, f32 coeff1_73708,
                                           f32 coeff2_73709, f32 coeff2_73710,
                                           f32 etai2_73711, f32 etai2_73712,
                                           f32 etai_73713, f32 etai_73714,
                                           f32 i_73715, f32 i_73716,
                                           f32 kappai_73717, f32 kappai_73718,
                                           f32 one_73719, f32 one_73720,
                                           f32 rho_73721, f32 two_73722,
                                           f32 two_73723, f32 zero_73724,
                                           f32 zero_73725,
                                           f32 day_count_fraction_73726) = {
  {coeff1_73707, coeff1_73708, coeff2_73709, coeff2_73710,
   day_count_fraction_73726, etai2_73711, etai2_73712, etai_73713, etai_73714,
   i_73715, i_73716, kappai_73717, kappai_73718, one_73719, one_73720,
   rho_73721, two_73722, two_73723, zero_73724, zero_73725}
}

fun {f32} lifted_27250(f32 x_73727) = {
  {x_73727}
}

fun {f32} lifted_27254(f32 x_73728, f32 y_73729) = {
  let {f32 res_73730} = fsub32(x_73728, y_73729)
  in {res_73730}
}

fun {f32} lifted_27261(i32 x_73731) = {
  let {f32 res_73732} = sitofp i32 x_73731 to f32
  in {res_73732}
}

fun {f32, f32} lifted_27259(f32 b_73733) = {
  let {f32 res_73734} = lifted_27261(0i32)
  in {res_73734, b_73733}
}

fun {f32} lifted_27312(i32 x_73735) = {
  let {f32 res_73736} = sitofp i32 x_73735 to f32
  in {res_73736}
}

fun {f32, f32} lifted_27310(f32 a_73737) = {
  let {f32 res_73738} = lifted_27312(0i32)
  in {a_73737, res_73738}
}

fun {f32, f32} lifted_27324(f32 x_73739, f32 x_73740) = {
  {x_73739, x_73740}
}

fun {f32} lifted_27331(i32 x_73741) = {
  let {f32 res_73742} = sitofp i32 x_73741 to f32
  in {res_73742}
}

fun {f32, f32} lifted_27329(f32 b_73743) = {
  let {f32 res_73744} = lifted_27331(0i32)
  in {res_73744, b_73743}
}

fun {f32, f32} lifted_27340(f32 x_73745, f32 x_73746) = {
  {x_73745, x_73746}
}

fun {f32, f32} lifted_27356(f32 a_73747, f32 b_73748) = {
  {a_73747, b_73748}
}

fun {f32} lifted_27368(f32 x_73749) = {
  {x_73749}
}

fun {f32} lifted_27372(f32 x_73750, f32 y_73751) = {
  let {f32 res_73752} = fmul32(x_73750, y_73751)
  in {res_73752}
}

fun {f32} lifted_27376(f32 x_73753) = {
  {x_73753}
}

fun {f32} lifted_27379(f32 x_73754) = {
  {x_73754}
}

fun {f32} lifted_27383(f32 x_73755, f32 y_73756) = {
  let {f32 res_73757} = fmul32(x_73755, y_73756)
  in {res_73757}
}

fun {f32} lifted_27388(f32 x_73758, f32 y_73759) = {
  let {f32 res_73760} = fsub32(x_73758, y_73759)
  in {res_73760}
}

fun {f32} lifted_27392(f32 x_73761) = {
  {x_73761}
}

fun {f32} lifted_27396(f32 x_73762, f32 y_73763) = {
  let {f32 res_73764} = fmul32(x_73762, y_73763)
  in {res_73764}
}

fun {f32} lifted_27400(f32 x_73765) = {
  {x_73765}
}

fun {f32} lifted_27403(f32 x_73766) = {
  {x_73766}
}

fun {f32} lifted_27407(f32 x_73767, f32 y_73768) = {
  let {f32 res_73769} = fmul32(x_73767, y_73768)
  in {res_73769}
}

fun {f32} lifted_27412(f32 x_73770, f32 y_73771) = {
  let {f32 res_73772} = fadd32(x_73770, y_73771)
  in {res_73772}
}

fun {f32, f32} lifted_27366(f32 a_73773, f32 b_73774, f32 c_73775,
                            f32 d_73776) = {
  let {f32 arg_73777} = lifted_27368(a_73773)
  let {f32 arg_73778} = lifted_27372(arg_73777, c_73775)
  let {f32 arg_73779} = lifted_27376(arg_73778)
  let {f32 arg_73780} = lifted_27379(b_73774)
  let {f32 arg_73781} = lifted_27383(arg_73780, d_73776)
  let {f32 res_73782} = lifted_27388(arg_73779, arg_73781)
  let {f32 arg_73783} = lifted_27392(b_73774)
  let {f32 arg_73784} = lifted_27396(arg_73783, c_73775)
  let {f32 arg_73785} = lifted_27400(arg_73784)
  let {f32 arg_73786} = lifted_27403(a_73773)
  let {f32 arg_73787} = lifted_27407(arg_73786, d_73776)
  let {f32 res_73788} = lifted_27412(arg_73785, arg_73787)
  in {res_73782, res_73788}
}

fun {f32, f32} lifted_27350(f32 x_73789, f32 x_73790, f32 y_73791,
                            f32 y_73792) = {
  let {f32 arg_73793, f32 arg_73794} = lifted_27356(x_73789, x_73790)
  let {f32 res_73795, f32 res_73796} = lifted_27366(arg_73793, arg_73794,
                                                    y_73791, y_73792)
  in {res_73795, res_73796}
}

fun {f32, f32} lifted_27423(f32 x_73797, f32 x_73798) = {
  {x_73797, x_73798}
}

fun {f32, f32} lifted_27439(f32 a_73799, f32 b_73800) = {
  {a_73799, b_73800}
}

fun {f32} lifted_27451(f32 x_73801) = {
  {x_73801}
}

fun {f32} lifted_27455(f32 x_73802, f32 y_73803) = {
  let {f32 res_73804} = fmul32(x_73802, y_73803)
  in {res_73804}
}

fun {f32} lifted_27459(f32 x_73805) = {
  {x_73805}
}

fun {f32} lifted_27462(f32 x_73806) = {
  {x_73806}
}

fun {f32} lifted_27466(f32 x_73807, f32 y_73808) = {
  let {f32 res_73809} = fmul32(x_73807, y_73808)
  in {res_73809}
}

fun {f32} lifted_27471(f32 x_73810, f32 y_73811) = {
  let {f32 res_73812} = fsub32(x_73810, y_73811)
  in {res_73812}
}

fun {f32} lifted_27475(f32 x_73813) = {
  {x_73813}
}

fun {f32} lifted_27479(f32 x_73814, f32 y_73815) = {
  let {f32 res_73816} = fmul32(x_73814, y_73815)
  in {res_73816}
}

fun {f32} lifted_27483(f32 x_73817) = {
  {x_73817}
}

fun {f32} lifted_27486(f32 x_73818) = {
  {x_73818}
}

fun {f32} lifted_27490(f32 x_73819, f32 y_73820) = {
  let {f32 res_73821} = fmul32(x_73819, y_73820)
  in {res_73821}
}

fun {f32} lifted_27495(f32 x_73822, f32 y_73823) = {
  let {f32 res_73824} = fadd32(x_73822, y_73823)
  in {res_73824}
}

fun {f32, f32} lifted_27449(f32 a_73825, f32 b_73826, f32 c_73827,
                            f32 d_73828) = {
  let {f32 arg_73829} = lifted_27451(a_73825)
  let {f32 arg_73830} = lifted_27455(arg_73829, c_73827)
  let {f32 arg_73831} = lifted_27459(arg_73830)
  let {f32 arg_73832} = lifted_27462(b_73826)
  let {f32 arg_73833} = lifted_27466(arg_73832, d_73828)
  let {f32 res_73834} = lifted_27471(arg_73831, arg_73833)
  let {f32 arg_73835} = lifted_27475(b_73826)
  let {f32 arg_73836} = lifted_27479(arg_73835, c_73827)
  let {f32 arg_73837} = lifted_27483(arg_73836)
  let {f32 arg_73838} = lifted_27486(a_73825)
  let {f32 arg_73839} = lifted_27490(arg_73838, d_73828)
  let {f32 res_73840} = lifted_27495(arg_73837, arg_73839)
  in {res_73834, res_73840}
}

fun {f32, f32} lifted_27433(f32 x_73841, f32 x_73842, f32 y_73843,
                            f32 y_73844) = {
  let {f32 arg_73845, f32 arg_73846} = lifted_27439(x_73841, x_73842)
  let {f32 res_73847, f32 res_73848} = lifted_27449(arg_73845, arg_73846,
                                                    y_73843, y_73844)
  in {res_73847, res_73848}
}

fun {f32, f32} lifted_27513(f32 a_73849, f32 b_73850) = {
  {a_73849, b_73850}
}

fun {f32} lifted_27523(f32 x_73851) = {
  {x_73851}
}

fun {f32} lifted_27527(f32 x_73852, f32 y_73853) = {
  let {f32 res_73854} = fsub32(x_73852, y_73853)
  in {res_73854}
}

fun {f32} lifted_27531(f32 x_73855) = {
  {x_73855}
}

fun {f32} lifted_27535(f32 x_73856, f32 y_73857) = {
  let {f32 res_73858} = fsub32(x_73856, y_73857)
  in {res_73858}
}

fun {f32, f32} lifted_27521(f32 a_73859, f32 b_73860, f32 c_73861,
                            f32 d_73862) = {
  let {f32 arg_73863} = lifted_27523(a_73859)
  let {f32 res_73864} = lifted_27527(arg_73863, c_73861)
  let {f32 arg_73865} = lifted_27531(b_73860)
  let {f32 res_73866} = lifted_27535(arg_73865, d_73862)
  in {res_73864, res_73866}
}

fun {f32, f32} lifted_27509(f32 x_73867, f32 x_73868, f32 y_73869,
                            f32 y_73870) = {
  let {f32 arg_73871, f32 arg_73872} = lifted_27513(x_73867, x_73868)
  let {f32 res_73873, f32 res_73874} = lifted_27521(arg_73871, arg_73872,
                                                    y_73869, y_73870)
  in {res_73873, res_73874}
}

fun {f32, f32} lifted_27549(f32 x_73875, f32 x_73876) = {
  {x_73875, x_73876}
}

fun {f32, f32} lifted_27565(f32 a_73877, f32 b_73878) = {
  {a_73877, b_73878}
}

fun {f32} lifted_27577(f32 x_73879) = {
  {x_73879}
}

fun {f32} lifted_27581(f32 x_73880, f32 y_73881) = {
  let {f32 res_73882} = fmul32(x_73880, y_73881)
  in {res_73882}
}

fun {f32} lifted_27585(f32 x_73883) = {
  {x_73883}
}

fun {f32} lifted_27588(f32 x_73884) = {
  {x_73884}
}

fun {f32} lifted_27592(f32 x_73885, f32 y_73886) = {
  let {f32 res_73887} = fmul32(x_73885, y_73886)
  in {res_73887}
}

fun {f32} lifted_27597(f32 x_73888, f32 y_73889) = {
  let {f32 res_73890} = fsub32(x_73888, y_73889)
  in {res_73890}
}

fun {f32} lifted_27601(f32 x_73891) = {
  {x_73891}
}

fun {f32} lifted_27605(f32 x_73892, f32 y_73893) = {
  let {f32 res_73894} = fmul32(x_73892, y_73893)
  in {res_73894}
}

fun {f32} lifted_27609(f32 x_73895) = {
  {x_73895}
}

fun {f32} lifted_27612(f32 x_73896) = {
  {x_73896}
}

fun {f32} lifted_27616(f32 x_73897, f32 y_73898) = {
  let {f32 res_73899} = fmul32(x_73897, y_73898)
  in {res_73899}
}

fun {f32} lifted_27621(f32 x_73900, f32 y_73901) = {
  let {f32 res_73902} = fadd32(x_73900, y_73901)
  in {res_73902}
}

fun {f32, f32} lifted_27575(f32 a_73903, f32 b_73904, f32 c_73905,
                            f32 d_73906) = {
  let {f32 arg_73907} = lifted_27577(a_73903)
  let {f32 arg_73908} = lifted_27581(arg_73907, c_73905)
  let {f32 arg_73909} = lifted_27585(arg_73908)
  let {f32 arg_73910} = lifted_27588(b_73904)
  let {f32 arg_73911} = lifted_27592(arg_73910, d_73906)
  let {f32 res_73912} = lifted_27597(arg_73909, arg_73911)
  let {f32 arg_73913} = lifted_27601(b_73904)
  let {f32 arg_73914} = lifted_27605(arg_73913, c_73905)
  let {f32 arg_73915} = lifted_27609(arg_73914)
  let {f32 arg_73916} = lifted_27612(a_73903)
  let {f32 arg_73917} = lifted_27616(arg_73916, d_73906)
  let {f32 res_73918} = lifted_27621(arg_73915, arg_73917)
  in {res_73912, res_73918}
}

fun {f32, f32} lifted_27559(f32 x_73919, f32 x_73920, f32 y_73921,
                            f32 y_73922) = {
  let {f32 arg_73923, f32 arg_73924} = lifted_27565(x_73919, x_73920)
  let {f32 res_73925, f32 res_73926} = lifted_27575(arg_73923, arg_73924,
                                                    y_73921, y_73922)
  in {res_73925, res_73926}
}

fun {f32, f32} lifted_27632(f32 x_73927, f32 x_73928) = {
  {x_73927, x_73928}
}

fun {f32, f32} lifted_27639(f32 x_73929, f32 x_73930) = {
  {x_73929, x_73930}
}

fun {f32, f32} lifted_27646(f32 x_73931, f32 x_73932) = {
  {x_73931, x_73932}
}

fun {f32, f32} lifted_27653(f32 x_73933, f32 x_73934) = {
  {x_73933, x_73934}
}

fun {f32, f32} lifted_27667(f32 a_73935, f32 b_73936) = {
  {a_73935, b_73936}
}

fun {f32} lifted_27677(f32 x_73937) = {
  {x_73937}
}

fun {f32} lifted_27681(f32 x_73938, f32 y_73939) = {
  let {f32 res_73940} = fadd32(x_73938, y_73939)
  in {res_73940}
}

fun {f32} lifted_27685(f32 x_73941) = {
  {x_73941}
}

fun {f32} lifted_27689(f32 x_73942, f32 y_73943) = {
  let {f32 res_73944} = fadd32(x_73942, y_73943)
  in {res_73944}
}

fun {f32, f32} lifted_27675(f32 a_73945, f32 b_73946, f32 c_73947,
                            f32 d_73948) = {
  let {f32 arg_73949} = lifted_27677(a_73945)
  let {f32 res_73950} = lifted_27681(arg_73949, c_73947)
  let {f32 arg_73951} = lifted_27685(b_73946)
  let {f32 res_73952} = lifted_27689(arg_73951, d_73948)
  in {res_73950, res_73952}
}

fun {f32, f32} lifted_27663(f32 x_73953, f32 x_73954, f32 y_73955,
                            f32 y_73956) = {
  let {f32 arg_73957, f32 arg_73958} = lifted_27667(x_73953, x_73954)
  let {f32 res_73959, f32 res_73960} = lifted_27675(arg_73957, arg_73958,
                                                    y_73955, y_73956)
  in {res_73959, res_73960}
}

fun {f32, f32} lifted_27709(f32 a_73961, f32 b_73962) = {
  {a_73961, b_73962}
}

fun {f32} lifted_27721(f32 x_73963) = {
  {x_73963}
}

fun {f32} lifted_27725(f32 x_73964, f32 y_73965) = {
  let {f32 res_73966} = fmul32(x_73964, y_73965)
  in {res_73966}
}

fun {f32} lifted_27729(f32 x_73967) = {
  {x_73967}
}

fun {f32} lifted_27732(f32 x_73968) = {
  {x_73968}
}

fun {f32} lifted_27736(f32 x_73969, f32 y_73970) = {
  let {f32 res_73971} = fmul32(x_73969, y_73970)
  in {res_73971}
}

fun {f32} lifted_27741(f32 x_73972, f32 y_73973) = {
  let {f32 res_73974} = fsub32(x_73972, y_73973)
  in {res_73974}
}

fun {f32} lifted_27745(f32 x_73975) = {
  {x_73975}
}

fun {f32} lifted_27749(f32 x_73976, f32 y_73977) = {
  let {f32 res_73978} = fmul32(x_73976, y_73977)
  in {res_73978}
}

fun {f32} lifted_27753(f32 x_73979) = {
  {x_73979}
}

fun {f32} lifted_27756(f32 x_73980) = {
  {x_73980}
}

fun {f32} lifted_27760(f32 x_73981, f32 y_73982) = {
  let {f32 res_73983} = fmul32(x_73981, y_73982)
  in {res_73983}
}

fun {f32} lifted_27765(f32 x_73984, f32 y_73985) = {
  let {f32 res_73986} = fadd32(x_73984, y_73985)
  in {res_73986}
}

fun {f32, f32} lifted_27719(f32 a_73987, f32 b_73988, f32 c_73989,
                            f32 d_73990) = {
  let {f32 arg_73991} = lifted_27721(a_73987)
  let {f32 arg_73992} = lifted_27725(arg_73991, c_73989)
  let {f32 arg_73993} = lifted_27729(arg_73992)
  let {f32 arg_73994} = lifted_27732(b_73988)
  let {f32 arg_73995} = lifted_27736(arg_73994, d_73990)
  let {f32 res_73996} = lifted_27741(arg_73993, arg_73995)
  let {f32 arg_73997} = lifted_27745(b_73988)
  let {f32 arg_73998} = lifted_27749(arg_73997, c_73989)
  let {f32 arg_73999} = lifted_27753(arg_73998)
  let {f32 arg_74000} = lifted_27756(a_73987)
  let {f32 arg_74001} = lifted_27760(arg_74000, d_73990)
  let {f32 res_74002} = lifted_27765(arg_73999, arg_74001)
  in {res_73996, res_74002}
}

fun {f32, f32} lifted_27703(f32 x_74003, f32 x_74004, f32 y_74005,
                            f32 y_74006) = {
  let {f32 arg_74007, f32 arg_74008} = lifted_27709(x_74003, x_74004)
  let {f32 res_74009, f32 res_74010} = lifted_27719(arg_74007, arg_74008,
                                                    y_74005, y_74006)
  in {res_74009, res_74010}
}

fun {f32, f32} lifted_27785(f32 a_74011, f32 b_74012) = {
  {a_74011, b_74012}
}

fun {f32} lifted_27797(f32 x_74013) = {
  {x_74013}
}

fun {f32} lifted_27801(f32 x_74014, f32 y_74015) = {
  let {f32 res_74016} = fmul32(x_74014, y_74015)
  in {res_74016}
}

fun {f32} lifted_27805(f32 x_74017) = {
  {x_74017}
}

fun {f32} lifted_27808(f32 x_74018) = {
  {x_74018}
}

fun {f32} lifted_27812(f32 x_74019, f32 y_74020) = {
  let {f32 res_74021} = fmul32(x_74019, y_74020)
  in {res_74021}
}

fun {f32} lifted_27817(f32 x_74022, f32 y_74023) = {
  let {f32 res_74024} = fsub32(x_74022, y_74023)
  in {res_74024}
}

fun {f32} lifted_27821(f32 x_74025) = {
  {x_74025}
}

fun {f32} lifted_27825(f32 x_74026, f32 y_74027) = {
  let {f32 res_74028} = fmul32(x_74026, y_74027)
  in {res_74028}
}

fun {f32} lifted_27829(f32 x_74029) = {
  {x_74029}
}

fun {f32} lifted_27832(f32 x_74030) = {
  {x_74030}
}

fun {f32} lifted_27836(f32 x_74031, f32 y_74032) = {
  let {f32 res_74033} = fmul32(x_74031, y_74032)
  in {res_74033}
}

fun {f32} lifted_27841(f32 x_74034, f32 y_74035) = {
  let {f32 res_74036} = fadd32(x_74034, y_74035)
  in {res_74036}
}

fun {f32, f32} lifted_27795(f32 a_74037, f32 b_74038, f32 c_74039,
                            f32 d_74040) = {
  let {f32 arg_74041} = lifted_27797(a_74037)
  let {f32 arg_74042} = lifted_27801(arg_74041, c_74039)
  let {f32 arg_74043} = lifted_27805(arg_74042)
  let {f32 arg_74044} = lifted_27808(b_74038)
  let {f32 arg_74045} = lifted_27812(arg_74044, d_74040)
  let {f32 res_74046} = lifted_27817(arg_74043, arg_74045)
  let {f32 arg_74047} = lifted_27821(b_74038)
  let {f32 arg_74048} = lifted_27825(arg_74047, c_74039)
  let {f32 arg_74049} = lifted_27829(arg_74048)
  let {f32 arg_74050} = lifted_27832(a_74037)
  let {f32 arg_74051} = lifted_27836(arg_74050, d_74040)
  let {f32 res_74052} = lifted_27841(arg_74049, arg_74051)
  in {res_74046, res_74052}
}

fun {f32, f32} lifted_27779(f32 x_74053, f32 x_74054, f32 y_74055,
                            f32 y_74056) = {
  let {f32 arg_74057, f32 arg_74058} = lifted_27785(x_74053, x_74054)
  let {f32 res_74059, f32 res_74060} = lifted_27795(arg_74057, arg_74058,
                                                    y_74055, y_74056)
  in {res_74059, res_74060}
}

fun {f32, f32} lifted_27859(f32 a_74061, f32 b_74062) = {
  {a_74061, b_74062}
}

fun {f32} lifted_27869(f32 x_74063) = {
  {x_74063}
}

fun {f32} lifted_27873(f32 x_74064, f32 y_74065) = {
  let {f32 res_74066} = fadd32(x_74064, y_74065)
  in {res_74066}
}

fun {f32} lifted_27877(f32 x_74067) = {
  {x_74067}
}

fun {f32} lifted_27881(f32 x_74068, f32 y_74069) = {
  let {f32 res_74070} = fadd32(x_74068, y_74069)
  in {res_74070}
}

fun {f32, f32} lifted_27867(f32 a_74071, f32 b_74072, f32 c_74073,
                            f32 d_74074) = {
  let {f32 arg_74075} = lifted_27869(a_74071)
  let {f32 res_74076} = lifted_27873(arg_74075, c_74073)
  let {f32 arg_74077} = lifted_27877(b_74072)
  let {f32 res_74078} = lifted_27881(arg_74077, d_74074)
  in {res_74076, res_74078}
}

fun {f32, f32} lifted_27855(f32 x_74079, f32 x_74080, f32 y_74081,
                            f32 y_74082) = {
  let {f32 arg_74083, f32 arg_74084} = lifted_27859(x_74079, x_74080)
  let {f32 res_74085, f32 res_74086} = lifted_27867(arg_74083, arg_74084,
                                                    y_74081, y_74082)
  in {res_74085, res_74086}
}

fun {f32} lifted_27900(f32 x_74087) = {
  {x_74087}
}

fun {f32} lifted_27903(f32 x_74088) = {
  {x_74088}
}

fun {f32} lifted_27907(f32 x_74089, f32 y_74090) = {
  let {f32 res_74091} = fmul32(x_74089, y_74090)
  in {res_74091}
}

fun {f32} lifted_27911(f32 x_74092) = {
  {x_74092}
}

fun {f32} lifted_27914(f32 x_74093) = {
  {x_74093}
}

fun {f32} lifted_27918(f32 x_74094, f32 y_74095) = {
  let {f32 res_74096} = fmul32(x_74094, y_74095)
  in {res_74096}
}

fun {f32} lifted_27923(f32 x_74097, f32 y_74098) = {
  let {f32 res_74099} = fadd32(x_74097, y_74098)
  in {res_74099}
}

fun {f32} lifted_27927(f32 x_74100) = {
  let {f32 res_74101} = sqrt32(x_74100)
  in {res_74101}
}

fun {f32} lifted_27932(f32 x_74102, f32 y_74103) = {
  let {f32 res_74104} = fadd32(x_74102, y_74103)
  in {res_74104}
}

fun {f32} lifted_27936(f32 x_74105) = {
  {x_74105}
}

fun {f32} lifted_27939(i32 x_74106) = {
  let {f32 res_74107} = sitofp i32 x_74106 to f32
  in {res_74107}
}

fun {f32} lifted_27944(f32 x_74108, f32 y_74109) = {
  let {f32 res_74110} = fdiv32(x_74108, y_74109)
  in {res_74110}
}

fun {f32} lifted_27948(f32 x_74111) = {
  let {f32 res_74112} = sqrt32(x_74111)
  in {res_74112}
}

fun {f32} lifted_27957(f32 x_74113) = {
  {x_74113}
}

fun {bool} lifted_27961(f32 x_74114, f32 y_74115) = {
  let {bool res_74116} = lt32(x_74114, y_74115)
  in {res_74116}
}

fun {f32} lifted_27966(f32 x_74117) = {
  {x_74117}
}

fun {bool} lifted_27970(f32 x_74118, f32 y_74119) = {
  let {bool res_74120} = eq_f32(x_74118, y_74119)
  in {res_74120}
}

fun {f32} lifted_27955(f32 x_74121) = {
  let {f32 arg_74122} = lifted_27957(x_74121)
  let {bool cond_74123} = lifted_27961(arg_74122, 0.0f32)
  let {f32 res_74124} =
    -- Branch returns: {f32}
    if cond_74123
    then {
      let {f32 res_74125} = fsub32(0.0f32, 1.0f32)
      in {res_74125}
    } else {
      let {f32 arg_74126} = lifted_27966(x_74121)
      let {bool cond_74127} = lifted_27970(arg_74126, 0.0f32)
      let {f32 res_74128} =
        -- Branch returns: {f32}
        if cond_74127
        then {0.0f32} else {1.0f32}
      in {res_74128}
    }
  in {res_74124}
}

fun {i32} lifted_27977(f32 x_74129) = {
  let {i32 res_74130} = fptosi f32 x_74129 to i32
  in {res_74130}
}

fun {f32} lifted_27981(i32 x_74131) = {
  let {f32 res_74132} = sitofp i32 x_74131 to f32
  in {res_74132}
}

fun {f32} lifted_27985(f32 x_74133) = {
  {x_74133}
}

fun {f32} lifted_27988(i32 x_74134) = {
  let {f32 res_74135} = sitofp i32 x_74134 to f32
  in {res_74135}
}

fun {f32} lifted_27992(f32 x_74136) = {
  {x_74136}
}

fun {f32} lifted_27996(f32 x_74137, f32 y_74138) = {
  let {f32 res_74139} = fsub32(x_74137, y_74138)
  in {res_74139}
}

fun {f32} lifted_28000(f32 x_74140) = {
  {x_74140}
}

fun {f32} lifted_28003(f32 x_74141) = {
  {x_74141}
}

fun {f32} lifted_28007(f32 x_74142, f32 y_74143) = {
  let {f32 res_74144} = fmul32(x_74142, y_74143)
  in {res_74144}
}

fun {f32} lifted_28011(f32 x_74145) = {
  {x_74145}
}

fun {f32} lifted_28014(f32 x_74146) = {
  {x_74146}
}

fun {f32} lifted_28018(f32 x_74147, f32 y_74148) = {
  let {f32 res_74149} = fmul32(x_74147, y_74148)
  in {res_74149}
}

fun {f32} lifted_28023(f32 x_74150, f32 y_74151) = {
  let {f32 res_74152} = fadd32(x_74150, y_74151)
  in {res_74152}
}

fun {f32} lifted_28027(f32 x_74153) = {
  let {f32 res_74154} = sqrt32(x_74153)
  in {res_74154}
}

fun {f32} lifted_28032(f32 x_74155, f32 y_74156) = {
  let {f32 res_74157} = fadd32(x_74155, y_74156)
  in {res_74157}
}

fun {f32} lifted_28036(f32 x_74158) = {
  {x_74158}
}

fun {f32} lifted_28039(i32 x_74159) = {
  let {f32 res_74160} = sitofp i32 x_74159 to f32
  in {res_74160}
}

fun {f32} lifted_28044(f32 x_74161, f32 y_74162) = {
  let {f32 res_74163} = fdiv32(x_74161, y_74162)
  in {res_74163}
}

fun {f32} lifted_28048(f32 x_74164) = {
  let {f32 res_74165} = sqrt32(x_74164)
  in {res_74165}
}

fun {f32} lifted_28053(f32 x_74166, f32 y_74167) = {
  let {f32 res_74168} = fmul32(x_74166, y_74167)
  in {res_74168}
}

fun {f32, f32} lifted_27898(f32 a_74169, f32 b_74170) = {
  let {f32 arg_74171} = lifted_27900(a_74169)
  let {f32 arg_74172} = lifted_27903(a_74169)
  let {f32 arg_74173} = lifted_27907(arg_74172, a_74169)
  let {f32 arg_74174} = lifted_27911(arg_74173)
  let {f32 arg_74175} = lifted_27914(b_74170)
  let {f32 arg_74176} = lifted_27918(arg_74175, b_74170)
  let {f32 arg_74177} = lifted_27923(arg_74174, arg_74176)
  let {f32 arg_74178} = lifted_27927(arg_74177)
  let {f32 arg_74179} = lifted_27932(arg_74171, arg_74178)
  let {f32 arg_74180} = lifted_27936(arg_74179)
  let {f32 arg_74181} = lifted_27939(2i32)
  let {f32 arg_74182} = lifted_27944(arg_74180, arg_74181)
  let {f32 res_74183} = lifted_27948(arg_74182)
  let {f32 gamma_74184} = res_74183
  let {f32 arg_74185} = lifted_27955(b_74170)
  let {i32 arg_74186} = lifted_27977(arg_74185)
  let {f32 arg_74187} = lifted_27981(arg_74186)
  let {f32 arg_74188} = lifted_27985(arg_74187)
  let {f32 arg_74189} = lifted_27988(0i32)
  let {f32 arg_74190} = lifted_27992(arg_74189)
  let {f32 arg_74191} = lifted_27996(arg_74190, a_74169)
  let {f32 arg_74192} = lifted_28000(arg_74191)
  let {f32 arg_74193} = lifted_28003(a_74169)
  let {f32 arg_74194} = lifted_28007(arg_74193, a_74169)
  let {f32 arg_74195} = lifted_28011(arg_74194)
  let {f32 arg_74196} = lifted_28014(b_74170)
  let {f32 arg_74197} = lifted_28018(arg_74196, b_74170)
  let {f32 arg_74198} = lifted_28023(arg_74195, arg_74197)
  let {f32 arg_74199} = lifted_28027(arg_74198)
  let {f32 arg_74200} = lifted_28032(arg_74192, arg_74199)
  let {f32 arg_74201} = lifted_28036(arg_74200)
  let {f32 arg_74202} = lifted_28039(2i32)
  let {f32 arg_74203} = lifted_28044(arg_74201, arg_74202)
  let {f32 arg_74204} = lifted_28048(arg_74203)
  let {f32 res_74205} = lifted_28053(arg_74188, arg_74204)
  let {f32 delta_74206} = res_74205
  in {gamma_74184, delta_74206}
}

fun {f32, f32} lifted_28066(f32 x_74207, f32 x_74208) = {
  {x_74207, x_74208}
}

fun {f32, f32} lifted_28080(f32 a_74209, f32 b_74210) = {
  {a_74209, b_74210}
}

fun {f32} lifted_28090(f32 x_74211) = {
  {x_74211}
}

fun {f32} lifted_28094(f32 x_74212, f32 y_74213) = {
  let {f32 res_74214} = fsub32(x_74212, y_74213)
  in {res_74214}
}

fun {f32} lifted_28098(f32 x_74215) = {
  {x_74215}
}

fun {f32} lifted_28102(f32 x_74216, f32 y_74217) = {
  let {f32 res_74218} = fsub32(x_74216, y_74217)
  in {res_74218}
}

fun {f32, f32} lifted_28088(f32 a_74219, f32 b_74220, f32 c_74221,
                            f32 d_74222) = {
  let {f32 arg_74223} = lifted_28090(a_74219)
  let {f32 res_74224} = lifted_28094(arg_74223, c_74221)
  let {f32 arg_74225} = lifted_28098(b_74220)
  let {f32 res_74226} = lifted_28102(arg_74225, d_74222)
  in {res_74224, res_74226}
}

fun {f32, f32} lifted_28076(f32 x_74227, f32 x_74228, f32 y_74229,
                            f32 y_74230) = {
  let {f32 arg_74231, f32 arg_74232} = lifted_28080(x_74227, x_74228)
  let {f32 res_74233, f32 res_74234} = lifted_28088(arg_74231, arg_74232,
                                                    y_74229, y_74230)
  in {res_74233, res_74234}
}

fun {f32, f32} lifted_28116(f32 x_74235, f32 x_74236) = {
  {x_74235, x_74236}
}

fun {f32, f32} lifted_28123(f32 x_74237, f32 x_74238) = {
  {x_74237, x_74238}
}

fun {f32, f32} lifted_28137(f32 a_74239, f32 b_74240) = {
  {a_74239, b_74240}
}

fun {f32} lifted_28147(f32 x_74241) = {
  {x_74241}
}

fun {f32} lifted_28151(f32 x_74242, f32 y_74243) = {
  let {f32 res_74244} = fadd32(x_74242, y_74243)
  in {res_74244}
}

fun {f32} lifted_28155(f32 x_74245) = {
  {x_74245}
}

fun {f32} lifted_28159(f32 x_74246, f32 y_74247) = {
  let {f32 res_74248} = fadd32(x_74246, y_74247)
  in {res_74248}
}

fun {f32, f32} lifted_28145(f32 a_74249, f32 b_74250, f32 c_74251,
                            f32 d_74252) = {
  let {f32 arg_74253} = lifted_28147(a_74249)
  let {f32 res_74254} = lifted_28151(arg_74253, c_74251)
  let {f32 arg_74255} = lifted_28155(b_74250)
  let {f32 res_74256} = lifted_28159(arg_74255, d_74252)
  in {res_74254, res_74256}
}

fun {f32, f32} lifted_28133(f32 x_74257, f32 x_74258, f32 y_74259,
                            f32 y_74260) = {
  let {f32 arg_74261, f32 arg_74262} = lifted_28137(x_74257, x_74258)
  let {f32 res_74263, f32 res_74264} = lifted_28145(arg_74261, arg_74262,
                                                    y_74259, y_74260)
  in {res_74263, res_74264}
}

fun {f32, f32} lifted_28180(f32 a_74265, f32 b_74266) = {
  {a_74265, b_74266}
}

fun {f32} lifted_28193(f32 x_74267) = {
  {x_74267}
}

fun {f32} lifted_28197(f32 x_74268, f32 y_74269) = {
  let {f32 res_74270} = fmul32(x_74268, y_74269)
  in {res_74270}
}

fun {f32} lifted_28201(f32 x_74271) = {
  {x_74271}
}

fun {f32} lifted_28204(f32 x_74272) = {
  {x_74272}
}

fun {f32} lifted_28208(f32 x_74273, f32 y_74274) = {
  let {f32 res_74275} = fmul32(x_74273, y_74274)
  in {res_74275}
}

fun {f32} lifted_28213(f32 x_74276, f32 y_74277) = {
  let {f32 res_74278} = fadd32(x_74276, y_74277)
  in {res_74278}
}

fun {f32} lifted_28217(f32 x_74279) = {
  {x_74279}
}

fun {f32} lifted_28220(f32 x_74280) = {
  {x_74280}
}

fun {f32} lifted_28224(f32 x_74281, f32 y_74282) = {
  let {f32 res_74283} = fmul32(x_74281, y_74282)
  in {res_74283}
}

fun {f32} lifted_28228(f32 x_74284) = {
  {x_74284}
}

fun {f32} lifted_28231(f32 x_74285) = {
  {x_74285}
}

fun {f32} lifted_28235(f32 x_74286, f32 y_74287) = {
  let {f32 res_74288} = fmul32(x_74286, y_74287)
  in {res_74288}
}

fun {f32} lifted_28240(f32 x_74289, f32 y_74290) = {
  let {f32 res_74291} = fadd32(x_74289, y_74290)
  in {res_74291}
}

fun {f32} lifted_28245(f32 x_74292, f32 y_74293) = {
  let {f32 res_74294} = fdiv32(x_74292, y_74293)
  in {res_74294}
}

fun {f32} lifted_28249(f32 x_74295) = {
  {x_74295}
}

fun {f32} lifted_28253(f32 x_74296, f32 y_74297) = {
  let {f32 res_74298} = fmul32(x_74296, y_74297)
  in {res_74298}
}

fun {f32} lifted_28257(f32 x_74299) = {
  {x_74299}
}

fun {f32} lifted_28260(f32 x_74300) = {
  {x_74300}
}

fun {f32} lifted_28264(f32 x_74301, f32 y_74302) = {
  let {f32 res_74303} = fmul32(x_74301, y_74302)
  in {res_74303}
}

fun {f32} lifted_28269(f32 x_74304, f32 y_74305) = {
  let {f32 res_74306} = fsub32(x_74304, y_74305)
  in {res_74306}
}

fun {f32} lifted_28273(f32 x_74307) = {
  {x_74307}
}

fun {f32} lifted_28276(f32 x_74308) = {
  {x_74308}
}

fun {f32} lifted_28280(f32 x_74309, f32 y_74310) = {
  let {f32 res_74311} = fmul32(x_74309, y_74310)
  in {res_74311}
}

fun {f32} lifted_28284(f32 x_74312) = {
  {x_74312}
}

fun {f32} lifted_28287(f32 x_74313) = {
  {x_74313}
}

fun {f32} lifted_28291(f32 x_74314, f32 y_74315) = {
  let {f32 res_74316} = fmul32(x_74314, y_74315)
  in {res_74316}
}

fun {f32} lifted_28296(f32 x_74317, f32 y_74318) = {
  let {f32 res_74319} = fadd32(x_74317, y_74318)
  in {res_74319}
}

fun {f32} lifted_28301(f32 x_74320, f32 y_74321) = {
  let {f32 res_74322} = fdiv32(x_74320, y_74321)
  in {res_74322}
}

fun {f32, f32} lifted_28191(f32 a_74323, f32 b_74324, f32 c_74325,
                            f32 d_74326) = {
  let {f32 arg_74327} = lifted_28193(a_74323)
  let {f32 arg_74328} = lifted_28197(arg_74327, c_74325)
  let {f32 arg_74329} = lifted_28201(arg_74328)
  let {f32 arg_74330} = lifted_28204(b_74324)
  let {f32 arg_74331} = lifted_28208(arg_74330, d_74326)
  let {f32 arg_74332} = lifted_28213(arg_74329, arg_74331)
  let {f32 arg_74333} = lifted_28217(arg_74332)
  let {f32 arg_74334} = lifted_28220(c_74325)
  let {f32 arg_74335} = lifted_28224(arg_74334, c_74325)
  let {f32 arg_74336} = lifted_28228(arg_74335)
  let {f32 arg_74337} = lifted_28231(d_74326)
  let {f32 arg_74338} = lifted_28235(arg_74337, d_74326)
  let {f32 arg_74339} = lifted_28240(arg_74336, arg_74338)
  let {f32 res_74340} = lifted_28245(arg_74333, arg_74339)
  let {f32 arg_74341} = lifted_28249(b_74324)
  let {f32 arg_74342} = lifted_28253(arg_74341, c_74325)
  let {f32 arg_74343} = lifted_28257(arg_74342)
  let {f32 arg_74344} = lifted_28260(a_74323)
  let {f32 arg_74345} = lifted_28264(arg_74344, d_74326)
  let {f32 arg_74346} = lifted_28269(arg_74343, arg_74345)
  let {f32 arg_74347} = lifted_28273(arg_74346)
  let {f32 arg_74348} = lifted_28276(c_74325)
  let {f32 arg_74349} = lifted_28280(arg_74348, c_74325)
  let {f32 arg_74350} = lifted_28284(arg_74349)
  let {f32 arg_74351} = lifted_28287(d_74326)
  let {f32 arg_74352} = lifted_28291(arg_74351, d_74326)
  let {f32 arg_74353} = lifted_28296(arg_74350, arg_74352)
  let {f32 res_74354} = lifted_28301(arg_74347, arg_74353)
  in {res_74340, res_74354}
}

fun {f32, f32} lifted_28173(f32 x_74355, f32 x_74356, f32 y_74357,
                            f32 y_74358) = {
  let {f32 arg_74359, f32 arg_74360} = lifted_28180(x_74355, x_74356)
  let {f32 res_74361, f32 res_74362} = lifted_28191(arg_74359, arg_74360,
                                                    y_74357, y_74358)
  in {res_74361, res_74362}
}

fun {f32, f32} lifted_28315(f32 x_74363, f32 x_74364) = {
  {x_74363, x_74364}
}

fun {f32, f32} lifted_28322(f32 x_74365, f32 x_74366) = {
  {x_74365, x_74366}
}

fun {f32, f32} lifted_28338(f32 a_74367, f32 b_74368) = {
  {a_74367, b_74368}
}

fun {f32} lifted_28350(f32 x_74369) = {
  {x_74369}
}

fun {f32} lifted_28354(f32 x_74370, f32 y_74371) = {
  let {f32 res_74372} = fmul32(x_74370, y_74371)
  in {res_74372}
}

fun {f32} lifted_28358(f32 x_74373) = {
  {x_74373}
}

fun {f32} lifted_28361(f32 x_74374) = {
  {x_74374}
}

fun {f32} lifted_28365(f32 x_74375, f32 y_74376) = {
  let {f32 res_74377} = fmul32(x_74375, y_74376)
  in {res_74377}
}

fun {f32} lifted_28370(f32 x_74378, f32 y_74379) = {
  let {f32 res_74380} = fsub32(x_74378, y_74379)
  in {res_74380}
}

fun {f32} lifted_28374(f32 x_74381) = {
  {x_74381}
}

fun {f32} lifted_28378(f32 x_74382, f32 y_74383) = {
  let {f32 res_74384} = fmul32(x_74382, y_74383)
  in {res_74384}
}

fun {f32} lifted_28382(f32 x_74385) = {
  {x_74385}
}

fun {f32} lifted_28385(f32 x_74386) = {
  {x_74386}
}

fun {f32} lifted_28389(f32 x_74387, f32 y_74388) = {
  let {f32 res_74389} = fmul32(x_74387, y_74388)
  in {res_74389}
}

fun {f32} lifted_28394(f32 x_74390, f32 y_74391) = {
  let {f32 res_74392} = fadd32(x_74390, y_74391)
  in {res_74392}
}

fun {f32, f32} lifted_28348(f32 a_74393, f32 b_74394, f32 c_74395,
                            f32 d_74396) = {
  let {f32 arg_74397} = lifted_28350(a_74393)
  let {f32 arg_74398} = lifted_28354(arg_74397, c_74395)
  let {f32 arg_74399} = lifted_28358(arg_74398)
  let {f32 arg_74400} = lifted_28361(b_74394)
  let {f32 arg_74401} = lifted_28365(arg_74400, d_74396)
  let {f32 res_74402} = lifted_28370(arg_74399, arg_74401)
  let {f32 arg_74403} = lifted_28374(b_74394)
  let {f32 arg_74404} = lifted_28378(arg_74403, c_74395)
  let {f32 arg_74405} = lifted_28382(arg_74404)
  let {f32 arg_74406} = lifted_28385(a_74393)
  let {f32 arg_74407} = lifted_28389(arg_74406, d_74396)
  let {f32 res_74408} = lifted_28394(arg_74405, arg_74407)
  in {res_74402, res_74408}
}

fun {f32, f32} lifted_28332(f32 x_74409, f32 x_74410, f32 y_74411,
                            f32 y_74412) = {
  let {f32 arg_74413, f32 arg_74414} = lifted_28338(x_74409, x_74410)
  let {f32 res_74415, f32 res_74416} = lifted_28348(arg_74413, arg_74414,
                                                    y_74411, y_74412)
  in {res_74415, res_74416}
}

fun {f32, f32} lifted_28412(f32 a_74417, f32 b_74418) = {
  {a_74417, b_74418}
}

fun {f32} lifted_28422(f32 x_74419) = {
  {x_74419}
}

fun {f32} lifted_28426(f32 x_74420, f32 y_74421) = {
  let {f32 res_74422} = fsub32(x_74420, y_74421)
  in {res_74422}
}

fun {f32} lifted_28430(f32 x_74423) = {
  {x_74423}
}

fun {f32} lifted_28434(f32 x_74424, f32 y_74425) = {
  let {f32 res_74426} = fsub32(x_74424, y_74425)
  in {res_74426}
}

fun {f32, f32} lifted_28420(f32 a_74427, f32 b_74428, f32 c_74429,
                            f32 d_74430) = {
  let {f32 arg_74431} = lifted_28422(a_74427)
  let {f32 res_74432} = lifted_28426(arg_74431, c_74429)
  let {f32 arg_74433} = lifted_28430(b_74428)
  let {f32 res_74434} = lifted_28434(arg_74433, d_74430)
  in {res_74432, res_74434}
}

fun {f32, f32} lifted_28408(f32 x_74435, f32 x_74436, f32 y_74437,
                            f32 y_74438) = {
  let {f32 arg_74439, f32 arg_74440} = lifted_28412(x_74435, x_74436)
  let {f32 res_74441, f32 res_74442} = lifted_28420(arg_74439, arg_74440,
                                                    y_74437, y_74438)
  in {res_74441, res_74442}
}

fun {f32} lifted_28450(f32 x_74443) = {
  let {f32 res_74444} = exp32(x_74443)
  in {res_74444}
}

fun {f32} lifted_28455(f32 x_74445) = {
  {x_74445}
}

fun {f32} lifted_28458(f32 x_74446) = {
  let {f32 res_74447} = cos32(x_74446)
  in {res_74447}
}

fun {f32} lifted_28463(f32 x_74448, f32 y_74449) = {
  let {f32 res_74450} = fmul32(x_74448, y_74449)
  in {res_74450}
}

fun {f32} lifted_28467(f32 a_74451) = {
  {a_74451}
}

fun {f32} lifted_28470(f32 x_74452) = {
  {x_74452}
}

fun {f32} lifted_28473(f32 x_74453) = {
  let {f32 res_74454} = sin32(x_74453)
  in {res_74454}
}

fun {f32} lifted_28478(f32 x_74455, f32 y_74456) = {
  let {f32 res_74457} = fmul32(x_74455, y_74456)
  in {res_74457}
}

fun {f32, f32} lifted_28483(f32 a_74458, f32 b_74459) = {
  {a_74458, b_74459}
}

fun {f32, f32} lifted_28448(f32 a_74460, f32 b_74461) = {
  let {f32 res_74462} = lifted_28450(a_74460)
  let {f32 expx_74463} = res_74462
  let {f32 arg_74464} = lifted_28455(expx_74463)
  let {f32 arg_74465} = lifted_28458(b_74461)
  let {f32 arg_74466} = lifted_28463(arg_74464, arg_74465)
  let {f32 arg_74467} = lifted_28467(arg_74466)
  let {f32 arg_74468} = lifted_28470(expx_74463)
  let {f32 arg_74469} = lifted_28473(b_74461)
  let {f32 arg_74470} = lifted_28478(arg_74468, arg_74469)
  let {f32 res_74471, f32 res_74472} = lifted_28483(arg_74467, arg_74470)
  in {res_74471, res_74472}
}

fun {f32, f32} lifted_28495(f32 x_74473, f32 x_74474) = {
  {x_74473, x_74474}
}

fun {f32, f32} lifted_28502(f32 x_74475, f32 x_74476) = {
  {x_74475, x_74476}
}

fun {f32, f32} lifted_28518(f32 a_74477, f32 b_74478) = {
  {a_74477, b_74478}
}

fun {f32} lifted_28530(f32 x_74479) = {
  {x_74479}
}

fun {f32} lifted_28534(f32 x_74480, f32 y_74481) = {
  let {f32 res_74482} = fmul32(x_74480, y_74481)
  in {res_74482}
}

fun {f32} lifted_28538(f32 x_74483) = {
  {x_74483}
}

fun {f32} lifted_28541(f32 x_74484) = {
  {x_74484}
}

fun {f32} lifted_28545(f32 x_74485, f32 y_74486) = {
  let {f32 res_74487} = fmul32(x_74485, y_74486)
  in {res_74487}
}

fun {f32} lifted_28550(f32 x_74488, f32 y_74489) = {
  let {f32 res_74490} = fsub32(x_74488, y_74489)
  in {res_74490}
}

fun {f32} lifted_28554(f32 x_74491) = {
  {x_74491}
}

fun {f32} lifted_28558(f32 x_74492, f32 y_74493) = {
  let {f32 res_74494} = fmul32(x_74492, y_74493)
  in {res_74494}
}

fun {f32} lifted_28562(f32 x_74495) = {
  {x_74495}
}

fun {f32} lifted_28565(f32 x_74496) = {
  {x_74496}
}

fun {f32} lifted_28569(f32 x_74497, f32 y_74498) = {
  let {f32 res_74499} = fmul32(x_74497, y_74498)
  in {res_74499}
}

fun {f32} lifted_28574(f32 x_74500, f32 y_74501) = {
  let {f32 res_74502} = fadd32(x_74500, y_74501)
  in {res_74502}
}

fun {f32, f32} lifted_28528(f32 a_74503, f32 b_74504, f32 c_74505,
                            f32 d_74506) = {
  let {f32 arg_74507} = lifted_28530(a_74503)
  let {f32 arg_74508} = lifted_28534(arg_74507, c_74505)
  let {f32 arg_74509} = lifted_28538(arg_74508)
  let {f32 arg_74510} = lifted_28541(b_74504)
  let {f32 arg_74511} = lifted_28545(arg_74510, d_74506)
  let {f32 res_74512} = lifted_28550(arg_74509, arg_74511)
  let {f32 arg_74513} = lifted_28554(b_74504)
  let {f32 arg_74514} = lifted_28558(arg_74513, c_74505)
  let {f32 arg_74515} = lifted_28562(arg_74514)
  let {f32 arg_74516} = lifted_28565(a_74503)
  let {f32 arg_74517} = lifted_28569(arg_74516, d_74506)
  let {f32 res_74518} = lifted_28574(arg_74515, arg_74517)
  in {res_74512, res_74518}
}

fun {f32, f32} lifted_28512(f32 x_74519, f32 x_74520, f32 y_74521,
                            f32 y_74522) = {
  let {f32 arg_74523, f32 arg_74524} = lifted_28518(x_74519, x_74520)
  let {f32 res_74525, f32 res_74526} = lifted_28528(arg_74523, arg_74524,
                                                    y_74521, y_74522)
  in {res_74525, res_74526}
}

fun {f32, f32} lifted_28585(f32 x_74527, f32 x_74528) = {
  {x_74527, x_74528}
}

fun {f32, f32} lifted_28592(f32 x_74529, f32 x_74530) = {
  {x_74529, x_74530}
}

fun {f32, f32} lifted_28599(f32 x_74531, f32 x_74532) = {
  {x_74531, x_74532}
}

fun {f32, f32} lifted_28606(f32 x_74533, f32 x_74534) = {
  {x_74533, x_74534}
}

fun {f32, f32} lifted_28622(f32 a_74535, f32 b_74536) = {
  {a_74535, b_74536}
}

fun {f32} lifted_28634(f32 x_74537) = {
  {x_74537}
}

fun {f32} lifted_28638(f32 x_74538, f32 y_74539) = {
  let {f32 res_74540} = fmul32(x_74538, y_74539)
  in {res_74540}
}

fun {f32} lifted_28642(f32 x_74541) = {
  {x_74541}
}

fun {f32} lifted_28645(f32 x_74542) = {
  {x_74542}
}

fun {f32} lifted_28649(f32 x_74543, f32 y_74544) = {
  let {f32 res_74545} = fmul32(x_74543, y_74544)
  in {res_74545}
}

fun {f32} lifted_28654(f32 x_74546, f32 y_74547) = {
  let {f32 res_74548} = fsub32(x_74546, y_74547)
  in {res_74548}
}

fun {f32} lifted_28658(f32 x_74549) = {
  {x_74549}
}

fun {f32} lifted_28662(f32 x_74550, f32 y_74551) = {
  let {f32 res_74552} = fmul32(x_74550, y_74551)
  in {res_74552}
}

fun {f32} lifted_28666(f32 x_74553) = {
  {x_74553}
}

fun {f32} lifted_28669(f32 x_74554) = {
  {x_74554}
}

fun {f32} lifted_28673(f32 x_74555, f32 y_74556) = {
  let {f32 res_74557} = fmul32(x_74555, y_74556)
  in {res_74557}
}

fun {f32} lifted_28678(f32 x_74558, f32 y_74559) = {
  let {f32 res_74560} = fadd32(x_74558, y_74559)
  in {res_74560}
}

fun {f32, f32} lifted_28632(f32 a_74561, f32 b_74562, f32 c_74563,
                            f32 d_74564) = {
  let {f32 arg_74565} = lifted_28634(a_74561)
  let {f32 arg_74566} = lifted_28638(arg_74565, c_74563)
  let {f32 arg_74567} = lifted_28642(arg_74566)
  let {f32 arg_74568} = lifted_28645(b_74562)
  let {f32 arg_74569} = lifted_28649(arg_74568, d_74564)
  let {f32 res_74570} = lifted_28654(arg_74567, arg_74569)
  let {f32 arg_74571} = lifted_28658(b_74562)
  let {f32 arg_74572} = lifted_28662(arg_74571, c_74563)
  let {f32 arg_74573} = lifted_28666(arg_74572)
  let {f32 arg_74574} = lifted_28669(a_74561)
  let {f32 arg_74575} = lifted_28673(arg_74574, d_74564)
  let {f32 res_74576} = lifted_28678(arg_74573, arg_74575)
  in {res_74570, res_74576}
}

fun {f32, f32} lifted_28616(f32 x_74577, f32 x_74578, f32 y_74579,
                            f32 y_74580) = {
  let {f32 arg_74581, f32 arg_74582} = lifted_28622(x_74577, x_74578)
  let {f32 res_74583, f32 res_74584} = lifted_28632(arg_74581, arg_74582,
                                                    y_74579, y_74580)
  in {res_74583, res_74584}
}

fun {f32, f32} lifted_28696(f32 a_74585, f32 b_74586) = {
  {a_74585, b_74586}
}

fun {f32} lifted_28706(f32 x_74587) = {
  {x_74587}
}

fun {f32} lifted_28710(f32 x_74588, f32 y_74589) = {
  let {f32 res_74590} = fsub32(x_74588, y_74589)
  in {res_74590}
}

fun {f32} lifted_28714(f32 x_74591) = {
  {x_74591}
}

fun {f32} lifted_28718(f32 x_74592, f32 y_74593) = {
  let {f32 res_74594} = fsub32(x_74592, y_74593)
  in {res_74594}
}

fun {f32, f32} lifted_28704(f32 a_74595, f32 b_74596, f32 c_74597,
                            f32 d_74598) = {
  let {f32 arg_74599} = lifted_28706(a_74595)
  let {f32 res_74600} = lifted_28710(arg_74599, c_74597)
  let {f32 arg_74601} = lifted_28714(b_74596)
  let {f32 res_74602} = lifted_28718(arg_74601, d_74598)
  in {res_74600, res_74602}
}

fun {f32, f32} lifted_28692(f32 x_74603, f32 x_74604, f32 y_74605,
                            f32 y_74606) = {
  let {f32 arg_74607, f32 arg_74608} = lifted_28696(x_74603, x_74604)
  let {f32 res_74609, f32 res_74610} = lifted_28704(arg_74607, arg_74608,
                                                    y_74605, y_74606)
  in {res_74609, res_74610}
}

fun {f32, f32} lifted_28729(f32 x_74611, f32 x_74612) = {
  {x_74611, x_74612}
}

fun {f32, f32} lifted_28736(f32 x_74613, f32 x_74614) = {
  {x_74613, x_74614}
}

fun {f32, f32} lifted_28750(f32 a_74615, f32 b_74616) = {
  {a_74615, b_74616}
}

fun {f32} lifted_28760(f32 x_74617) = {
  {x_74617}
}

fun {f32} lifted_28764(f32 x_74618, f32 y_74619) = {
  let {f32 res_74620} = fsub32(x_74618, y_74619)
  in {res_74620}
}

fun {f32} lifted_28768(f32 x_74621) = {
  {x_74621}
}

fun {f32} lifted_28772(f32 x_74622, f32 y_74623) = {
  let {f32 res_74624} = fsub32(x_74622, y_74623)
  in {res_74624}
}

fun {f32, f32} lifted_28758(f32 a_74625, f32 b_74626, f32 c_74627,
                            f32 d_74628) = {
  let {f32 arg_74629} = lifted_28760(a_74625)
  let {f32 res_74630} = lifted_28764(arg_74629, c_74627)
  let {f32 arg_74631} = lifted_28768(b_74626)
  let {f32 res_74632} = lifted_28772(arg_74631, d_74628)
  in {res_74630, res_74632}
}

fun {f32, f32} lifted_28746(f32 x_74633, f32 x_74634, f32 y_74635,
                            f32 y_74636) = {
  let {f32 arg_74637, f32 arg_74638} = lifted_28750(x_74633, x_74634)
  let {f32 res_74639, f32 res_74640} = lifted_28758(arg_74637, arg_74638,
                                                    y_74635, y_74636)
  in {res_74639, res_74640}
}

fun {f32, f32} lifted_28793(f32 a_74641, f32 b_74642) = {
  {a_74641, b_74642}
}

fun {f32} lifted_28806(f32 x_74643) = {
  {x_74643}
}

fun {f32} lifted_28810(f32 x_74644, f32 y_74645) = {
  let {f32 res_74646} = fmul32(x_74644, y_74645)
  in {res_74646}
}

fun {f32} lifted_28814(f32 x_74647) = {
  {x_74647}
}

fun {f32} lifted_28817(f32 x_74648) = {
  {x_74648}
}

fun {f32} lifted_28821(f32 x_74649, f32 y_74650) = {
  let {f32 res_74651} = fmul32(x_74649, y_74650)
  in {res_74651}
}

fun {f32} lifted_28826(f32 x_74652, f32 y_74653) = {
  let {f32 res_74654} = fadd32(x_74652, y_74653)
  in {res_74654}
}

fun {f32} lifted_28830(f32 x_74655) = {
  {x_74655}
}

fun {f32} lifted_28833(f32 x_74656) = {
  {x_74656}
}

fun {f32} lifted_28837(f32 x_74657, f32 y_74658) = {
  let {f32 res_74659} = fmul32(x_74657, y_74658)
  in {res_74659}
}

fun {f32} lifted_28841(f32 x_74660) = {
  {x_74660}
}

fun {f32} lifted_28844(f32 x_74661) = {
  {x_74661}
}

fun {f32} lifted_28848(f32 x_74662, f32 y_74663) = {
  let {f32 res_74664} = fmul32(x_74662, y_74663)
  in {res_74664}
}

fun {f32} lifted_28853(f32 x_74665, f32 y_74666) = {
  let {f32 res_74667} = fadd32(x_74665, y_74666)
  in {res_74667}
}

fun {f32} lifted_28858(f32 x_74668, f32 y_74669) = {
  let {f32 res_74670} = fdiv32(x_74668, y_74669)
  in {res_74670}
}

fun {f32} lifted_28862(f32 x_74671) = {
  {x_74671}
}

fun {f32} lifted_28866(f32 x_74672, f32 y_74673) = {
  let {f32 res_74674} = fmul32(x_74672, y_74673)
  in {res_74674}
}

fun {f32} lifted_28870(f32 x_74675) = {
  {x_74675}
}

fun {f32} lifted_28873(f32 x_74676) = {
  {x_74676}
}

fun {f32} lifted_28877(f32 x_74677, f32 y_74678) = {
  let {f32 res_74679} = fmul32(x_74677, y_74678)
  in {res_74679}
}

fun {f32} lifted_28882(f32 x_74680, f32 y_74681) = {
  let {f32 res_74682} = fsub32(x_74680, y_74681)
  in {res_74682}
}

fun {f32} lifted_28886(f32 x_74683) = {
  {x_74683}
}

fun {f32} lifted_28889(f32 x_74684) = {
  {x_74684}
}

fun {f32} lifted_28893(f32 x_74685, f32 y_74686) = {
  let {f32 res_74687} = fmul32(x_74685, y_74686)
  in {res_74687}
}

fun {f32} lifted_28897(f32 x_74688) = {
  {x_74688}
}

fun {f32} lifted_28900(f32 x_74689) = {
  {x_74689}
}

fun {f32} lifted_28904(f32 x_74690, f32 y_74691) = {
  let {f32 res_74692} = fmul32(x_74690, y_74691)
  in {res_74692}
}

fun {f32} lifted_28909(f32 x_74693, f32 y_74694) = {
  let {f32 res_74695} = fadd32(x_74693, y_74694)
  in {res_74695}
}

fun {f32} lifted_28914(f32 x_74696, f32 y_74697) = {
  let {f32 res_74698} = fdiv32(x_74696, y_74697)
  in {res_74698}
}

fun {f32, f32} lifted_28804(f32 a_74699, f32 b_74700, f32 c_74701,
                            f32 d_74702) = {
  let {f32 arg_74703} = lifted_28806(a_74699)
  let {f32 arg_74704} = lifted_28810(arg_74703, c_74701)
  let {f32 arg_74705} = lifted_28814(arg_74704)
  let {f32 arg_74706} = lifted_28817(b_74700)
  let {f32 arg_74707} = lifted_28821(arg_74706, d_74702)
  let {f32 arg_74708} = lifted_28826(arg_74705, arg_74707)
  let {f32 arg_74709} = lifted_28830(arg_74708)
  let {f32 arg_74710} = lifted_28833(c_74701)
  let {f32 arg_74711} = lifted_28837(arg_74710, c_74701)
  let {f32 arg_74712} = lifted_28841(arg_74711)
  let {f32 arg_74713} = lifted_28844(d_74702)
  let {f32 arg_74714} = lifted_28848(arg_74713, d_74702)
  let {f32 arg_74715} = lifted_28853(arg_74712, arg_74714)
  let {f32 res_74716} = lifted_28858(arg_74709, arg_74715)
  let {f32 arg_74717} = lifted_28862(b_74700)
  let {f32 arg_74718} = lifted_28866(arg_74717, c_74701)
  let {f32 arg_74719} = lifted_28870(arg_74718)
  let {f32 arg_74720} = lifted_28873(a_74699)
  let {f32 arg_74721} = lifted_28877(arg_74720, d_74702)
  let {f32 arg_74722} = lifted_28882(arg_74719, arg_74721)
  let {f32 arg_74723} = lifted_28886(arg_74722)
  let {f32 arg_74724} = lifted_28889(c_74701)
  let {f32 arg_74725} = lifted_28893(arg_74724, c_74701)
  let {f32 arg_74726} = lifted_28897(arg_74725)
  let {f32 arg_74727} = lifted_28900(d_74702)
  let {f32 arg_74728} = lifted_28904(arg_74727, d_74702)
  let {f32 arg_74729} = lifted_28909(arg_74726, arg_74728)
  let {f32 res_74730} = lifted_28914(arg_74723, arg_74729)
  in {res_74716, res_74730}
}

fun {f32, f32} lifted_28786(f32 x_74731, f32 x_74732, f32 y_74733,
                            f32 y_74734) = {
  let {f32 arg_74735, f32 arg_74736} = lifted_28793(x_74731, x_74732)
  let {f32 res_74737, f32 res_74738} = lifted_28804(arg_74735, arg_74736,
                                                    y_74733, y_74734)
  in {res_74737, res_74738}
}

fun {f32} lifted_28936(f32 x_74739) = {
  {x_74739}
}

fun {f32} lifted_28940(f32 x_74740, f32 y_74741) = {
  let {f32 res_74742} = fmul32(x_74740, y_74741)
  in {res_74742}
}

fun {f32} lifted_28944(f32 x_74743) = {
  {x_74743}
}

fun {f32} lifted_28947(f32 x_74744) = {
  {x_74744}
}

fun {f32} lifted_28951(f32 x_74745, f32 y_74746) = {
  let {f32 res_74747} = fmul32(x_74745, y_74746)
  in {res_74747}
}

fun {f32} lifted_28956(f32 x_74748, f32 y_74749) = {
  let {f32 res_74750} = fadd32(x_74748, y_74749)
  in {res_74750}
}

fun {f32} lifted_28960(f32 x_74751) = {
  let {f32 res_74752} = sqrt32(x_74751)
  in {res_74752}
}

fun {f32} lifted_28934(f32 a_74753, f32 b_74754) = {
  let {f32 arg_74755} = lifted_28936(a_74753)
  let {f32 arg_74756} = lifted_28940(arg_74755, a_74753)
  let {f32 arg_74757} = lifted_28944(arg_74756)
  let {f32 arg_74758} = lifted_28947(b_74754)
  let {f32 arg_74759} = lifted_28951(arg_74758, b_74754)
  let {f32 arg_74760} = lifted_28956(arg_74757, arg_74759)
  let {f32 res_74761} = lifted_28960(arg_74760)
  in {res_74761}
}

fun {f32} lifted_28965(f32 x_74762) = {
  let {f32 res_74763} = log32(x_74762)
  in {res_74763}
}

fun {f32} lifted_28969(f32 a_74764) = {
  {a_74764}
}

fun {f32} lifted_28976(f32 x_74765) = {
  {x_74765}
}

fun {f32} lifted_28980(f32 x_74766, f32 y_74767) = {
  let {f32 res_74768} = atan2_32(x_74766, y_74767)
  in {res_74768}
}

fun {f32} lifted_28974(f32 a_74769, f32 b_74770) = {
  let {f32 arg_74771} = lifted_28976(b_74770)
  let {f32 res_74772} = lifted_28980(arg_74771, a_74769)
  in {res_74772}
}

fun {f32, f32} lifted_28986(f32 a_74773, f32 b_74774) = {
  {a_74773, b_74774}
}

fun {f32, f32} lifted_28928(f32 z_74775, f32 z_74776) = {
  let {f32 arg_74777} = lifted_28934(z_74775, z_74776)
  let {f32 arg_74778} = lifted_28965(arg_74777)
  let {f32 arg_74779} = lifted_28969(arg_74778)
  let {f32 arg_74780} = lifted_28974(z_74775, z_74776)
  let {f32 res_74781, f32 res_74782} = lifted_28986(arg_74779, arg_74780)
  in {res_74781, res_74782}
}

fun {f32, f32} lifted_29004(f32 a_74783, f32 b_74784) = {
  {a_74783, b_74784}
}

fun {f32} lifted_29016(f32 x_74785) = {
  {x_74785}
}

fun {f32} lifted_29020(f32 x_74786, f32 y_74787) = {
  let {f32 res_74788} = fmul32(x_74786, y_74787)
  in {res_74788}
}

fun {f32} lifted_29024(f32 x_74789) = {
  {x_74789}
}

fun {f32} lifted_29027(f32 x_74790) = {
  {x_74790}
}

fun {f32} lifted_29031(f32 x_74791, f32 y_74792) = {
  let {f32 res_74793} = fmul32(x_74791, y_74792)
  in {res_74793}
}

fun {f32} lifted_29036(f32 x_74794, f32 y_74795) = {
  let {f32 res_74796} = fsub32(x_74794, y_74795)
  in {res_74796}
}

fun {f32} lifted_29040(f32 x_74797) = {
  {x_74797}
}

fun {f32} lifted_29044(f32 x_74798, f32 y_74799) = {
  let {f32 res_74800} = fmul32(x_74798, y_74799)
  in {res_74800}
}

fun {f32} lifted_29048(f32 x_74801) = {
  {x_74801}
}

fun {f32} lifted_29051(f32 x_74802) = {
  {x_74802}
}

fun {f32} lifted_29055(f32 x_74803, f32 y_74804) = {
  let {f32 res_74805} = fmul32(x_74803, y_74804)
  in {res_74805}
}

fun {f32} lifted_29060(f32 x_74806, f32 y_74807) = {
  let {f32 res_74808} = fadd32(x_74806, y_74807)
  in {res_74808}
}

fun {f32, f32} lifted_29014(f32 a_74809, f32 b_74810, f32 c_74811,
                            f32 d_74812) = {
  let {f32 arg_74813} = lifted_29016(a_74809)
  let {f32 arg_74814} = lifted_29020(arg_74813, c_74811)
  let {f32 arg_74815} = lifted_29024(arg_74814)
  let {f32 arg_74816} = lifted_29027(b_74810)
  let {f32 arg_74817} = lifted_29031(arg_74816, d_74812)
  let {f32 res_74818} = lifted_29036(arg_74815, arg_74817)
  let {f32 arg_74819} = lifted_29040(b_74810)
  let {f32 arg_74820} = lifted_29044(arg_74819, c_74811)
  let {f32 arg_74821} = lifted_29048(arg_74820)
  let {f32 arg_74822} = lifted_29051(a_74809)
  let {f32 arg_74823} = lifted_29055(arg_74822, d_74812)
  let {f32 res_74824} = lifted_29060(arg_74821, arg_74823)
  in {res_74818, res_74824}
}

fun {f32, f32} lifted_28998(f32 x_74825, f32 x_74826, f32 y_74827,
                            f32 y_74828) = {
  let {f32 arg_74829, f32 arg_74830} = lifted_29004(x_74825, x_74826)
  let {f32 res_74831, f32 res_74832} = lifted_29014(arg_74829, arg_74830,
                                                    y_74827, y_74828)
  in {res_74831, res_74832}
}

fun {f32, f32} lifted_29078(f32 a_74833, f32 b_74834) = {
  {a_74833, b_74834}
}

fun {f32} lifted_29088(f32 x_74835) = {
  {x_74835}
}

fun {f32} lifted_29092(f32 x_74836, f32 y_74837) = {
  let {f32 res_74838} = fsub32(x_74836, y_74837)
  in {res_74838}
}

fun {f32} lifted_29096(f32 x_74839) = {
  {x_74839}
}

fun {f32} lifted_29100(f32 x_74840, f32 y_74841) = {
  let {f32 res_74842} = fsub32(x_74840, y_74841)
  in {res_74842}
}

fun {f32, f32} lifted_29086(f32 a_74843, f32 b_74844, f32 c_74845,
                            f32 d_74846) = {
  let {f32 arg_74847} = lifted_29088(a_74843)
  let {f32 res_74848} = lifted_29092(arg_74847, c_74845)
  let {f32 arg_74849} = lifted_29096(b_74844)
  let {f32 res_74850} = lifted_29100(arg_74849, d_74846)
  in {res_74848, res_74850}
}

fun {f32, f32} lifted_29074(f32 x_74851, f32 x_74852, f32 y_74853,
                            f32 y_74854) = {
  let {f32 arg_74855, f32 arg_74856} = lifted_29078(x_74851, x_74852)
  let {f32 res_74857, f32 res_74858} = lifted_29086(arg_74855, arg_74856,
                                                    y_74853, y_74854)
  in {res_74857, res_74858}
}

fun {f32, f32} lifted_29120(f32 a_74859, f32 b_74860) = {
  {a_74859, b_74860}
}

fun {f32} lifted_29132(f32 x_74861) = {
  {x_74861}
}

fun {f32} lifted_29136(f32 x_74862, f32 y_74863) = {
  let {f32 res_74864} = fmul32(x_74862, y_74863)
  in {res_74864}
}

fun {f32} lifted_29140(f32 x_74865) = {
  {x_74865}
}

fun {f32} lifted_29143(f32 x_74866) = {
  {x_74866}
}

fun {f32} lifted_29147(f32 x_74867, f32 y_74868) = {
  let {f32 res_74869} = fmul32(x_74867, y_74868)
  in {res_74869}
}

fun {f32} lifted_29152(f32 x_74870, f32 y_74871) = {
  let {f32 res_74872} = fsub32(x_74870, y_74871)
  in {res_74872}
}

fun {f32} lifted_29156(f32 x_74873) = {
  {x_74873}
}

fun {f32} lifted_29160(f32 x_74874, f32 y_74875) = {
  let {f32 res_74876} = fmul32(x_74874, y_74875)
  in {res_74876}
}

fun {f32} lifted_29164(f32 x_74877) = {
  {x_74877}
}

fun {f32} lifted_29167(f32 x_74878) = {
  {x_74878}
}

fun {f32} lifted_29171(f32 x_74879, f32 y_74880) = {
  let {f32 res_74881} = fmul32(x_74879, y_74880)
  in {res_74881}
}

fun {f32} lifted_29176(f32 x_74882, f32 y_74883) = {
  let {f32 res_74884} = fadd32(x_74882, y_74883)
  in {res_74884}
}

fun {f32, f32} lifted_29130(f32 a_74885, f32 b_74886, f32 c_74887,
                            f32 d_74888) = {
  let {f32 arg_74889} = lifted_29132(a_74885)
  let {f32 arg_74890} = lifted_29136(arg_74889, c_74887)
  let {f32 arg_74891} = lifted_29140(arg_74890)
  let {f32 arg_74892} = lifted_29143(b_74886)
  let {f32 arg_74893} = lifted_29147(arg_74892, d_74888)
  let {f32 res_74894} = lifted_29152(arg_74891, arg_74893)
  let {f32 arg_74895} = lifted_29156(b_74886)
  let {f32 arg_74896} = lifted_29160(arg_74895, c_74887)
  let {f32 arg_74897} = lifted_29164(arg_74896)
  let {f32 arg_74898} = lifted_29167(a_74885)
  let {f32 arg_74899} = lifted_29171(arg_74898, d_74888)
  let {f32 res_74900} = lifted_29176(arg_74897, arg_74899)
  in {res_74894, res_74900}
}

fun {f32, f32} lifted_29114(f32 x_74901, f32 x_74902, f32 y_74903,
                            f32 y_74904) = {
  let {f32 arg_74905, f32 arg_74906} = lifted_29120(x_74901, x_74902)
  let {f32 res_74907, f32 res_74908} = lifted_29130(arg_74905, arg_74906,
                                                    y_74903, y_74904)
  in {res_74907, res_74908}
}

fun {f32, f32} lifted_29187(f32 x_74909, f32 x_74910) = {
  {x_74909, x_74910}
}

fun {f32, f32} lifted_29194(f32 x_74911, f32 x_74912) = {
  {x_74911, x_74912}
}

fun {f32, f32} lifted_29210(f32 a_74913, f32 b_74914) = {
  {a_74913, b_74914}
}

fun {f32} lifted_29222(f32 x_74915) = {
  {x_74915}
}

fun {f32} lifted_29226(f32 x_74916, f32 y_74917) = {
  let {f32 res_74918} = fmul32(x_74916, y_74917)
  in {res_74918}
}

fun {f32} lifted_29230(f32 x_74919) = {
  {x_74919}
}

fun {f32} lifted_29233(f32 x_74920) = {
  {x_74920}
}

fun {f32} lifted_29237(f32 x_74921, f32 y_74922) = {
  let {f32 res_74923} = fmul32(x_74921, y_74922)
  in {res_74923}
}

fun {f32} lifted_29242(f32 x_74924, f32 y_74925) = {
  let {f32 res_74926} = fsub32(x_74924, y_74925)
  in {res_74926}
}

fun {f32} lifted_29246(f32 x_74927) = {
  {x_74927}
}

fun {f32} lifted_29250(f32 x_74928, f32 y_74929) = {
  let {f32 res_74930} = fmul32(x_74928, y_74929)
  in {res_74930}
}

fun {f32} lifted_29254(f32 x_74931) = {
  {x_74931}
}

fun {f32} lifted_29257(f32 x_74932) = {
  {x_74932}
}

fun {f32} lifted_29261(f32 x_74933, f32 y_74934) = {
  let {f32 res_74935} = fmul32(x_74933, y_74934)
  in {res_74935}
}

fun {f32} lifted_29266(f32 x_74936, f32 y_74937) = {
  let {f32 res_74938} = fadd32(x_74936, y_74937)
  in {res_74938}
}

fun {f32, f32} lifted_29220(f32 a_74939, f32 b_74940, f32 c_74941,
                            f32 d_74942) = {
  let {f32 arg_74943} = lifted_29222(a_74939)
  let {f32 arg_74944} = lifted_29226(arg_74943, c_74941)
  let {f32 arg_74945} = lifted_29230(arg_74944)
  let {f32 arg_74946} = lifted_29233(b_74940)
  let {f32 arg_74947} = lifted_29237(arg_74946, d_74942)
  let {f32 res_74948} = lifted_29242(arg_74945, arg_74947)
  let {f32 arg_74949} = lifted_29246(b_74940)
  let {f32 arg_74950} = lifted_29250(arg_74949, c_74941)
  let {f32 arg_74951} = lifted_29254(arg_74950)
  let {f32 arg_74952} = lifted_29257(a_74939)
  let {f32 arg_74953} = lifted_29261(arg_74952, d_74942)
  let {f32 res_74954} = lifted_29266(arg_74951, arg_74953)
  in {res_74948, res_74954}
}

fun {f32, f32} lifted_29204(f32 x_74955, f32 x_74956, f32 y_74957,
                            f32 y_74958) = {
  let {f32 arg_74959, f32 arg_74960} = lifted_29210(x_74955, x_74956)
  let {f32 res_74961, f32 res_74962} = lifted_29220(arg_74959, arg_74960,
                                                    y_74957, y_74958)
  in {res_74961, res_74962}
}

fun {f32, f32} lifted_29277(f32 x_74963, f32 x_74964) = {
  {x_74963, x_74964}
}

fun {f32, f32} lifted_29284(f32 x_74965, f32 x_74966) = {
  {x_74965, x_74966}
}

fun {f32, f32} lifted_29298(f32 a_74967, f32 b_74968) = {
  {a_74967, b_74968}
}

fun {f32} lifted_29308(f32 x_74969) = {
  {x_74969}
}

fun {f32} lifted_29312(f32 x_74970, f32 y_74971) = {
  let {f32 res_74972} = fsub32(x_74970, y_74971)
  in {res_74972}
}

fun {f32} lifted_29316(f32 x_74973) = {
  {x_74973}
}

fun {f32} lifted_29320(f32 x_74974, f32 y_74975) = {
  let {f32 res_74976} = fsub32(x_74974, y_74975)
  in {res_74976}
}

fun {f32, f32} lifted_29306(f32 a_74977, f32 b_74978, f32 c_74979,
                            f32 d_74980) = {
  let {f32 arg_74981} = lifted_29308(a_74977)
  let {f32 res_74982} = lifted_29312(arg_74981, c_74979)
  let {f32 arg_74983} = lifted_29316(b_74978)
  let {f32 res_74984} = lifted_29320(arg_74983, d_74980)
  in {res_74982, res_74984}
}

fun {f32, f32} lifted_29294(f32 x_74985, f32 x_74986, f32 y_74987,
                            f32 y_74988) = {
  let {f32 arg_74989, f32 arg_74990} = lifted_29298(x_74985, x_74986)
  let {f32 res_74991, f32 res_74992} = lifted_29306(arg_74989, arg_74990,
                                                    y_74987, y_74988)
  in {res_74991, res_74992}
}

fun {f32, f32} lifted_29340(f32 a_74993, f32 b_74994) = {
  {a_74993, b_74994}
}

fun {f32} lifted_29352(f32 x_74995) = {
  {x_74995}
}

fun {f32} lifted_29356(f32 x_74996, f32 y_74997) = {
  let {f32 res_74998} = fmul32(x_74996, y_74997)
  in {res_74998}
}

fun {f32} lifted_29360(f32 x_74999) = {
  {x_74999}
}

fun {f32} lifted_29363(f32 x_75000) = {
  {x_75000}
}

fun {f32} lifted_29367(f32 x_75001, f32 y_75002) = {
  let {f32 res_75003} = fmul32(x_75001, y_75002)
  in {res_75003}
}

fun {f32} lifted_29372(f32 x_75004, f32 y_75005) = {
  let {f32 res_75006} = fsub32(x_75004, y_75005)
  in {res_75006}
}

fun {f32} lifted_29376(f32 x_75007) = {
  {x_75007}
}

fun {f32} lifted_29380(f32 x_75008, f32 y_75009) = {
  let {f32 res_75010} = fmul32(x_75008, y_75009)
  in {res_75010}
}

fun {f32} lifted_29384(f32 x_75011) = {
  {x_75011}
}

fun {f32} lifted_29387(f32 x_75012) = {
  {x_75012}
}

fun {f32} lifted_29391(f32 x_75013, f32 y_75014) = {
  let {f32 res_75015} = fmul32(x_75013, y_75014)
  in {res_75015}
}

fun {f32} lifted_29396(f32 x_75016, f32 y_75017) = {
  let {f32 res_75018} = fadd32(x_75016, y_75017)
  in {res_75018}
}

fun {f32, f32} lifted_29350(f32 a_75019, f32 b_75020, f32 c_75021,
                            f32 d_75022) = {
  let {f32 arg_75023} = lifted_29352(a_75019)
  let {f32 arg_75024} = lifted_29356(arg_75023, c_75021)
  let {f32 arg_75025} = lifted_29360(arg_75024)
  let {f32 arg_75026} = lifted_29363(b_75020)
  let {f32 arg_75027} = lifted_29367(arg_75026, d_75022)
  let {f32 res_75028} = lifted_29372(arg_75025, arg_75027)
  let {f32 arg_75029} = lifted_29376(b_75020)
  let {f32 arg_75030} = lifted_29380(arg_75029, c_75021)
  let {f32 arg_75031} = lifted_29384(arg_75030)
  let {f32 arg_75032} = lifted_29387(a_75019)
  let {f32 arg_75033} = lifted_29391(arg_75032, d_75022)
  let {f32 res_75034} = lifted_29396(arg_75031, arg_75033)
  in {res_75028, res_75034}
}

fun {f32, f32} lifted_29334(f32 x_75035, f32 x_75036, f32 y_75037,
                            f32 y_75038) = {
  let {f32 arg_75039, f32 arg_75040} = lifted_29340(x_75035, x_75036)
  let {f32 res_75041, f32 res_75042} = lifted_29350(arg_75039, arg_75040,
                                                    y_75037, y_75038)
  in {res_75041, res_75042}
}

fun {f32, f32} lifted_29407(f32 x_75043, f32 x_75044) = {
  {x_75043, x_75044}
}

fun {f32, f32} lifted_29414(f32 x_75045, f32 x_75046) = {
  {x_75045, x_75046}
}

fun {f32, f32} lifted_29421(f32 x_75047, f32 x_75048) = {
  {x_75047, x_75048}
}

fun {f32, f32} lifted_29437(f32 a_75049, f32 b_75050) = {
  {a_75049, b_75050}
}

fun {f32} lifted_29449(f32 x_75051) = {
  {x_75051}
}

fun {f32} lifted_29453(f32 x_75052, f32 y_75053) = {
  let {f32 res_75054} = fmul32(x_75052, y_75053)
  in {res_75054}
}

fun {f32} lifted_29457(f32 x_75055) = {
  {x_75055}
}

fun {f32} lifted_29460(f32 x_75056) = {
  {x_75056}
}

fun {f32} lifted_29464(f32 x_75057, f32 y_75058) = {
  let {f32 res_75059} = fmul32(x_75057, y_75058)
  in {res_75059}
}

fun {f32} lifted_29469(f32 x_75060, f32 y_75061) = {
  let {f32 res_75062} = fsub32(x_75060, y_75061)
  in {res_75062}
}

fun {f32} lifted_29473(f32 x_75063) = {
  {x_75063}
}

fun {f32} lifted_29477(f32 x_75064, f32 y_75065) = {
  let {f32 res_75066} = fmul32(x_75064, y_75065)
  in {res_75066}
}

fun {f32} lifted_29481(f32 x_75067) = {
  {x_75067}
}

fun {f32} lifted_29484(f32 x_75068) = {
  {x_75068}
}

fun {f32} lifted_29488(f32 x_75069, f32 y_75070) = {
  let {f32 res_75071} = fmul32(x_75069, y_75070)
  in {res_75071}
}

fun {f32} lifted_29493(f32 x_75072, f32 y_75073) = {
  let {f32 res_75074} = fadd32(x_75072, y_75073)
  in {res_75074}
}

fun {f32, f32} lifted_29447(f32 a_75075, f32 b_75076, f32 c_75077,
                            f32 d_75078) = {
  let {f32 arg_75079} = lifted_29449(a_75075)
  let {f32 arg_75080} = lifted_29453(arg_75079, c_75077)
  let {f32 arg_75081} = lifted_29457(arg_75080)
  let {f32 arg_75082} = lifted_29460(b_75076)
  let {f32 arg_75083} = lifted_29464(arg_75082, d_75078)
  let {f32 res_75084} = lifted_29469(arg_75081, arg_75083)
  let {f32 arg_75085} = lifted_29473(b_75076)
  let {f32 arg_75086} = lifted_29477(arg_75085, c_75077)
  let {f32 arg_75087} = lifted_29481(arg_75086)
  let {f32 arg_75088} = lifted_29484(a_75075)
  let {f32 arg_75089} = lifted_29488(arg_75088, d_75078)
  let {f32 res_75090} = lifted_29493(arg_75087, arg_75089)
  in {res_75084, res_75090}
}

fun {f32, f32} lifted_29431(f32 x_75091, f32 x_75092, f32 y_75093,
                            f32 y_75094) = {
  let {f32 arg_75095, f32 arg_75096} = lifted_29437(x_75091, x_75092)
  let {f32 res_75097, f32 res_75098} = lifted_29447(arg_75095, arg_75096,
                                                    y_75093, y_75094)
  in {res_75097, res_75098}
}

fun {f32, f32} lifted_29511(f32 a_75099, f32 b_75100) = {
  {a_75099, b_75100}
}

fun {f32} lifted_29521(f32 x_75101) = {
  {x_75101}
}

fun {f32} lifted_29525(f32 x_75102, f32 y_75103) = {
  let {f32 res_75104} = fsub32(x_75102, y_75103)
  in {res_75104}
}

fun {f32} lifted_29529(f32 x_75105) = {
  {x_75105}
}

fun {f32} lifted_29533(f32 x_75106, f32 y_75107) = {
  let {f32 res_75108} = fsub32(x_75106, y_75107)
  in {res_75108}
}

fun {f32, f32} lifted_29519(f32 a_75109, f32 b_75110, f32 c_75111,
                            f32 d_75112) = {
  let {f32 arg_75113} = lifted_29521(a_75109)
  let {f32 res_75114} = lifted_29525(arg_75113, c_75111)
  let {f32 arg_75115} = lifted_29529(b_75110)
  let {f32 res_75116} = lifted_29533(arg_75115, d_75112)
  in {res_75114, res_75116}
}

fun {f32, f32} lifted_29507(f32 x_75117, f32 x_75118, f32 y_75119,
                            f32 y_75120) = {
  let {f32 arg_75121, f32 arg_75122} = lifted_29511(x_75117, x_75118)
  let {f32 res_75123, f32 res_75124} = lifted_29519(arg_75121, arg_75122,
                                                    y_75119, y_75120)
  in {res_75123, res_75124}
}

fun {f32, f32} lifted_29554(f32 a_75125, f32 b_75126) = {
  {a_75125, b_75126}
}

fun {f32} lifted_29567(f32 x_75127) = {
  {x_75127}
}

fun {f32} lifted_29571(f32 x_75128, f32 y_75129) = {
  let {f32 res_75130} = fmul32(x_75128, y_75129)
  in {res_75130}
}

fun {f32} lifted_29575(f32 x_75131) = {
  {x_75131}
}

fun {f32} lifted_29578(f32 x_75132) = {
  {x_75132}
}

fun {f32} lifted_29582(f32 x_75133, f32 y_75134) = {
  let {f32 res_75135} = fmul32(x_75133, y_75134)
  in {res_75135}
}

fun {f32} lifted_29587(f32 x_75136, f32 y_75137) = {
  let {f32 res_75138} = fadd32(x_75136, y_75137)
  in {res_75138}
}

fun {f32} lifted_29591(f32 x_75139) = {
  {x_75139}
}

fun {f32} lifted_29594(f32 x_75140) = {
  {x_75140}
}

fun {f32} lifted_29598(f32 x_75141, f32 y_75142) = {
  let {f32 res_75143} = fmul32(x_75141, y_75142)
  in {res_75143}
}

fun {f32} lifted_29602(f32 x_75144) = {
  {x_75144}
}

fun {f32} lifted_29605(f32 x_75145) = {
  {x_75145}
}

fun {f32} lifted_29609(f32 x_75146, f32 y_75147) = {
  let {f32 res_75148} = fmul32(x_75146, y_75147)
  in {res_75148}
}

fun {f32} lifted_29614(f32 x_75149, f32 y_75150) = {
  let {f32 res_75151} = fadd32(x_75149, y_75150)
  in {res_75151}
}

fun {f32} lifted_29619(f32 x_75152, f32 y_75153) = {
  let {f32 res_75154} = fdiv32(x_75152, y_75153)
  in {res_75154}
}

fun {f32} lifted_29623(f32 x_75155) = {
  {x_75155}
}

fun {f32} lifted_29627(f32 x_75156, f32 y_75157) = {
  let {f32 res_75158} = fmul32(x_75156, y_75157)
  in {res_75158}
}

fun {f32} lifted_29631(f32 x_75159) = {
  {x_75159}
}

fun {f32} lifted_29634(f32 x_75160) = {
  {x_75160}
}

fun {f32} lifted_29638(f32 x_75161, f32 y_75162) = {
  let {f32 res_75163} = fmul32(x_75161, y_75162)
  in {res_75163}
}

fun {f32} lifted_29643(f32 x_75164, f32 y_75165) = {
  let {f32 res_75166} = fsub32(x_75164, y_75165)
  in {res_75166}
}

fun {f32} lifted_29647(f32 x_75167) = {
  {x_75167}
}

fun {f32} lifted_29650(f32 x_75168) = {
  {x_75168}
}

fun {f32} lifted_29654(f32 x_75169, f32 y_75170) = {
  let {f32 res_75171} = fmul32(x_75169, y_75170)
  in {res_75171}
}

fun {f32} lifted_29658(f32 x_75172) = {
  {x_75172}
}

fun {f32} lifted_29661(f32 x_75173) = {
  {x_75173}
}

fun {f32} lifted_29665(f32 x_75174, f32 y_75175) = {
  let {f32 res_75176} = fmul32(x_75174, y_75175)
  in {res_75176}
}

fun {f32} lifted_29670(f32 x_75177, f32 y_75178) = {
  let {f32 res_75179} = fadd32(x_75177, y_75178)
  in {res_75179}
}

fun {f32} lifted_29675(f32 x_75180, f32 y_75181) = {
  let {f32 res_75182} = fdiv32(x_75180, y_75181)
  in {res_75182}
}

fun {f32, f32} lifted_29565(f32 a_75183, f32 b_75184, f32 c_75185,
                            f32 d_75186) = {
  let {f32 arg_75187} = lifted_29567(a_75183)
  let {f32 arg_75188} = lifted_29571(arg_75187, c_75185)
  let {f32 arg_75189} = lifted_29575(arg_75188)
  let {f32 arg_75190} = lifted_29578(b_75184)
  let {f32 arg_75191} = lifted_29582(arg_75190, d_75186)
  let {f32 arg_75192} = lifted_29587(arg_75189, arg_75191)
  let {f32 arg_75193} = lifted_29591(arg_75192)
  let {f32 arg_75194} = lifted_29594(c_75185)
  let {f32 arg_75195} = lifted_29598(arg_75194, c_75185)
  let {f32 arg_75196} = lifted_29602(arg_75195)
  let {f32 arg_75197} = lifted_29605(d_75186)
  let {f32 arg_75198} = lifted_29609(arg_75197, d_75186)
  let {f32 arg_75199} = lifted_29614(arg_75196, arg_75198)
  let {f32 res_75200} = lifted_29619(arg_75193, arg_75199)
  let {f32 arg_75201} = lifted_29623(b_75184)
  let {f32 arg_75202} = lifted_29627(arg_75201, c_75185)
  let {f32 arg_75203} = lifted_29631(arg_75202)
  let {f32 arg_75204} = lifted_29634(a_75183)
  let {f32 arg_75205} = lifted_29638(arg_75204, d_75186)
  let {f32 arg_75206} = lifted_29643(arg_75203, arg_75205)
  let {f32 arg_75207} = lifted_29647(arg_75206)
  let {f32 arg_75208} = lifted_29650(c_75185)
  let {f32 arg_75209} = lifted_29654(arg_75208, c_75185)
  let {f32 arg_75210} = lifted_29658(arg_75209)
  let {f32 arg_75211} = lifted_29661(d_75186)
  let {f32 arg_75212} = lifted_29665(arg_75211, d_75186)
  let {f32 arg_75213} = lifted_29670(arg_75210, arg_75212)
  let {f32 res_75214} = lifted_29675(arg_75207, arg_75213)
  in {res_75200, res_75214}
}

fun {f32, f32} lifted_29547(f32 x_75215, f32 x_75216, f32 y_75217,
                            f32 y_75218) = {
  let {f32 arg_75219, f32 arg_75220} = lifted_29554(x_75215, x_75216)
  let {f32 res_75221, f32 res_75222} = lifted_29565(arg_75219, arg_75220,
                                                    y_75217, y_75218)
  in {res_75221, res_75222}
}

fun {f32, f32} lifted_29693(f32 a_75223, f32 b_75224) = {
  {a_75223, b_75224}
}

fun {f32} lifted_29703(f32 x_75225) = {
  {x_75225}
}

fun {f32} lifted_29707(f32 x_75226, f32 y_75227) = {
  let {f32 res_75228} = fadd32(x_75226, y_75227)
  in {res_75228}
}

fun {f32} lifted_29711(f32 x_75229) = {
  {x_75229}
}

fun {f32} lifted_29715(f32 x_75230, f32 y_75231) = {
  let {f32 res_75232} = fadd32(x_75230, y_75231)
  in {res_75232}
}

fun {f32, f32} lifted_29701(f32 a_75233, f32 b_75234, f32 c_75235,
                            f32 d_75236) = {
  let {f32 arg_75237} = lifted_29703(a_75233)
  let {f32 res_75238} = lifted_29707(arg_75237, c_75235)
  let {f32 arg_75239} = lifted_29711(b_75234)
  let {f32 res_75240} = lifted_29715(arg_75239, d_75236)
  in {res_75238, res_75240}
}

fun {f32, f32} lifted_29689(f32 x_75241, f32 x_75242, f32 y_75243,
                            f32 y_75244) = {
  let {f32 arg_75245, f32 arg_75246} = lifted_29693(x_75241, x_75242)
  let {f32 res_75247, f32 res_75248} = lifted_29701(arg_75245, arg_75246,
                                                    y_75243, y_75244)
  in {res_75247, res_75248}
}

fun {f32} lifted_29731(f32 x_75249) = {
  let {f32 res_75250} = exp32(x_75249)
  in {res_75250}
}

fun {f32} lifted_29736(f32 x_75251) = {
  {x_75251}
}

fun {f32} lifted_29739(f32 x_75252) = {
  let {f32 res_75253} = cos32(x_75252)
  in {res_75253}
}

fun {f32} lifted_29744(f32 x_75254, f32 y_75255) = {
  let {f32 res_75256} = fmul32(x_75254, y_75255)
  in {res_75256}
}

fun {f32} lifted_29748(f32 a_75257) = {
  {a_75257}
}

fun {f32} lifted_29751(f32 x_75258) = {
  {x_75258}
}

fun {f32} lifted_29754(f32 x_75259) = {
  let {f32 res_75260} = sin32(x_75259)
  in {res_75260}
}

fun {f32} lifted_29759(f32 x_75261, f32 y_75262) = {
  let {f32 res_75263} = fmul32(x_75261, y_75262)
  in {res_75263}
}

fun {f32, f32} lifted_29764(f32 a_75264, f32 b_75265) = {
  {a_75264, b_75265}
}

fun {f32, f32} lifted_29729(f32 a_75266, f32 b_75267) = {
  let {f32 res_75268} = lifted_29731(a_75266)
  let {f32 expx_75269} = res_75268
  let {f32 arg_75270} = lifted_29736(expx_75269)
  let {f32 arg_75271} = lifted_29739(b_75267)
  let {f32 arg_75272} = lifted_29744(arg_75270, arg_75271)
  let {f32 arg_75273} = lifted_29748(arg_75272)
  let {f32 arg_75274} = lifted_29751(expx_75269)
  let {f32 arg_75275} = lifted_29754(b_75267)
  let {f32 arg_75276} = lifted_29759(arg_75274, arg_75275)
  let {f32 res_75277, f32 res_75278} = lifted_29764(arg_75273, arg_75276)
  in {res_75277, res_75278}
}

fun {f32, f32} lifted_27307(f32 coeff1_75279, f32 coeff1_75280,
                            f32 coeff2_75281, f32 coeff2_75282,
                            f32 day_count_fraction_75283, f32 etai2_75284,
                            f32 etai2_75285, f32 etai_75286, f32 etai_75287,
                            f32 i_75288, f32 i_75289, f32 kappai_75290,
                            f32 kappai_75291, f32 one_75292, f32 one_75293,
                            f32 rho_75294, f32 two_75295, f32 two_75296,
                            f32 zero_75297, f32 zero_75298, f32 xi_75299,
                            f32 xi_75300) = {
  let {f32 res_75301, f32 res_75302} = lifted_27310(day_count_fraction_75283)
  let {f32 ti_75303} = res_75301
  let {f32 ti_75304} = res_75302
  let {f32 arg_75305, f32 arg_75306} = lifted_27324(kappai_75290, kappai_75291)
  let {f32 arg_75307, f32 arg_75308} = lifted_27329(rho_75294)
  let {f32 arg_75309, f32 arg_75310} = lifted_27340(arg_75307, arg_75308)
  let {f32 arg_75311, f32 arg_75312} = lifted_27350(arg_75309, arg_75310,
                                                    etai_75286, etai_75287)
  let {f32 arg_75313, f32 arg_75314} = lifted_27423(arg_75311, arg_75312)
  let {f32 arg_75315, f32 arg_75316} = lifted_27433(arg_75313, arg_75314,
                                                    xi_75299, xi_75300)
  let {f32 res_75317, f32 res_75318} = lifted_27509(arg_75305, arg_75306,
                                                    arg_75315, arg_75316)
  let {f32 d0_75319} = res_75317
  let {f32 d0_75320} = res_75318
  let {f32 arg_75321, f32 arg_75322} = lifted_27549(d0_75319, d0_75320)
  let {f32 arg_75323, f32 arg_75324} = lifted_27559(arg_75321, arg_75322,
                                                    d0_75319, d0_75320)
  let {f32 arg_75325, f32 arg_75326} = lifted_27632(arg_75323, arg_75324)
  let {f32 arg_75327, f32 arg_75328} = lifted_27639(etai2_75284, etai2_75285)
  let {f32 arg_75329, f32 arg_75330} = lifted_27646(xi_75299, xi_75300)
  let {f32 arg_75331, f32 arg_75332} = lifted_27653(i_75288, i_75289)
  let {f32 arg_75333, f32 arg_75334} = lifted_27663(arg_75331, arg_75332,
                                                    xi_75299, xi_75300)
  let {f32 arg_75335, f32 arg_75336} = lifted_27703(arg_75329, arg_75330,
                                                    arg_75333, arg_75334)
  let {f32 arg_75337, f32 arg_75338} = lifted_27779(arg_75327, arg_75328,
                                                    arg_75335, arg_75336)
  let {f32 arg_75339, f32 arg_75340} = lifted_27855(arg_75325, arg_75326,
                                                    arg_75337, arg_75338)
  let {f32 res_75341, f32 res_75342} = lifted_27898(arg_75339, arg_75340)
  let {f32 d_75343} = res_75341
  let {f32 d_75344} = res_75342
  let {f32 arg_75345, f32 arg_75346} = lifted_28066(d0_75319, d0_75320)
  let {f32 res_75347, f32 res_75348} = lifted_28076(arg_75345, arg_75346,
                                                    d_75343, d_75344)
  let {f32 a_minus_75349} = res_75347
  let {f32 a_minus_75350} = res_75348
  let {f32 arg_75351, f32 arg_75352} = lifted_28116(a_minus_75349,
                                                    a_minus_75350)
  let {f32 arg_75353, f32 arg_75354} = lifted_28123(d0_75319, d0_75320)
  let {f32 arg_75355, f32 arg_75356} = lifted_28133(arg_75353, arg_75354,
                                                    d_75343, d_75344)
  let {f32 res_75357, f32 res_75358} = lifted_28173(arg_75351, arg_75352,
                                                    arg_75355, arg_75356)
  let {f32 g_75359} = res_75357
  let {f32 g_75360} = res_75358
  let {f32 arg_75361, f32 arg_75362} = lifted_28315(zero_75297, zero_75298)
  let {f32 arg_75363, f32 arg_75364} = lifted_28322(d_75343, d_75344)
  let {f32 arg_75365, f32 arg_75366} = lifted_28332(arg_75363, arg_75364,
                                                    ti_75303, ti_75304)
  let {f32 arg_75367, f32 arg_75368} = lifted_28408(arg_75361, arg_75362,
                                                    arg_75365, arg_75366)
  let {f32 res_75369, f32 res_75370} = lifted_28448(arg_75367, arg_75368)
  let {f32 e_75371} = res_75369
  let {f32 e_75372} = res_75370
  let {f32 arg_75373, f32 arg_75374} = lifted_28495(coeff1_75279, coeff1_75280)
  let {f32 arg_75375, f32 arg_75376} = lifted_28502(a_minus_75349,
                                                    a_minus_75350)
  let {f32 arg_75377, f32 arg_75378} = lifted_28512(arg_75375, arg_75376,
                                                    ti_75303, ti_75304)
  let {f32 arg_75379, f32 arg_75380} = lifted_28585(arg_75377, arg_75378)
  let {f32 arg_75381, f32 arg_75382} = lifted_28592(two_75295, two_75296)
  let {f32 arg_75383, f32 arg_75384} = lifted_28599(one_75292, one_75293)
  let {f32 arg_75385, f32 arg_75386} = lifted_28606(g_75359, g_75360)
  let {f32 arg_75387, f32 arg_75388} = lifted_28616(arg_75385, arg_75386,
                                                    e_75371, e_75372)
  let {f32 arg_75389, f32 arg_75390} = lifted_28692(arg_75383, arg_75384,
                                                    arg_75387, arg_75388)
  let {f32 arg_75391, f32 arg_75392} = lifted_28729(arg_75389, arg_75390)
  let {f32 arg_75393, f32 arg_75394} = lifted_28736(one_75292, one_75293)
  let {f32 arg_75395, f32 arg_75396} = lifted_28746(arg_75393, arg_75394,
                                                    g_75359, g_75360)
  let {f32 arg_75397, f32 arg_75398} = lifted_28786(arg_75391, arg_75392,
                                                    arg_75395, arg_75396)
  let {f32 arg_75399, f32 arg_75400} = lifted_28928(arg_75397, arg_75398)
  let {f32 arg_75401, f32 arg_75402} = lifted_28998(arg_75381, arg_75382,
                                                    arg_75399, arg_75400)
  let {f32 arg_75403, f32 arg_75404} = lifted_29074(arg_75379, arg_75380,
                                                    arg_75401, arg_75402)
  let {f32 arg_75405, f32 arg_75406} = lifted_29114(arg_75373, arg_75374,
                                                    arg_75403, arg_75404)
  let {f32 arg_75407, f32 arg_75408} = lifted_29187(arg_75405, arg_75406)
  let {f32 arg_75409, f32 arg_75410} = lifted_29194(coeff2_75281, coeff2_75282)
  let {f32 arg_75411, f32 arg_75412} = lifted_29204(arg_75409, arg_75410,
                                                    a_minus_75349,
                                                    a_minus_75350)
  let {f32 arg_75413, f32 arg_75414} = lifted_29277(arg_75411, arg_75412)
  let {f32 arg_75415, f32 arg_75416} = lifted_29284(one_75292, one_75293)
  let {f32 arg_75417, f32 arg_75418} = lifted_29294(arg_75415, arg_75416,
                                                    e_75371, e_75372)
  let {f32 arg_75419, f32 arg_75420} = lifted_29334(arg_75413, arg_75414,
                                                    arg_75417, arg_75418)
  let {f32 arg_75421, f32 arg_75422} = lifted_29407(arg_75419, arg_75420)
  let {f32 arg_75423, f32 arg_75424} = lifted_29414(one_75292, one_75293)
  let {f32 arg_75425, f32 arg_75426} = lifted_29421(g_75359, g_75360)
  let {f32 arg_75427, f32 arg_75428} = lifted_29431(arg_75425, arg_75426,
                                                    e_75371, e_75372)
  let {f32 arg_75429, f32 arg_75430} = lifted_29507(arg_75423, arg_75424,
                                                    arg_75427, arg_75428)
  let {f32 arg_75431, f32 arg_75432} = lifted_29547(arg_75421, arg_75422,
                                                    arg_75429, arg_75430)
  let {f32 arg_75433, f32 arg_75434} = lifted_29689(arg_75407, arg_75408,
                                                    arg_75431, arg_75432)
  let {f32 res_75435, f32 res_75436} = lifted_29729(arg_75433, arg_75434)
  in {res_75435, res_75436}
}

fun {f32, f32} lifted_29782(f32 a_75437, f32 b_75438) = {
  {a_75437, b_75438}
}

fun {f32} lifted_29792(f32 x_75439) = {
  {x_75439}
}

fun {f32} lifted_29796(f32 x_75440, f32 y_75441) = {
  let {f32 res_75442} = fsub32(x_75440, y_75441)
  in {res_75442}
}

fun {f32} lifted_29800(f32 x_75443) = {
  {x_75443}
}

fun {f32} lifted_29804(f32 x_75444, f32 y_75445) = {
  let {f32 res_75446} = fsub32(x_75444, y_75445)
  in {res_75446}
}

fun {f32, f32} lifted_29790(f32 a_75447, f32 b_75448, f32 c_75449,
                            f32 d_75450) = {
  let {f32 arg_75451} = lifted_29792(a_75447)
  let {f32 res_75452} = lifted_29796(arg_75451, c_75449)
  let {f32 arg_75453} = lifted_29800(b_75448)
  let {f32 res_75454} = lifted_29804(arg_75453, d_75450)
  in {res_75452, res_75454}
}

fun {f32, f32} lifted_29778(f32 x_75455, f32 x_75456, f32 y_75457,
                            f32 y_75458) = {
  let {f32 arg_75459, f32 arg_75460} = lifted_29782(x_75455, x_75456)
  let {f32 res_75461, f32 res_75462} = lifted_29790(arg_75459, arg_75460,
                                                    y_75457, y_75458)
  in {res_75461, res_75462}
}

fun {f32} lifted_29818(f64 x_75463) = {
  let {f32 res_75464} = fpconv f64 x_75463 to f32
  in {res_75464}
}

fun {f32} lifted_29816(f64 x_75465) = {
  let {f32 res_75466} = lifted_29818(x_75465)
  in {res_75466}
}

fun {f32} lifted_29823(f32 x_75467) = {
  {x_75467}
}

fun {f32, f32} lifted_29829(f32 x_75468, f32 x_75469) = {
  {x_75468, x_75469}
}

fun {f32, f32} lifted_29836(f32 x_75470, f32 x_75471) = {
  {x_75470, x_75471}
}

fun {f32, f32} lifted_29852(f32 a_75472, f32 b_75473) = {
  {a_75472, b_75473}
}

fun {f32} lifted_29864(f32 x_75474) = {
  {x_75474}
}

fun {f32} lifted_29868(f32 x_75475, f32 y_75476) = {
  let {f32 res_75477} = fmul32(x_75475, y_75476)
  in {res_75477}
}

fun {f32} lifted_29872(f32 x_75478) = {
  {x_75478}
}

fun {f32} lifted_29875(f32 x_75479) = {
  {x_75479}
}

fun {f32} lifted_29879(f32 x_75480, f32 y_75481) = {
  let {f32 res_75482} = fmul32(x_75480, y_75481)
  in {res_75482}
}

fun {f32} lifted_29884(f32 x_75483, f32 y_75484) = {
  let {f32 res_75485} = fsub32(x_75483, y_75484)
  in {res_75485}
}

fun {f32} lifted_29888(f32 x_75486) = {
  {x_75486}
}

fun {f32} lifted_29892(f32 x_75487, f32 y_75488) = {
  let {f32 res_75489} = fmul32(x_75487, y_75488)
  in {res_75489}
}

fun {f32} lifted_29896(f32 x_75490) = {
  {x_75490}
}

fun {f32} lifted_29899(f32 x_75491) = {
  {x_75491}
}

fun {f32} lifted_29903(f32 x_75492, f32 y_75493) = {
  let {f32 res_75494} = fmul32(x_75492, y_75493)
  in {res_75494}
}

fun {f32} lifted_29908(f32 x_75495, f32 y_75496) = {
  let {f32 res_75497} = fadd32(x_75495, y_75496)
  in {res_75497}
}

fun {f32, f32} lifted_29862(f32 a_75498, f32 b_75499, f32 c_75500,
                            f32 d_75501) = {
  let {f32 arg_75502} = lifted_29864(a_75498)
  let {f32 arg_75503} = lifted_29868(arg_75502, c_75500)
  let {f32 arg_75504} = lifted_29872(arg_75503)
  let {f32 arg_75505} = lifted_29875(b_75499)
  let {f32 arg_75506} = lifted_29879(arg_75505, d_75501)
  let {f32 res_75507} = lifted_29884(arg_75504, arg_75506)
  let {f32 arg_75508} = lifted_29888(b_75499)
  let {f32 arg_75509} = lifted_29892(arg_75508, c_75500)
  let {f32 arg_75510} = lifted_29896(arg_75509)
  let {f32 arg_75511} = lifted_29899(a_75498)
  let {f32 arg_75512} = lifted_29903(arg_75511, d_75501)
  let {f32 res_75513} = lifted_29908(arg_75510, arg_75512)
  in {res_75507, res_75513}
}

fun {f32, f32} lifted_29846(f32 x_75514, f32 x_75515, f32 y_75516,
                            f32 y_75517) = {
  let {f32 arg_75518, f32 arg_75519} = lifted_29852(x_75514, x_75515)
  let {f32 res_75520, f32 res_75521} = lifted_29862(arg_75518, arg_75519,
                                                    y_75516, y_75517)
  in {res_75520, res_75521}
}

fun {f32, f32} lifted_29926(f32 a_75522, f32 b_75523) = {
  {a_75522, b_75523}
}

fun {f32} lifted_29936(f32 x_75524) = {
  {x_75524}
}

fun {f32} lifted_29940(f32 x_75525, f32 y_75526) = {
  let {f32 res_75527} = fsub32(x_75525, y_75526)
  in {res_75527}
}

fun {f32} lifted_29944(f32 x_75528) = {
  {x_75528}
}

fun {f32} lifted_29948(f32 x_75529, f32 y_75530) = {
  let {f32 res_75531} = fsub32(x_75529, y_75530)
  in {res_75531}
}

fun {f32, f32} lifted_29934(f32 a_75532, f32 b_75533, f32 c_75534,
                            f32 d_75535) = {
  let {f32 arg_75536} = lifted_29936(a_75532)
  let {f32 res_75537} = lifted_29940(arg_75536, c_75534)
  let {f32 arg_75538} = lifted_29944(b_75533)
  let {f32 res_75539} = lifted_29948(arg_75538, d_75535)
  in {res_75537, res_75539}
}

fun {f32, f32} lifted_29922(f32 x_75540, f32 x_75541, f32 y_75542,
                            f32 y_75543) = {
  let {f32 arg_75544, f32 arg_75545} = lifted_29926(x_75540, x_75541)
  let {f32 res_75546, f32 res_75547} = lifted_29934(arg_75544, arg_75545,
                                                    y_75542, y_75543)
  in {res_75546, res_75547}
}

fun {f32} lifted_29957(f32 _a_75548, f32 b_75549) = {
  {b_75549}
}

fun {f32} lifted_29961(f32 x_75550, f32 y_75551) = {
  let {f32 res_75552} = fmul32(x_75550, y_75551)
  in {res_75552}
}

fun {f32} lifted_29965(f32 x_75553) = {
  {x_75553}
}

fun {f32} lifted_29968(f32 x_75554) = {
  {x_75554}
}

fun {f32} lifted_29972(f32 x_75555, f32 y_75556) = {
  let {f32 res_75557} = fmul32(x_75555, y_75556)
  in {res_75557}
}

fun {f32} lifted_29977(f32 x_75558, f32 y_75559) = {
  let {f32 res_75560} = fdiv32(x_75558, y_75559)
  in {res_75560}
}

fun {f32} lifted_19384(bool ap1_75561, f32 i_75562, f32 i_75563,
                       f32 psi_h_75564, f32 psi_h_75565, f32 psi_h_75566,
                       f32 psi_h_75567, f32 psi_h_75568, f32 psi_h_75569,
                       f32 psi_h_75570, f32 psi_h_75571, f32 psi_h_75572,
                       f32 psi_h_75573, f32 psi_h_75574, f32 psi_h_75575,
                       f32 psi_h_75576, f32 psi_h_75577, f32 psi_h_75578,
                       f32 psi_h_75579, f32 psi_h_75580, f32 psi_h_75581,
                       f32 psi_h_75582, f32 v0_75583,
                       f32 day_count_fraction_75584) = {
  let {f32 res_75585} =
    -- Branch returns: {f32}
    if ap1_75561
    then {v0_75583} else {
      let {i32 arg_75586} = sub32(0i32, 1i32)
      let {f32 res_75587} = lifted_19388(arg_75586)
      let {f32 eta_75588} = res_75587
      let {f32 res_75589} = lifted_19397(1.0e-2f64)
      let {f32 eps_75590} = res_75589
      let {f32 arg_75591, f32 arg_75592, f32 arg_75593, f32 arg_75594,
           f32 arg_75595, f32 arg_75596, f32 arg_75597, f32 arg_75598,
           f32 arg_75599, f32 arg_75600, f32 arg_75601, f32 arg_75602,
           f32 arg_75603, f32 arg_75604, f32 arg_75605, f32 arg_75606,
           f32 arg_75607, f32 arg_75608, f32 arg_75609,
           f32 arg_75610} = lifted_19442(psi_h_75564, psi_h_75565, psi_h_75566,
                                         psi_h_75567, psi_h_75568, psi_h_75569,
                                         psi_h_75570, psi_h_75571, psi_h_75572,
                                         psi_h_75573, psi_h_75574, psi_h_75575,
                                         psi_h_75576, psi_h_75577, psi_h_75578,
                                         psi_h_75579, psi_h_75580, psi_h_75581,
                                         psi_h_75582, day_count_fraction_75584)
      let {f32 arg_75611} = lifted_19464(eps_75590)
      let {f32 arg_75612, f32 arg_75613} = lifted_19468(arg_75611, eta_75588)
      let {f32 arg_75614, f32 arg_75615} = lifted_19512(arg_75591, arg_75592,
                                                        arg_75593, arg_75594,
                                                        arg_75595, arg_75596,
                                                        arg_75597, arg_75598,
                                                        arg_75599, arg_75600,
                                                        arg_75601, arg_75602,
                                                        arg_75603, arg_75604,
                                                        arg_75605, arg_75606,
                                                        arg_75607, arg_75608,
                                                        arg_75609, arg_75610,
                                                        arg_75612, arg_75613)
      let {f32 arg_75616, f32 arg_75617} = lifted_21980(arg_75614, arg_75615)
      let {f32 arg_75618, f32 arg_75619, f32 arg_75620, f32 arg_75621,
           f32 arg_75622, f32 arg_75623, f32 arg_75624, f32 arg_75625,
           f32 arg_75626, f32 arg_75627, f32 arg_75628, f32 arg_75629,
           f32 arg_75630, f32 arg_75631, f32 arg_75632, f32 arg_75633,
           f32 arg_75634, f32 arg_75635, f32 arg_75636,
           f32 arg_75637} = lifted_22021(psi_h_75564, psi_h_75565, psi_h_75566,
                                         psi_h_75567, psi_h_75568, psi_h_75569,
                                         psi_h_75570, psi_h_75571, psi_h_75572,
                                         psi_h_75573, psi_h_75574, psi_h_75575,
                                         psi_h_75576, psi_h_75577, psi_h_75578,
                                         psi_h_75579, psi_h_75580, psi_h_75581,
                                         psi_h_75582, day_count_fraction_75584)
      let {f32 arg_75638} = lifted_22043(eps_75590)
      let {f32 arg_75639} = lifted_22047(arg_75638)
      let {f32 arg_75640, f32 arg_75641} = lifted_22051(arg_75639, eta_75588)
      let {f32 arg_75642, f32 arg_75643} = lifted_22095(arg_75618, arg_75619,
                                                        arg_75620, arg_75621,
                                                        arg_75622, arg_75623,
                                                        arg_75624, arg_75625,
                                                        arg_75626, arg_75627,
                                                        arg_75628, arg_75629,
                                                        arg_75630, arg_75631,
                                                        arg_75632, arg_75633,
                                                        arg_75634, arg_75635,
                                                        arg_75636, arg_75637,
                                                        arg_75640, arg_75641)
      let {f32 res_75644, f32 res_75645} = lifted_24566(arg_75616, arg_75617,
                                                        arg_75642, arg_75643)
      let {f32 two_da_time_eps_75646} = res_75644
      let {f32 two_da_time_eps_75647} = res_75645
      let {f32 arg_75648, f32 arg_75649, f32 arg_75650, f32 arg_75651,
           f32 arg_75652, f32 arg_75653, f32 arg_75654, f32 arg_75655,
           f32 arg_75656, f32 arg_75657, f32 arg_75658, f32 arg_75659,
           f32 arg_75660, f32 arg_75661, f32 arg_75662, f32 arg_75663,
           f32 arg_75664, f32 arg_75665, f32 arg_75666,
           f32 arg_75667} = lifted_24640(psi_h_75564, psi_h_75565, psi_h_75566,
                                         psi_h_75567, psi_h_75568, psi_h_75569,
                                         psi_h_75570, psi_h_75571, psi_h_75572,
                                         psi_h_75573, psi_h_75574, psi_h_75575,
                                         psi_h_75576, psi_h_75577, psi_h_75578,
                                         psi_h_75579, psi_h_75580, psi_h_75581,
                                         psi_h_75582, day_count_fraction_75584)
      let {f32 arg_75668} = lifted_24662(eta_75588)
      let {f32 arg_75669} = lifted_24666(arg_75668, eps_75590)
      let {f32 arg_75670, f32 arg_75671} = lifted_24671(arg_75669)
      let {f32 arg_75672, f32 arg_75673} = lifted_24719(arg_75648, arg_75649,
                                                        arg_75650, arg_75651,
                                                        arg_75652, arg_75653,
                                                        arg_75654, arg_75655,
                                                        arg_75656, arg_75657,
                                                        arg_75658, arg_75659,
                                                        arg_75660, arg_75661,
                                                        arg_75662, arg_75663,
                                                        arg_75664, arg_75665,
                                                        arg_75666, arg_75667,
                                                        arg_75670, arg_75671)
      let {f32 arg_75674, f32 arg_75675} = lifted_27187(arg_75672, arg_75673)
      let {f32 arg_75676, f32 arg_75677, f32 arg_75678, f32 arg_75679,
           f32 arg_75680, f32 arg_75681, f32 arg_75682, f32 arg_75683,
           f32 arg_75684, f32 arg_75685, f32 arg_75686, f32 arg_75687,
           f32 arg_75688, f32 arg_75689, f32 arg_75690, f32 arg_75691,
           f32 arg_75692, f32 arg_75693, f32 arg_75694,
           f32 arg_75695} = lifted_27228(psi_h_75564, psi_h_75565, psi_h_75566,
                                         psi_h_75567, psi_h_75568, psi_h_75569,
                                         psi_h_75570, psi_h_75571, psi_h_75572,
                                         psi_h_75573, psi_h_75574, psi_h_75575,
                                         psi_h_75576, psi_h_75577, psi_h_75578,
                                         psi_h_75579, psi_h_75580, psi_h_75581,
                                         psi_h_75582, day_count_fraction_75584)
      let {f32 arg_75696} = lifted_27250(eta_75588)
      let {f32 arg_75697} = lifted_27254(arg_75696, eps_75590)
      let {f32 arg_75698, f32 arg_75699} = lifted_27259(arg_75697)
      let {f32 arg_75700, f32 arg_75701} = lifted_27307(arg_75676, arg_75677,
                                                        arg_75678, arg_75679,
                                                        arg_75680, arg_75681,
                                                        arg_75682, arg_75683,
                                                        arg_75684, arg_75685,
                                                        arg_75686, arg_75687,
                                                        arg_75688, arg_75689,
                                                        arg_75690, arg_75691,
                                                        arg_75692, arg_75693,
                                                        arg_75694, arg_75695,
                                                        arg_75698, arg_75699)
      let {f32 res_75702, f32 res_75703} = lifted_29778(arg_75674, arg_75675,
                                                        arg_75700, arg_75701)
      let {f32 two_db_time_eps_75704} = res_75702
      let {f32 two_db_time_eps_75705} = res_75703
      let {f32 arg_75706} = lifted_29816(0.5f64)
      let {f32 arg_75707} = lifted_29823(arg_75706)
      let {f32 arg_75708, f32 arg_75709} = lifted_29829(two_da_time_eps_75646,
                                                        two_da_time_eps_75647)
      let {f32 arg_75710, f32 arg_75711} = lifted_29836(i_75562, i_75563)
      let {f32 arg_75712, f32 arg_75713} = lifted_29846(arg_75710, arg_75711,
                                                        two_db_time_eps_75704,
                                                        two_db_time_eps_75705)
      let {f32 arg_75714, f32 arg_75715} = lifted_29922(arg_75708, arg_75709,
                                                        arg_75712, arg_75713)
      let {f32 arg_75716} = lifted_29957(arg_75714, arg_75715)
      let {f32 arg_75717} = lifted_29961(arg_75707, arg_75716)
      let {f32 arg_75718} = lifted_29965(arg_75717)
      let {f32 arg_75719} = lifted_29968(day_count_fraction_75584)
      let {f32 arg_75720} = lifted_29972(arg_75719, eps_75590)
      let {f32 res_75721} = lifted_29977(arg_75718, arg_75720)
      in {res_75721}
    }
  in {res_75585}
}

fun {f32} lifted_29984(f32 x_75722, f32 y_75723) = {
  let {f32 res_75724} = fmul32(x_75722, y_75723)
  in {res_75724}
}

fun {f32} lifted_29991(i32 x_75725) = {
  let {f32 res_75726} = sitofp i32 x_75725 to f32
  in {res_75726}
}

fun {f32, f32} lifted_29989(f32 a_75727) = {
  let {f32 res_75728} = lifted_29991(0i32)
  in {a_75727, res_75728}
}

fun {f32, f32} lifted_30003(f32 x_75729, f32 x_75730) = {
  {x_75729, x_75730}
}

fun {f32, f32} lifted_30010(f32 x_75731, f32 x_75732) = {
  {x_75731, x_75732}
}

fun {f32, f32} lifted_30017(f32 x_75733, f32 x_75734) = {
  {x_75733, x_75734}
}

fun {f32, f32} lifted_30031(f32 a_75735, f32 b_75736) = {
  {a_75735, b_75736}
}

fun {f32} lifted_30041(f32 x_75737) = {
  {x_75737}
}

fun {f32} lifted_30045(f32 x_75738, f32 y_75739) = {
  let {f32 res_75740} = fadd32(x_75738, y_75739)
  in {res_75740}
}

fun {f32} lifted_30049(f32 x_75741) = {
  {x_75741}
}

fun {f32} lifted_30053(f32 x_75742, f32 y_75743) = {
  let {f32 res_75744} = fadd32(x_75742, y_75743)
  in {res_75744}
}

fun {f32, f32} lifted_30039(f32 a_75745, f32 b_75746, f32 c_75747,
                            f32 d_75748) = {
  let {f32 arg_75749} = lifted_30041(a_75745)
  let {f32 res_75750} = lifted_30045(arg_75749, c_75747)
  let {f32 arg_75751} = lifted_30049(b_75746)
  let {f32 res_75752} = lifted_30053(arg_75751, d_75748)
  in {res_75750, res_75752}
}

fun {f32, f32} lifted_30027(f32 x_75753, f32 x_75754, f32 y_75755,
                            f32 y_75756) = {
  let {f32 arg_75757, f32 arg_75758} = lifted_30031(x_75753, x_75754)
  let {f32 res_75759, f32 res_75760} = lifted_30039(arg_75757, arg_75758,
                                                    y_75755, y_75756)
  in {res_75759, res_75760}
}

fun {f32, f32} lifted_30073(f32 a_75761, f32 b_75762) = {
  {a_75761, b_75762}
}

fun {f32} lifted_30085(f32 x_75763) = {
  {x_75763}
}

fun {f32} lifted_30089(f32 x_75764, f32 y_75765) = {
  let {f32 res_75766} = fmul32(x_75764, y_75765)
  in {res_75766}
}

fun {f32} lifted_30093(f32 x_75767) = {
  {x_75767}
}

fun {f32} lifted_30096(f32 x_75768) = {
  {x_75768}
}

fun {f32} lifted_30100(f32 x_75769, f32 y_75770) = {
  let {f32 res_75771} = fmul32(x_75769, y_75770)
  in {res_75771}
}

fun {f32} lifted_30105(f32 x_75772, f32 y_75773) = {
  let {f32 res_75774} = fsub32(x_75772, y_75773)
  in {res_75774}
}

fun {f32} lifted_30109(f32 x_75775) = {
  {x_75775}
}

fun {f32} lifted_30113(f32 x_75776, f32 y_75777) = {
  let {f32 res_75778} = fmul32(x_75776, y_75777)
  in {res_75778}
}

fun {f32} lifted_30117(f32 x_75779) = {
  {x_75779}
}

fun {f32} lifted_30120(f32 x_75780) = {
  {x_75780}
}

fun {f32} lifted_30124(f32 x_75781, f32 y_75782) = {
  let {f32 res_75783} = fmul32(x_75781, y_75782)
  in {res_75783}
}

fun {f32} lifted_30129(f32 x_75784, f32 y_75785) = {
  let {f32 res_75786} = fadd32(x_75784, y_75785)
  in {res_75786}
}

fun {f32, f32} lifted_30083(f32 a_75787, f32 b_75788, f32 c_75789,
                            f32 d_75790) = {
  let {f32 arg_75791} = lifted_30085(a_75787)
  let {f32 arg_75792} = lifted_30089(arg_75791, c_75789)
  let {f32 arg_75793} = lifted_30093(arg_75792)
  let {f32 arg_75794} = lifted_30096(b_75788)
  let {f32 arg_75795} = lifted_30100(arg_75794, d_75790)
  let {f32 res_75796} = lifted_30105(arg_75793, arg_75795)
  let {f32 arg_75797} = lifted_30109(b_75788)
  let {f32 arg_75798} = lifted_30113(arg_75797, c_75789)
  let {f32 arg_75799} = lifted_30117(arg_75798)
  let {f32 arg_75800} = lifted_30120(a_75787)
  let {f32 arg_75801} = lifted_30124(arg_75800, d_75790)
  let {f32 res_75802} = lifted_30129(arg_75799, arg_75801)
  in {res_75796, res_75802}
}

fun {f32, f32} lifted_30067(f32 x_75803, f32 x_75804, f32 y_75805,
                            f32 y_75806) = {
  let {f32 arg_75807, f32 arg_75808} = lifted_30073(x_75803, x_75804)
  let {f32 res_75809, f32 res_75810} = lifted_30083(arg_75807, arg_75808,
                                                    y_75805, y_75806)
  in {res_75809, res_75810}
}

fun {f32, f32} lifted_30149(f32 a_75811, f32 b_75812) = {
  {a_75811, b_75812}
}

fun {f32} lifted_30161(f32 x_75813) = {
  {x_75813}
}

fun {f32} lifted_30165(f32 x_75814, f32 y_75815) = {
  let {f32 res_75816} = fmul32(x_75814, y_75815)
  in {res_75816}
}

fun {f32} lifted_30169(f32 x_75817) = {
  {x_75817}
}

fun {f32} lifted_30172(f32 x_75818) = {
  {x_75818}
}

fun {f32} lifted_30176(f32 x_75819, f32 y_75820) = {
  let {f32 res_75821} = fmul32(x_75819, y_75820)
  in {res_75821}
}

fun {f32} lifted_30181(f32 x_75822, f32 y_75823) = {
  let {f32 res_75824} = fsub32(x_75822, y_75823)
  in {res_75824}
}

fun {f32} lifted_30185(f32 x_75825) = {
  {x_75825}
}

fun {f32} lifted_30189(f32 x_75826, f32 y_75827) = {
  let {f32 res_75828} = fmul32(x_75826, y_75827)
  in {res_75828}
}

fun {f32} lifted_30193(f32 x_75829) = {
  {x_75829}
}

fun {f32} lifted_30196(f32 x_75830) = {
  {x_75830}
}

fun {f32} lifted_30200(f32 x_75831, f32 y_75832) = {
  let {f32 res_75833} = fmul32(x_75831, y_75832)
  in {res_75833}
}

fun {f32} lifted_30205(f32 x_75834, f32 y_75835) = {
  let {f32 res_75836} = fadd32(x_75834, y_75835)
  in {res_75836}
}

fun {f32, f32} lifted_30159(f32 a_75837, f32 b_75838, f32 c_75839,
                            f32 d_75840) = {
  let {f32 arg_75841} = lifted_30161(a_75837)
  let {f32 arg_75842} = lifted_30165(arg_75841, c_75839)
  let {f32 arg_75843} = lifted_30169(arg_75842)
  let {f32 arg_75844} = lifted_30172(b_75838)
  let {f32 arg_75845} = lifted_30176(arg_75844, d_75840)
  let {f32 res_75846} = lifted_30181(arg_75843, arg_75845)
  let {f32 arg_75847} = lifted_30185(b_75838)
  let {f32 arg_75848} = lifted_30189(arg_75847, c_75839)
  let {f32 arg_75849} = lifted_30193(arg_75848)
  let {f32 arg_75850} = lifted_30196(a_75837)
  let {f32 arg_75851} = lifted_30200(arg_75850, d_75840)
  let {f32 res_75852} = lifted_30205(arg_75849, arg_75851)
  in {res_75846, res_75852}
}

fun {f32, f32} lifted_30143(f32 x_75853, f32 x_75854, f32 y_75855,
                            f32 y_75856) = {
  let {f32 arg_75857, f32 arg_75858} = lifted_30149(x_75853, x_75854)
  let {f32 res_75859, f32 res_75860} = lifted_30159(arg_75857, arg_75858,
                                                    y_75855, y_75856)
  in {res_75859, res_75860}
}

fun {f32} lifted_30221(f32 x_75861) = {
  let {f32 res_75862} = exp32(x_75861)
  in {res_75862}
}

fun {f32} lifted_30226(f32 x_75863) = {
  {x_75863}
}

fun {f32} lifted_30229(f32 x_75864) = {
  let {f32 res_75865} = cos32(x_75864)
  in {res_75865}
}

fun {f32} lifted_30234(f32 x_75866, f32 y_75867) = {
  let {f32 res_75868} = fmul32(x_75866, y_75867)
  in {res_75868}
}

fun {f32} lifted_30238(f32 a_75869) = {
  {a_75869}
}

fun {f32} lifted_30241(f32 x_75870) = {
  {x_75870}
}

fun {f32} lifted_30244(f32 x_75871) = {
  let {f32 res_75872} = sin32(x_75871)
  in {res_75872}
}

fun {f32} lifted_30249(f32 x_75873, f32 y_75874) = {
  let {f32 res_75875} = fmul32(x_75873, y_75874)
  in {res_75875}
}

fun {f32, f32} lifted_30254(f32 a_75876, f32 b_75877) = {
  {a_75876, b_75877}
}

fun {f32, f32} lifted_30219(f32 a_75878, f32 b_75879) = {
  let {f32 res_75880} = lifted_30221(a_75878)
  let {f32 expx_75881} = res_75880
  let {f32 arg_75882} = lifted_30226(expx_75881)
  let {f32 arg_75883} = lifted_30229(b_75879)
  let {f32 arg_75884} = lifted_30234(arg_75882, arg_75883)
  let {f32 arg_75885} = lifted_30238(arg_75884)
  let {f32 arg_75886} = lifted_30241(expx_75881)
  let {f32 arg_75887} = lifted_30244(b_75879)
  let {f32 arg_75888} = lifted_30249(arg_75886, arg_75887)
  let {f32 res_75889, f32 res_75890} = lifted_30254(arg_75885, arg_75888)
  in {res_75889, res_75890}
}

fun {f32, f32} lifted_19325(f32 day_count_fraction_75891, f32 i_75892,
                            f32 i_75893, bool sigma2_75894, f32 sigma2_75895,
                            f32 sigma2_75896, f32 sigma2_75897,
                            f32 sigma2_75898, f32 sigma2_75899,
                            f32 sigma2_75900, f32 sigma2_75901,
                            f32 sigma2_75902, f32 sigma2_75903,
                            f32 sigma2_75904, f32 sigma2_75905,
                            f32 sigma2_75906, f32 sigma2_75907,
                            f32 sigma2_75908, f32 sigma2_75909,
                            f32 sigma2_75910, f32 sigma2_75911,
                            f32 sigma2_75912, f32 sigma2_75913,
                            f32 sigma2_75914, f32 sigma2_75915,
                            f32 sigma2_75916, f32 xi_75917, f32 xi_75918) = {
  let {f64 arg_75919} = fsub64(0.0f64, 0.5f64)
  let {f32 arg_75920} = lifted_19329(arg_75919)
  let {f32 arg_75921} = lifted_19336(arg_75920)
  let {f32 arg_75922} = lifted_19340(arg_75921, day_count_fraction_75891)
  let {f32 arg_75923} = lifted_19344(arg_75922)
  let {f32 arg_75924} = lifted_19384(sigma2_75894, sigma2_75895, sigma2_75896,
                                     sigma2_75897, sigma2_75898, sigma2_75899,
                                     sigma2_75900, sigma2_75901, sigma2_75902,
                                     sigma2_75903, sigma2_75904, sigma2_75905,
                                     sigma2_75906, sigma2_75907, sigma2_75908,
                                     sigma2_75909, sigma2_75910, sigma2_75911,
                                     sigma2_75912, sigma2_75913, sigma2_75914,
                                     sigma2_75915, sigma2_75916,
                                     day_count_fraction_75891)
  let {f32 arg_75925} = lifted_29984(arg_75923, arg_75924)
  let {f32 res_75926, f32 res_75927} = lifted_29989(arg_75925)
  let {f32 minus_half_sigma2_t_75928} = res_75926
  let {f32 minus_half_sigma2_t_75929} = res_75927
  let {f32 arg_75930, f32 arg_75931} = lifted_30003(minus_half_sigma2_t_75928,
                                                    minus_half_sigma2_t_75929)
  let {f32 arg_75932, f32 arg_75933} = lifted_30010(xi_75917, xi_75918)
  let {f32 arg_75934, f32 arg_75935} = lifted_30017(i_75892, i_75893)
  let {f32 arg_75936, f32 arg_75937} = lifted_30027(arg_75934, arg_75935,
                                                    xi_75917, xi_75918)
  let {f32 arg_75938, f32 arg_75939} = lifted_30067(arg_75932, arg_75933,
                                                    arg_75936, arg_75937)
  let {f32 arg_75940, f32 arg_75941} = lifted_30143(arg_75930, arg_75931,
                                                    arg_75938, arg_75939)
  let {f32 res_75942, f32 res_75943} = lifted_30219(arg_75940, arg_75941)
  in {res_75942, res_75943}
}

fun {f32, f32} lifted_30265(f32 x_75944, f32 x_75945) = {
  {x_75944, x_75945}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_30306(f32 coeff1_75946, f32 coeff1_75947,
                                           f32 coeff2_75948, f32 coeff2_75949,
                                           f32 etai2_75950, f32 etai2_75951,
                                           f32 etai_75952, f32 etai_75953,
                                           f32 i_75954, f32 i_75955,
                                           f32 kappai_75956, f32 kappai_75957,
                                           f32 one_75958, f32 one_75959,
                                           f32 rho_75960, f32 two_75961,
                                           f32 two_75962, f32 zero_75963,
                                           f32 zero_75964,
                                           f32 day_count_fraction_75965) = {
  {coeff1_75946, coeff1_75947, coeff2_75948, coeff2_75949,
   day_count_fraction_75965, etai2_75950, etai2_75951, etai_75952, etai_75953,
   i_75954, i_75955, kappai_75956, kappai_75957, one_75958, one_75959,
   rho_75960, two_75961, two_75962, zero_75963, zero_75964}
}

fun {f32} lifted_30373(i32 x_75966) = {
  let {f32 res_75967} = sitofp i32 x_75966 to f32
  in {res_75967}
}

fun {f32, f32} lifted_30371(f32 a_75968) = {
  let {f32 res_75969} = lifted_30373(0i32)
  in {a_75968, res_75969}
}

fun {f32, f32} lifted_30385(f32 x_75970, f32 x_75971) = {
  {x_75970, x_75971}
}

fun {f32} lifted_30392(i32 x_75972) = {
  let {f32 res_75973} = sitofp i32 x_75972 to f32
  in {res_75973}
}

fun {f32, f32} lifted_30390(f32 b_75974) = {
  let {f32 res_75975} = lifted_30392(0i32)
  in {res_75975, b_75974}
}

fun {f32, f32} lifted_30401(f32 x_75976, f32 x_75977) = {
  {x_75976, x_75977}
}

fun {f32, f32} lifted_30417(f32 a_75978, f32 b_75979) = {
  {a_75978, b_75979}
}

fun {f32} lifted_30429(f32 x_75980) = {
  {x_75980}
}

fun {f32} lifted_30433(f32 x_75981, f32 y_75982) = {
  let {f32 res_75983} = fmul32(x_75981, y_75982)
  in {res_75983}
}

fun {f32} lifted_30437(f32 x_75984) = {
  {x_75984}
}

fun {f32} lifted_30440(f32 x_75985) = {
  {x_75985}
}

fun {f32} lifted_30444(f32 x_75986, f32 y_75987) = {
  let {f32 res_75988} = fmul32(x_75986, y_75987)
  in {res_75988}
}

fun {f32} lifted_30449(f32 x_75989, f32 y_75990) = {
  let {f32 res_75991} = fsub32(x_75989, y_75990)
  in {res_75991}
}

fun {f32} lifted_30453(f32 x_75992) = {
  {x_75992}
}

fun {f32} lifted_30457(f32 x_75993, f32 y_75994) = {
  let {f32 res_75995} = fmul32(x_75993, y_75994)
  in {res_75995}
}

fun {f32} lifted_30461(f32 x_75996) = {
  {x_75996}
}

fun {f32} lifted_30464(f32 x_75997) = {
  {x_75997}
}

fun {f32} lifted_30468(f32 x_75998, f32 y_75999) = {
  let {f32 res_76000} = fmul32(x_75998, y_75999)
  in {res_76000}
}

fun {f32} lifted_30473(f32 x_76001, f32 y_76002) = {
  let {f32 res_76003} = fadd32(x_76001, y_76002)
  in {res_76003}
}

fun {f32, f32} lifted_30427(f32 a_76004, f32 b_76005, f32 c_76006,
                            f32 d_76007) = {
  let {f32 arg_76008} = lifted_30429(a_76004)
  let {f32 arg_76009} = lifted_30433(arg_76008, c_76006)
  let {f32 arg_76010} = lifted_30437(arg_76009)
  let {f32 arg_76011} = lifted_30440(b_76005)
  let {f32 arg_76012} = lifted_30444(arg_76011, d_76007)
  let {f32 res_76013} = lifted_30449(arg_76010, arg_76012)
  let {f32 arg_76014} = lifted_30453(b_76005)
  let {f32 arg_76015} = lifted_30457(arg_76014, c_76006)
  let {f32 arg_76016} = lifted_30461(arg_76015)
  let {f32 arg_76017} = lifted_30464(a_76004)
  let {f32 arg_76018} = lifted_30468(arg_76017, d_76007)
  let {f32 res_76019} = lifted_30473(arg_76016, arg_76018)
  in {res_76013, res_76019}
}

fun {f32, f32} lifted_30411(f32 x_76020, f32 x_76021, f32 y_76022,
                            f32 y_76023) = {
  let {f32 arg_76024, f32 arg_76025} = lifted_30417(x_76020, x_76021)
  let {f32 res_76026, f32 res_76027} = lifted_30427(arg_76024, arg_76025,
                                                    y_76022, y_76023)
  in {res_76026, res_76027}
}

fun {f32, f32} lifted_30484(f32 x_76028, f32 x_76029) = {
  {x_76028, x_76029}
}

fun {f32, f32} lifted_30500(f32 a_76030, f32 b_76031) = {
  {a_76030, b_76031}
}

fun {f32} lifted_30512(f32 x_76032) = {
  {x_76032}
}

fun {f32} lifted_30516(f32 x_76033, f32 y_76034) = {
  let {f32 res_76035} = fmul32(x_76033, y_76034)
  in {res_76035}
}

fun {f32} lifted_30520(f32 x_76036) = {
  {x_76036}
}

fun {f32} lifted_30523(f32 x_76037) = {
  {x_76037}
}

fun {f32} lifted_30527(f32 x_76038, f32 y_76039) = {
  let {f32 res_76040} = fmul32(x_76038, y_76039)
  in {res_76040}
}

fun {f32} lifted_30532(f32 x_76041, f32 y_76042) = {
  let {f32 res_76043} = fsub32(x_76041, y_76042)
  in {res_76043}
}

fun {f32} lifted_30536(f32 x_76044) = {
  {x_76044}
}

fun {f32} lifted_30540(f32 x_76045, f32 y_76046) = {
  let {f32 res_76047} = fmul32(x_76045, y_76046)
  in {res_76047}
}

fun {f32} lifted_30544(f32 x_76048) = {
  {x_76048}
}

fun {f32} lifted_30547(f32 x_76049) = {
  {x_76049}
}

fun {f32} lifted_30551(f32 x_76050, f32 y_76051) = {
  let {f32 res_76052} = fmul32(x_76050, y_76051)
  in {res_76052}
}

fun {f32} lifted_30556(f32 x_76053, f32 y_76054) = {
  let {f32 res_76055} = fadd32(x_76053, y_76054)
  in {res_76055}
}

fun {f32, f32} lifted_30510(f32 a_76056, f32 b_76057, f32 c_76058,
                            f32 d_76059) = {
  let {f32 arg_76060} = lifted_30512(a_76056)
  let {f32 arg_76061} = lifted_30516(arg_76060, c_76058)
  let {f32 arg_76062} = lifted_30520(arg_76061)
  let {f32 arg_76063} = lifted_30523(b_76057)
  let {f32 arg_76064} = lifted_30527(arg_76063, d_76059)
  let {f32 res_76065} = lifted_30532(arg_76062, arg_76064)
  let {f32 arg_76066} = lifted_30536(b_76057)
  let {f32 arg_76067} = lifted_30540(arg_76066, c_76058)
  let {f32 arg_76068} = lifted_30544(arg_76067)
  let {f32 arg_76069} = lifted_30547(a_76056)
  let {f32 arg_76070} = lifted_30551(arg_76069, d_76059)
  let {f32 res_76071} = lifted_30556(arg_76068, arg_76070)
  in {res_76065, res_76071}
}

fun {f32, f32} lifted_30494(f32 x_76072, f32 x_76073, f32 y_76074,
                            f32 y_76075) = {
  let {f32 arg_76076, f32 arg_76077} = lifted_30500(x_76072, x_76073)
  let {f32 res_76078, f32 res_76079} = lifted_30510(arg_76076, arg_76077,
                                                    y_76074, y_76075)
  in {res_76078, res_76079}
}

fun {f32, f32} lifted_30574(f32 a_76080, f32 b_76081) = {
  {a_76080, b_76081}
}

fun {f32} lifted_30584(f32 x_76082) = {
  {x_76082}
}

fun {f32} lifted_30588(f32 x_76083, f32 y_76084) = {
  let {f32 res_76085} = fsub32(x_76083, y_76084)
  in {res_76085}
}

fun {f32} lifted_30592(f32 x_76086) = {
  {x_76086}
}

fun {f32} lifted_30596(f32 x_76087, f32 y_76088) = {
  let {f32 res_76089} = fsub32(x_76087, y_76088)
  in {res_76089}
}

fun {f32, f32} lifted_30582(f32 a_76090, f32 b_76091, f32 c_76092,
                            f32 d_76093) = {
  let {f32 arg_76094} = lifted_30584(a_76090)
  let {f32 res_76095} = lifted_30588(arg_76094, c_76092)
  let {f32 arg_76096} = lifted_30592(b_76091)
  let {f32 res_76097} = lifted_30596(arg_76096, d_76093)
  in {res_76095, res_76097}
}

fun {f32, f32} lifted_30570(f32 x_76098, f32 x_76099, f32 y_76100,
                            f32 y_76101) = {
  let {f32 arg_76102, f32 arg_76103} = lifted_30574(x_76098, x_76099)
  let {f32 res_76104, f32 res_76105} = lifted_30582(arg_76102, arg_76103,
                                                    y_76100, y_76101)
  in {res_76104, res_76105}
}

fun {f32, f32} lifted_30610(f32 x_76106, f32 x_76107) = {
  {x_76106, x_76107}
}

fun {f32, f32} lifted_30626(f32 a_76108, f32 b_76109) = {
  {a_76108, b_76109}
}

fun {f32} lifted_30638(f32 x_76110) = {
  {x_76110}
}

fun {f32} lifted_30642(f32 x_76111, f32 y_76112) = {
  let {f32 res_76113} = fmul32(x_76111, y_76112)
  in {res_76113}
}

fun {f32} lifted_30646(f32 x_76114) = {
  {x_76114}
}

fun {f32} lifted_30649(f32 x_76115) = {
  {x_76115}
}

fun {f32} lifted_30653(f32 x_76116, f32 y_76117) = {
  let {f32 res_76118} = fmul32(x_76116, y_76117)
  in {res_76118}
}

fun {f32} lifted_30658(f32 x_76119, f32 y_76120) = {
  let {f32 res_76121} = fsub32(x_76119, y_76120)
  in {res_76121}
}

fun {f32} lifted_30662(f32 x_76122) = {
  {x_76122}
}

fun {f32} lifted_30666(f32 x_76123, f32 y_76124) = {
  let {f32 res_76125} = fmul32(x_76123, y_76124)
  in {res_76125}
}

fun {f32} lifted_30670(f32 x_76126) = {
  {x_76126}
}

fun {f32} lifted_30673(f32 x_76127) = {
  {x_76127}
}

fun {f32} lifted_30677(f32 x_76128, f32 y_76129) = {
  let {f32 res_76130} = fmul32(x_76128, y_76129)
  in {res_76130}
}

fun {f32} lifted_30682(f32 x_76131, f32 y_76132) = {
  let {f32 res_76133} = fadd32(x_76131, y_76132)
  in {res_76133}
}

fun {f32, f32} lifted_30636(f32 a_76134, f32 b_76135, f32 c_76136,
                            f32 d_76137) = {
  let {f32 arg_76138} = lifted_30638(a_76134)
  let {f32 arg_76139} = lifted_30642(arg_76138, c_76136)
  let {f32 arg_76140} = lifted_30646(arg_76139)
  let {f32 arg_76141} = lifted_30649(b_76135)
  let {f32 arg_76142} = lifted_30653(arg_76141, d_76137)
  let {f32 res_76143} = lifted_30658(arg_76140, arg_76142)
  let {f32 arg_76144} = lifted_30662(b_76135)
  let {f32 arg_76145} = lifted_30666(arg_76144, c_76136)
  let {f32 arg_76146} = lifted_30670(arg_76145)
  let {f32 arg_76147} = lifted_30673(a_76134)
  let {f32 arg_76148} = lifted_30677(arg_76147, d_76137)
  let {f32 res_76149} = lifted_30682(arg_76146, arg_76148)
  in {res_76143, res_76149}
}

fun {f32, f32} lifted_30620(f32 x_76150, f32 x_76151, f32 y_76152,
                            f32 y_76153) = {
  let {f32 arg_76154, f32 arg_76155} = lifted_30626(x_76150, x_76151)
  let {f32 res_76156, f32 res_76157} = lifted_30636(arg_76154, arg_76155,
                                                    y_76152, y_76153)
  in {res_76156, res_76157}
}

fun {f32, f32} lifted_30693(f32 x_76158, f32 x_76159) = {
  {x_76158, x_76159}
}

fun {f32, f32} lifted_30700(f32 x_76160, f32 x_76161) = {
  {x_76160, x_76161}
}

fun {f32, f32} lifted_30707(f32 x_76162, f32 x_76163) = {
  {x_76162, x_76163}
}

fun {f32, f32} lifted_30714(f32 x_76164, f32 x_76165) = {
  {x_76164, x_76165}
}

fun {f32, f32} lifted_30728(f32 a_76166, f32 b_76167) = {
  {a_76166, b_76167}
}

fun {f32} lifted_30738(f32 x_76168) = {
  {x_76168}
}

fun {f32} lifted_30742(f32 x_76169, f32 y_76170) = {
  let {f32 res_76171} = fadd32(x_76169, y_76170)
  in {res_76171}
}

fun {f32} lifted_30746(f32 x_76172) = {
  {x_76172}
}

fun {f32} lifted_30750(f32 x_76173, f32 y_76174) = {
  let {f32 res_76175} = fadd32(x_76173, y_76174)
  in {res_76175}
}

fun {f32, f32} lifted_30736(f32 a_76176, f32 b_76177, f32 c_76178,
                            f32 d_76179) = {
  let {f32 arg_76180} = lifted_30738(a_76176)
  let {f32 res_76181} = lifted_30742(arg_76180, c_76178)
  let {f32 arg_76182} = lifted_30746(b_76177)
  let {f32 res_76183} = lifted_30750(arg_76182, d_76179)
  in {res_76181, res_76183}
}

fun {f32, f32} lifted_30724(f32 x_76184, f32 x_76185, f32 y_76186,
                            f32 y_76187) = {
  let {f32 arg_76188, f32 arg_76189} = lifted_30728(x_76184, x_76185)
  let {f32 res_76190, f32 res_76191} = lifted_30736(arg_76188, arg_76189,
                                                    y_76186, y_76187)
  in {res_76190, res_76191}
}

fun {f32, f32} lifted_30770(f32 a_76192, f32 b_76193) = {
  {a_76192, b_76193}
}

fun {f32} lifted_30782(f32 x_76194) = {
  {x_76194}
}

fun {f32} lifted_30786(f32 x_76195, f32 y_76196) = {
  let {f32 res_76197} = fmul32(x_76195, y_76196)
  in {res_76197}
}

fun {f32} lifted_30790(f32 x_76198) = {
  {x_76198}
}

fun {f32} lifted_30793(f32 x_76199) = {
  {x_76199}
}

fun {f32} lifted_30797(f32 x_76200, f32 y_76201) = {
  let {f32 res_76202} = fmul32(x_76200, y_76201)
  in {res_76202}
}

fun {f32} lifted_30802(f32 x_76203, f32 y_76204) = {
  let {f32 res_76205} = fsub32(x_76203, y_76204)
  in {res_76205}
}

fun {f32} lifted_30806(f32 x_76206) = {
  {x_76206}
}

fun {f32} lifted_30810(f32 x_76207, f32 y_76208) = {
  let {f32 res_76209} = fmul32(x_76207, y_76208)
  in {res_76209}
}

fun {f32} lifted_30814(f32 x_76210) = {
  {x_76210}
}

fun {f32} lifted_30817(f32 x_76211) = {
  {x_76211}
}

fun {f32} lifted_30821(f32 x_76212, f32 y_76213) = {
  let {f32 res_76214} = fmul32(x_76212, y_76213)
  in {res_76214}
}

fun {f32} lifted_30826(f32 x_76215, f32 y_76216) = {
  let {f32 res_76217} = fadd32(x_76215, y_76216)
  in {res_76217}
}

fun {f32, f32} lifted_30780(f32 a_76218, f32 b_76219, f32 c_76220,
                            f32 d_76221) = {
  let {f32 arg_76222} = lifted_30782(a_76218)
  let {f32 arg_76223} = lifted_30786(arg_76222, c_76220)
  let {f32 arg_76224} = lifted_30790(arg_76223)
  let {f32 arg_76225} = lifted_30793(b_76219)
  let {f32 arg_76226} = lifted_30797(arg_76225, d_76221)
  let {f32 res_76227} = lifted_30802(arg_76224, arg_76226)
  let {f32 arg_76228} = lifted_30806(b_76219)
  let {f32 arg_76229} = lifted_30810(arg_76228, c_76220)
  let {f32 arg_76230} = lifted_30814(arg_76229)
  let {f32 arg_76231} = lifted_30817(a_76218)
  let {f32 arg_76232} = lifted_30821(arg_76231, d_76221)
  let {f32 res_76233} = lifted_30826(arg_76230, arg_76232)
  in {res_76227, res_76233}
}

fun {f32, f32} lifted_30764(f32 x_76234, f32 x_76235, f32 y_76236,
                            f32 y_76237) = {
  let {f32 arg_76238, f32 arg_76239} = lifted_30770(x_76234, x_76235)
  let {f32 res_76240, f32 res_76241} = lifted_30780(arg_76238, arg_76239,
                                                    y_76236, y_76237)
  in {res_76240, res_76241}
}

fun {f32, f32} lifted_30846(f32 a_76242, f32 b_76243) = {
  {a_76242, b_76243}
}

fun {f32} lifted_30858(f32 x_76244) = {
  {x_76244}
}

fun {f32} lifted_30862(f32 x_76245, f32 y_76246) = {
  let {f32 res_76247} = fmul32(x_76245, y_76246)
  in {res_76247}
}

fun {f32} lifted_30866(f32 x_76248) = {
  {x_76248}
}

fun {f32} lifted_30869(f32 x_76249) = {
  {x_76249}
}

fun {f32} lifted_30873(f32 x_76250, f32 y_76251) = {
  let {f32 res_76252} = fmul32(x_76250, y_76251)
  in {res_76252}
}

fun {f32} lifted_30878(f32 x_76253, f32 y_76254) = {
  let {f32 res_76255} = fsub32(x_76253, y_76254)
  in {res_76255}
}

fun {f32} lifted_30882(f32 x_76256) = {
  {x_76256}
}

fun {f32} lifted_30886(f32 x_76257, f32 y_76258) = {
  let {f32 res_76259} = fmul32(x_76257, y_76258)
  in {res_76259}
}

fun {f32} lifted_30890(f32 x_76260) = {
  {x_76260}
}

fun {f32} lifted_30893(f32 x_76261) = {
  {x_76261}
}

fun {f32} lifted_30897(f32 x_76262, f32 y_76263) = {
  let {f32 res_76264} = fmul32(x_76262, y_76263)
  in {res_76264}
}

fun {f32} lifted_30902(f32 x_76265, f32 y_76266) = {
  let {f32 res_76267} = fadd32(x_76265, y_76266)
  in {res_76267}
}

fun {f32, f32} lifted_30856(f32 a_76268, f32 b_76269, f32 c_76270,
                            f32 d_76271) = {
  let {f32 arg_76272} = lifted_30858(a_76268)
  let {f32 arg_76273} = lifted_30862(arg_76272, c_76270)
  let {f32 arg_76274} = lifted_30866(arg_76273)
  let {f32 arg_76275} = lifted_30869(b_76269)
  let {f32 arg_76276} = lifted_30873(arg_76275, d_76271)
  let {f32 res_76277} = lifted_30878(arg_76274, arg_76276)
  let {f32 arg_76278} = lifted_30882(b_76269)
  let {f32 arg_76279} = lifted_30886(arg_76278, c_76270)
  let {f32 arg_76280} = lifted_30890(arg_76279)
  let {f32 arg_76281} = lifted_30893(a_76268)
  let {f32 arg_76282} = lifted_30897(arg_76281, d_76271)
  let {f32 res_76283} = lifted_30902(arg_76280, arg_76282)
  in {res_76277, res_76283}
}

fun {f32, f32} lifted_30840(f32 x_76284, f32 x_76285, f32 y_76286,
                            f32 y_76287) = {
  let {f32 arg_76288, f32 arg_76289} = lifted_30846(x_76284, x_76285)
  let {f32 res_76290, f32 res_76291} = lifted_30856(arg_76288, arg_76289,
                                                    y_76286, y_76287)
  in {res_76290, res_76291}
}

fun {f32, f32} lifted_30920(f32 a_76292, f32 b_76293) = {
  {a_76292, b_76293}
}

fun {f32} lifted_30930(f32 x_76294) = {
  {x_76294}
}

fun {f32} lifted_30934(f32 x_76295, f32 y_76296) = {
  let {f32 res_76297} = fadd32(x_76295, y_76296)
  in {res_76297}
}

fun {f32} lifted_30938(f32 x_76298) = {
  {x_76298}
}

fun {f32} lifted_30942(f32 x_76299, f32 y_76300) = {
  let {f32 res_76301} = fadd32(x_76299, y_76300)
  in {res_76301}
}

fun {f32, f32} lifted_30928(f32 a_76302, f32 b_76303, f32 c_76304,
                            f32 d_76305) = {
  let {f32 arg_76306} = lifted_30930(a_76302)
  let {f32 res_76307} = lifted_30934(arg_76306, c_76304)
  let {f32 arg_76308} = lifted_30938(b_76303)
  let {f32 res_76309} = lifted_30942(arg_76308, d_76305)
  in {res_76307, res_76309}
}

fun {f32, f32} lifted_30916(f32 x_76310, f32 x_76311, f32 y_76312,
                            f32 y_76313) = {
  let {f32 arg_76314, f32 arg_76315} = lifted_30920(x_76310, x_76311)
  let {f32 res_76316, f32 res_76317} = lifted_30928(arg_76314, arg_76315,
                                                    y_76312, y_76313)
  in {res_76316, res_76317}
}

fun {f32} lifted_30961(f32 x_76318) = {
  {x_76318}
}

fun {f32} lifted_30964(f32 x_76319) = {
  {x_76319}
}

fun {f32} lifted_30968(f32 x_76320, f32 y_76321) = {
  let {f32 res_76322} = fmul32(x_76320, y_76321)
  in {res_76322}
}

fun {f32} lifted_30972(f32 x_76323) = {
  {x_76323}
}

fun {f32} lifted_30975(f32 x_76324) = {
  {x_76324}
}

fun {f32} lifted_30979(f32 x_76325, f32 y_76326) = {
  let {f32 res_76327} = fmul32(x_76325, y_76326)
  in {res_76327}
}

fun {f32} lifted_30984(f32 x_76328, f32 y_76329) = {
  let {f32 res_76330} = fadd32(x_76328, y_76329)
  in {res_76330}
}

fun {f32} lifted_30988(f32 x_76331) = {
  let {f32 res_76332} = sqrt32(x_76331)
  in {res_76332}
}

fun {f32} lifted_30993(f32 x_76333, f32 y_76334) = {
  let {f32 res_76335} = fadd32(x_76333, y_76334)
  in {res_76335}
}

fun {f32} lifted_30997(f32 x_76336) = {
  {x_76336}
}

fun {f32} lifted_31000(i32 x_76337) = {
  let {f32 res_76338} = sitofp i32 x_76337 to f32
  in {res_76338}
}

fun {f32} lifted_31005(f32 x_76339, f32 y_76340) = {
  let {f32 res_76341} = fdiv32(x_76339, y_76340)
  in {res_76341}
}

fun {f32} lifted_31009(f32 x_76342) = {
  let {f32 res_76343} = sqrt32(x_76342)
  in {res_76343}
}

fun {f32} lifted_31018(f32 x_76344) = {
  {x_76344}
}

fun {bool} lifted_31022(f32 x_76345, f32 y_76346) = {
  let {bool res_76347} = lt32(x_76345, y_76346)
  in {res_76347}
}

fun {f32} lifted_31027(f32 x_76348) = {
  {x_76348}
}

fun {bool} lifted_31031(f32 x_76349, f32 y_76350) = {
  let {bool res_76351} = eq_f32(x_76349, y_76350)
  in {res_76351}
}

fun {f32} lifted_31016(f32 x_76352) = {
  let {f32 arg_76353} = lifted_31018(x_76352)
  let {bool cond_76354} = lifted_31022(arg_76353, 0.0f32)
  let {f32 res_76355} =
    -- Branch returns: {f32}
    if cond_76354
    then {
      let {f32 res_76356} = fsub32(0.0f32, 1.0f32)
      in {res_76356}
    } else {
      let {f32 arg_76357} = lifted_31027(x_76352)
      let {bool cond_76358} = lifted_31031(arg_76357, 0.0f32)
      let {f32 res_76359} =
        -- Branch returns: {f32}
        if cond_76358
        then {0.0f32} else {1.0f32}
      in {res_76359}
    }
  in {res_76355}
}

fun {i32} lifted_31038(f32 x_76360) = {
  let {i32 res_76361} = fptosi f32 x_76360 to i32
  in {res_76361}
}

fun {f32} lifted_31042(i32 x_76362) = {
  let {f32 res_76363} = sitofp i32 x_76362 to f32
  in {res_76363}
}

fun {f32} lifted_31046(f32 x_76364) = {
  {x_76364}
}

fun {f32} lifted_31049(i32 x_76365) = {
  let {f32 res_76366} = sitofp i32 x_76365 to f32
  in {res_76366}
}

fun {f32} lifted_31053(f32 x_76367) = {
  {x_76367}
}

fun {f32} lifted_31057(f32 x_76368, f32 y_76369) = {
  let {f32 res_76370} = fsub32(x_76368, y_76369)
  in {res_76370}
}

fun {f32} lifted_31061(f32 x_76371) = {
  {x_76371}
}

fun {f32} lifted_31064(f32 x_76372) = {
  {x_76372}
}

fun {f32} lifted_31068(f32 x_76373, f32 y_76374) = {
  let {f32 res_76375} = fmul32(x_76373, y_76374)
  in {res_76375}
}

fun {f32} lifted_31072(f32 x_76376) = {
  {x_76376}
}

fun {f32} lifted_31075(f32 x_76377) = {
  {x_76377}
}

fun {f32} lifted_31079(f32 x_76378, f32 y_76379) = {
  let {f32 res_76380} = fmul32(x_76378, y_76379)
  in {res_76380}
}

fun {f32} lifted_31084(f32 x_76381, f32 y_76382) = {
  let {f32 res_76383} = fadd32(x_76381, y_76382)
  in {res_76383}
}

fun {f32} lifted_31088(f32 x_76384) = {
  let {f32 res_76385} = sqrt32(x_76384)
  in {res_76385}
}

fun {f32} lifted_31093(f32 x_76386, f32 y_76387) = {
  let {f32 res_76388} = fadd32(x_76386, y_76387)
  in {res_76388}
}

fun {f32} lifted_31097(f32 x_76389) = {
  {x_76389}
}

fun {f32} lifted_31100(i32 x_76390) = {
  let {f32 res_76391} = sitofp i32 x_76390 to f32
  in {res_76391}
}

fun {f32} lifted_31105(f32 x_76392, f32 y_76393) = {
  let {f32 res_76394} = fdiv32(x_76392, y_76393)
  in {res_76394}
}

fun {f32} lifted_31109(f32 x_76395) = {
  let {f32 res_76396} = sqrt32(x_76395)
  in {res_76396}
}

fun {f32} lifted_31114(f32 x_76397, f32 y_76398) = {
  let {f32 res_76399} = fmul32(x_76397, y_76398)
  in {res_76399}
}

fun {f32, f32} lifted_30959(f32 a_76400, f32 b_76401) = {
  let {f32 arg_76402} = lifted_30961(a_76400)
  let {f32 arg_76403} = lifted_30964(a_76400)
  let {f32 arg_76404} = lifted_30968(arg_76403, a_76400)
  let {f32 arg_76405} = lifted_30972(arg_76404)
  let {f32 arg_76406} = lifted_30975(b_76401)
  let {f32 arg_76407} = lifted_30979(arg_76406, b_76401)
  let {f32 arg_76408} = lifted_30984(arg_76405, arg_76407)
  let {f32 arg_76409} = lifted_30988(arg_76408)
  let {f32 arg_76410} = lifted_30993(arg_76402, arg_76409)
  let {f32 arg_76411} = lifted_30997(arg_76410)
  let {f32 arg_76412} = lifted_31000(2i32)
  let {f32 arg_76413} = lifted_31005(arg_76411, arg_76412)
  let {f32 res_76414} = lifted_31009(arg_76413)
  let {f32 gamma_76415} = res_76414
  let {f32 arg_76416} = lifted_31016(b_76401)
  let {i32 arg_76417} = lifted_31038(arg_76416)
  let {f32 arg_76418} = lifted_31042(arg_76417)
  let {f32 arg_76419} = lifted_31046(arg_76418)
  let {f32 arg_76420} = lifted_31049(0i32)
  let {f32 arg_76421} = lifted_31053(arg_76420)
  let {f32 arg_76422} = lifted_31057(arg_76421, a_76400)
  let {f32 arg_76423} = lifted_31061(arg_76422)
  let {f32 arg_76424} = lifted_31064(a_76400)
  let {f32 arg_76425} = lifted_31068(arg_76424, a_76400)
  let {f32 arg_76426} = lifted_31072(arg_76425)
  let {f32 arg_76427} = lifted_31075(b_76401)
  let {f32 arg_76428} = lifted_31079(arg_76427, b_76401)
  let {f32 arg_76429} = lifted_31084(arg_76426, arg_76428)
  let {f32 arg_76430} = lifted_31088(arg_76429)
  let {f32 arg_76431} = lifted_31093(arg_76423, arg_76430)
  let {f32 arg_76432} = lifted_31097(arg_76431)
  let {f32 arg_76433} = lifted_31100(2i32)
  let {f32 arg_76434} = lifted_31105(arg_76432, arg_76433)
  let {f32 arg_76435} = lifted_31109(arg_76434)
  let {f32 res_76436} = lifted_31114(arg_76419, arg_76435)
  let {f32 delta_76437} = res_76436
  in {gamma_76415, delta_76437}
}

fun {f32, f32} lifted_31127(f32 x_76438, f32 x_76439) = {
  {x_76438, x_76439}
}

fun {f32, f32} lifted_31141(f32 a_76440, f32 b_76441) = {
  {a_76440, b_76441}
}

fun {f32} lifted_31151(f32 x_76442) = {
  {x_76442}
}

fun {f32} lifted_31155(f32 x_76443, f32 y_76444) = {
  let {f32 res_76445} = fsub32(x_76443, y_76444)
  in {res_76445}
}

fun {f32} lifted_31159(f32 x_76446) = {
  {x_76446}
}

fun {f32} lifted_31163(f32 x_76447, f32 y_76448) = {
  let {f32 res_76449} = fsub32(x_76447, y_76448)
  in {res_76449}
}

fun {f32, f32} lifted_31149(f32 a_76450, f32 b_76451, f32 c_76452,
                            f32 d_76453) = {
  let {f32 arg_76454} = lifted_31151(a_76450)
  let {f32 res_76455} = lifted_31155(arg_76454, c_76452)
  let {f32 arg_76456} = lifted_31159(b_76451)
  let {f32 res_76457} = lifted_31163(arg_76456, d_76453)
  in {res_76455, res_76457}
}

fun {f32, f32} lifted_31137(f32 x_76458, f32 x_76459, f32 y_76460,
                            f32 y_76461) = {
  let {f32 arg_76462, f32 arg_76463} = lifted_31141(x_76458, x_76459)
  let {f32 res_76464, f32 res_76465} = lifted_31149(arg_76462, arg_76463,
                                                    y_76460, y_76461)
  in {res_76464, res_76465}
}

fun {f32, f32} lifted_31177(f32 x_76466, f32 x_76467) = {
  {x_76466, x_76467}
}

fun {f32, f32} lifted_31184(f32 x_76468, f32 x_76469) = {
  {x_76468, x_76469}
}

fun {f32, f32} lifted_31198(f32 a_76470, f32 b_76471) = {
  {a_76470, b_76471}
}

fun {f32} lifted_31208(f32 x_76472) = {
  {x_76472}
}

fun {f32} lifted_31212(f32 x_76473, f32 y_76474) = {
  let {f32 res_76475} = fadd32(x_76473, y_76474)
  in {res_76475}
}

fun {f32} lifted_31216(f32 x_76476) = {
  {x_76476}
}

fun {f32} lifted_31220(f32 x_76477, f32 y_76478) = {
  let {f32 res_76479} = fadd32(x_76477, y_76478)
  in {res_76479}
}

fun {f32, f32} lifted_31206(f32 a_76480, f32 b_76481, f32 c_76482,
                            f32 d_76483) = {
  let {f32 arg_76484} = lifted_31208(a_76480)
  let {f32 res_76485} = lifted_31212(arg_76484, c_76482)
  let {f32 arg_76486} = lifted_31216(b_76481)
  let {f32 res_76487} = lifted_31220(arg_76486, d_76483)
  in {res_76485, res_76487}
}

fun {f32, f32} lifted_31194(f32 x_76488, f32 x_76489, f32 y_76490,
                            f32 y_76491) = {
  let {f32 arg_76492, f32 arg_76493} = lifted_31198(x_76488, x_76489)
  let {f32 res_76494, f32 res_76495} = lifted_31206(arg_76492, arg_76493,
                                                    y_76490, y_76491)
  in {res_76494, res_76495}
}

fun {f32, f32} lifted_31241(f32 a_76496, f32 b_76497) = {
  {a_76496, b_76497}
}

fun {f32} lifted_31254(f32 x_76498) = {
  {x_76498}
}

fun {f32} lifted_31258(f32 x_76499, f32 y_76500) = {
  let {f32 res_76501} = fmul32(x_76499, y_76500)
  in {res_76501}
}

fun {f32} lifted_31262(f32 x_76502) = {
  {x_76502}
}

fun {f32} lifted_31265(f32 x_76503) = {
  {x_76503}
}

fun {f32} lifted_31269(f32 x_76504, f32 y_76505) = {
  let {f32 res_76506} = fmul32(x_76504, y_76505)
  in {res_76506}
}

fun {f32} lifted_31274(f32 x_76507, f32 y_76508) = {
  let {f32 res_76509} = fadd32(x_76507, y_76508)
  in {res_76509}
}

fun {f32} lifted_31278(f32 x_76510) = {
  {x_76510}
}

fun {f32} lifted_31281(f32 x_76511) = {
  {x_76511}
}

fun {f32} lifted_31285(f32 x_76512, f32 y_76513) = {
  let {f32 res_76514} = fmul32(x_76512, y_76513)
  in {res_76514}
}

fun {f32} lifted_31289(f32 x_76515) = {
  {x_76515}
}

fun {f32} lifted_31292(f32 x_76516) = {
  {x_76516}
}

fun {f32} lifted_31296(f32 x_76517, f32 y_76518) = {
  let {f32 res_76519} = fmul32(x_76517, y_76518)
  in {res_76519}
}

fun {f32} lifted_31301(f32 x_76520, f32 y_76521) = {
  let {f32 res_76522} = fadd32(x_76520, y_76521)
  in {res_76522}
}

fun {f32} lifted_31306(f32 x_76523, f32 y_76524) = {
  let {f32 res_76525} = fdiv32(x_76523, y_76524)
  in {res_76525}
}

fun {f32} lifted_31310(f32 x_76526) = {
  {x_76526}
}

fun {f32} lifted_31314(f32 x_76527, f32 y_76528) = {
  let {f32 res_76529} = fmul32(x_76527, y_76528)
  in {res_76529}
}

fun {f32} lifted_31318(f32 x_76530) = {
  {x_76530}
}

fun {f32} lifted_31321(f32 x_76531) = {
  {x_76531}
}

fun {f32} lifted_31325(f32 x_76532, f32 y_76533) = {
  let {f32 res_76534} = fmul32(x_76532, y_76533)
  in {res_76534}
}

fun {f32} lifted_31330(f32 x_76535, f32 y_76536) = {
  let {f32 res_76537} = fsub32(x_76535, y_76536)
  in {res_76537}
}

fun {f32} lifted_31334(f32 x_76538) = {
  {x_76538}
}

fun {f32} lifted_31337(f32 x_76539) = {
  {x_76539}
}

fun {f32} lifted_31341(f32 x_76540, f32 y_76541) = {
  let {f32 res_76542} = fmul32(x_76540, y_76541)
  in {res_76542}
}

fun {f32} lifted_31345(f32 x_76543) = {
  {x_76543}
}

fun {f32} lifted_31348(f32 x_76544) = {
  {x_76544}
}

fun {f32} lifted_31352(f32 x_76545, f32 y_76546) = {
  let {f32 res_76547} = fmul32(x_76545, y_76546)
  in {res_76547}
}

fun {f32} lifted_31357(f32 x_76548, f32 y_76549) = {
  let {f32 res_76550} = fadd32(x_76548, y_76549)
  in {res_76550}
}

fun {f32} lifted_31362(f32 x_76551, f32 y_76552) = {
  let {f32 res_76553} = fdiv32(x_76551, y_76552)
  in {res_76553}
}

fun {f32, f32} lifted_31252(f32 a_76554, f32 b_76555, f32 c_76556,
                            f32 d_76557) = {
  let {f32 arg_76558} = lifted_31254(a_76554)
  let {f32 arg_76559} = lifted_31258(arg_76558, c_76556)
  let {f32 arg_76560} = lifted_31262(arg_76559)
  let {f32 arg_76561} = lifted_31265(b_76555)
  let {f32 arg_76562} = lifted_31269(arg_76561, d_76557)
  let {f32 arg_76563} = lifted_31274(arg_76560, arg_76562)
  let {f32 arg_76564} = lifted_31278(arg_76563)
  let {f32 arg_76565} = lifted_31281(c_76556)
  let {f32 arg_76566} = lifted_31285(arg_76565, c_76556)
  let {f32 arg_76567} = lifted_31289(arg_76566)
  let {f32 arg_76568} = lifted_31292(d_76557)
  let {f32 arg_76569} = lifted_31296(arg_76568, d_76557)
  let {f32 arg_76570} = lifted_31301(arg_76567, arg_76569)
  let {f32 res_76571} = lifted_31306(arg_76564, arg_76570)
  let {f32 arg_76572} = lifted_31310(b_76555)
  let {f32 arg_76573} = lifted_31314(arg_76572, c_76556)
  let {f32 arg_76574} = lifted_31318(arg_76573)
  let {f32 arg_76575} = lifted_31321(a_76554)
  let {f32 arg_76576} = lifted_31325(arg_76575, d_76557)
  let {f32 arg_76577} = lifted_31330(arg_76574, arg_76576)
  let {f32 arg_76578} = lifted_31334(arg_76577)
  let {f32 arg_76579} = lifted_31337(c_76556)
  let {f32 arg_76580} = lifted_31341(arg_76579, c_76556)
  let {f32 arg_76581} = lifted_31345(arg_76580)
  let {f32 arg_76582} = lifted_31348(d_76557)
  let {f32 arg_76583} = lifted_31352(arg_76582, d_76557)
  let {f32 arg_76584} = lifted_31357(arg_76581, arg_76583)
  let {f32 res_76585} = lifted_31362(arg_76578, arg_76584)
  in {res_76571, res_76585}
}

fun {f32, f32} lifted_31234(f32 x_76586, f32 x_76587, f32 y_76588,
                            f32 y_76589) = {
  let {f32 arg_76590, f32 arg_76591} = lifted_31241(x_76586, x_76587)
  let {f32 res_76592, f32 res_76593} = lifted_31252(arg_76590, arg_76591,
                                                    y_76588, y_76589)
  in {res_76592, res_76593}
}

fun {f32, f32} lifted_31376(f32 x_76594, f32 x_76595) = {
  {x_76594, x_76595}
}

fun {f32, f32} lifted_31383(f32 x_76596, f32 x_76597) = {
  {x_76596, x_76597}
}

fun {f32, f32} lifted_31399(f32 a_76598, f32 b_76599) = {
  {a_76598, b_76599}
}

fun {f32} lifted_31411(f32 x_76600) = {
  {x_76600}
}

fun {f32} lifted_31415(f32 x_76601, f32 y_76602) = {
  let {f32 res_76603} = fmul32(x_76601, y_76602)
  in {res_76603}
}

fun {f32} lifted_31419(f32 x_76604) = {
  {x_76604}
}

fun {f32} lifted_31422(f32 x_76605) = {
  {x_76605}
}

fun {f32} lifted_31426(f32 x_76606, f32 y_76607) = {
  let {f32 res_76608} = fmul32(x_76606, y_76607)
  in {res_76608}
}

fun {f32} lifted_31431(f32 x_76609, f32 y_76610) = {
  let {f32 res_76611} = fsub32(x_76609, y_76610)
  in {res_76611}
}

fun {f32} lifted_31435(f32 x_76612) = {
  {x_76612}
}

fun {f32} lifted_31439(f32 x_76613, f32 y_76614) = {
  let {f32 res_76615} = fmul32(x_76613, y_76614)
  in {res_76615}
}

fun {f32} lifted_31443(f32 x_76616) = {
  {x_76616}
}

fun {f32} lifted_31446(f32 x_76617) = {
  {x_76617}
}

fun {f32} lifted_31450(f32 x_76618, f32 y_76619) = {
  let {f32 res_76620} = fmul32(x_76618, y_76619)
  in {res_76620}
}

fun {f32} lifted_31455(f32 x_76621, f32 y_76622) = {
  let {f32 res_76623} = fadd32(x_76621, y_76622)
  in {res_76623}
}

fun {f32, f32} lifted_31409(f32 a_76624, f32 b_76625, f32 c_76626,
                            f32 d_76627) = {
  let {f32 arg_76628} = lifted_31411(a_76624)
  let {f32 arg_76629} = lifted_31415(arg_76628, c_76626)
  let {f32 arg_76630} = lifted_31419(arg_76629)
  let {f32 arg_76631} = lifted_31422(b_76625)
  let {f32 arg_76632} = lifted_31426(arg_76631, d_76627)
  let {f32 res_76633} = lifted_31431(arg_76630, arg_76632)
  let {f32 arg_76634} = lifted_31435(b_76625)
  let {f32 arg_76635} = lifted_31439(arg_76634, c_76626)
  let {f32 arg_76636} = lifted_31443(arg_76635)
  let {f32 arg_76637} = lifted_31446(a_76624)
  let {f32 arg_76638} = lifted_31450(arg_76637, d_76627)
  let {f32 res_76639} = lifted_31455(arg_76636, arg_76638)
  in {res_76633, res_76639}
}

fun {f32, f32} lifted_31393(f32 x_76640, f32 x_76641, f32 y_76642,
                            f32 y_76643) = {
  let {f32 arg_76644, f32 arg_76645} = lifted_31399(x_76640, x_76641)
  let {f32 res_76646, f32 res_76647} = lifted_31409(arg_76644, arg_76645,
                                                    y_76642, y_76643)
  in {res_76646, res_76647}
}

fun {f32, f32} lifted_31473(f32 a_76648, f32 b_76649) = {
  {a_76648, b_76649}
}

fun {f32} lifted_31483(f32 x_76650) = {
  {x_76650}
}

fun {f32} lifted_31487(f32 x_76651, f32 y_76652) = {
  let {f32 res_76653} = fsub32(x_76651, y_76652)
  in {res_76653}
}

fun {f32} lifted_31491(f32 x_76654) = {
  {x_76654}
}

fun {f32} lifted_31495(f32 x_76655, f32 y_76656) = {
  let {f32 res_76657} = fsub32(x_76655, y_76656)
  in {res_76657}
}

fun {f32, f32} lifted_31481(f32 a_76658, f32 b_76659, f32 c_76660,
                            f32 d_76661) = {
  let {f32 arg_76662} = lifted_31483(a_76658)
  let {f32 res_76663} = lifted_31487(arg_76662, c_76660)
  let {f32 arg_76664} = lifted_31491(b_76659)
  let {f32 res_76665} = lifted_31495(arg_76664, d_76661)
  in {res_76663, res_76665}
}

fun {f32, f32} lifted_31469(f32 x_76666, f32 x_76667, f32 y_76668,
                            f32 y_76669) = {
  let {f32 arg_76670, f32 arg_76671} = lifted_31473(x_76666, x_76667)
  let {f32 res_76672, f32 res_76673} = lifted_31481(arg_76670, arg_76671,
                                                    y_76668, y_76669)
  in {res_76672, res_76673}
}

fun {f32} lifted_31511(f32 x_76674) = {
  let {f32 res_76675} = exp32(x_76674)
  in {res_76675}
}

fun {f32} lifted_31516(f32 x_76676) = {
  {x_76676}
}

fun {f32} lifted_31519(f32 x_76677) = {
  let {f32 res_76678} = cos32(x_76677)
  in {res_76678}
}

fun {f32} lifted_31524(f32 x_76679, f32 y_76680) = {
  let {f32 res_76681} = fmul32(x_76679, y_76680)
  in {res_76681}
}

fun {f32} lifted_31528(f32 a_76682) = {
  {a_76682}
}

fun {f32} lifted_31531(f32 x_76683) = {
  {x_76683}
}

fun {f32} lifted_31534(f32 x_76684) = {
  let {f32 res_76685} = sin32(x_76684)
  in {res_76685}
}

fun {f32} lifted_31539(f32 x_76686, f32 y_76687) = {
  let {f32 res_76688} = fmul32(x_76686, y_76687)
  in {res_76688}
}

fun {f32, f32} lifted_31544(f32 a_76689, f32 b_76690) = {
  {a_76689, b_76690}
}

fun {f32, f32} lifted_31509(f32 a_76691, f32 b_76692) = {
  let {f32 res_76693} = lifted_31511(a_76691)
  let {f32 expx_76694} = res_76693
  let {f32 arg_76695} = lifted_31516(expx_76694)
  let {f32 arg_76696} = lifted_31519(b_76692)
  let {f32 arg_76697} = lifted_31524(arg_76695, arg_76696)
  let {f32 arg_76698} = lifted_31528(arg_76697)
  let {f32 arg_76699} = lifted_31531(expx_76694)
  let {f32 arg_76700} = lifted_31534(b_76692)
  let {f32 arg_76701} = lifted_31539(arg_76699, arg_76700)
  let {f32 res_76702, f32 res_76703} = lifted_31544(arg_76698, arg_76701)
  in {res_76702, res_76703}
}

fun {f32, f32} lifted_31556(f32 x_76704, f32 x_76705) = {
  {x_76704, x_76705}
}

fun {f32, f32} lifted_31563(f32 x_76706, f32 x_76707) = {
  {x_76706, x_76707}
}

fun {f32, f32} lifted_31579(f32 a_76708, f32 b_76709) = {
  {a_76708, b_76709}
}

fun {f32} lifted_31591(f32 x_76710) = {
  {x_76710}
}

fun {f32} lifted_31595(f32 x_76711, f32 y_76712) = {
  let {f32 res_76713} = fmul32(x_76711, y_76712)
  in {res_76713}
}

fun {f32} lifted_31599(f32 x_76714) = {
  {x_76714}
}

fun {f32} lifted_31602(f32 x_76715) = {
  {x_76715}
}

fun {f32} lifted_31606(f32 x_76716, f32 y_76717) = {
  let {f32 res_76718} = fmul32(x_76716, y_76717)
  in {res_76718}
}

fun {f32} lifted_31611(f32 x_76719, f32 y_76720) = {
  let {f32 res_76721} = fsub32(x_76719, y_76720)
  in {res_76721}
}

fun {f32} lifted_31615(f32 x_76722) = {
  {x_76722}
}

fun {f32} lifted_31619(f32 x_76723, f32 y_76724) = {
  let {f32 res_76725} = fmul32(x_76723, y_76724)
  in {res_76725}
}

fun {f32} lifted_31623(f32 x_76726) = {
  {x_76726}
}

fun {f32} lifted_31626(f32 x_76727) = {
  {x_76727}
}

fun {f32} lifted_31630(f32 x_76728, f32 y_76729) = {
  let {f32 res_76730} = fmul32(x_76728, y_76729)
  in {res_76730}
}

fun {f32} lifted_31635(f32 x_76731, f32 y_76732) = {
  let {f32 res_76733} = fadd32(x_76731, y_76732)
  in {res_76733}
}

fun {f32, f32} lifted_31589(f32 a_76734, f32 b_76735, f32 c_76736,
                            f32 d_76737) = {
  let {f32 arg_76738} = lifted_31591(a_76734)
  let {f32 arg_76739} = lifted_31595(arg_76738, c_76736)
  let {f32 arg_76740} = lifted_31599(arg_76739)
  let {f32 arg_76741} = lifted_31602(b_76735)
  let {f32 arg_76742} = lifted_31606(arg_76741, d_76737)
  let {f32 res_76743} = lifted_31611(arg_76740, arg_76742)
  let {f32 arg_76744} = lifted_31615(b_76735)
  let {f32 arg_76745} = lifted_31619(arg_76744, c_76736)
  let {f32 arg_76746} = lifted_31623(arg_76745)
  let {f32 arg_76747} = lifted_31626(a_76734)
  let {f32 arg_76748} = lifted_31630(arg_76747, d_76737)
  let {f32 res_76749} = lifted_31635(arg_76746, arg_76748)
  in {res_76743, res_76749}
}

fun {f32, f32} lifted_31573(f32 x_76750, f32 x_76751, f32 y_76752,
                            f32 y_76753) = {
  let {f32 arg_76754, f32 arg_76755} = lifted_31579(x_76750, x_76751)
  let {f32 res_76756, f32 res_76757} = lifted_31589(arg_76754, arg_76755,
                                                    y_76752, y_76753)
  in {res_76756, res_76757}
}

fun {f32, f32} lifted_31646(f32 x_76758, f32 x_76759) = {
  {x_76758, x_76759}
}

fun {f32, f32} lifted_31653(f32 x_76760, f32 x_76761) = {
  {x_76760, x_76761}
}

fun {f32, f32} lifted_31660(f32 x_76762, f32 x_76763) = {
  {x_76762, x_76763}
}

fun {f32, f32} lifted_31667(f32 x_76764, f32 x_76765) = {
  {x_76764, x_76765}
}

fun {f32, f32} lifted_31683(f32 a_76766, f32 b_76767) = {
  {a_76766, b_76767}
}

fun {f32} lifted_31695(f32 x_76768) = {
  {x_76768}
}

fun {f32} lifted_31699(f32 x_76769, f32 y_76770) = {
  let {f32 res_76771} = fmul32(x_76769, y_76770)
  in {res_76771}
}

fun {f32} lifted_31703(f32 x_76772) = {
  {x_76772}
}

fun {f32} lifted_31706(f32 x_76773) = {
  {x_76773}
}

fun {f32} lifted_31710(f32 x_76774, f32 y_76775) = {
  let {f32 res_76776} = fmul32(x_76774, y_76775)
  in {res_76776}
}

fun {f32} lifted_31715(f32 x_76777, f32 y_76778) = {
  let {f32 res_76779} = fsub32(x_76777, y_76778)
  in {res_76779}
}

fun {f32} lifted_31719(f32 x_76780) = {
  {x_76780}
}

fun {f32} lifted_31723(f32 x_76781, f32 y_76782) = {
  let {f32 res_76783} = fmul32(x_76781, y_76782)
  in {res_76783}
}

fun {f32} lifted_31727(f32 x_76784) = {
  {x_76784}
}

fun {f32} lifted_31730(f32 x_76785) = {
  {x_76785}
}

fun {f32} lifted_31734(f32 x_76786, f32 y_76787) = {
  let {f32 res_76788} = fmul32(x_76786, y_76787)
  in {res_76788}
}

fun {f32} lifted_31739(f32 x_76789, f32 y_76790) = {
  let {f32 res_76791} = fadd32(x_76789, y_76790)
  in {res_76791}
}

fun {f32, f32} lifted_31693(f32 a_76792, f32 b_76793, f32 c_76794,
                            f32 d_76795) = {
  let {f32 arg_76796} = lifted_31695(a_76792)
  let {f32 arg_76797} = lifted_31699(arg_76796, c_76794)
  let {f32 arg_76798} = lifted_31703(arg_76797)
  let {f32 arg_76799} = lifted_31706(b_76793)
  let {f32 arg_76800} = lifted_31710(arg_76799, d_76795)
  let {f32 res_76801} = lifted_31715(arg_76798, arg_76800)
  let {f32 arg_76802} = lifted_31719(b_76793)
  let {f32 arg_76803} = lifted_31723(arg_76802, c_76794)
  let {f32 arg_76804} = lifted_31727(arg_76803)
  let {f32 arg_76805} = lifted_31730(a_76792)
  let {f32 arg_76806} = lifted_31734(arg_76805, d_76795)
  let {f32 res_76807} = lifted_31739(arg_76804, arg_76806)
  in {res_76801, res_76807}
}

fun {f32, f32} lifted_31677(f32 x_76808, f32 x_76809, f32 y_76810,
                            f32 y_76811) = {
  let {f32 arg_76812, f32 arg_76813} = lifted_31683(x_76808, x_76809)
  let {f32 res_76814, f32 res_76815} = lifted_31693(arg_76812, arg_76813,
                                                    y_76810, y_76811)
  in {res_76814, res_76815}
}

fun {f32, f32} lifted_31757(f32 a_76816, f32 b_76817) = {
  {a_76816, b_76817}
}

fun {f32} lifted_31767(f32 x_76818) = {
  {x_76818}
}

fun {f32} lifted_31771(f32 x_76819, f32 y_76820) = {
  let {f32 res_76821} = fsub32(x_76819, y_76820)
  in {res_76821}
}

fun {f32} lifted_31775(f32 x_76822) = {
  {x_76822}
}

fun {f32} lifted_31779(f32 x_76823, f32 y_76824) = {
  let {f32 res_76825} = fsub32(x_76823, y_76824)
  in {res_76825}
}

fun {f32, f32} lifted_31765(f32 a_76826, f32 b_76827, f32 c_76828,
                            f32 d_76829) = {
  let {f32 arg_76830} = lifted_31767(a_76826)
  let {f32 res_76831} = lifted_31771(arg_76830, c_76828)
  let {f32 arg_76832} = lifted_31775(b_76827)
  let {f32 res_76833} = lifted_31779(arg_76832, d_76829)
  in {res_76831, res_76833}
}

fun {f32, f32} lifted_31753(f32 x_76834, f32 x_76835, f32 y_76836,
                            f32 y_76837) = {
  let {f32 arg_76838, f32 arg_76839} = lifted_31757(x_76834, x_76835)
  let {f32 res_76840, f32 res_76841} = lifted_31765(arg_76838, arg_76839,
                                                    y_76836, y_76837)
  in {res_76840, res_76841}
}

fun {f32, f32} lifted_31790(f32 x_76842, f32 x_76843) = {
  {x_76842, x_76843}
}

fun {f32, f32} lifted_31797(f32 x_76844, f32 x_76845) = {
  {x_76844, x_76845}
}

fun {f32, f32} lifted_31811(f32 a_76846, f32 b_76847) = {
  {a_76846, b_76847}
}

fun {f32} lifted_31821(f32 x_76848) = {
  {x_76848}
}

fun {f32} lifted_31825(f32 x_76849, f32 y_76850) = {
  let {f32 res_76851} = fsub32(x_76849, y_76850)
  in {res_76851}
}

fun {f32} lifted_31829(f32 x_76852) = {
  {x_76852}
}

fun {f32} lifted_31833(f32 x_76853, f32 y_76854) = {
  let {f32 res_76855} = fsub32(x_76853, y_76854)
  in {res_76855}
}

fun {f32, f32} lifted_31819(f32 a_76856, f32 b_76857, f32 c_76858,
                            f32 d_76859) = {
  let {f32 arg_76860} = lifted_31821(a_76856)
  let {f32 res_76861} = lifted_31825(arg_76860, c_76858)
  let {f32 arg_76862} = lifted_31829(b_76857)
  let {f32 res_76863} = lifted_31833(arg_76862, d_76859)
  in {res_76861, res_76863}
}

fun {f32, f32} lifted_31807(f32 x_76864, f32 x_76865, f32 y_76866,
                            f32 y_76867) = {
  let {f32 arg_76868, f32 arg_76869} = lifted_31811(x_76864, x_76865)
  let {f32 res_76870, f32 res_76871} = lifted_31819(arg_76868, arg_76869,
                                                    y_76866, y_76867)
  in {res_76870, res_76871}
}

fun {f32, f32} lifted_31854(f32 a_76872, f32 b_76873) = {
  {a_76872, b_76873}
}

fun {f32} lifted_31867(f32 x_76874) = {
  {x_76874}
}

fun {f32} lifted_31871(f32 x_76875, f32 y_76876) = {
  let {f32 res_76877} = fmul32(x_76875, y_76876)
  in {res_76877}
}

fun {f32} lifted_31875(f32 x_76878) = {
  {x_76878}
}

fun {f32} lifted_31878(f32 x_76879) = {
  {x_76879}
}

fun {f32} lifted_31882(f32 x_76880, f32 y_76881) = {
  let {f32 res_76882} = fmul32(x_76880, y_76881)
  in {res_76882}
}

fun {f32} lifted_31887(f32 x_76883, f32 y_76884) = {
  let {f32 res_76885} = fadd32(x_76883, y_76884)
  in {res_76885}
}

fun {f32} lifted_31891(f32 x_76886) = {
  {x_76886}
}

fun {f32} lifted_31894(f32 x_76887) = {
  {x_76887}
}

fun {f32} lifted_31898(f32 x_76888, f32 y_76889) = {
  let {f32 res_76890} = fmul32(x_76888, y_76889)
  in {res_76890}
}

fun {f32} lifted_31902(f32 x_76891) = {
  {x_76891}
}

fun {f32} lifted_31905(f32 x_76892) = {
  {x_76892}
}

fun {f32} lifted_31909(f32 x_76893, f32 y_76894) = {
  let {f32 res_76895} = fmul32(x_76893, y_76894)
  in {res_76895}
}

fun {f32} lifted_31914(f32 x_76896, f32 y_76897) = {
  let {f32 res_76898} = fadd32(x_76896, y_76897)
  in {res_76898}
}

fun {f32} lifted_31919(f32 x_76899, f32 y_76900) = {
  let {f32 res_76901} = fdiv32(x_76899, y_76900)
  in {res_76901}
}

fun {f32} lifted_31923(f32 x_76902) = {
  {x_76902}
}

fun {f32} lifted_31927(f32 x_76903, f32 y_76904) = {
  let {f32 res_76905} = fmul32(x_76903, y_76904)
  in {res_76905}
}

fun {f32} lifted_31931(f32 x_76906) = {
  {x_76906}
}

fun {f32} lifted_31934(f32 x_76907) = {
  {x_76907}
}

fun {f32} lifted_31938(f32 x_76908, f32 y_76909) = {
  let {f32 res_76910} = fmul32(x_76908, y_76909)
  in {res_76910}
}

fun {f32} lifted_31943(f32 x_76911, f32 y_76912) = {
  let {f32 res_76913} = fsub32(x_76911, y_76912)
  in {res_76913}
}

fun {f32} lifted_31947(f32 x_76914) = {
  {x_76914}
}

fun {f32} lifted_31950(f32 x_76915) = {
  {x_76915}
}

fun {f32} lifted_31954(f32 x_76916, f32 y_76917) = {
  let {f32 res_76918} = fmul32(x_76916, y_76917)
  in {res_76918}
}

fun {f32} lifted_31958(f32 x_76919) = {
  {x_76919}
}

fun {f32} lifted_31961(f32 x_76920) = {
  {x_76920}
}

fun {f32} lifted_31965(f32 x_76921, f32 y_76922) = {
  let {f32 res_76923} = fmul32(x_76921, y_76922)
  in {res_76923}
}

fun {f32} lifted_31970(f32 x_76924, f32 y_76925) = {
  let {f32 res_76926} = fadd32(x_76924, y_76925)
  in {res_76926}
}

fun {f32} lifted_31975(f32 x_76927, f32 y_76928) = {
  let {f32 res_76929} = fdiv32(x_76927, y_76928)
  in {res_76929}
}

fun {f32, f32} lifted_31865(f32 a_76930, f32 b_76931, f32 c_76932,
                            f32 d_76933) = {
  let {f32 arg_76934} = lifted_31867(a_76930)
  let {f32 arg_76935} = lifted_31871(arg_76934, c_76932)
  let {f32 arg_76936} = lifted_31875(arg_76935)
  let {f32 arg_76937} = lifted_31878(b_76931)
  let {f32 arg_76938} = lifted_31882(arg_76937, d_76933)
  let {f32 arg_76939} = lifted_31887(arg_76936, arg_76938)
  let {f32 arg_76940} = lifted_31891(arg_76939)
  let {f32 arg_76941} = lifted_31894(c_76932)
  let {f32 arg_76942} = lifted_31898(arg_76941, c_76932)
  let {f32 arg_76943} = lifted_31902(arg_76942)
  let {f32 arg_76944} = lifted_31905(d_76933)
  let {f32 arg_76945} = lifted_31909(arg_76944, d_76933)
  let {f32 arg_76946} = lifted_31914(arg_76943, arg_76945)
  let {f32 res_76947} = lifted_31919(arg_76940, arg_76946)
  let {f32 arg_76948} = lifted_31923(b_76931)
  let {f32 arg_76949} = lifted_31927(arg_76948, c_76932)
  let {f32 arg_76950} = lifted_31931(arg_76949)
  let {f32 arg_76951} = lifted_31934(a_76930)
  let {f32 arg_76952} = lifted_31938(arg_76951, d_76933)
  let {f32 arg_76953} = lifted_31943(arg_76950, arg_76952)
  let {f32 arg_76954} = lifted_31947(arg_76953)
  let {f32 arg_76955} = lifted_31950(c_76932)
  let {f32 arg_76956} = lifted_31954(arg_76955, c_76932)
  let {f32 arg_76957} = lifted_31958(arg_76956)
  let {f32 arg_76958} = lifted_31961(d_76933)
  let {f32 arg_76959} = lifted_31965(arg_76958, d_76933)
  let {f32 arg_76960} = lifted_31970(arg_76957, arg_76959)
  let {f32 res_76961} = lifted_31975(arg_76954, arg_76960)
  in {res_76947, res_76961}
}

fun {f32, f32} lifted_31847(f32 x_76962, f32 x_76963, f32 y_76964,
                            f32 y_76965) = {
  let {f32 arg_76966, f32 arg_76967} = lifted_31854(x_76962, x_76963)
  let {f32 res_76968, f32 res_76969} = lifted_31865(arg_76966, arg_76967,
                                                    y_76964, y_76965)
  in {res_76968, res_76969}
}

fun {f32} lifted_31997(f32 x_76970) = {
  {x_76970}
}

fun {f32} lifted_32001(f32 x_76971, f32 y_76972) = {
  let {f32 res_76973} = fmul32(x_76971, y_76972)
  in {res_76973}
}

fun {f32} lifted_32005(f32 x_76974) = {
  {x_76974}
}

fun {f32} lifted_32008(f32 x_76975) = {
  {x_76975}
}

fun {f32} lifted_32012(f32 x_76976, f32 y_76977) = {
  let {f32 res_76978} = fmul32(x_76976, y_76977)
  in {res_76978}
}

fun {f32} lifted_32017(f32 x_76979, f32 y_76980) = {
  let {f32 res_76981} = fadd32(x_76979, y_76980)
  in {res_76981}
}

fun {f32} lifted_32021(f32 x_76982) = {
  let {f32 res_76983} = sqrt32(x_76982)
  in {res_76983}
}

fun {f32} lifted_31995(f32 a_76984, f32 b_76985) = {
  let {f32 arg_76986} = lifted_31997(a_76984)
  let {f32 arg_76987} = lifted_32001(arg_76986, a_76984)
  let {f32 arg_76988} = lifted_32005(arg_76987)
  let {f32 arg_76989} = lifted_32008(b_76985)
  let {f32 arg_76990} = lifted_32012(arg_76989, b_76985)
  let {f32 arg_76991} = lifted_32017(arg_76988, arg_76990)
  let {f32 res_76992} = lifted_32021(arg_76991)
  in {res_76992}
}

fun {f32} lifted_32026(f32 x_76993) = {
  let {f32 res_76994} = log32(x_76993)
  in {res_76994}
}

fun {f32} lifted_32030(f32 a_76995) = {
  {a_76995}
}

fun {f32} lifted_32037(f32 x_76996) = {
  {x_76996}
}

fun {f32} lifted_32041(f32 x_76997, f32 y_76998) = {
  let {f32 res_76999} = atan2_32(x_76997, y_76998)
  in {res_76999}
}

fun {f32} lifted_32035(f32 a_77000, f32 b_77001) = {
  let {f32 arg_77002} = lifted_32037(b_77001)
  let {f32 res_77003} = lifted_32041(arg_77002, a_77000)
  in {res_77003}
}

fun {f32, f32} lifted_32047(f32 a_77004, f32 b_77005) = {
  {a_77004, b_77005}
}

fun {f32, f32} lifted_31989(f32 z_77006, f32 z_77007) = {
  let {f32 arg_77008} = lifted_31995(z_77006, z_77007)
  let {f32 arg_77009} = lifted_32026(arg_77008)
  let {f32 arg_77010} = lifted_32030(arg_77009)
  let {f32 arg_77011} = lifted_32035(z_77006, z_77007)
  let {f32 res_77012, f32 res_77013} = lifted_32047(arg_77010, arg_77011)
  in {res_77012, res_77013}
}

fun {f32, f32} lifted_32065(f32 a_77014, f32 b_77015) = {
  {a_77014, b_77015}
}

fun {f32} lifted_32077(f32 x_77016) = {
  {x_77016}
}

fun {f32} lifted_32081(f32 x_77017, f32 y_77018) = {
  let {f32 res_77019} = fmul32(x_77017, y_77018)
  in {res_77019}
}

fun {f32} lifted_32085(f32 x_77020) = {
  {x_77020}
}

fun {f32} lifted_32088(f32 x_77021) = {
  {x_77021}
}

fun {f32} lifted_32092(f32 x_77022, f32 y_77023) = {
  let {f32 res_77024} = fmul32(x_77022, y_77023)
  in {res_77024}
}

fun {f32} lifted_32097(f32 x_77025, f32 y_77026) = {
  let {f32 res_77027} = fsub32(x_77025, y_77026)
  in {res_77027}
}

fun {f32} lifted_32101(f32 x_77028) = {
  {x_77028}
}

fun {f32} lifted_32105(f32 x_77029, f32 y_77030) = {
  let {f32 res_77031} = fmul32(x_77029, y_77030)
  in {res_77031}
}

fun {f32} lifted_32109(f32 x_77032) = {
  {x_77032}
}

fun {f32} lifted_32112(f32 x_77033) = {
  {x_77033}
}

fun {f32} lifted_32116(f32 x_77034, f32 y_77035) = {
  let {f32 res_77036} = fmul32(x_77034, y_77035)
  in {res_77036}
}

fun {f32} lifted_32121(f32 x_77037, f32 y_77038) = {
  let {f32 res_77039} = fadd32(x_77037, y_77038)
  in {res_77039}
}

fun {f32, f32} lifted_32075(f32 a_77040, f32 b_77041, f32 c_77042,
                            f32 d_77043) = {
  let {f32 arg_77044} = lifted_32077(a_77040)
  let {f32 arg_77045} = lifted_32081(arg_77044, c_77042)
  let {f32 arg_77046} = lifted_32085(arg_77045)
  let {f32 arg_77047} = lifted_32088(b_77041)
  let {f32 arg_77048} = lifted_32092(arg_77047, d_77043)
  let {f32 res_77049} = lifted_32097(arg_77046, arg_77048)
  let {f32 arg_77050} = lifted_32101(b_77041)
  let {f32 arg_77051} = lifted_32105(arg_77050, c_77042)
  let {f32 arg_77052} = lifted_32109(arg_77051)
  let {f32 arg_77053} = lifted_32112(a_77040)
  let {f32 arg_77054} = lifted_32116(arg_77053, d_77043)
  let {f32 res_77055} = lifted_32121(arg_77052, arg_77054)
  in {res_77049, res_77055}
}

fun {f32, f32} lifted_32059(f32 x_77056, f32 x_77057, f32 y_77058,
                            f32 y_77059) = {
  let {f32 arg_77060, f32 arg_77061} = lifted_32065(x_77056, x_77057)
  let {f32 res_77062, f32 res_77063} = lifted_32075(arg_77060, arg_77061,
                                                    y_77058, y_77059)
  in {res_77062, res_77063}
}

fun {f32, f32} lifted_32139(f32 a_77064, f32 b_77065) = {
  {a_77064, b_77065}
}

fun {f32} lifted_32149(f32 x_77066) = {
  {x_77066}
}

fun {f32} lifted_32153(f32 x_77067, f32 y_77068) = {
  let {f32 res_77069} = fsub32(x_77067, y_77068)
  in {res_77069}
}

fun {f32} lifted_32157(f32 x_77070) = {
  {x_77070}
}

fun {f32} lifted_32161(f32 x_77071, f32 y_77072) = {
  let {f32 res_77073} = fsub32(x_77071, y_77072)
  in {res_77073}
}

fun {f32, f32} lifted_32147(f32 a_77074, f32 b_77075, f32 c_77076,
                            f32 d_77077) = {
  let {f32 arg_77078} = lifted_32149(a_77074)
  let {f32 res_77079} = lifted_32153(arg_77078, c_77076)
  let {f32 arg_77080} = lifted_32157(b_77075)
  let {f32 res_77081} = lifted_32161(arg_77080, d_77077)
  in {res_77079, res_77081}
}

fun {f32, f32} lifted_32135(f32 x_77082, f32 x_77083, f32 y_77084,
                            f32 y_77085) = {
  let {f32 arg_77086, f32 arg_77087} = lifted_32139(x_77082, x_77083)
  let {f32 res_77088, f32 res_77089} = lifted_32147(arg_77086, arg_77087,
                                                    y_77084, y_77085)
  in {res_77088, res_77089}
}

fun {f32, f32} lifted_32181(f32 a_77090, f32 b_77091) = {
  {a_77090, b_77091}
}

fun {f32} lifted_32193(f32 x_77092) = {
  {x_77092}
}

fun {f32} lifted_32197(f32 x_77093, f32 y_77094) = {
  let {f32 res_77095} = fmul32(x_77093, y_77094)
  in {res_77095}
}

fun {f32} lifted_32201(f32 x_77096) = {
  {x_77096}
}

fun {f32} lifted_32204(f32 x_77097) = {
  {x_77097}
}

fun {f32} lifted_32208(f32 x_77098, f32 y_77099) = {
  let {f32 res_77100} = fmul32(x_77098, y_77099)
  in {res_77100}
}

fun {f32} lifted_32213(f32 x_77101, f32 y_77102) = {
  let {f32 res_77103} = fsub32(x_77101, y_77102)
  in {res_77103}
}

fun {f32} lifted_32217(f32 x_77104) = {
  {x_77104}
}

fun {f32} lifted_32221(f32 x_77105, f32 y_77106) = {
  let {f32 res_77107} = fmul32(x_77105, y_77106)
  in {res_77107}
}

fun {f32} lifted_32225(f32 x_77108) = {
  {x_77108}
}

fun {f32} lifted_32228(f32 x_77109) = {
  {x_77109}
}

fun {f32} lifted_32232(f32 x_77110, f32 y_77111) = {
  let {f32 res_77112} = fmul32(x_77110, y_77111)
  in {res_77112}
}

fun {f32} lifted_32237(f32 x_77113, f32 y_77114) = {
  let {f32 res_77115} = fadd32(x_77113, y_77114)
  in {res_77115}
}

fun {f32, f32} lifted_32191(f32 a_77116, f32 b_77117, f32 c_77118,
                            f32 d_77119) = {
  let {f32 arg_77120} = lifted_32193(a_77116)
  let {f32 arg_77121} = lifted_32197(arg_77120, c_77118)
  let {f32 arg_77122} = lifted_32201(arg_77121)
  let {f32 arg_77123} = lifted_32204(b_77117)
  let {f32 arg_77124} = lifted_32208(arg_77123, d_77119)
  let {f32 res_77125} = lifted_32213(arg_77122, arg_77124)
  let {f32 arg_77126} = lifted_32217(b_77117)
  let {f32 arg_77127} = lifted_32221(arg_77126, c_77118)
  let {f32 arg_77128} = lifted_32225(arg_77127)
  let {f32 arg_77129} = lifted_32228(a_77116)
  let {f32 arg_77130} = lifted_32232(arg_77129, d_77119)
  let {f32 res_77131} = lifted_32237(arg_77128, arg_77130)
  in {res_77125, res_77131}
}

fun {f32, f32} lifted_32175(f32 x_77132, f32 x_77133, f32 y_77134,
                            f32 y_77135) = {
  let {f32 arg_77136, f32 arg_77137} = lifted_32181(x_77132, x_77133)
  let {f32 res_77138, f32 res_77139} = lifted_32191(arg_77136, arg_77137,
                                                    y_77134, y_77135)
  in {res_77138, res_77139}
}

fun {f32, f32} lifted_32248(f32 x_77140, f32 x_77141) = {
  {x_77140, x_77141}
}

fun {f32, f32} lifted_32255(f32 x_77142, f32 x_77143) = {
  {x_77142, x_77143}
}

fun {f32, f32} lifted_32271(f32 a_77144, f32 b_77145) = {
  {a_77144, b_77145}
}

fun {f32} lifted_32283(f32 x_77146) = {
  {x_77146}
}

fun {f32} lifted_32287(f32 x_77147, f32 y_77148) = {
  let {f32 res_77149} = fmul32(x_77147, y_77148)
  in {res_77149}
}

fun {f32} lifted_32291(f32 x_77150) = {
  {x_77150}
}

fun {f32} lifted_32294(f32 x_77151) = {
  {x_77151}
}

fun {f32} lifted_32298(f32 x_77152, f32 y_77153) = {
  let {f32 res_77154} = fmul32(x_77152, y_77153)
  in {res_77154}
}

fun {f32} lifted_32303(f32 x_77155, f32 y_77156) = {
  let {f32 res_77157} = fsub32(x_77155, y_77156)
  in {res_77157}
}

fun {f32} lifted_32307(f32 x_77158) = {
  {x_77158}
}

fun {f32} lifted_32311(f32 x_77159, f32 y_77160) = {
  let {f32 res_77161} = fmul32(x_77159, y_77160)
  in {res_77161}
}

fun {f32} lifted_32315(f32 x_77162) = {
  {x_77162}
}

fun {f32} lifted_32318(f32 x_77163) = {
  {x_77163}
}

fun {f32} lifted_32322(f32 x_77164, f32 y_77165) = {
  let {f32 res_77166} = fmul32(x_77164, y_77165)
  in {res_77166}
}

fun {f32} lifted_32327(f32 x_77167, f32 y_77168) = {
  let {f32 res_77169} = fadd32(x_77167, y_77168)
  in {res_77169}
}

fun {f32, f32} lifted_32281(f32 a_77170, f32 b_77171, f32 c_77172,
                            f32 d_77173) = {
  let {f32 arg_77174} = lifted_32283(a_77170)
  let {f32 arg_77175} = lifted_32287(arg_77174, c_77172)
  let {f32 arg_77176} = lifted_32291(arg_77175)
  let {f32 arg_77177} = lifted_32294(b_77171)
  let {f32 arg_77178} = lifted_32298(arg_77177, d_77173)
  let {f32 res_77179} = lifted_32303(arg_77176, arg_77178)
  let {f32 arg_77180} = lifted_32307(b_77171)
  let {f32 arg_77181} = lifted_32311(arg_77180, c_77172)
  let {f32 arg_77182} = lifted_32315(arg_77181)
  let {f32 arg_77183} = lifted_32318(a_77170)
  let {f32 arg_77184} = lifted_32322(arg_77183, d_77173)
  let {f32 res_77185} = lifted_32327(arg_77182, arg_77184)
  in {res_77179, res_77185}
}

fun {f32, f32} lifted_32265(f32 x_77186, f32 x_77187, f32 y_77188,
                            f32 y_77189) = {
  let {f32 arg_77190, f32 arg_77191} = lifted_32271(x_77186, x_77187)
  let {f32 res_77192, f32 res_77193} = lifted_32281(arg_77190, arg_77191,
                                                    y_77188, y_77189)
  in {res_77192, res_77193}
}

fun {f32, f32} lifted_32338(f32 x_77194, f32 x_77195) = {
  {x_77194, x_77195}
}

fun {f32, f32} lifted_32345(f32 x_77196, f32 x_77197) = {
  {x_77196, x_77197}
}

fun {f32, f32} lifted_32359(f32 a_77198, f32 b_77199) = {
  {a_77198, b_77199}
}

fun {f32} lifted_32369(f32 x_77200) = {
  {x_77200}
}

fun {f32} lifted_32373(f32 x_77201, f32 y_77202) = {
  let {f32 res_77203} = fsub32(x_77201, y_77202)
  in {res_77203}
}

fun {f32} lifted_32377(f32 x_77204) = {
  {x_77204}
}

fun {f32} lifted_32381(f32 x_77205, f32 y_77206) = {
  let {f32 res_77207} = fsub32(x_77205, y_77206)
  in {res_77207}
}

fun {f32, f32} lifted_32367(f32 a_77208, f32 b_77209, f32 c_77210,
                            f32 d_77211) = {
  let {f32 arg_77212} = lifted_32369(a_77208)
  let {f32 res_77213} = lifted_32373(arg_77212, c_77210)
  let {f32 arg_77214} = lifted_32377(b_77209)
  let {f32 res_77215} = lifted_32381(arg_77214, d_77211)
  in {res_77213, res_77215}
}

fun {f32, f32} lifted_32355(f32 x_77216, f32 x_77217, f32 y_77218,
                            f32 y_77219) = {
  let {f32 arg_77220, f32 arg_77221} = lifted_32359(x_77216, x_77217)
  let {f32 res_77222, f32 res_77223} = lifted_32367(arg_77220, arg_77221,
                                                    y_77218, y_77219)
  in {res_77222, res_77223}
}

fun {f32, f32} lifted_32401(f32 a_77224, f32 b_77225) = {
  {a_77224, b_77225}
}

fun {f32} lifted_32413(f32 x_77226) = {
  {x_77226}
}

fun {f32} lifted_32417(f32 x_77227, f32 y_77228) = {
  let {f32 res_77229} = fmul32(x_77227, y_77228)
  in {res_77229}
}

fun {f32} lifted_32421(f32 x_77230) = {
  {x_77230}
}

fun {f32} lifted_32424(f32 x_77231) = {
  {x_77231}
}

fun {f32} lifted_32428(f32 x_77232, f32 y_77233) = {
  let {f32 res_77234} = fmul32(x_77232, y_77233)
  in {res_77234}
}

fun {f32} lifted_32433(f32 x_77235, f32 y_77236) = {
  let {f32 res_77237} = fsub32(x_77235, y_77236)
  in {res_77237}
}

fun {f32} lifted_32437(f32 x_77238) = {
  {x_77238}
}

fun {f32} lifted_32441(f32 x_77239, f32 y_77240) = {
  let {f32 res_77241} = fmul32(x_77239, y_77240)
  in {res_77241}
}

fun {f32} lifted_32445(f32 x_77242) = {
  {x_77242}
}

fun {f32} lifted_32448(f32 x_77243) = {
  {x_77243}
}

fun {f32} lifted_32452(f32 x_77244, f32 y_77245) = {
  let {f32 res_77246} = fmul32(x_77244, y_77245)
  in {res_77246}
}

fun {f32} lifted_32457(f32 x_77247, f32 y_77248) = {
  let {f32 res_77249} = fadd32(x_77247, y_77248)
  in {res_77249}
}

fun {f32, f32} lifted_32411(f32 a_77250, f32 b_77251, f32 c_77252,
                            f32 d_77253) = {
  let {f32 arg_77254} = lifted_32413(a_77250)
  let {f32 arg_77255} = lifted_32417(arg_77254, c_77252)
  let {f32 arg_77256} = lifted_32421(arg_77255)
  let {f32 arg_77257} = lifted_32424(b_77251)
  let {f32 arg_77258} = lifted_32428(arg_77257, d_77253)
  let {f32 res_77259} = lifted_32433(arg_77256, arg_77258)
  let {f32 arg_77260} = lifted_32437(b_77251)
  let {f32 arg_77261} = lifted_32441(arg_77260, c_77252)
  let {f32 arg_77262} = lifted_32445(arg_77261)
  let {f32 arg_77263} = lifted_32448(a_77250)
  let {f32 arg_77264} = lifted_32452(arg_77263, d_77253)
  let {f32 res_77265} = lifted_32457(arg_77262, arg_77264)
  in {res_77259, res_77265}
}

fun {f32, f32} lifted_32395(f32 x_77266, f32 x_77267, f32 y_77268,
                            f32 y_77269) = {
  let {f32 arg_77270, f32 arg_77271} = lifted_32401(x_77266, x_77267)
  let {f32 res_77272, f32 res_77273} = lifted_32411(arg_77270, arg_77271,
                                                    y_77268, y_77269)
  in {res_77272, res_77273}
}

fun {f32, f32} lifted_32468(f32 x_77274, f32 x_77275) = {
  {x_77274, x_77275}
}

fun {f32, f32} lifted_32475(f32 x_77276, f32 x_77277) = {
  {x_77276, x_77277}
}

fun {f32, f32} lifted_32482(f32 x_77278, f32 x_77279) = {
  {x_77278, x_77279}
}

fun {f32, f32} lifted_32498(f32 a_77280, f32 b_77281) = {
  {a_77280, b_77281}
}

fun {f32} lifted_32510(f32 x_77282) = {
  {x_77282}
}

fun {f32} lifted_32514(f32 x_77283, f32 y_77284) = {
  let {f32 res_77285} = fmul32(x_77283, y_77284)
  in {res_77285}
}

fun {f32} lifted_32518(f32 x_77286) = {
  {x_77286}
}

fun {f32} lifted_32521(f32 x_77287) = {
  {x_77287}
}

fun {f32} lifted_32525(f32 x_77288, f32 y_77289) = {
  let {f32 res_77290} = fmul32(x_77288, y_77289)
  in {res_77290}
}

fun {f32} lifted_32530(f32 x_77291, f32 y_77292) = {
  let {f32 res_77293} = fsub32(x_77291, y_77292)
  in {res_77293}
}

fun {f32} lifted_32534(f32 x_77294) = {
  {x_77294}
}

fun {f32} lifted_32538(f32 x_77295, f32 y_77296) = {
  let {f32 res_77297} = fmul32(x_77295, y_77296)
  in {res_77297}
}

fun {f32} lifted_32542(f32 x_77298) = {
  {x_77298}
}

fun {f32} lifted_32545(f32 x_77299) = {
  {x_77299}
}

fun {f32} lifted_32549(f32 x_77300, f32 y_77301) = {
  let {f32 res_77302} = fmul32(x_77300, y_77301)
  in {res_77302}
}

fun {f32} lifted_32554(f32 x_77303, f32 y_77304) = {
  let {f32 res_77305} = fadd32(x_77303, y_77304)
  in {res_77305}
}

fun {f32, f32} lifted_32508(f32 a_77306, f32 b_77307, f32 c_77308,
                            f32 d_77309) = {
  let {f32 arg_77310} = lifted_32510(a_77306)
  let {f32 arg_77311} = lifted_32514(arg_77310, c_77308)
  let {f32 arg_77312} = lifted_32518(arg_77311)
  let {f32 arg_77313} = lifted_32521(b_77307)
  let {f32 arg_77314} = lifted_32525(arg_77313, d_77309)
  let {f32 res_77315} = lifted_32530(arg_77312, arg_77314)
  let {f32 arg_77316} = lifted_32534(b_77307)
  let {f32 arg_77317} = lifted_32538(arg_77316, c_77308)
  let {f32 arg_77318} = lifted_32542(arg_77317)
  let {f32 arg_77319} = lifted_32545(a_77306)
  let {f32 arg_77320} = lifted_32549(arg_77319, d_77309)
  let {f32 res_77321} = lifted_32554(arg_77318, arg_77320)
  in {res_77315, res_77321}
}

fun {f32, f32} lifted_32492(f32 x_77322, f32 x_77323, f32 y_77324,
                            f32 y_77325) = {
  let {f32 arg_77326, f32 arg_77327} = lifted_32498(x_77322, x_77323)
  let {f32 res_77328, f32 res_77329} = lifted_32508(arg_77326, arg_77327,
                                                    y_77324, y_77325)
  in {res_77328, res_77329}
}

fun {f32, f32} lifted_32572(f32 a_77330, f32 b_77331) = {
  {a_77330, b_77331}
}

fun {f32} lifted_32582(f32 x_77332) = {
  {x_77332}
}

fun {f32} lifted_32586(f32 x_77333, f32 y_77334) = {
  let {f32 res_77335} = fsub32(x_77333, y_77334)
  in {res_77335}
}

fun {f32} lifted_32590(f32 x_77336) = {
  {x_77336}
}

fun {f32} lifted_32594(f32 x_77337, f32 y_77338) = {
  let {f32 res_77339} = fsub32(x_77337, y_77338)
  in {res_77339}
}

fun {f32, f32} lifted_32580(f32 a_77340, f32 b_77341, f32 c_77342,
                            f32 d_77343) = {
  let {f32 arg_77344} = lifted_32582(a_77340)
  let {f32 res_77345} = lifted_32586(arg_77344, c_77342)
  let {f32 arg_77346} = lifted_32590(b_77341)
  let {f32 res_77347} = lifted_32594(arg_77346, d_77343)
  in {res_77345, res_77347}
}

fun {f32, f32} lifted_32568(f32 x_77348, f32 x_77349, f32 y_77350,
                            f32 y_77351) = {
  let {f32 arg_77352, f32 arg_77353} = lifted_32572(x_77348, x_77349)
  let {f32 res_77354, f32 res_77355} = lifted_32580(arg_77352, arg_77353,
                                                    y_77350, y_77351)
  in {res_77354, res_77355}
}

fun {f32, f32} lifted_32615(f32 a_77356, f32 b_77357) = {
  {a_77356, b_77357}
}

fun {f32} lifted_32628(f32 x_77358) = {
  {x_77358}
}

fun {f32} lifted_32632(f32 x_77359, f32 y_77360) = {
  let {f32 res_77361} = fmul32(x_77359, y_77360)
  in {res_77361}
}

fun {f32} lifted_32636(f32 x_77362) = {
  {x_77362}
}

fun {f32} lifted_32639(f32 x_77363) = {
  {x_77363}
}

fun {f32} lifted_32643(f32 x_77364, f32 y_77365) = {
  let {f32 res_77366} = fmul32(x_77364, y_77365)
  in {res_77366}
}

fun {f32} lifted_32648(f32 x_77367, f32 y_77368) = {
  let {f32 res_77369} = fadd32(x_77367, y_77368)
  in {res_77369}
}

fun {f32} lifted_32652(f32 x_77370) = {
  {x_77370}
}

fun {f32} lifted_32655(f32 x_77371) = {
  {x_77371}
}

fun {f32} lifted_32659(f32 x_77372, f32 y_77373) = {
  let {f32 res_77374} = fmul32(x_77372, y_77373)
  in {res_77374}
}

fun {f32} lifted_32663(f32 x_77375) = {
  {x_77375}
}

fun {f32} lifted_32666(f32 x_77376) = {
  {x_77376}
}

fun {f32} lifted_32670(f32 x_77377, f32 y_77378) = {
  let {f32 res_77379} = fmul32(x_77377, y_77378)
  in {res_77379}
}

fun {f32} lifted_32675(f32 x_77380, f32 y_77381) = {
  let {f32 res_77382} = fadd32(x_77380, y_77381)
  in {res_77382}
}

fun {f32} lifted_32680(f32 x_77383, f32 y_77384) = {
  let {f32 res_77385} = fdiv32(x_77383, y_77384)
  in {res_77385}
}

fun {f32} lifted_32684(f32 x_77386) = {
  {x_77386}
}

fun {f32} lifted_32688(f32 x_77387, f32 y_77388) = {
  let {f32 res_77389} = fmul32(x_77387, y_77388)
  in {res_77389}
}

fun {f32} lifted_32692(f32 x_77390) = {
  {x_77390}
}

fun {f32} lifted_32695(f32 x_77391) = {
  {x_77391}
}

fun {f32} lifted_32699(f32 x_77392, f32 y_77393) = {
  let {f32 res_77394} = fmul32(x_77392, y_77393)
  in {res_77394}
}

fun {f32} lifted_32704(f32 x_77395, f32 y_77396) = {
  let {f32 res_77397} = fsub32(x_77395, y_77396)
  in {res_77397}
}

fun {f32} lifted_32708(f32 x_77398) = {
  {x_77398}
}

fun {f32} lifted_32711(f32 x_77399) = {
  {x_77399}
}

fun {f32} lifted_32715(f32 x_77400, f32 y_77401) = {
  let {f32 res_77402} = fmul32(x_77400, y_77401)
  in {res_77402}
}

fun {f32} lifted_32719(f32 x_77403) = {
  {x_77403}
}

fun {f32} lifted_32722(f32 x_77404) = {
  {x_77404}
}

fun {f32} lifted_32726(f32 x_77405, f32 y_77406) = {
  let {f32 res_77407} = fmul32(x_77405, y_77406)
  in {res_77407}
}

fun {f32} lifted_32731(f32 x_77408, f32 y_77409) = {
  let {f32 res_77410} = fadd32(x_77408, y_77409)
  in {res_77410}
}

fun {f32} lifted_32736(f32 x_77411, f32 y_77412) = {
  let {f32 res_77413} = fdiv32(x_77411, y_77412)
  in {res_77413}
}

fun {f32, f32} lifted_32626(f32 a_77414, f32 b_77415, f32 c_77416,
                            f32 d_77417) = {
  let {f32 arg_77418} = lifted_32628(a_77414)
  let {f32 arg_77419} = lifted_32632(arg_77418, c_77416)
  let {f32 arg_77420} = lifted_32636(arg_77419)
  let {f32 arg_77421} = lifted_32639(b_77415)
  let {f32 arg_77422} = lifted_32643(arg_77421, d_77417)
  let {f32 arg_77423} = lifted_32648(arg_77420, arg_77422)
  let {f32 arg_77424} = lifted_32652(arg_77423)
  let {f32 arg_77425} = lifted_32655(c_77416)
  let {f32 arg_77426} = lifted_32659(arg_77425, c_77416)
  let {f32 arg_77427} = lifted_32663(arg_77426)
  let {f32 arg_77428} = lifted_32666(d_77417)
  let {f32 arg_77429} = lifted_32670(arg_77428, d_77417)
  let {f32 arg_77430} = lifted_32675(arg_77427, arg_77429)
  let {f32 res_77431} = lifted_32680(arg_77424, arg_77430)
  let {f32 arg_77432} = lifted_32684(b_77415)
  let {f32 arg_77433} = lifted_32688(arg_77432, c_77416)
  let {f32 arg_77434} = lifted_32692(arg_77433)
  let {f32 arg_77435} = lifted_32695(a_77414)
  let {f32 arg_77436} = lifted_32699(arg_77435, d_77417)
  let {f32 arg_77437} = lifted_32704(arg_77434, arg_77436)
  let {f32 arg_77438} = lifted_32708(arg_77437)
  let {f32 arg_77439} = lifted_32711(c_77416)
  let {f32 arg_77440} = lifted_32715(arg_77439, c_77416)
  let {f32 arg_77441} = lifted_32719(arg_77440)
  let {f32 arg_77442} = lifted_32722(d_77417)
  let {f32 arg_77443} = lifted_32726(arg_77442, d_77417)
  let {f32 arg_77444} = lifted_32731(arg_77441, arg_77443)
  let {f32 res_77445} = lifted_32736(arg_77438, arg_77444)
  in {res_77431, res_77445}
}

fun {f32, f32} lifted_32608(f32 x_77446, f32 x_77447, f32 y_77448,
                            f32 y_77449) = {
  let {f32 arg_77450, f32 arg_77451} = lifted_32615(x_77446, x_77447)
  let {f32 res_77452, f32 res_77453} = lifted_32626(arg_77450, arg_77451,
                                                    y_77448, y_77449)
  in {res_77452, res_77453}
}

fun {f32, f32} lifted_32754(f32 a_77454, f32 b_77455) = {
  {a_77454, b_77455}
}

fun {f32} lifted_32764(f32 x_77456) = {
  {x_77456}
}

fun {f32} lifted_32768(f32 x_77457, f32 y_77458) = {
  let {f32 res_77459} = fadd32(x_77457, y_77458)
  in {res_77459}
}

fun {f32} lifted_32772(f32 x_77460) = {
  {x_77460}
}

fun {f32} lifted_32776(f32 x_77461, f32 y_77462) = {
  let {f32 res_77463} = fadd32(x_77461, y_77462)
  in {res_77463}
}

fun {f32, f32} lifted_32762(f32 a_77464, f32 b_77465, f32 c_77466,
                            f32 d_77467) = {
  let {f32 arg_77468} = lifted_32764(a_77464)
  let {f32 res_77469} = lifted_32768(arg_77468, c_77466)
  let {f32 arg_77470} = lifted_32772(b_77465)
  let {f32 res_77471} = lifted_32776(arg_77470, d_77467)
  in {res_77469, res_77471}
}

fun {f32, f32} lifted_32750(f32 x_77472, f32 x_77473, f32 y_77474,
                            f32 y_77475) = {
  let {f32 arg_77476, f32 arg_77477} = lifted_32754(x_77472, x_77473)
  let {f32 res_77478, f32 res_77479} = lifted_32762(arg_77476, arg_77477,
                                                    y_77474, y_77475)
  in {res_77478, res_77479}
}

fun {f32} lifted_32792(f32 x_77480) = {
  let {f32 res_77481} = exp32(x_77480)
  in {res_77481}
}

fun {f32} lifted_32797(f32 x_77482) = {
  {x_77482}
}

fun {f32} lifted_32800(f32 x_77483) = {
  let {f32 res_77484} = cos32(x_77483)
  in {res_77484}
}

fun {f32} lifted_32805(f32 x_77485, f32 y_77486) = {
  let {f32 res_77487} = fmul32(x_77485, y_77486)
  in {res_77487}
}

fun {f32} lifted_32809(f32 a_77488) = {
  {a_77488}
}

fun {f32} lifted_32812(f32 x_77489) = {
  {x_77489}
}

fun {f32} lifted_32815(f32 x_77490) = {
  let {f32 res_77491} = sin32(x_77490)
  in {res_77491}
}

fun {f32} lifted_32820(f32 x_77492, f32 y_77493) = {
  let {f32 res_77494} = fmul32(x_77492, y_77493)
  in {res_77494}
}

fun {f32, f32} lifted_32825(f32 a_77495, f32 b_77496) = {
  {a_77495, b_77496}
}

fun {f32, f32} lifted_32790(f32 a_77497, f32 b_77498) = {
  let {f32 res_77499} = lifted_32792(a_77497)
  let {f32 expx_77500} = res_77499
  let {f32 arg_77501} = lifted_32797(expx_77500)
  let {f32 arg_77502} = lifted_32800(b_77498)
  let {f32 arg_77503} = lifted_32805(arg_77501, arg_77502)
  let {f32 arg_77504} = lifted_32809(arg_77503)
  let {f32 arg_77505} = lifted_32812(expx_77500)
  let {f32 arg_77506} = lifted_32815(b_77498)
  let {f32 arg_77507} = lifted_32820(arg_77505, arg_77506)
  let {f32 res_77508, f32 res_77509} = lifted_32825(arg_77504, arg_77507)
  in {res_77508, res_77509}
}

fun {f32, f32} lifted_30368(f32 coeff1_77510, f32 coeff1_77511,
                            f32 coeff2_77512, f32 coeff2_77513,
                            f32 day_count_fraction_77514, f32 etai2_77515,
                            f32 etai2_77516, f32 etai_77517, f32 etai_77518,
                            f32 i_77519, f32 i_77520, f32 kappai_77521,
                            f32 kappai_77522, f32 one_77523, f32 one_77524,
                            f32 rho_77525, f32 two_77526, f32 two_77527,
                            f32 zero_77528, f32 zero_77529, f32 xi_77530,
                            f32 xi_77531) = {
  let {f32 res_77532, f32 res_77533} = lifted_30371(day_count_fraction_77514)
  let {f32 ti_77534} = res_77532
  let {f32 ti_77535} = res_77533
  let {f32 arg_77536, f32 arg_77537} = lifted_30385(kappai_77521, kappai_77522)
  let {f32 arg_77538, f32 arg_77539} = lifted_30390(rho_77525)
  let {f32 arg_77540, f32 arg_77541} = lifted_30401(arg_77538, arg_77539)
  let {f32 arg_77542, f32 arg_77543} = lifted_30411(arg_77540, arg_77541,
                                                    etai_77517, etai_77518)
  let {f32 arg_77544, f32 arg_77545} = lifted_30484(arg_77542, arg_77543)
  let {f32 arg_77546, f32 arg_77547} = lifted_30494(arg_77544, arg_77545,
                                                    xi_77530, xi_77531)
  let {f32 res_77548, f32 res_77549} = lifted_30570(arg_77536, arg_77537,
                                                    arg_77546, arg_77547)
  let {f32 d0_77550} = res_77548
  let {f32 d0_77551} = res_77549
  let {f32 arg_77552, f32 arg_77553} = lifted_30610(d0_77550, d0_77551)
  let {f32 arg_77554, f32 arg_77555} = lifted_30620(arg_77552, arg_77553,
                                                    d0_77550, d0_77551)
  let {f32 arg_77556, f32 arg_77557} = lifted_30693(arg_77554, arg_77555)
  let {f32 arg_77558, f32 arg_77559} = lifted_30700(etai2_77515, etai2_77516)
  let {f32 arg_77560, f32 arg_77561} = lifted_30707(xi_77530, xi_77531)
  let {f32 arg_77562, f32 arg_77563} = lifted_30714(i_77519, i_77520)
  let {f32 arg_77564, f32 arg_77565} = lifted_30724(arg_77562, arg_77563,
                                                    xi_77530, xi_77531)
  let {f32 arg_77566, f32 arg_77567} = lifted_30764(arg_77560, arg_77561,
                                                    arg_77564, arg_77565)
  let {f32 arg_77568, f32 arg_77569} = lifted_30840(arg_77558, arg_77559,
                                                    arg_77566, arg_77567)
  let {f32 arg_77570, f32 arg_77571} = lifted_30916(arg_77556, arg_77557,
                                                    arg_77568, arg_77569)
  let {f32 res_77572, f32 res_77573} = lifted_30959(arg_77570, arg_77571)
  let {f32 d_77574} = res_77572
  let {f32 d_77575} = res_77573
  let {f32 arg_77576, f32 arg_77577} = lifted_31127(d0_77550, d0_77551)
  let {f32 res_77578, f32 res_77579} = lifted_31137(arg_77576, arg_77577,
                                                    d_77574, d_77575)
  let {f32 a_minus_77580} = res_77578
  let {f32 a_minus_77581} = res_77579
  let {f32 arg_77582, f32 arg_77583} = lifted_31177(a_minus_77580,
                                                    a_minus_77581)
  let {f32 arg_77584, f32 arg_77585} = lifted_31184(d0_77550, d0_77551)
  let {f32 arg_77586, f32 arg_77587} = lifted_31194(arg_77584, arg_77585,
                                                    d_77574, d_77575)
  let {f32 res_77588, f32 res_77589} = lifted_31234(arg_77582, arg_77583,
                                                    arg_77586, arg_77587)
  let {f32 g_77590} = res_77588
  let {f32 g_77591} = res_77589
  let {f32 arg_77592, f32 arg_77593} = lifted_31376(zero_77528, zero_77529)
  let {f32 arg_77594, f32 arg_77595} = lifted_31383(d_77574, d_77575)
  let {f32 arg_77596, f32 arg_77597} = lifted_31393(arg_77594, arg_77595,
                                                    ti_77534, ti_77535)
  let {f32 arg_77598, f32 arg_77599} = lifted_31469(arg_77592, arg_77593,
                                                    arg_77596, arg_77597)
  let {f32 res_77600, f32 res_77601} = lifted_31509(arg_77598, arg_77599)
  let {f32 e_77602} = res_77600
  let {f32 e_77603} = res_77601
  let {f32 arg_77604, f32 arg_77605} = lifted_31556(coeff1_77510, coeff1_77511)
  let {f32 arg_77606, f32 arg_77607} = lifted_31563(a_minus_77580,
                                                    a_minus_77581)
  let {f32 arg_77608, f32 arg_77609} = lifted_31573(arg_77606, arg_77607,
                                                    ti_77534, ti_77535)
  let {f32 arg_77610, f32 arg_77611} = lifted_31646(arg_77608, arg_77609)
  let {f32 arg_77612, f32 arg_77613} = lifted_31653(two_77526, two_77527)
  let {f32 arg_77614, f32 arg_77615} = lifted_31660(one_77523, one_77524)
  let {f32 arg_77616, f32 arg_77617} = lifted_31667(g_77590, g_77591)
  let {f32 arg_77618, f32 arg_77619} = lifted_31677(arg_77616, arg_77617,
                                                    e_77602, e_77603)
  let {f32 arg_77620, f32 arg_77621} = lifted_31753(arg_77614, arg_77615,
                                                    arg_77618, arg_77619)
  let {f32 arg_77622, f32 arg_77623} = lifted_31790(arg_77620, arg_77621)
  let {f32 arg_77624, f32 arg_77625} = lifted_31797(one_77523, one_77524)
  let {f32 arg_77626, f32 arg_77627} = lifted_31807(arg_77624, arg_77625,
                                                    g_77590, g_77591)
  let {f32 arg_77628, f32 arg_77629} = lifted_31847(arg_77622, arg_77623,
                                                    arg_77626, arg_77627)
  let {f32 arg_77630, f32 arg_77631} = lifted_31989(arg_77628, arg_77629)
  let {f32 arg_77632, f32 arg_77633} = lifted_32059(arg_77612, arg_77613,
                                                    arg_77630, arg_77631)
  let {f32 arg_77634, f32 arg_77635} = lifted_32135(arg_77610, arg_77611,
                                                    arg_77632, arg_77633)
  let {f32 arg_77636, f32 arg_77637} = lifted_32175(arg_77604, arg_77605,
                                                    arg_77634, arg_77635)
  let {f32 arg_77638, f32 arg_77639} = lifted_32248(arg_77636, arg_77637)
  let {f32 arg_77640, f32 arg_77641} = lifted_32255(coeff2_77512, coeff2_77513)
  let {f32 arg_77642, f32 arg_77643} = lifted_32265(arg_77640, arg_77641,
                                                    a_minus_77580,
                                                    a_minus_77581)
  let {f32 arg_77644, f32 arg_77645} = lifted_32338(arg_77642, arg_77643)
  let {f32 arg_77646, f32 arg_77647} = lifted_32345(one_77523, one_77524)
  let {f32 arg_77648, f32 arg_77649} = lifted_32355(arg_77646, arg_77647,
                                                    e_77602, e_77603)
  let {f32 arg_77650, f32 arg_77651} = lifted_32395(arg_77644, arg_77645,
                                                    arg_77648, arg_77649)
  let {f32 arg_77652, f32 arg_77653} = lifted_32468(arg_77650, arg_77651)
  let {f32 arg_77654, f32 arg_77655} = lifted_32475(one_77523, one_77524)
  let {f32 arg_77656, f32 arg_77657} = lifted_32482(g_77590, g_77591)
  let {f32 arg_77658, f32 arg_77659} = lifted_32492(arg_77656, arg_77657,
                                                    e_77602, e_77603)
  let {f32 arg_77660, f32 arg_77661} = lifted_32568(arg_77654, arg_77655,
                                                    arg_77658, arg_77659)
  let {f32 arg_77662, f32 arg_77663} = lifted_32608(arg_77652, arg_77653,
                                                    arg_77660, arg_77661)
  let {f32 arg_77664, f32 arg_77665} = lifted_32750(arg_77638, arg_77639,
                                                    arg_77662, arg_77663)
  let {f32 res_77666, f32 res_77667} = lifted_32790(arg_77664, arg_77665)
  in {res_77666, res_77667}
}

fun {f32, f32} lifted_32843(f32 a_77668, f32 b_77669) = {
  {a_77668, b_77669}
}

fun {f32} lifted_32853(f32 x_77670) = {
  {x_77670}
}

fun {f32} lifted_32857(f32 x_77671, f32 y_77672) = {
  let {f32 res_77673} = fsub32(x_77671, y_77672)
  in {res_77673}
}

fun {f32} lifted_32861(f32 x_77674) = {
  {x_77674}
}

fun {f32} lifted_32865(f32 x_77675, f32 y_77676) = {
  let {f32 res_77677} = fsub32(x_77675, y_77676)
  in {res_77677}
}

fun {f32, f32} lifted_32851(f32 a_77678, f32 b_77679, f32 c_77680,
                            f32 d_77681) = {
  let {f32 arg_77682} = lifted_32853(a_77678)
  let {f32 res_77683} = lifted_32857(arg_77682, c_77680)
  let {f32 arg_77684} = lifted_32861(b_77679)
  let {f32 res_77685} = lifted_32865(arg_77684, d_77681)
  in {res_77683, res_77685}
}

fun {f32, f32} lifted_32839(f32 x_77686, f32 x_77687, f32 y_77688,
                            f32 y_77689) = {
  let {f32 arg_77690, f32 arg_77691} = lifted_32843(x_77686, x_77687)
  let {f32 res_77692, f32 res_77693} = lifted_32851(arg_77690, arg_77691,
                                                    y_77688, y_77689)
  in {res_77692, res_77693}
}

fun {f32, f32} lifted_32876(f32 x_77694, f32 x_77695) = {
  {x_77694, x_77695}
}

fun {f32, f32} lifted_32890(f32 a_77696, f32 b_77697) = {
  {a_77696, b_77697}
}

fun {f32} lifted_32900(f32 x_77698) = {
  {x_77698}
}

fun {f32} lifted_32904(f32 x_77699, f32 y_77700) = {
  let {f32 res_77701} = fsub32(x_77699, y_77700)
  in {res_77701}
}

fun {f32} lifted_32908(f32 x_77702) = {
  {x_77702}
}

fun {f32} lifted_32912(f32 x_77703, f32 y_77704) = {
  let {f32 res_77705} = fsub32(x_77703, y_77704)
  in {res_77705}
}

fun {f32, f32} lifted_32898(f32 a_77706, f32 b_77707, f32 c_77708,
                            f32 d_77709) = {
  let {f32 arg_77710} = lifted_32900(a_77706)
  let {f32 res_77711} = lifted_32904(arg_77710, c_77708)
  let {f32 arg_77712} = lifted_32908(b_77707)
  let {f32 res_77713} = lifted_32912(arg_77712, d_77709)
  in {res_77711, res_77713}
}

fun {f32, f32} lifted_32886(f32 x_77714, f32 x_77715, f32 y_77716,
                            f32 y_77717) = {
  let {f32 arg_77718, f32 arg_77719} = lifted_32890(x_77714, x_77715)
  let {f32 res_77720, f32 res_77721} = lifted_32898(arg_77718, arg_77719,
                                                    y_77716, y_77717)
  in {res_77720, res_77721}
}

fun {f32, f32, f32, bool, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32} lifted_32956
(f32 i_77722, f32 i_77723, bool sigma2_77724, f32 sigma2_77725,
 f32 sigma2_77726, f32 sigma2_77727, f32 sigma2_77728, f32 sigma2_77729,
 f32 sigma2_77730, f32 sigma2_77731, f32 sigma2_77732, f32 sigma2_77733,
 f32 sigma2_77734, f32 sigma2_77735, f32 sigma2_77736, f32 sigma2_77737,
 f32 sigma2_77738, f32 sigma2_77739, f32 sigma2_77740, f32 sigma2_77741,
 f32 sigma2_77742, f32 sigma2_77743, f32 sigma2_77744, f32 sigma2_77745,
 f32 sigma2_77746, f32 day_count_fraction_77747) = {
  {day_count_fraction_77747, i_77722, i_77723, sigma2_77724, sigma2_77725,
   sigma2_77726, sigma2_77727, sigma2_77728, sigma2_77729, sigma2_77730,
   sigma2_77731, sigma2_77732, sigma2_77733, sigma2_77734, sigma2_77735,
   sigma2_77736, sigma2_77737, sigma2_77738, sigma2_77739, sigma2_77740,
   sigma2_77741, sigma2_77742, sigma2_77743, sigma2_77744, sigma2_77745,
   sigma2_77746}
}

fun {f32} lifted_33026(f64 x_77748) = {
  let {f32 res_77749} = fpconv f64 x_77748 to f32
  in {res_77749}
}

fun {f32} lifted_33024(f64 x_77750) = {
  let {f32 res_77751} = lifted_33026(x_77750)
  in {res_77751}
}

fun {f32} lifted_33031(f32 x_77752) = {
  {x_77752}
}

fun {f32} lifted_33035(f32 x_77753, f32 y_77754) = {
  let {f32 res_77755} = fmul32(x_77753, y_77754)
  in {res_77755}
}

fun {f32} lifted_33039(f32 x_77756) = {
  {x_77756}
}

fun {f32} lifted_33085(i32 x_77757) = {
  let {f32 res_77758} = sitofp i32 x_77757 to f32
  in {res_77758}
}

fun {f32} lifted_33083(i32 x_77759) = {
  let {f32 res_77760} = lifted_33085(x_77759)
  in {res_77760}
}

fun {f32} lifted_33094(f64 x_77761) = {
  let {f32 res_77762} = fpconv f64 x_77761 to f32
  in {res_77762}
}

fun {f32} lifted_33092(f64 x_77763) = {
  let {f32 res_77764} = lifted_33094(x_77763)
  in {res_77764}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_33137(f32 coeff1_77765, f32 coeff1_77766,
                                           f32 coeff2_77767, f32 coeff2_77768,
                                           f32 etai2_77769, f32 etai2_77770,
                                           f32 etai_77771, f32 etai_77772,
                                           f32 i_77773, f32 i_77774,
                                           f32 kappai_77775, f32 kappai_77776,
                                           f32 one_77777, f32 one_77778,
                                           f32 rho_77779, f32 two_77780,
                                           f32 two_77781, f32 zero_77782,
                                           f32 zero_77783,
                                           f32 day_count_fraction_77784) = {
  {coeff1_77765, coeff1_77766, coeff2_77767, coeff2_77768,
   day_count_fraction_77784, etai2_77769, etai2_77770, etai_77771, etai_77772,
   i_77773, i_77774, kappai_77775, kappai_77776, one_77777, one_77778,
   rho_77779, two_77780, two_77781, zero_77782, zero_77783}
}

fun {f32} lifted_33159(f32 a_77785) = {
  {a_77785}
}

fun {f32, f32} lifted_33163(f32 a_77786, f32 b_77787) = {
  {a_77786, b_77787}
}

fun {f32} lifted_33212(i32 x_77788) = {
  let {f32 res_77789} = sitofp i32 x_77788 to f32
  in {res_77789}
}

fun {f32, f32} lifted_33210(f32 a_77790) = {
  let {f32 res_77791} = lifted_33212(0i32)
  in {a_77790, res_77791}
}

fun {f32, f32} lifted_33224(f32 x_77792, f32 x_77793) = {
  {x_77792, x_77793}
}

fun {f32} lifted_33231(i32 x_77794) = {
  let {f32 res_77795} = sitofp i32 x_77794 to f32
  in {res_77795}
}

fun {f32, f32} lifted_33229(f32 b_77796) = {
  let {f32 res_77797} = lifted_33231(0i32)
  in {res_77797, b_77796}
}

fun {f32, f32} lifted_33240(f32 x_77798, f32 x_77799) = {
  {x_77798, x_77799}
}

fun {f32, f32} lifted_33256(f32 a_77800, f32 b_77801) = {
  {a_77800, b_77801}
}

fun {f32} lifted_33268(f32 x_77802) = {
  {x_77802}
}

fun {f32} lifted_33272(f32 x_77803, f32 y_77804) = {
  let {f32 res_77805} = fmul32(x_77803, y_77804)
  in {res_77805}
}

fun {f32} lifted_33276(f32 x_77806) = {
  {x_77806}
}

fun {f32} lifted_33279(f32 x_77807) = {
  {x_77807}
}

fun {f32} lifted_33283(f32 x_77808, f32 y_77809) = {
  let {f32 res_77810} = fmul32(x_77808, y_77809)
  in {res_77810}
}

fun {f32} lifted_33288(f32 x_77811, f32 y_77812) = {
  let {f32 res_77813} = fsub32(x_77811, y_77812)
  in {res_77813}
}

fun {f32} lifted_33292(f32 x_77814) = {
  {x_77814}
}

fun {f32} lifted_33296(f32 x_77815, f32 y_77816) = {
  let {f32 res_77817} = fmul32(x_77815, y_77816)
  in {res_77817}
}

fun {f32} lifted_33300(f32 x_77818) = {
  {x_77818}
}

fun {f32} lifted_33303(f32 x_77819) = {
  {x_77819}
}

fun {f32} lifted_33307(f32 x_77820, f32 y_77821) = {
  let {f32 res_77822} = fmul32(x_77820, y_77821)
  in {res_77822}
}

fun {f32} lifted_33312(f32 x_77823, f32 y_77824) = {
  let {f32 res_77825} = fadd32(x_77823, y_77824)
  in {res_77825}
}

fun {f32, f32} lifted_33266(f32 a_77826, f32 b_77827, f32 c_77828,
                            f32 d_77829) = {
  let {f32 arg_77830} = lifted_33268(a_77826)
  let {f32 arg_77831} = lifted_33272(arg_77830, c_77828)
  let {f32 arg_77832} = lifted_33276(arg_77831)
  let {f32 arg_77833} = lifted_33279(b_77827)
  let {f32 arg_77834} = lifted_33283(arg_77833, d_77829)
  let {f32 res_77835} = lifted_33288(arg_77832, arg_77834)
  let {f32 arg_77836} = lifted_33292(b_77827)
  let {f32 arg_77837} = lifted_33296(arg_77836, c_77828)
  let {f32 arg_77838} = lifted_33300(arg_77837)
  let {f32 arg_77839} = lifted_33303(a_77826)
  let {f32 arg_77840} = lifted_33307(arg_77839, d_77829)
  let {f32 res_77841} = lifted_33312(arg_77838, arg_77840)
  in {res_77835, res_77841}
}

fun {f32, f32} lifted_33250(f32 x_77842, f32 x_77843, f32 y_77844,
                            f32 y_77845) = {
  let {f32 arg_77846, f32 arg_77847} = lifted_33256(x_77842, x_77843)
  let {f32 res_77848, f32 res_77849} = lifted_33266(arg_77846, arg_77847,
                                                    y_77844, y_77845)
  in {res_77848, res_77849}
}

fun {f32, f32} lifted_33323(f32 x_77850, f32 x_77851) = {
  {x_77850, x_77851}
}

fun {f32, f32} lifted_33339(f32 a_77852, f32 b_77853) = {
  {a_77852, b_77853}
}

fun {f32} lifted_33351(f32 x_77854) = {
  {x_77854}
}

fun {f32} lifted_33355(f32 x_77855, f32 y_77856) = {
  let {f32 res_77857} = fmul32(x_77855, y_77856)
  in {res_77857}
}

fun {f32} lifted_33359(f32 x_77858) = {
  {x_77858}
}

fun {f32} lifted_33362(f32 x_77859) = {
  {x_77859}
}

fun {f32} lifted_33366(f32 x_77860, f32 y_77861) = {
  let {f32 res_77862} = fmul32(x_77860, y_77861)
  in {res_77862}
}

fun {f32} lifted_33371(f32 x_77863, f32 y_77864) = {
  let {f32 res_77865} = fsub32(x_77863, y_77864)
  in {res_77865}
}

fun {f32} lifted_33375(f32 x_77866) = {
  {x_77866}
}

fun {f32} lifted_33379(f32 x_77867, f32 y_77868) = {
  let {f32 res_77869} = fmul32(x_77867, y_77868)
  in {res_77869}
}

fun {f32} lifted_33383(f32 x_77870) = {
  {x_77870}
}

fun {f32} lifted_33386(f32 x_77871) = {
  {x_77871}
}

fun {f32} lifted_33390(f32 x_77872, f32 y_77873) = {
  let {f32 res_77874} = fmul32(x_77872, y_77873)
  in {res_77874}
}

fun {f32} lifted_33395(f32 x_77875, f32 y_77876) = {
  let {f32 res_77877} = fadd32(x_77875, y_77876)
  in {res_77877}
}

fun {f32, f32} lifted_33349(f32 a_77878, f32 b_77879, f32 c_77880,
                            f32 d_77881) = {
  let {f32 arg_77882} = lifted_33351(a_77878)
  let {f32 arg_77883} = lifted_33355(arg_77882, c_77880)
  let {f32 arg_77884} = lifted_33359(arg_77883)
  let {f32 arg_77885} = lifted_33362(b_77879)
  let {f32 arg_77886} = lifted_33366(arg_77885, d_77881)
  let {f32 res_77887} = lifted_33371(arg_77884, arg_77886)
  let {f32 arg_77888} = lifted_33375(b_77879)
  let {f32 arg_77889} = lifted_33379(arg_77888, c_77880)
  let {f32 arg_77890} = lifted_33383(arg_77889)
  let {f32 arg_77891} = lifted_33386(a_77878)
  let {f32 arg_77892} = lifted_33390(arg_77891, d_77881)
  let {f32 res_77893} = lifted_33395(arg_77890, arg_77892)
  in {res_77887, res_77893}
}

fun {f32, f32} lifted_33333(f32 x_77894, f32 x_77895, f32 y_77896,
                            f32 y_77897) = {
  let {f32 arg_77898, f32 arg_77899} = lifted_33339(x_77894, x_77895)
  let {f32 res_77900, f32 res_77901} = lifted_33349(arg_77898, arg_77899,
                                                    y_77896, y_77897)
  in {res_77900, res_77901}
}

fun {f32, f32} lifted_33413(f32 a_77902, f32 b_77903) = {
  {a_77902, b_77903}
}

fun {f32} lifted_33423(f32 x_77904) = {
  {x_77904}
}

fun {f32} lifted_33427(f32 x_77905, f32 y_77906) = {
  let {f32 res_77907} = fsub32(x_77905, y_77906)
  in {res_77907}
}

fun {f32} lifted_33431(f32 x_77908) = {
  {x_77908}
}

fun {f32} lifted_33435(f32 x_77909, f32 y_77910) = {
  let {f32 res_77911} = fsub32(x_77909, y_77910)
  in {res_77911}
}

fun {f32, f32} lifted_33421(f32 a_77912, f32 b_77913, f32 c_77914,
                            f32 d_77915) = {
  let {f32 arg_77916} = lifted_33423(a_77912)
  let {f32 res_77917} = lifted_33427(arg_77916, c_77914)
  let {f32 arg_77918} = lifted_33431(b_77913)
  let {f32 res_77919} = lifted_33435(arg_77918, d_77915)
  in {res_77917, res_77919}
}

fun {f32, f32} lifted_33409(f32 x_77920, f32 x_77921, f32 y_77922,
                            f32 y_77923) = {
  let {f32 arg_77924, f32 arg_77925} = lifted_33413(x_77920, x_77921)
  let {f32 res_77926, f32 res_77927} = lifted_33421(arg_77924, arg_77925,
                                                    y_77922, y_77923)
  in {res_77926, res_77927}
}

fun {f32, f32} lifted_33449(f32 x_77928, f32 x_77929) = {
  {x_77928, x_77929}
}

fun {f32, f32} lifted_33465(f32 a_77930, f32 b_77931) = {
  {a_77930, b_77931}
}

fun {f32} lifted_33477(f32 x_77932) = {
  {x_77932}
}

fun {f32} lifted_33481(f32 x_77933, f32 y_77934) = {
  let {f32 res_77935} = fmul32(x_77933, y_77934)
  in {res_77935}
}

fun {f32} lifted_33485(f32 x_77936) = {
  {x_77936}
}

fun {f32} lifted_33488(f32 x_77937) = {
  {x_77937}
}

fun {f32} lifted_33492(f32 x_77938, f32 y_77939) = {
  let {f32 res_77940} = fmul32(x_77938, y_77939)
  in {res_77940}
}

fun {f32} lifted_33497(f32 x_77941, f32 y_77942) = {
  let {f32 res_77943} = fsub32(x_77941, y_77942)
  in {res_77943}
}

fun {f32} lifted_33501(f32 x_77944) = {
  {x_77944}
}

fun {f32} lifted_33505(f32 x_77945, f32 y_77946) = {
  let {f32 res_77947} = fmul32(x_77945, y_77946)
  in {res_77947}
}

fun {f32} lifted_33509(f32 x_77948) = {
  {x_77948}
}

fun {f32} lifted_33512(f32 x_77949) = {
  {x_77949}
}

fun {f32} lifted_33516(f32 x_77950, f32 y_77951) = {
  let {f32 res_77952} = fmul32(x_77950, y_77951)
  in {res_77952}
}

fun {f32} lifted_33521(f32 x_77953, f32 y_77954) = {
  let {f32 res_77955} = fadd32(x_77953, y_77954)
  in {res_77955}
}

fun {f32, f32} lifted_33475(f32 a_77956, f32 b_77957, f32 c_77958,
                            f32 d_77959) = {
  let {f32 arg_77960} = lifted_33477(a_77956)
  let {f32 arg_77961} = lifted_33481(arg_77960, c_77958)
  let {f32 arg_77962} = lifted_33485(arg_77961)
  let {f32 arg_77963} = lifted_33488(b_77957)
  let {f32 arg_77964} = lifted_33492(arg_77963, d_77959)
  let {f32 res_77965} = lifted_33497(arg_77962, arg_77964)
  let {f32 arg_77966} = lifted_33501(b_77957)
  let {f32 arg_77967} = lifted_33505(arg_77966, c_77958)
  let {f32 arg_77968} = lifted_33509(arg_77967)
  let {f32 arg_77969} = lifted_33512(a_77956)
  let {f32 arg_77970} = lifted_33516(arg_77969, d_77959)
  let {f32 res_77971} = lifted_33521(arg_77968, arg_77970)
  in {res_77965, res_77971}
}

fun {f32, f32} lifted_33459(f32 x_77972, f32 x_77973, f32 y_77974,
                            f32 y_77975) = {
  let {f32 arg_77976, f32 arg_77977} = lifted_33465(x_77972, x_77973)
  let {f32 res_77978, f32 res_77979} = lifted_33475(arg_77976, arg_77977,
                                                    y_77974, y_77975)
  in {res_77978, res_77979}
}

fun {f32, f32} lifted_33532(f32 x_77980, f32 x_77981) = {
  {x_77980, x_77981}
}

fun {f32, f32} lifted_33539(f32 x_77982, f32 x_77983) = {
  {x_77982, x_77983}
}

fun {f32, f32} lifted_33546(f32 x_77984, f32 x_77985) = {
  {x_77984, x_77985}
}

fun {f32, f32} lifted_33553(f32 x_77986, f32 x_77987) = {
  {x_77986, x_77987}
}

fun {f32, f32} lifted_33567(f32 a_77988, f32 b_77989) = {
  {a_77988, b_77989}
}

fun {f32} lifted_33577(f32 x_77990) = {
  {x_77990}
}

fun {f32} lifted_33581(f32 x_77991, f32 y_77992) = {
  let {f32 res_77993} = fadd32(x_77991, y_77992)
  in {res_77993}
}

fun {f32} lifted_33585(f32 x_77994) = {
  {x_77994}
}

fun {f32} lifted_33589(f32 x_77995, f32 y_77996) = {
  let {f32 res_77997} = fadd32(x_77995, y_77996)
  in {res_77997}
}

fun {f32, f32} lifted_33575(f32 a_77998, f32 b_77999, f32 c_78000,
                            f32 d_78001) = {
  let {f32 arg_78002} = lifted_33577(a_77998)
  let {f32 res_78003} = lifted_33581(arg_78002, c_78000)
  let {f32 arg_78004} = lifted_33585(b_77999)
  let {f32 res_78005} = lifted_33589(arg_78004, d_78001)
  in {res_78003, res_78005}
}

fun {f32, f32} lifted_33563(f32 x_78006, f32 x_78007, f32 y_78008,
                            f32 y_78009) = {
  let {f32 arg_78010, f32 arg_78011} = lifted_33567(x_78006, x_78007)
  let {f32 res_78012, f32 res_78013} = lifted_33575(arg_78010, arg_78011,
                                                    y_78008, y_78009)
  in {res_78012, res_78013}
}

fun {f32, f32} lifted_33609(f32 a_78014, f32 b_78015) = {
  {a_78014, b_78015}
}

fun {f32} lifted_33621(f32 x_78016) = {
  {x_78016}
}

fun {f32} lifted_33625(f32 x_78017, f32 y_78018) = {
  let {f32 res_78019} = fmul32(x_78017, y_78018)
  in {res_78019}
}

fun {f32} lifted_33629(f32 x_78020) = {
  {x_78020}
}

fun {f32} lifted_33632(f32 x_78021) = {
  {x_78021}
}

fun {f32} lifted_33636(f32 x_78022, f32 y_78023) = {
  let {f32 res_78024} = fmul32(x_78022, y_78023)
  in {res_78024}
}

fun {f32} lifted_33641(f32 x_78025, f32 y_78026) = {
  let {f32 res_78027} = fsub32(x_78025, y_78026)
  in {res_78027}
}

fun {f32} lifted_33645(f32 x_78028) = {
  {x_78028}
}

fun {f32} lifted_33649(f32 x_78029, f32 y_78030) = {
  let {f32 res_78031} = fmul32(x_78029, y_78030)
  in {res_78031}
}

fun {f32} lifted_33653(f32 x_78032) = {
  {x_78032}
}

fun {f32} lifted_33656(f32 x_78033) = {
  {x_78033}
}

fun {f32} lifted_33660(f32 x_78034, f32 y_78035) = {
  let {f32 res_78036} = fmul32(x_78034, y_78035)
  in {res_78036}
}

fun {f32} lifted_33665(f32 x_78037, f32 y_78038) = {
  let {f32 res_78039} = fadd32(x_78037, y_78038)
  in {res_78039}
}

fun {f32, f32} lifted_33619(f32 a_78040, f32 b_78041, f32 c_78042,
                            f32 d_78043) = {
  let {f32 arg_78044} = lifted_33621(a_78040)
  let {f32 arg_78045} = lifted_33625(arg_78044, c_78042)
  let {f32 arg_78046} = lifted_33629(arg_78045)
  let {f32 arg_78047} = lifted_33632(b_78041)
  let {f32 arg_78048} = lifted_33636(arg_78047, d_78043)
  let {f32 res_78049} = lifted_33641(arg_78046, arg_78048)
  let {f32 arg_78050} = lifted_33645(b_78041)
  let {f32 arg_78051} = lifted_33649(arg_78050, c_78042)
  let {f32 arg_78052} = lifted_33653(arg_78051)
  let {f32 arg_78053} = lifted_33656(a_78040)
  let {f32 arg_78054} = lifted_33660(arg_78053, d_78043)
  let {f32 res_78055} = lifted_33665(arg_78052, arg_78054)
  in {res_78049, res_78055}
}

fun {f32, f32} lifted_33603(f32 x_78056, f32 x_78057, f32 y_78058,
                            f32 y_78059) = {
  let {f32 arg_78060, f32 arg_78061} = lifted_33609(x_78056, x_78057)
  let {f32 res_78062, f32 res_78063} = lifted_33619(arg_78060, arg_78061,
                                                    y_78058, y_78059)
  in {res_78062, res_78063}
}

fun {f32, f32} lifted_33685(f32 a_78064, f32 b_78065) = {
  {a_78064, b_78065}
}

fun {f32} lifted_33697(f32 x_78066) = {
  {x_78066}
}

fun {f32} lifted_33701(f32 x_78067, f32 y_78068) = {
  let {f32 res_78069} = fmul32(x_78067, y_78068)
  in {res_78069}
}

fun {f32} lifted_33705(f32 x_78070) = {
  {x_78070}
}

fun {f32} lifted_33708(f32 x_78071) = {
  {x_78071}
}

fun {f32} lifted_33712(f32 x_78072, f32 y_78073) = {
  let {f32 res_78074} = fmul32(x_78072, y_78073)
  in {res_78074}
}

fun {f32} lifted_33717(f32 x_78075, f32 y_78076) = {
  let {f32 res_78077} = fsub32(x_78075, y_78076)
  in {res_78077}
}

fun {f32} lifted_33721(f32 x_78078) = {
  {x_78078}
}

fun {f32} lifted_33725(f32 x_78079, f32 y_78080) = {
  let {f32 res_78081} = fmul32(x_78079, y_78080)
  in {res_78081}
}

fun {f32} lifted_33729(f32 x_78082) = {
  {x_78082}
}

fun {f32} lifted_33732(f32 x_78083) = {
  {x_78083}
}

fun {f32} lifted_33736(f32 x_78084, f32 y_78085) = {
  let {f32 res_78086} = fmul32(x_78084, y_78085)
  in {res_78086}
}

fun {f32} lifted_33741(f32 x_78087, f32 y_78088) = {
  let {f32 res_78089} = fadd32(x_78087, y_78088)
  in {res_78089}
}

fun {f32, f32} lifted_33695(f32 a_78090, f32 b_78091, f32 c_78092,
                            f32 d_78093) = {
  let {f32 arg_78094} = lifted_33697(a_78090)
  let {f32 arg_78095} = lifted_33701(arg_78094, c_78092)
  let {f32 arg_78096} = lifted_33705(arg_78095)
  let {f32 arg_78097} = lifted_33708(b_78091)
  let {f32 arg_78098} = lifted_33712(arg_78097, d_78093)
  let {f32 res_78099} = lifted_33717(arg_78096, arg_78098)
  let {f32 arg_78100} = lifted_33721(b_78091)
  let {f32 arg_78101} = lifted_33725(arg_78100, c_78092)
  let {f32 arg_78102} = lifted_33729(arg_78101)
  let {f32 arg_78103} = lifted_33732(a_78090)
  let {f32 arg_78104} = lifted_33736(arg_78103, d_78093)
  let {f32 res_78105} = lifted_33741(arg_78102, arg_78104)
  in {res_78099, res_78105}
}

fun {f32, f32} lifted_33679(f32 x_78106, f32 x_78107, f32 y_78108,
                            f32 y_78109) = {
  let {f32 arg_78110, f32 arg_78111} = lifted_33685(x_78106, x_78107)
  let {f32 res_78112, f32 res_78113} = lifted_33695(arg_78110, arg_78111,
                                                    y_78108, y_78109)
  in {res_78112, res_78113}
}

fun {f32, f32} lifted_33759(f32 a_78114, f32 b_78115) = {
  {a_78114, b_78115}
}

fun {f32} lifted_33769(f32 x_78116) = {
  {x_78116}
}

fun {f32} lifted_33773(f32 x_78117, f32 y_78118) = {
  let {f32 res_78119} = fadd32(x_78117, y_78118)
  in {res_78119}
}

fun {f32} lifted_33777(f32 x_78120) = {
  {x_78120}
}

fun {f32} lifted_33781(f32 x_78121, f32 y_78122) = {
  let {f32 res_78123} = fadd32(x_78121, y_78122)
  in {res_78123}
}

fun {f32, f32} lifted_33767(f32 a_78124, f32 b_78125, f32 c_78126,
                            f32 d_78127) = {
  let {f32 arg_78128} = lifted_33769(a_78124)
  let {f32 res_78129} = lifted_33773(arg_78128, c_78126)
  let {f32 arg_78130} = lifted_33777(b_78125)
  let {f32 res_78131} = lifted_33781(arg_78130, d_78127)
  in {res_78129, res_78131}
}

fun {f32, f32} lifted_33755(f32 x_78132, f32 x_78133, f32 y_78134,
                            f32 y_78135) = {
  let {f32 arg_78136, f32 arg_78137} = lifted_33759(x_78132, x_78133)
  let {f32 res_78138, f32 res_78139} = lifted_33767(arg_78136, arg_78137,
                                                    y_78134, y_78135)
  in {res_78138, res_78139}
}

fun {f32} lifted_33800(f32 x_78140) = {
  {x_78140}
}

fun {f32} lifted_33803(f32 x_78141) = {
  {x_78141}
}

fun {f32} lifted_33807(f32 x_78142, f32 y_78143) = {
  let {f32 res_78144} = fmul32(x_78142, y_78143)
  in {res_78144}
}

fun {f32} lifted_33811(f32 x_78145) = {
  {x_78145}
}

fun {f32} lifted_33814(f32 x_78146) = {
  {x_78146}
}

fun {f32} lifted_33818(f32 x_78147, f32 y_78148) = {
  let {f32 res_78149} = fmul32(x_78147, y_78148)
  in {res_78149}
}

fun {f32} lifted_33823(f32 x_78150, f32 y_78151) = {
  let {f32 res_78152} = fadd32(x_78150, y_78151)
  in {res_78152}
}

fun {f32} lifted_33827(f32 x_78153) = {
  let {f32 res_78154} = sqrt32(x_78153)
  in {res_78154}
}

fun {f32} lifted_33832(f32 x_78155, f32 y_78156) = {
  let {f32 res_78157} = fadd32(x_78155, y_78156)
  in {res_78157}
}

fun {f32} lifted_33836(f32 x_78158) = {
  {x_78158}
}

fun {f32} lifted_33839(i32 x_78159) = {
  let {f32 res_78160} = sitofp i32 x_78159 to f32
  in {res_78160}
}

fun {f32} lifted_33844(f32 x_78161, f32 y_78162) = {
  let {f32 res_78163} = fdiv32(x_78161, y_78162)
  in {res_78163}
}

fun {f32} lifted_33848(f32 x_78164) = {
  let {f32 res_78165} = sqrt32(x_78164)
  in {res_78165}
}

fun {f32} lifted_33857(f32 x_78166) = {
  {x_78166}
}

fun {bool} lifted_33861(f32 x_78167, f32 y_78168) = {
  let {bool res_78169} = lt32(x_78167, y_78168)
  in {res_78169}
}

fun {f32} lifted_33866(f32 x_78170) = {
  {x_78170}
}

fun {bool} lifted_33870(f32 x_78171, f32 y_78172) = {
  let {bool res_78173} = eq_f32(x_78171, y_78172)
  in {res_78173}
}

fun {f32} lifted_33855(f32 x_78174) = {
  let {f32 arg_78175} = lifted_33857(x_78174)
  let {bool cond_78176} = lifted_33861(arg_78175, 0.0f32)
  let {f32 res_78177} =
    -- Branch returns: {f32}
    if cond_78176
    then {
      let {f32 res_78178} = fsub32(0.0f32, 1.0f32)
      in {res_78178}
    } else {
      let {f32 arg_78179} = lifted_33866(x_78174)
      let {bool cond_78180} = lifted_33870(arg_78179, 0.0f32)
      let {f32 res_78181} =
        -- Branch returns: {f32}
        if cond_78180
        then {0.0f32} else {1.0f32}
      in {res_78181}
    }
  in {res_78177}
}

fun {i32} lifted_33877(f32 x_78182) = {
  let {i32 res_78183} = fptosi f32 x_78182 to i32
  in {res_78183}
}

fun {f32} lifted_33881(i32 x_78184) = {
  let {f32 res_78185} = sitofp i32 x_78184 to f32
  in {res_78185}
}

fun {f32} lifted_33885(f32 x_78186) = {
  {x_78186}
}

fun {f32} lifted_33888(i32 x_78187) = {
  let {f32 res_78188} = sitofp i32 x_78187 to f32
  in {res_78188}
}

fun {f32} lifted_33892(f32 x_78189) = {
  {x_78189}
}

fun {f32} lifted_33896(f32 x_78190, f32 y_78191) = {
  let {f32 res_78192} = fsub32(x_78190, y_78191)
  in {res_78192}
}

fun {f32} lifted_33900(f32 x_78193) = {
  {x_78193}
}

fun {f32} lifted_33903(f32 x_78194) = {
  {x_78194}
}

fun {f32} lifted_33907(f32 x_78195, f32 y_78196) = {
  let {f32 res_78197} = fmul32(x_78195, y_78196)
  in {res_78197}
}

fun {f32} lifted_33911(f32 x_78198) = {
  {x_78198}
}

fun {f32} lifted_33914(f32 x_78199) = {
  {x_78199}
}

fun {f32} lifted_33918(f32 x_78200, f32 y_78201) = {
  let {f32 res_78202} = fmul32(x_78200, y_78201)
  in {res_78202}
}

fun {f32} lifted_33923(f32 x_78203, f32 y_78204) = {
  let {f32 res_78205} = fadd32(x_78203, y_78204)
  in {res_78205}
}

fun {f32} lifted_33927(f32 x_78206) = {
  let {f32 res_78207} = sqrt32(x_78206)
  in {res_78207}
}

fun {f32} lifted_33932(f32 x_78208, f32 y_78209) = {
  let {f32 res_78210} = fadd32(x_78208, y_78209)
  in {res_78210}
}

fun {f32} lifted_33936(f32 x_78211) = {
  {x_78211}
}

fun {f32} lifted_33939(i32 x_78212) = {
  let {f32 res_78213} = sitofp i32 x_78212 to f32
  in {res_78213}
}

fun {f32} lifted_33944(f32 x_78214, f32 y_78215) = {
  let {f32 res_78216} = fdiv32(x_78214, y_78215)
  in {res_78216}
}

fun {f32} lifted_33948(f32 x_78217) = {
  let {f32 res_78218} = sqrt32(x_78217)
  in {res_78218}
}

fun {f32} lifted_33953(f32 x_78219, f32 y_78220) = {
  let {f32 res_78221} = fmul32(x_78219, y_78220)
  in {res_78221}
}

fun {f32, f32} lifted_33798(f32 a_78222, f32 b_78223) = {
  let {f32 arg_78224} = lifted_33800(a_78222)
  let {f32 arg_78225} = lifted_33803(a_78222)
  let {f32 arg_78226} = lifted_33807(arg_78225, a_78222)
  let {f32 arg_78227} = lifted_33811(arg_78226)
  let {f32 arg_78228} = lifted_33814(b_78223)
  let {f32 arg_78229} = lifted_33818(arg_78228, b_78223)
  let {f32 arg_78230} = lifted_33823(arg_78227, arg_78229)
  let {f32 arg_78231} = lifted_33827(arg_78230)
  let {f32 arg_78232} = lifted_33832(arg_78224, arg_78231)
  let {f32 arg_78233} = lifted_33836(arg_78232)
  let {f32 arg_78234} = lifted_33839(2i32)
  let {f32 arg_78235} = lifted_33844(arg_78233, arg_78234)
  let {f32 res_78236} = lifted_33848(arg_78235)
  let {f32 gamma_78237} = res_78236
  let {f32 arg_78238} = lifted_33855(b_78223)
  let {i32 arg_78239} = lifted_33877(arg_78238)
  let {f32 arg_78240} = lifted_33881(arg_78239)
  let {f32 arg_78241} = lifted_33885(arg_78240)
  let {f32 arg_78242} = lifted_33888(0i32)
  let {f32 arg_78243} = lifted_33892(arg_78242)
  let {f32 arg_78244} = lifted_33896(arg_78243, a_78222)
  let {f32 arg_78245} = lifted_33900(arg_78244)
  let {f32 arg_78246} = lifted_33903(a_78222)
  let {f32 arg_78247} = lifted_33907(arg_78246, a_78222)
  let {f32 arg_78248} = lifted_33911(arg_78247)
  let {f32 arg_78249} = lifted_33914(b_78223)
  let {f32 arg_78250} = lifted_33918(arg_78249, b_78223)
  let {f32 arg_78251} = lifted_33923(arg_78248, arg_78250)
  let {f32 arg_78252} = lifted_33927(arg_78251)
  let {f32 arg_78253} = lifted_33932(arg_78245, arg_78252)
  let {f32 arg_78254} = lifted_33936(arg_78253)
  let {f32 arg_78255} = lifted_33939(2i32)
  let {f32 arg_78256} = lifted_33944(arg_78254, arg_78255)
  let {f32 arg_78257} = lifted_33948(arg_78256)
  let {f32 res_78258} = lifted_33953(arg_78241, arg_78257)
  let {f32 delta_78259} = res_78258
  in {gamma_78237, delta_78259}
}

fun {f32, f32} lifted_33966(f32 x_78260, f32 x_78261) = {
  {x_78260, x_78261}
}

fun {f32, f32} lifted_33980(f32 a_78262, f32 b_78263) = {
  {a_78262, b_78263}
}

fun {f32} lifted_33990(f32 x_78264) = {
  {x_78264}
}

fun {f32} lifted_33994(f32 x_78265, f32 y_78266) = {
  let {f32 res_78267} = fsub32(x_78265, y_78266)
  in {res_78267}
}

fun {f32} lifted_33998(f32 x_78268) = {
  {x_78268}
}

fun {f32} lifted_34002(f32 x_78269, f32 y_78270) = {
  let {f32 res_78271} = fsub32(x_78269, y_78270)
  in {res_78271}
}

fun {f32, f32} lifted_33988(f32 a_78272, f32 b_78273, f32 c_78274,
                            f32 d_78275) = {
  let {f32 arg_78276} = lifted_33990(a_78272)
  let {f32 res_78277} = lifted_33994(arg_78276, c_78274)
  let {f32 arg_78278} = lifted_33998(b_78273)
  let {f32 res_78279} = lifted_34002(arg_78278, d_78275)
  in {res_78277, res_78279}
}

fun {f32, f32} lifted_33976(f32 x_78280, f32 x_78281, f32 y_78282,
                            f32 y_78283) = {
  let {f32 arg_78284, f32 arg_78285} = lifted_33980(x_78280, x_78281)
  let {f32 res_78286, f32 res_78287} = lifted_33988(arg_78284, arg_78285,
                                                    y_78282, y_78283)
  in {res_78286, res_78287}
}

fun {f32, f32} lifted_34016(f32 x_78288, f32 x_78289) = {
  {x_78288, x_78289}
}

fun {f32, f32} lifted_34023(f32 x_78290, f32 x_78291) = {
  {x_78290, x_78291}
}

fun {f32, f32} lifted_34037(f32 a_78292, f32 b_78293) = {
  {a_78292, b_78293}
}

fun {f32} lifted_34047(f32 x_78294) = {
  {x_78294}
}

fun {f32} lifted_34051(f32 x_78295, f32 y_78296) = {
  let {f32 res_78297} = fadd32(x_78295, y_78296)
  in {res_78297}
}

fun {f32} lifted_34055(f32 x_78298) = {
  {x_78298}
}

fun {f32} lifted_34059(f32 x_78299, f32 y_78300) = {
  let {f32 res_78301} = fadd32(x_78299, y_78300)
  in {res_78301}
}

fun {f32, f32} lifted_34045(f32 a_78302, f32 b_78303, f32 c_78304,
                            f32 d_78305) = {
  let {f32 arg_78306} = lifted_34047(a_78302)
  let {f32 res_78307} = lifted_34051(arg_78306, c_78304)
  let {f32 arg_78308} = lifted_34055(b_78303)
  let {f32 res_78309} = lifted_34059(arg_78308, d_78305)
  in {res_78307, res_78309}
}

fun {f32, f32} lifted_34033(f32 x_78310, f32 x_78311, f32 y_78312,
                            f32 y_78313) = {
  let {f32 arg_78314, f32 arg_78315} = lifted_34037(x_78310, x_78311)
  let {f32 res_78316, f32 res_78317} = lifted_34045(arg_78314, arg_78315,
                                                    y_78312, y_78313)
  in {res_78316, res_78317}
}

fun {f32, f32} lifted_34080(f32 a_78318, f32 b_78319) = {
  {a_78318, b_78319}
}

fun {f32} lifted_34093(f32 x_78320) = {
  {x_78320}
}

fun {f32} lifted_34097(f32 x_78321, f32 y_78322) = {
  let {f32 res_78323} = fmul32(x_78321, y_78322)
  in {res_78323}
}

fun {f32} lifted_34101(f32 x_78324) = {
  {x_78324}
}

fun {f32} lifted_34104(f32 x_78325) = {
  {x_78325}
}

fun {f32} lifted_34108(f32 x_78326, f32 y_78327) = {
  let {f32 res_78328} = fmul32(x_78326, y_78327)
  in {res_78328}
}

fun {f32} lifted_34113(f32 x_78329, f32 y_78330) = {
  let {f32 res_78331} = fadd32(x_78329, y_78330)
  in {res_78331}
}

fun {f32} lifted_34117(f32 x_78332) = {
  {x_78332}
}

fun {f32} lifted_34120(f32 x_78333) = {
  {x_78333}
}

fun {f32} lifted_34124(f32 x_78334, f32 y_78335) = {
  let {f32 res_78336} = fmul32(x_78334, y_78335)
  in {res_78336}
}

fun {f32} lifted_34128(f32 x_78337) = {
  {x_78337}
}

fun {f32} lifted_34131(f32 x_78338) = {
  {x_78338}
}

fun {f32} lifted_34135(f32 x_78339, f32 y_78340) = {
  let {f32 res_78341} = fmul32(x_78339, y_78340)
  in {res_78341}
}

fun {f32} lifted_34140(f32 x_78342, f32 y_78343) = {
  let {f32 res_78344} = fadd32(x_78342, y_78343)
  in {res_78344}
}

fun {f32} lifted_34145(f32 x_78345, f32 y_78346) = {
  let {f32 res_78347} = fdiv32(x_78345, y_78346)
  in {res_78347}
}

fun {f32} lifted_34149(f32 x_78348) = {
  {x_78348}
}

fun {f32} lifted_34153(f32 x_78349, f32 y_78350) = {
  let {f32 res_78351} = fmul32(x_78349, y_78350)
  in {res_78351}
}

fun {f32} lifted_34157(f32 x_78352) = {
  {x_78352}
}

fun {f32} lifted_34160(f32 x_78353) = {
  {x_78353}
}

fun {f32} lifted_34164(f32 x_78354, f32 y_78355) = {
  let {f32 res_78356} = fmul32(x_78354, y_78355)
  in {res_78356}
}

fun {f32} lifted_34169(f32 x_78357, f32 y_78358) = {
  let {f32 res_78359} = fsub32(x_78357, y_78358)
  in {res_78359}
}

fun {f32} lifted_34173(f32 x_78360) = {
  {x_78360}
}

fun {f32} lifted_34176(f32 x_78361) = {
  {x_78361}
}

fun {f32} lifted_34180(f32 x_78362, f32 y_78363) = {
  let {f32 res_78364} = fmul32(x_78362, y_78363)
  in {res_78364}
}

fun {f32} lifted_34184(f32 x_78365) = {
  {x_78365}
}

fun {f32} lifted_34187(f32 x_78366) = {
  {x_78366}
}

fun {f32} lifted_34191(f32 x_78367, f32 y_78368) = {
  let {f32 res_78369} = fmul32(x_78367, y_78368)
  in {res_78369}
}

fun {f32} lifted_34196(f32 x_78370, f32 y_78371) = {
  let {f32 res_78372} = fadd32(x_78370, y_78371)
  in {res_78372}
}

fun {f32} lifted_34201(f32 x_78373, f32 y_78374) = {
  let {f32 res_78375} = fdiv32(x_78373, y_78374)
  in {res_78375}
}

fun {f32, f32} lifted_34091(f32 a_78376, f32 b_78377, f32 c_78378,
                            f32 d_78379) = {
  let {f32 arg_78380} = lifted_34093(a_78376)
  let {f32 arg_78381} = lifted_34097(arg_78380, c_78378)
  let {f32 arg_78382} = lifted_34101(arg_78381)
  let {f32 arg_78383} = lifted_34104(b_78377)
  let {f32 arg_78384} = lifted_34108(arg_78383, d_78379)
  let {f32 arg_78385} = lifted_34113(arg_78382, arg_78384)
  let {f32 arg_78386} = lifted_34117(arg_78385)
  let {f32 arg_78387} = lifted_34120(c_78378)
  let {f32 arg_78388} = lifted_34124(arg_78387, c_78378)
  let {f32 arg_78389} = lifted_34128(arg_78388)
  let {f32 arg_78390} = lifted_34131(d_78379)
  let {f32 arg_78391} = lifted_34135(arg_78390, d_78379)
  let {f32 arg_78392} = lifted_34140(arg_78389, arg_78391)
  let {f32 res_78393} = lifted_34145(arg_78386, arg_78392)
  let {f32 arg_78394} = lifted_34149(b_78377)
  let {f32 arg_78395} = lifted_34153(arg_78394, c_78378)
  let {f32 arg_78396} = lifted_34157(arg_78395)
  let {f32 arg_78397} = lifted_34160(a_78376)
  let {f32 arg_78398} = lifted_34164(arg_78397, d_78379)
  let {f32 arg_78399} = lifted_34169(arg_78396, arg_78398)
  let {f32 arg_78400} = lifted_34173(arg_78399)
  let {f32 arg_78401} = lifted_34176(c_78378)
  let {f32 arg_78402} = lifted_34180(arg_78401, c_78378)
  let {f32 arg_78403} = lifted_34184(arg_78402)
  let {f32 arg_78404} = lifted_34187(d_78379)
  let {f32 arg_78405} = lifted_34191(arg_78404, d_78379)
  let {f32 arg_78406} = lifted_34196(arg_78403, arg_78405)
  let {f32 res_78407} = lifted_34201(arg_78400, arg_78406)
  in {res_78393, res_78407}
}

fun {f32, f32} lifted_34073(f32 x_78408, f32 x_78409, f32 y_78410,
                            f32 y_78411) = {
  let {f32 arg_78412, f32 arg_78413} = lifted_34080(x_78408, x_78409)
  let {f32 res_78414, f32 res_78415} = lifted_34091(arg_78412, arg_78413,
                                                    y_78410, y_78411)
  in {res_78414, res_78415}
}

fun {f32, f32} lifted_34215(f32 x_78416, f32 x_78417) = {
  {x_78416, x_78417}
}

fun {f32, f32} lifted_34222(f32 x_78418, f32 x_78419) = {
  {x_78418, x_78419}
}

fun {f32, f32} lifted_34238(f32 a_78420, f32 b_78421) = {
  {a_78420, b_78421}
}

fun {f32} lifted_34250(f32 x_78422) = {
  {x_78422}
}

fun {f32} lifted_34254(f32 x_78423, f32 y_78424) = {
  let {f32 res_78425} = fmul32(x_78423, y_78424)
  in {res_78425}
}

fun {f32} lifted_34258(f32 x_78426) = {
  {x_78426}
}

fun {f32} lifted_34261(f32 x_78427) = {
  {x_78427}
}

fun {f32} lifted_34265(f32 x_78428, f32 y_78429) = {
  let {f32 res_78430} = fmul32(x_78428, y_78429)
  in {res_78430}
}

fun {f32} lifted_34270(f32 x_78431, f32 y_78432) = {
  let {f32 res_78433} = fsub32(x_78431, y_78432)
  in {res_78433}
}

fun {f32} lifted_34274(f32 x_78434) = {
  {x_78434}
}

fun {f32} lifted_34278(f32 x_78435, f32 y_78436) = {
  let {f32 res_78437} = fmul32(x_78435, y_78436)
  in {res_78437}
}

fun {f32} lifted_34282(f32 x_78438) = {
  {x_78438}
}

fun {f32} lifted_34285(f32 x_78439) = {
  {x_78439}
}

fun {f32} lifted_34289(f32 x_78440, f32 y_78441) = {
  let {f32 res_78442} = fmul32(x_78440, y_78441)
  in {res_78442}
}

fun {f32} lifted_34294(f32 x_78443, f32 y_78444) = {
  let {f32 res_78445} = fadd32(x_78443, y_78444)
  in {res_78445}
}

fun {f32, f32} lifted_34248(f32 a_78446, f32 b_78447, f32 c_78448,
                            f32 d_78449) = {
  let {f32 arg_78450} = lifted_34250(a_78446)
  let {f32 arg_78451} = lifted_34254(arg_78450, c_78448)
  let {f32 arg_78452} = lifted_34258(arg_78451)
  let {f32 arg_78453} = lifted_34261(b_78447)
  let {f32 arg_78454} = lifted_34265(arg_78453, d_78449)
  let {f32 res_78455} = lifted_34270(arg_78452, arg_78454)
  let {f32 arg_78456} = lifted_34274(b_78447)
  let {f32 arg_78457} = lifted_34278(arg_78456, c_78448)
  let {f32 arg_78458} = lifted_34282(arg_78457)
  let {f32 arg_78459} = lifted_34285(a_78446)
  let {f32 arg_78460} = lifted_34289(arg_78459, d_78449)
  let {f32 res_78461} = lifted_34294(arg_78458, arg_78460)
  in {res_78455, res_78461}
}

fun {f32, f32} lifted_34232(f32 x_78462, f32 x_78463, f32 y_78464,
                            f32 y_78465) = {
  let {f32 arg_78466, f32 arg_78467} = lifted_34238(x_78462, x_78463)
  let {f32 res_78468, f32 res_78469} = lifted_34248(arg_78466, arg_78467,
                                                    y_78464, y_78465)
  in {res_78468, res_78469}
}

fun {f32, f32} lifted_34312(f32 a_78470, f32 b_78471) = {
  {a_78470, b_78471}
}

fun {f32} lifted_34322(f32 x_78472) = {
  {x_78472}
}

fun {f32} lifted_34326(f32 x_78473, f32 y_78474) = {
  let {f32 res_78475} = fsub32(x_78473, y_78474)
  in {res_78475}
}

fun {f32} lifted_34330(f32 x_78476) = {
  {x_78476}
}

fun {f32} lifted_34334(f32 x_78477, f32 y_78478) = {
  let {f32 res_78479} = fsub32(x_78477, y_78478)
  in {res_78479}
}

fun {f32, f32} lifted_34320(f32 a_78480, f32 b_78481, f32 c_78482,
                            f32 d_78483) = {
  let {f32 arg_78484} = lifted_34322(a_78480)
  let {f32 res_78485} = lifted_34326(arg_78484, c_78482)
  let {f32 arg_78486} = lifted_34330(b_78481)
  let {f32 res_78487} = lifted_34334(arg_78486, d_78483)
  in {res_78485, res_78487}
}

fun {f32, f32} lifted_34308(f32 x_78488, f32 x_78489, f32 y_78490,
                            f32 y_78491) = {
  let {f32 arg_78492, f32 arg_78493} = lifted_34312(x_78488, x_78489)
  let {f32 res_78494, f32 res_78495} = lifted_34320(arg_78492, arg_78493,
                                                    y_78490, y_78491)
  in {res_78494, res_78495}
}

fun {f32} lifted_34350(f32 x_78496) = {
  let {f32 res_78497} = exp32(x_78496)
  in {res_78497}
}

fun {f32} lifted_34355(f32 x_78498) = {
  {x_78498}
}

fun {f32} lifted_34358(f32 x_78499) = {
  let {f32 res_78500} = cos32(x_78499)
  in {res_78500}
}

fun {f32} lifted_34363(f32 x_78501, f32 y_78502) = {
  let {f32 res_78503} = fmul32(x_78501, y_78502)
  in {res_78503}
}

fun {f32} lifted_34367(f32 a_78504) = {
  {a_78504}
}

fun {f32} lifted_34370(f32 x_78505) = {
  {x_78505}
}

fun {f32} lifted_34373(f32 x_78506) = {
  let {f32 res_78507} = sin32(x_78506)
  in {res_78507}
}

fun {f32} lifted_34378(f32 x_78508, f32 y_78509) = {
  let {f32 res_78510} = fmul32(x_78508, y_78509)
  in {res_78510}
}

fun {f32, f32} lifted_34383(f32 a_78511, f32 b_78512) = {
  {a_78511, b_78512}
}

fun {f32, f32} lifted_34348(f32 a_78513, f32 b_78514) = {
  let {f32 res_78515} = lifted_34350(a_78513)
  let {f32 expx_78516} = res_78515
  let {f32 arg_78517} = lifted_34355(expx_78516)
  let {f32 arg_78518} = lifted_34358(b_78514)
  let {f32 arg_78519} = lifted_34363(arg_78517, arg_78518)
  let {f32 arg_78520} = lifted_34367(arg_78519)
  let {f32 arg_78521} = lifted_34370(expx_78516)
  let {f32 arg_78522} = lifted_34373(b_78514)
  let {f32 arg_78523} = lifted_34378(arg_78521, arg_78522)
  let {f32 res_78524, f32 res_78525} = lifted_34383(arg_78520, arg_78523)
  in {res_78524, res_78525}
}

fun {f32, f32} lifted_34395(f32 x_78526, f32 x_78527) = {
  {x_78526, x_78527}
}

fun {f32, f32} lifted_34402(f32 x_78528, f32 x_78529) = {
  {x_78528, x_78529}
}

fun {f32, f32} lifted_34418(f32 a_78530, f32 b_78531) = {
  {a_78530, b_78531}
}

fun {f32} lifted_34430(f32 x_78532) = {
  {x_78532}
}

fun {f32} lifted_34434(f32 x_78533, f32 y_78534) = {
  let {f32 res_78535} = fmul32(x_78533, y_78534)
  in {res_78535}
}

fun {f32} lifted_34438(f32 x_78536) = {
  {x_78536}
}

fun {f32} lifted_34441(f32 x_78537) = {
  {x_78537}
}

fun {f32} lifted_34445(f32 x_78538, f32 y_78539) = {
  let {f32 res_78540} = fmul32(x_78538, y_78539)
  in {res_78540}
}

fun {f32} lifted_34450(f32 x_78541, f32 y_78542) = {
  let {f32 res_78543} = fsub32(x_78541, y_78542)
  in {res_78543}
}

fun {f32} lifted_34454(f32 x_78544) = {
  {x_78544}
}

fun {f32} lifted_34458(f32 x_78545, f32 y_78546) = {
  let {f32 res_78547} = fmul32(x_78545, y_78546)
  in {res_78547}
}

fun {f32} lifted_34462(f32 x_78548) = {
  {x_78548}
}

fun {f32} lifted_34465(f32 x_78549) = {
  {x_78549}
}

fun {f32} lifted_34469(f32 x_78550, f32 y_78551) = {
  let {f32 res_78552} = fmul32(x_78550, y_78551)
  in {res_78552}
}

fun {f32} lifted_34474(f32 x_78553, f32 y_78554) = {
  let {f32 res_78555} = fadd32(x_78553, y_78554)
  in {res_78555}
}

fun {f32, f32} lifted_34428(f32 a_78556, f32 b_78557, f32 c_78558,
                            f32 d_78559) = {
  let {f32 arg_78560} = lifted_34430(a_78556)
  let {f32 arg_78561} = lifted_34434(arg_78560, c_78558)
  let {f32 arg_78562} = lifted_34438(arg_78561)
  let {f32 arg_78563} = lifted_34441(b_78557)
  let {f32 arg_78564} = lifted_34445(arg_78563, d_78559)
  let {f32 res_78565} = lifted_34450(arg_78562, arg_78564)
  let {f32 arg_78566} = lifted_34454(b_78557)
  let {f32 arg_78567} = lifted_34458(arg_78566, c_78558)
  let {f32 arg_78568} = lifted_34462(arg_78567)
  let {f32 arg_78569} = lifted_34465(a_78556)
  let {f32 arg_78570} = lifted_34469(arg_78569, d_78559)
  let {f32 res_78571} = lifted_34474(arg_78568, arg_78570)
  in {res_78565, res_78571}
}

fun {f32, f32} lifted_34412(f32 x_78572, f32 x_78573, f32 y_78574,
                            f32 y_78575) = {
  let {f32 arg_78576, f32 arg_78577} = lifted_34418(x_78572, x_78573)
  let {f32 res_78578, f32 res_78579} = lifted_34428(arg_78576, arg_78577,
                                                    y_78574, y_78575)
  in {res_78578, res_78579}
}

fun {f32, f32} lifted_34485(f32 x_78580, f32 x_78581) = {
  {x_78580, x_78581}
}

fun {f32, f32} lifted_34492(f32 x_78582, f32 x_78583) = {
  {x_78582, x_78583}
}

fun {f32, f32} lifted_34499(f32 x_78584, f32 x_78585) = {
  {x_78584, x_78585}
}

fun {f32, f32} lifted_34506(f32 x_78586, f32 x_78587) = {
  {x_78586, x_78587}
}

fun {f32, f32} lifted_34522(f32 a_78588, f32 b_78589) = {
  {a_78588, b_78589}
}

fun {f32} lifted_34534(f32 x_78590) = {
  {x_78590}
}

fun {f32} lifted_34538(f32 x_78591, f32 y_78592) = {
  let {f32 res_78593} = fmul32(x_78591, y_78592)
  in {res_78593}
}

fun {f32} lifted_34542(f32 x_78594) = {
  {x_78594}
}

fun {f32} lifted_34545(f32 x_78595) = {
  {x_78595}
}

fun {f32} lifted_34549(f32 x_78596, f32 y_78597) = {
  let {f32 res_78598} = fmul32(x_78596, y_78597)
  in {res_78598}
}

fun {f32} lifted_34554(f32 x_78599, f32 y_78600) = {
  let {f32 res_78601} = fsub32(x_78599, y_78600)
  in {res_78601}
}

fun {f32} lifted_34558(f32 x_78602) = {
  {x_78602}
}

fun {f32} lifted_34562(f32 x_78603, f32 y_78604) = {
  let {f32 res_78605} = fmul32(x_78603, y_78604)
  in {res_78605}
}

fun {f32} lifted_34566(f32 x_78606) = {
  {x_78606}
}

fun {f32} lifted_34569(f32 x_78607) = {
  {x_78607}
}

fun {f32} lifted_34573(f32 x_78608, f32 y_78609) = {
  let {f32 res_78610} = fmul32(x_78608, y_78609)
  in {res_78610}
}

fun {f32} lifted_34578(f32 x_78611, f32 y_78612) = {
  let {f32 res_78613} = fadd32(x_78611, y_78612)
  in {res_78613}
}

fun {f32, f32} lifted_34532(f32 a_78614, f32 b_78615, f32 c_78616,
                            f32 d_78617) = {
  let {f32 arg_78618} = lifted_34534(a_78614)
  let {f32 arg_78619} = lifted_34538(arg_78618, c_78616)
  let {f32 arg_78620} = lifted_34542(arg_78619)
  let {f32 arg_78621} = lifted_34545(b_78615)
  let {f32 arg_78622} = lifted_34549(arg_78621, d_78617)
  let {f32 res_78623} = lifted_34554(arg_78620, arg_78622)
  let {f32 arg_78624} = lifted_34558(b_78615)
  let {f32 arg_78625} = lifted_34562(arg_78624, c_78616)
  let {f32 arg_78626} = lifted_34566(arg_78625)
  let {f32 arg_78627} = lifted_34569(a_78614)
  let {f32 arg_78628} = lifted_34573(arg_78627, d_78617)
  let {f32 res_78629} = lifted_34578(arg_78626, arg_78628)
  in {res_78623, res_78629}
}

fun {f32, f32} lifted_34516(f32 x_78630, f32 x_78631, f32 y_78632,
                            f32 y_78633) = {
  let {f32 arg_78634, f32 arg_78635} = lifted_34522(x_78630, x_78631)
  let {f32 res_78636, f32 res_78637} = lifted_34532(arg_78634, arg_78635,
                                                    y_78632, y_78633)
  in {res_78636, res_78637}
}

fun {f32, f32} lifted_34596(f32 a_78638, f32 b_78639) = {
  {a_78638, b_78639}
}

fun {f32} lifted_34606(f32 x_78640) = {
  {x_78640}
}

fun {f32} lifted_34610(f32 x_78641, f32 y_78642) = {
  let {f32 res_78643} = fsub32(x_78641, y_78642)
  in {res_78643}
}

fun {f32} lifted_34614(f32 x_78644) = {
  {x_78644}
}

fun {f32} lifted_34618(f32 x_78645, f32 y_78646) = {
  let {f32 res_78647} = fsub32(x_78645, y_78646)
  in {res_78647}
}

fun {f32, f32} lifted_34604(f32 a_78648, f32 b_78649, f32 c_78650,
                            f32 d_78651) = {
  let {f32 arg_78652} = lifted_34606(a_78648)
  let {f32 res_78653} = lifted_34610(arg_78652, c_78650)
  let {f32 arg_78654} = lifted_34614(b_78649)
  let {f32 res_78655} = lifted_34618(arg_78654, d_78651)
  in {res_78653, res_78655}
}

fun {f32, f32} lifted_34592(f32 x_78656, f32 x_78657, f32 y_78658,
                            f32 y_78659) = {
  let {f32 arg_78660, f32 arg_78661} = lifted_34596(x_78656, x_78657)
  let {f32 res_78662, f32 res_78663} = lifted_34604(arg_78660, arg_78661,
                                                    y_78658, y_78659)
  in {res_78662, res_78663}
}

fun {f32, f32} lifted_34629(f32 x_78664, f32 x_78665) = {
  {x_78664, x_78665}
}

fun {f32, f32} lifted_34636(f32 x_78666, f32 x_78667) = {
  {x_78666, x_78667}
}

fun {f32, f32} lifted_34650(f32 a_78668, f32 b_78669) = {
  {a_78668, b_78669}
}

fun {f32} lifted_34660(f32 x_78670) = {
  {x_78670}
}

fun {f32} lifted_34664(f32 x_78671, f32 y_78672) = {
  let {f32 res_78673} = fsub32(x_78671, y_78672)
  in {res_78673}
}

fun {f32} lifted_34668(f32 x_78674) = {
  {x_78674}
}

fun {f32} lifted_34672(f32 x_78675, f32 y_78676) = {
  let {f32 res_78677} = fsub32(x_78675, y_78676)
  in {res_78677}
}

fun {f32, f32} lifted_34658(f32 a_78678, f32 b_78679, f32 c_78680,
                            f32 d_78681) = {
  let {f32 arg_78682} = lifted_34660(a_78678)
  let {f32 res_78683} = lifted_34664(arg_78682, c_78680)
  let {f32 arg_78684} = lifted_34668(b_78679)
  let {f32 res_78685} = lifted_34672(arg_78684, d_78681)
  in {res_78683, res_78685}
}

fun {f32, f32} lifted_34646(f32 x_78686, f32 x_78687, f32 y_78688,
                            f32 y_78689) = {
  let {f32 arg_78690, f32 arg_78691} = lifted_34650(x_78686, x_78687)
  let {f32 res_78692, f32 res_78693} = lifted_34658(arg_78690, arg_78691,
                                                    y_78688, y_78689)
  in {res_78692, res_78693}
}

fun {f32, f32} lifted_34693(f32 a_78694, f32 b_78695) = {
  {a_78694, b_78695}
}

fun {f32} lifted_34706(f32 x_78696) = {
  {x_78696}
}

fun {f32} lifted_34710(f32 x_78697, f32 y_78698) = {
  let {f32 res_78699} = fmul32(x_78697, y_78698)
  in {res_78699}
}

fun {f32} lifted_34714(f32 x_78700) = {
  {x_78700}
}

fun {f32} lifted_34717(f32 x_78701) = {
  {x_78701}
}

fun {f32} lifted_34721(f32 x_78702, f32 y_78703) = {
  let {f32 res_78704} = fmul32(x_78702, y_78703)
  in {res_78704}
}

fun {f32} lifted_34726(f32 x_78705, f32 y_78706) = {
  let {f32 res_78707} = fadd32(x_78705, y_78706)
  in {res_78707}
}

fun {f32} lifted_34730(f32 x_78708) = {
  {x_78708}
}

fun {f32} lifted_34733(f32 x_78709) = {
  {x_78709}
}

fun {f32} lifted_34737(f32 x_78710, f32 y_78711) = {
  let {f32 res_78712} = fmul32(x_78710, y_78711)
  in {res_78712}
}

fun {f32} lifted_34741(f32 x_78713) = {
  {x_78713}
}

fun {f32} lifted_34744(f32 x_78714) = {
  {x_78714}
}

fun {f32} lifted_34748(f32 x_78715, f32 y_78716) = {
  let {f32 res_78717} = fmul32(x_78715, y_78716)
  in {res_78717}
}

fun {f32} lifted_34753(f32 x_78718, f32 y_78719) = {
  let {f32 res_78720} = fadd32(x_78718, y_78719)
  in {res_78720}
}

fun {f32} lifted_34758(f32 x_78721, f32 y_78722) = {
  let {f32 res_78723} = fdiv32(x_78721, y_78722)
  in {res_78723}
}

fun {f32} lifted_34762(f32 x_78724) = {
  {x_78724}
}

fun {f32} lifted_34766(f32 x_78725, f32 y_78726) = {
  let {f32 res_78727} = fmul32(x_78725, y_78726)
  in {res_78727}
}

fun {f32} lifted_34770(f32 x_78728) = {
  {x_78728}
}

fun {f32} lifted_34773(f32 x_78729) = {
  {x_78729}
}

fun {f32} lifted_34777(f32 x_78730, f32 y_78731) = {
  let {f32 res_78732} = fmul32(x_78730, y_78731)
  in {res_78732}
}

fun {f32} lifted_34782(f32 x_78733, f32 y_78734) = {
  let {f32 res_78735} = fsub32(x_78733, y_78734)
  in {res_78735}
}

fun {f32} lifted_34786(f32 x_78736) = {
  {x_78736}
}

fun {f32} lifted_34789(f32 x_78737) = {
  {x_78737}
}

fun {f32} lifted_34793(f32 x_78738, f32 y_78739) = {
  let {f32 res_78740} = fmul32(x_78738, y_78739)
  in {res_78740}
}

fun {f32} lifted_34797(f32 x_78741) = {
  {x_78741}
}

fun {f32} lifted_34800(f32 x_78742) = {
  {x_78742}
}

fun {f32} lifted_34804(f32 x_78743, f32 y_78744) = {
  let {f32 res_78745} = fmul32(x_78743, y_78744)
  in {res_78745}
}

fun {f32} lifted_34809(f32 x_78746, f32 y_78747) = {
  let {f32 res_78748} = fadd32(x_78746, y_78747)
  in {res_78748}
}

fun {f32} lifted_34814(f32 x_78749, f32 y_78750) = {
  let {f32 res_78751} = fdiv32(x_78749, y_78750)
  in {res_78751}
}

fun {f32, f32} lifted_34704(f32 a_78752, f32 b_78753, f32 c_78754,
                            f32 d_78755) = {
  let {f32 arg_78756} = lifted_34706(a_78752)
  let {f32 arg_78757} = lifted_34710(arg_78756, c_78754)
  let {f32 arg_78758} = lifted_34714(arg_78757)
  let {f32 arg_78759} = lifted_34717(b_78753)
  let {f32 arg_78760} = lifted_34721(arg_78759, d_78755)
  let {f32 arg_78761} = lifted_34726(arg_78758, arg_78760)
  let {f32 arg_78762} = lifted_34730(arg_78761)
  let {f32 arg_78763} = lifted_34733(c_78754)
  let {f32 arg_78764} = lifted_34737(arg_78763, c_78754)
  let {f32 arg_78765} = lifted_34741(arg_78764)
  let {f32 arg_78766} = lifted_34744(d_78755)
  let {f32 arg_78767} = lifted_34748(arg_78766, d_78755)
  let {f32 arg_78768} = lifted_34753(arg_78765, arg_78767)
  let {f32 res_78769} = lifted_34758(arg_78762, arg_78768)
  let {f32 arg_78770} = lifted_34762(b_78753)
  let {f32 arg_78771} = lifted_34766(arg_78770, c_78754)
  let {f32 arg_78772} = lifted_34770(arg_78771)
  let {f32 arg_78773} = lifted_34773(a_78752)
  let {f32 arg_78774} = lifted_34777(arg_78773, d_78755)
  let {f32 arg_78775} = lifted_34782(arg_78772, arg_78774)
  let {f32 arg_78776} = lifted_34786(arg_78775)
  let {f32 arg_78777} = lifted_34789(c_78754)
  let {f32 arg_78778} = lifted_34793(arg_78777, c_78754)
  let {f32 arg_78779} = lifted_34797(arg_78778)
  let {f32 arg_78780} = lifted_34800(d_78755)
  let {f32 arg_78781} = lifted_34804(arg_78780, d_78755)
  let {f32 arg_78782} = lifted_34809(arg_78779, arg_78781)
  let {f32 res_78783} = lifted_34814(arg_78776, arg_78782)
  in {res_78769, res_78783}
}

fun {f32, f32} lifted_34686(f32 x_78784, f32 x_78785, f32 y_78786,
                            f32 y_78787) = {
  let {f32 arg_78788, f32 arg_78789} = lifted_34693(x_78784, x_78785)
  let {f32 res_78790, f32 res_78791} = lifted_34704(arg_78788, arg_78789,
                                                    y_78786, y_78787)
  in {res_78790, res_78791}
}

fun {f32} lifted_34836(f32 x_78792) = {
  {x_78792}
}

fun {f32} lifted_34840(f32 x_78793, f32 y_78794) = {
  let {f32 res_78795} = fmul32(x_78793, y_78794)
  in {res_78795}
}

fun {f32} lifted_34844(f32 x_78796) = {
  {x_78796}
}

fun {f32} lifted_34847(f32 x_78797) = {
  {x_78797}
}

fun {f32} lifted_34851(f32 x_78798, f32 y_78799) = {
  let {f32 res_78800} = fmul32(x_78798, y_78799)
  in {res_78800}
}

fun {f32} lifted_34856(f32 x_78801, f32 y_78802) = {
  let {f32 res_78803} = fadd32(x_78801, y_78802)
  in {res_78803}
}

fun {f32} lifted_34860(f32 x_78804) = {
  let {f32 res_78805} = sqrt32(x_78804)
  in {res_78805}
}

fun {f32} lifted_34834(f32 a_78806, f32 b_78807) = {
  let {f32 arg_78808} = lifted_34836(a_78806)
  let {f32 arg_78809} = lifted_34840(arg_78808, a_78806)
  let {f32 arg_78810} = lifted_34844(arg_78809)
  let {f32 arg_78811} = lifted_34847(b_78807)
  let {f32 arg_78812} = lifted_34851(arg_78811, b_78807)
  let {f32 arg_78813} = lifted_34856(arg_78810, arg_78812)
  let {f32 res_78814} = lifted_34860(arg_78813)
  in {res_78814}
}

fun {f32} lifted_34865(f32 x_78815) = {
  let {f32 res_78816} = log32(x_78815)
  in {res_78816}
}

fun {f32} lifted_34869(f32 a_78817) = {
  {a_78817}
}

fun {f32} lifted_34876(f32 x_78818) = {
  {x_78818}
}

fun {f32} lifted_34880(f32 x_78819, f32 y_78820) = {
  let {f32 res_78821} = atan2_32(x_78819, y_78820)
  in {res_78821}
}

fun {f32} lifted_34874(f32 a_78822, f32 b_78823) = {
  let {f32 arg_78824} = lifted_34876(b_78823)
  let {f32 res_78825} = lifted_34880(arg_78824, a_78822)
  in {res_78825}
}

fun {f32, f32} lifted_34886(f32 a_78826, f32 b_78827) = {
  {a_78826, b_78827}
}

fun {f32, f32} lifted_34828(f32 z_78828, f32 z_78829) = {
  let {f32 arg_78830} = lifted_34834(z_78828, z_78829)
  let {f32 arg_78831} = lifted_34865(arg_78830)
  let {f32 arg_78832} = lifted_34869(arg_78831)
  let {f32 arg_78833} = lifted_34874(z_78828, z_78829)
  let {f32 res_78834, f32 res_78835} = lifted_34886(arg_78832, arg_78833)
  in {res_78834, res_78835}
}

fun {f32, f32} lifted_34904(f32 a_78836, f32 b_78837) = {
  {a_78836, b_78837}
}

fun {f32} lifted_34916(f32 x_78838) = {
  {x_78838}
}

fun {f32} lifted_34920(f32 x_78839, f32 y_78840) = {
  let {f32 res_78841} = fmul32(x_78839, y_78840)
  in {res_78841}
}

fun {f32} lifted_34924(f32 x_78842) = {
  {x_78842}
}

fun {f32} lifted_34927(f32 x_78843) = {
  {x_78843}
}

fun {f32} lifted_34931(f32 x_78844, f32 y_78845) = {
  let {f32 res_78846} = fmul32(x_78844, y_78845)
  in {res_78846}
}

fun {f32} lifted_34936(f32 x_78847, f32 y_78848) = {
  let {f32 res_78849} = fsub32(x_78847, y_78848)
  in {res_78849}
}

fun {f32} lifted_34940(f32 x_78850) = {
  {x_78850}
}

fun {f32} lifted_34944(f32 x_78851, f32 y_78852) = {
  let {f32 res_78853} = fmul32(x_78851, y_78852)
  in {res_78853}
}

fun {f32} lifted_34948(f32 x_78854) = {
  {x_78854}
}

fun {f32} lifted_34951(f32 x_78855) = {
  {x_78855}
}

fun {f32} lifted_34955(f32 x_78856, f32 y_78857) = {
  let {f32 res_78858} = fmul32(x_78856, y_78857)
  in {res_78858}
}

fun {f32} lifted_34960(f32 x_78859, f32 y_78860) = {
  let {f32 res_78861} = fadd32(x_78859, y_78860)
  in {res_78861}
}

fun {f32, f32} lifted_34914(f32 a_78862, f32 b_78863, f32 c_78864,
                            f32 d_78865) = {
  let {f32 arg_78866} = lifted_34916(a_78862)
  let {f32 arg_78867} = lifted_34920(arg_78866, c_78864)
  let {f32 arg_78868} = lifted_34924(arg_78867)
  let {f32 arg_78869} = lifted_34927(b_78863)
  let {f32 arg_78870} = lifted_34931(arg_78869, d_78865)
  let {f32 res_78871} = lifted_34936(arg_78868, arg_78870)
  let {f32 arg_78872} = lifted_34940(b_78863)
  let {f32 arg_78873} = lifted_34944(arg_78872, c_78864)
  let {f32 arg_78874} = lifted_34948(arg_78873)
  let {f32 arg_78875} = lifted_34951(a_78862)
  let {f32 arg_78876} = lifted_34955(arg_78875, d_78865)
  let {f32 res_78877} = lifted_34960(arg_78874, arg_78876)
  in {res_78871, res_78877}
}

fun {f32, f32} lifted_34898(f32 x_78878, f32 x_78879, f32 y_78880,
                            f32 y_78881) = {
  let {f32 arg_78882, f32 arg_78883} = lifted_34904(x_78878, x_78879)
  let {f32 res_78884, f32 res_78885} = lifted_34914(arg_78882, arg_78883,
                                                    y_78880, y_78881)
  in {res_78884, res_78885}
}

fun {f32, f32} lifted_34978(f32 a_78886, f32 b_78887) = {
  {a_78886, b_78887}
}

fun {f32} lifted_34988(f32 x_78888) = {
  {x_78888}
}

fun {f32} lifted_34992(f32 x_78889, f32 y_78890) = {
  let {f32 res_78891} = fsub32(x_78889, y_78890)
  in {res_78891}
}

fun {f32} lifted_34996(f32 x_78892) = {
  {x_78892}
}

fun {f32} lifted_35000(f32 x_78893, f32 y_78894) = {
  let {f32 res_78895} = fsub32(x_78893, y_78894)
  in {res_78895}
}

fun {f32, f32} lifted_34986(f32 a_78896, f32 b_78897, f32 c_78898,
                            f32 d_78899) = {
  let {f32 arg_78900} = lifted_34988(a_78896)
  let {f32 res_78901} = lifted_34992(arg_78900, c_78898)
  let {f32 arg_78902} = lifted_34996(b_78897)
  let {f32 res_78903} = lifted_35000(arg_78902, d_78899)
  in {res_78901, res_78903}
}

fun {f32, f32} lifted_34974(f32 x_78904, f32 x_78905, f32 y_78906,
                            f32 y_78907) = {
  let {f32 arg_78908, f32 arg_78909} = lifted_34978(x_78904, x_78905)
  let {f32 res_78910, f32 res_78911} = lifted_34986(arg_78908, arg_78909,
                                                    y_78906, y_78907)
  in {res_78910, res_78911}
}

fun {f32, f32} lifted_35020(f32 a_78912, f32 b_78913) = {
  {a_78912, b_78913}
}

fun {f32} lifted_35032(f32 x_78914) = {
  {x_78914}
}

fun {f32} lifted_35036(f32 x_78915, f32 y_78916) = {
  let {f32 res_78917} = fmul32(x_78915, y_78916)
  in {res_78917}
}

fun {f32} lifted_35040(f32 x_78918) = {
  {x_78918}
}

fun {f32} lifted_35043(f32 x_78919) = {
  {x_78919}
}

fun {f32} lifted_35047(f32 x_78920, f32 y_78921) = {
  let {f32 res_78922} = fmul32(x_78920, y_78921)
  in {res_78922}
}

fun {f32} lifted_35052(f32 x_78923, f32 y_78924) = {
  let {f32 res_78925} = fsub32(x_78923, y_78924)
  in {res_78925}
}

fun {f32} lifted_35056(f32 x_78926) = {
  {x_78926}
}

fun {f32} lifted_35060(f32 x_78927, f32 y_78928) = {
  let {f32 res_78929} = fmul32(x_78927, y_78928)
  in {res_78929}
}

fun {f32} lifted_35064(f32 x_78930) = {
  {x_78930}
}

fun {f32} lifted_35067(f32 x_78931) = {
  {x_78931}
}

fun {f32} lifted_35071(f32 x_78932, f32 y_78933) = {
  let {f32 res_78934} = fmul32(x_78932, y_78933)
  in {res_78934}
}

fun {f32} lifted_35076(f32 x_78935, f32 y_78936) = {
  let {f32 res_78937} = fadd32(x_78935, y_78936)
  in {res_78937}
}

fun {f32, f32} lifted_35030(f32 a_78938, f32 b_78939, f32 c_78940,
                            f32 d_78941) = {
  let {f32 arg_78942} = lifted_35032(a_78938)
  let {f32 arg_78943} = lifted_35036(arg_78942, c_78940)
  let {f32 arg_78944} = lifted_35040(arg_78943)
  let {f32 arg_78945} = lifted_35043(b_78939)
  let {f32 arg_78946} = lifted_35047(arg_78945, d_78941)
  let {f32 res_78947} = lifted_35052(arg_78944, arg_78946)
  let {f32 arg_78948} = lifted_35056(b_78939)
  let {f32 arg_78949} = lifted_35060(arg_78948, c_78940)
  let {f32 arg_78950} = lifted_35064(arg_78949)
  let {f32 arg_78951} = lifted_35067(a_78938)
  let {f32 arg_78952} = lifted_35071(arg_78951, d_78941)
  let {f32 res_78953} = lifted_35076(arg_78950, arg_78952)
  in {res_78947, res_78953}
}

fun {f32, f32} lifted_35014(f32 x_78954, f32 x_78955, f32 y_78956,
                            f32 y_78957) = {
  let {f32 arg_78958, f32 arg_78959} = lifted_35020(x_78954, x_78955)
  let {f32 res_78960, f32 res_78961} = lifted_35030(arg_78958, arg_78959,
                                                    y_78956, y_78957)
  in {res_78960, res_78961}
}

fun {f32, f32} lifted_35087(f32 x_78962, f32 x_78963) = {
  {x_78962, x_78963}
}

fun {f32, f32} lifted_35094(f32 x_78964, f32 x_78965) = {
  {x_78964, x_78965}
}

fun {f32, f32} lifted_35110(f32 a_78966, f32 b_78967) = {
  {a_78966, b_78967}
}

fun {f32} lifted_35122(f32 x_78968) = {
  {x_78968}
}

fun {f32} lifted_35126(f32 x_78969, f32 y_78970) = {
  let {f32 res_78971} = fmul32(x_78969, y_78970)
  in {res_78971}
}

fun {f32} lifted_35130(f32 x_78972) = {
  {x_78972}
}

fun {f32} lifted_35133(f32 x_78973) = {
  {x_78973}
}

fun {f32} lifted_35137(f32 x_78974, f32 y_78975) = {
  let {f32 res_78976} = fmul32(x_78974, y_78975)
  in {res_78976}
}

fun {f32} lifted_35142(f32 x_78977, f32 y_78978) = {
  let {f32 res_78979} = fsub32(x_78977, y_78978)
  in {res_78979}
}

fun {f32} lifted_35146(f32 x_78980) = {
  {x_78980}
}

fun {f32} lifted_35150(f32 x_78981, f32 y_78982) = {
  let {f32 res_78983} = fmul32(x_78981, y_78982)
  in {res_78983}
}

fun {f32} lifted_35154(f32 x_78984) = {
  {x_78984}
}

fun {f32} lifted_35157(f32 x_78985) = {
  {x_78985}
}

fun {f32} lifted_35161(f32 x_78986, f32 y_78987) = {
  let {f32 res_78988} = fmul32(x_78986, y_78987)
  in {res_78988}
}

fun {f32} lifted_35166(f32 x_78989, f32 y_78990) = {
  let {f32 res_78991} = fadd32(x_78989, y_78990)
  in {res_78991}
}

fun {f32, f32} lifted_35120(f32 a_78992, f32 b_78993, f32 c_78994,
                            f32 d_78995) = {
  let {f32 arg_78996} = lifted_35122(a_78992)
  let {f32 arg_78997} = lifted_35126(arg_78996, c_78994)
  let {f32 arg_78998} = lifted_35130(arg_78997)
  let {f32 arg_78999} = lifted_35133(b_78993)
  let {f32 arg_79000} = lifted_35137(arg_78999, d_78995)
  let {f32 res_79001} = lifted_35142(arg_78998, arg_79000)
  let {f32 arg_79002} = lifted_35146(b_78993)
  let {f32 arg_79003} = lifted_35150(arg_79002, c_78994)
  let {f32 arg_79004} = lifted_35154(arg_79003)
  let {f32 arg_79005} = lifted_35157(a_78992)
  let {f32 arg_79006} = lifted_35161(arg_79005, d_78995)
  let {f32 res_79007} = lifted_35166(arg_79004, arg_79006)
  in {res_79001, res_79007}
}

fun {f32, f32} lifted_35104(f32 x_79008, f32 x_79009, f32 y_79010,
                            f32 y_79011) = {
  let {f32 arg_79012, f32 arg_79013} = lifted_35110(x_79008, x_79009)
  let {f32 res_79014, f32 res_79015} = lifted_35120(arg_79012, arg_79013,
                                                    y_79010, y_79011)
  in {res_79014, res_79015}
}

fun {f32, f32} lifted_35177(f32 x_79016, f32 x_79017) = {
  {x_79016, x_79017}
}

fun {f32, f32} lifted_35184(f32 x_79018, f32 x_79019) = {
  {x_79018, x_79019}
}

fun {f32, f32} lifted_35198(f32 a_79020, f32 b_79021) = {
  {a_79020, b_79021}
}

fun {f32} lifted_35208(f32 x_79022) = {
  {x_79022}
}

fun {f32} lifted_35212(f32 x_79023, f32 y_79024) = {
  let {f32 res_79025} = fsub32(x_79023, y_79024)
  in {res_79025}
}

fun {f32} lifted_35216(f32 x_79026) = {
  {x_79026}
}

fun {f32} lifted_35220(f32 x_79027, f32 y_79028) = {
  let {f32 res_79029} = fsub32(x_79027, y_79028)
  in {res_79029}
}

fun {f32, f32} lifted_35206(f32 a_79030, f32 b_79031, f32 c_79032,
                            f32 d_79033) = {
  let {f32 arg_79034} = lifted_35208(a_79030)
  let {f32 res_79035} = lifted_35212(arg_79034, c_79032)
  let {f32 arg_79036} = lifted_35216(b_79031)
  let {f32 res_79037} = lifted_35220(arg_79036, d_79033)
  in {res_79035, res_79037}
}

fun {f32, f32} lifted_35194(f32 x_79038, f32 x_79039, f32 y_79040,
                            f32 y_79041) = {
  let {f32 arg_79042, f32 arg_79043} = lifted_35198(x_79038, x_79039)
  let {f32 res_79044, f32 res_79045} = lifted_35206(arg_79042, arg_79043,
                                                    y_79040, y_79041)
  in {res_79044, res_79045}
}

fun {f32, f32} lifted_35240(f32 a_79046, f32 b_79047) = {
  {a_79046, b_79047}
}

fun {f32} lifted_35252(f32 x_79048) = {
  {x_79048}
}

fun {f32} lifted_35256(f32 x_79049, f32 y_79050) = {
  let {f32 res_79051} = fmul32(x_79049, y_79050)
  in {res_79051}
}

fun {f32} lifted_35260(f32 x_79052) = {
  {x_79052}
}

fun {f32} lifted_35263(f32 x_79053) = {
  {x_79053}
}

fun {f32} lifted_35267(f32 x_79054, f32 y_79055) = {
  let {f32 res_79056} = fmul32(x_79054, y_79055)
  in {res_79056}
}

fun {f32} lifted_35272(f32 x_79057, f32 y_79058) = {
  let {f32 res_79059} = fsub32(x_79057, y_79058)
  in {res_79059}
}

fun {f32} lifted_35276(f32 x_79060) = {
  {x_79060}
}

fun {f32} lifted_35280(f32 x_79061, f32 y_79062) = {
  let {f32 res_79063} = fmul32(x_79061, y_79062)
  in {res_79063}
}

fun {f32} lifted_35284(f32 x_79064) = {
  {x_79064}
}

fun {f32} lifted_35287(f32 x_79065) = {
  {x_79065}
}

fun {f32} lifted_35291(f32 x_79066, f32 y_79067) = {
  let {f32 res_79068} = fmul32(x_79066, y_79067)
  in {res_79068}
}

fun {f32} lifted_35296(f32 x_79069, f32 y_79070) = {
  let {f32 res_79071} = fadd32(x_79069, y_79070)
  in {res_79071}
}

fun {f32, f32} lifted_35250(f32 a_79072, f32 b_79073, f32 c_79074,
                            f32 d_79075) = {
  let {f32 arg_79076} = lifted_35252(a_79072)
  let {f32 arg_79077} = lifted_35256(arg_79076, c_79074)
  let {f32 arg_79078} = lifted_35260(arg_79077)
  let {f32 arg_79079} = lifted_35263(b_79073)
  let {f32 arg_79080} = lifted_35267(arg_79079, d_79075)
  let {f32 res_79081} = lifted_35272(arg_79078, arg_79080)
  let {f32 arg_79082} = lifted_35276(b_79073)
  let {f32 arg_79083} = lifted_35280(arg_79082, c_79074)
  let {f32 arg_79084} = lifted_35284(arg_79083)
  let {f32 arg_79085} = lifted_35287(a_79072)
  let {f32 arg_79086} = lifted_35291(arg_79085, d_79075)
  let {f32 res_79087} = lifted_35296(arg_79084, arg_79086)
  in {res_79081, res_79087}
}

fun {f32, f32} lifted_35234(f32 x_79088, f32 x_79089, f32 y_79090,
                            f32 y_79091) = {
  let {f32 arg_79092, f32 arg_79093} = lifted_35240(x_79088, x_79089)
  let {f32 res_79094, f32 res_79095} = lifted_35250(arg_79092, arg_79093,
                                                    y_79090, y_79091)
  in {res_79094, res_79095}
}

fun {f32, f32} lifted_35307(f32 x_79096, f32 x_79097) = {
  {x_79096, x_79097}
}

fun {f32, f32} lifted_35314(f32 x_79098, f32 x_79099) = {
  {x_79098, x_79099}
}

fun {f32, f32} lifted_35321(f32 x_79100, f32 x_79101) = {
  {x_79100, x_79101}
}

fun {f32, f32} lifted_35337(f32 a_79102, f32 b_79103) = {
  {a_79102, b_79103}
}

fun {f32} lifted_35349(f32 x_79104) = {
  {x_79104}
}

fun {f32} lifted_35353(f32 x_79105, f32 y_79106) = {
  let {f32 res_79107} = fmul32(x_79105, y_79106)
  in {res_79107}
}

fun {f32} lifted_35357(f32 x_79108) = {
  {x_79108}
}

fun {f32} lifted_35360(f32 x_79109) = {
  {x_79109}
}

fun {f32} lifted_35364(f32 x_79110, f32 y_79111) = {
  let {f32 res_79112} = fmul32(x_79110, y_79111)
  in {res_79112}
}

fun {f32} lifted_35369(f32 x_79113, f32 y_79114) = {
  let {f32 res_79115} = fsub32(x_79113, y_79114)
  in {res_79115}
}

fun {f32} lifted_35373(f32 x_79116) = {
  {x_79116}
}

fun {f32} lifted_35377(f32 x_79117, f32 y_79118) = {
  let {f32 res_79119} = fmul32(x_79117, y_79118)
  in {res_79119}
}

fun {f32} lifted_35381(f32 x_79120) = {
  {x_79120}
}

fun {f32} lifted_35384(f32 x_79121) = {
  {x_79121}
}

fun {f32} lifted_35388(f32 x_79122, f32 y_79123) = {
  let {f32 res_79124} = fmul32(x_79122, y_79123)
  in {res_79124}
}

fun {f32} lifted_35393(f32 x_79125, f32 y_79126) = {
  let {f32 res_79127} = fadd32(x_79125, y_79126)
  in {res_79127}
}

fun {f32, f32} lifted_35347(f32 a_79128, f32 b_79129, f32 c_79130,
                            f32 d_79131) = {
  let {f32 arg_79132} = lifted_35349(a_79128)
  let {f32 arg_79133} = lifted_35353(arg_79132, c_79130)
  let {f32 arg_79134} = lifted_35357(arg_79133)
  let {f32 arg_79135} = lifted_35360(b_79129)
  let {f32 arg_79136} = lifted_35364(arg_79135, d_79131)
  let {f32 res_79137} = lifted_35369(arg_79134, arg_79136)
  let {f32 arg_79138} = lifted_35373(b_79129)
  let {f32 arg_79139} = lifted_35377(arg_79138, c_79130)
  let {f32 arg_79140} = lifted_35381(arg_79139)
  let {f32 arg_79141} = lifted_35384(a_79128)
  let {f32 arg_79142} = lifted_35388(arg_79141, d_79131)
  let {f32 res_79143} = lifted_35393(arg_79140, arg_79142)
  in {res_79137, res_79143}
}

fun {f32, f32} lifted_35331(f32 x_79144, f32 x_79145, f32 y_79146,
                            f32 y_79147) = {
  let {f32 arg_79148, f32 arg_79149} = lifted_35337(x_79144, x_79145)
  let {f32 res_79150, f32 res_79151} = lifted_35347(arg_79148, arg_79149,
                                                    y_79146, y_79147)
  in {res_79150, res_79151}
}

fun {f32, f32} lifted_35411(f32 a_79152, f32 b_79153) = {
  {a_79152, b_79153}
}

fun {f32} lifted_35421(f32 x_79154) = {
  {x_79154}
}

fun {f32} lifted_35425(f32 x_79155, f32 y_79156) = {
  let {f32 res_79157} = fsub32(x_79155, y_79156)
  in {res_79157}
}

fun {f32} lifted_35429(f32 x_79158) = {
  {x_79158}
}

fun {f32} lifted_35433(f32 x_79159, f32 y_79160) = {
  let {f32 res_79161} = fsub32(x_79159, y_79160)
  in {res_79161}
}

fun {f32, f32} lifted_35419(f32 a_79162, f32 b_79163, f32 c_79164,
                            f32 d_79165) = {
  let {f32 arg_79166} = lifted_35421(a_79162)
  let {f32 res_79167} = lifted_35425(arg_79166, c_79164)
  let {f32 arg_79168} = lifted_35429(b_79163)
  let {f32 res_79169} = lifted_35433(arg_79168, d_79165)
  in {res_79167, res_79169}
}

fun {f32, f32} lifted_35407(f32 x_79170, f32 x_79171, f32 y_79172,
                            f32 y_79173) = {
  let {f32 arg_79174, f32 arg_79175} = lifted_35411(x_79170, x_79171)
  let {f32 res_79176, f32 res_79177} = lifted_35419(arg_79174, arg_79175,
                                                    y_79172, y_79173)
  in {res_79176, res_79177}
}

fun {f32, f32} lifted_35454(f32 a_79178, f32 b_79179) = {
  {a_79178, b_79179}
}

fun {f32} lifted_35467(f32 x_79180) = {
  {x_79180}
}

fun {f32} lifted_35471(f32 x_79181, f32 y_79182) = {
  let {f32 res_79183} = fmul32(x_79181, y_79182)
  in {res_79183}
}

fun {f32} lifted_35475(f32 x_79184) = {
  {x_79184}
}

fun {f32} lifted_35478(f32 x_79185) = {
  {x_79185}
}

fun {f32} lifted_35482(f32 x_79186, f32 y_79187) = {
  let {f32 res_79188} = fmul32(x_79186, y_79187)
  in {res_79188}
}

fun {f32} lifted_35487(f32 x_79189, f32 y_79190) = {
  let {f32 res_79191} = fadd32(x_79189, y_79190)
  in {res_79191}
}

fun {f32} lifted_35491(f32 x_79192) = {
  {x_79192}
}

fun {f32} lifted_35494(f32 x_79193) = {
  {x_79193}
}

fun {f32} lifted_35498(f32 x_79194, f32 y_79195) = {
  let {f32 res_79196} = fmul32(x_79194, y_79195)
  in {res_79196}
}

fun {f32} lifted_35502(f32 x_79197) = {
  {x_79197}
}

fun {f32} lifted_35505(f32 x_79198) = {
  {x_79198}
}

fun {f32} lifted_35509(f32 x_79199, f32 y_79200) = {
  let {f32 res_79201} = fmul32(x_79199, y_79200)
  in {res_79201}
}

fun {f32} lifted_35514(f32 x_79202, f32 y_79203) = {
  let {f32 res_79204} = fadd32(x_79202, y_79203)
  in {res_79204}
}

fun {f32} lifted_35519(f32 x_79205, f32 y_79206) = {
  let {f32 res_79207} = fdiv32(x_79205, y_79206)
  in {res_79207}
}

fun {f32} lifted_35523(f32 x_79208) = {
  {x_79208}
}

fun {f32} lifted_35527(f32 x_79209, f32 y_79210) = {
  let {f32 res_79211} = fmul32(x_79209, y_79210)
  in {res_79211}
}

fun {f32} lifted_35531(f32 x_79212) = {
  {x_79212}
}

fun {f32} lifted_35534(f32 x_79213) = {
  {x_79213}
}

fun {f32} lifted_35538(f32 x_79214, f32 y_79215) = {
  let {f32 res_79216} = fmul32(x_79214, y_79215)
  in {res_79216}
}

fun {f32} lifted_35543(f32 x_79217, f32 y_79218) = {
  let {f32 res_79219} = fsub32(x_79217, y_79218)
  in {res_79219}
}

fun {f32} lifted_35547(f32 x_79220) = {
  {x_79220}
}

fun {f32} lifted_35550(f32 x_79221) = {
  {x_79221}
}

fun {f32} lifted_35554(f32 x_79222, f32 y_79223) = {
  let {f32 res_79224} = fmul32(x_79222, y_79223)
  in {res_79224}
}

fun {f32} lifted_35558(f32 x_79225) = {
  {x_79225}
}

fun {f32} lifted_35561(f32 x_79226) = {
  {x_79226}
}

fun {f32} lifted_35565(f32 x_79227, f32 y_79228) = {
  let {f32 res_79229} = fmul32(x_79227, y_79228)
  in {res_79229}
}

fun {f32} lifted_35570(f32 x_79230, f32 y_79231) = {
  let {f32 res_79232} = fadd32(x_79230, y_79231)
  in {res_79232}
}

fun {f32} lifted_35575(f32 x_79233, f32 y_79234) = {
  let {f32 res_79235} = fdiv32(x_79233, y_79234)
  in {res_79235}
}

fun {f32, f32} lifted_35465(f32 a_79236, f32 b_79237, f32 c_79238,
                            f32 d_79239) = {
  let {f32 arg_79240} = lifted_35467(a_79236)
  let {f32 arg_79241} = lifted_35471(arg_79240, c_79238)
  let {f32 arg_79242} = lifted_35475(arg_79241)
  let {f32 arg_79243} = lifted_35478(b_79237)
  let {f32 arg_79244} = lifted_35482(arg_79243, d_79239)
  let {f32 arg_79245} = lifted_35487(arg_79242, arg_79244)
  let {f32 arg_79246} = lifted_35491(arg_79245)
  let {f32 arg_79247} = lifted_35494(c_79238)
  let {f32 arg_79248} = lifted_35498(arg_79247, c_79238)
  let {f32 arg_79249} = lifted_35502(arg_79248)
  let {f32 arg_79250} = lifted_35505(d_79239)
  let {f32 arg_79251} = lifted_35509(arg_79250, d_79239)
  let {f32 arg_79252} = lifted_35514(arg_79249, arg_79251)
  let {f32 res_79253} = lifted_35519(arg_79246, arg_79252)
  let {f32 arg_79254} = lifted_35523(b_79237)
  let {f32 arg_79255} = lifted_35527(arg_79254, c_79238)
  let {f32 arg_79256} = lifted_35531(arg_79255)
  let {f32 arg_79257} = lifted_35534(a_79236)
  let {f32 arg_79258} = lifted_35538(arg_79257, d_79239)
  let {f32 arg_79259} = lifted_35543(arg_79256, arg_79258)
  let {f32 arg_79260} = lifted_35547(arg_79259)
  let {f32 arg_79261} = lifted_35550(c_79238)
  let {f32 arg_79262} = lifted_35554(arg_79261, c_79238)
  let {f32 arg_79263} = lifted_35558(arg_79262)
  let {f32 arg_79264} = lifted_35561(d_79239)
  let {f32 arg_79265} = lifted_35565(arg_79264, d_79239)
  let {f32 arg_79266} = lifted_35570(arg_79263, arg_79265)
  let {f32 res_79267} = lifted_35575(arg_79260, arg_79266)
  in {res_79253, res_79267}
}

fun {f32, f32} lifted_35447(f32 x_79268, f32 x_79269, f32 y_79270,
                            f32 y_79271) = {
  let {f32 arg_79272, f32 arg_79273} = lifted_35454(x_79268, x_79269)
  let {f32 res_79274, f32 res_79275} = lifted_35465(arg_79272, arg_79273,
                                                    y_79270, y_79271)
  in {res_79274, res_79275}
}

fun {f32, f32} lifted_35593(f32 a_79276, f32 b_79277) = {
  {a_79276, b_79277}
}

fun {f32} lifted_35603(f32 x_79278) = {
  {x_79278}
}

fun {f32} lifted_35607(f32 x_79279, f32 y_79280) = {
  let {f32 res_79281} = fadd32(x_79279, y_79280)
  in {res_79281}
}

fun {f32} lifted_35611(f32 x_79282) = {
  {x_79282}
}

fun {f32} lifted_35615(f32 x_79283, f32 y_79284) = {
  let {f32 res_79285} = fadd32(x_79283, y_79284)
  in {res_79285}
}

fun {f32, f32} lifted_35601(f32 a_79286, f32 b_79287, f32 c_79288,
                            f32 d_79289) = {
  let {f32 arg_79290} = lifted_35603(a_79286)
  let {f32 res_79291} = lifted_35607(arg_79290, c_79288)
  let {f32 arg_79292} = lifted_35611(b_79287)
  let {f32 res_79293} = lifted_35615(arg_79292, d_79289)
  in {res_79291, res_79293}
}

fun {f32, f32} lifted_35589(f32 x_79294, f32 x_79295, f32 y_79296,
                            f32 y_79297) = {
  let {f32 arg_79298, f32 arg_79299} = lifted_35593(x_79294, x_79295)
  let {f32 res_79300, f32 res_79301} = lifted_35601(arg_79298, arg_79299,
                                                    y_79296, y_79297)
  in {res_79300, res_79301}
}

fun {f32} lifted_35631(f32 x_79302) = {
  let {f32 res_79303} = exp32(x_79302)
  in {res_79303}
}

fun {f32} lifted_35636(f32 x_79304) = {
  {x_79304}
}

fun {f32} lifted_35639(f32 x_79305) = {
  let {f32 res_79306} = cos32(x_79305)
  in {res_79306}
}

fun {f32} lifted_35644(f32 x_79307, f32 y_79308) = {
  let {f32 res_79309} = fmul32(x_79307, y_79308)
  in {res_79309}
}

fun {f32} lifted_35648(f32 a_79310) = {
  {a_79310}
}

fun {f32} lifted_35651(f32 x_79311) = {
  {x_79311}
}

fun {f32} lifted_35654(f32 x_79312) = {
  let {f32 res_79313} = sin32(x_79312)
  in {res_79313}
}

fun {f32} lifted_35659(f32 x_79314, f32 y_79315) = {
  let {f32 res_79316} = fmul32(x_79314, y_79315)
  in {res_79316}
}

fun {f32, f32} lifted_35664(f32 a_79317, f32 b_79318) = {
  {a_79317, b_79318}
}

fun {f32, f32} lifted_35629(f32 a_79319, f32 b_79320) = {
  let {f32 res_79321} = lifted_35631(a_79319)
  let {f32 expx_79322} = res_79321
  let {f32 arg_79323} = lifted_35636(expx_79322)
  let {f32 arg_79324} = lifted_35639(b_79320)
  let {f32 arg_79325} = lifted_35644(arg_79323, arg_79324)
  let {f32 arg_79326} = lifted_35648(arg_79325)
  let {f32 arg_79327} = lifted_35651(expx_79322)
  let {f32 arg_79328} = lifted_35654(b_79320)
  let {f32 arg_79329} = lifted_35659(arg_79327, arg_79328)
  let {f32 res_79330, f32 res_79331} = lifted_35664(arg_79326, arg_79329)
  in {res_79330, res_79331}
}

fun {f32, f32} lifted_33207(f32 coeff1_79332, f32 coeff1_79333,
                            f32 coeff2_79334, f32 coeff2_79335,
                            f32 day_count_fraction_79336, f32 etai2_79337,
                            f32 etai2_79338, f32 etai_79339, f32 etai_79340,
                            f32 i_79341, f32 i_79342, f32 kappai_79343,
                            f32 kappai_79344, f32 one_79345, f32 one_79346,
                            f32 rho_79347, f32 two_79348, f32 two_79349,
                            f32 zero_79350, f32 zero_79351, f32 xi_79352,
                            f32 xi_79353) = {
  let {f32 res_79354, f32 res_79355} = lifted_33210(day_count_fraction_79336)
  let {f32 ti_79356} = res_79354
  let {f32 ti_79357} = res_79355
  let {f32 arg_79358, f32 arg_79359} = lifted_33224(kappai_79343, kappai_79344)
  let {f32 arg_79360, f32 arg_79361} = lifted_33229(rho_79347)
  let {f32 arg_79362, f32 arg_79363} = lifted_33240(arg_79360, arg_79361)
  let {f32 arg_79364, f32 arg_79365} = lifted_33250(arg_79362, arg_79363,
                                                    etai_79339, etai_79340)
  let {f32 arg_79366, f32 arg_79367} = lifted_33323(arg_79364, arg_79365)
  let {f32 arg_79368, f32 arg_79369} = lifted_33333(arg_79366, arg_79367,
                                                    xi_79352, xi_79353)
  let {f32 res_79370, f32 res_79371} = lifted_33409(arg_79358, arg_79359,
                                                    arg_79368, arg_79369)
  let {f32 d0_79372} = res_79370
  let {f32 d0_79373} = res_79371
  let {f32 arg_79374, f32 arg_79375} = lifted_33449(d0_79372, d0_79373)
  let {f32 arg_79376, f32 arg_79377} = lifted_33459(arg_79374, arg_79375,
                                                    d0_79372, d0_79373)
  let {f32 arg_79378, f32 arg_79379} = lifted_33532(arg_79376, arg_79377)
  let {f32 arg_79380, f32 arg_79381} = lifted_33539(etai2_79337, etai2_79338)
  let {f32 arg_79382, f32 arg_79383} = lifted_33546(xi_79352, xi_79353)
  let {f32 arg_79384, f32 arg_79385} = lifted_33553(i_79341, i_79342)
  let {f32 arg_79386, f32 arg_79387} = lifted_33563(arg_79384, arg_79385,
                                                    xi_79352, xi_79353)
  let {f32 arg_79388, f32 arg_79389} = lifted_33603(arg_79382, arg_79383,
                                                    arg_79386, arg_79387)
  let {f32 arg_79390, f32 arg_79391} = lifted_33679(arg_79380, arg_79381,
                                                    arg_79388, arg_79389)
  let {f32 arg_79392, f32 arg_79393} = lifted_33755(arg_79378, arg_79379,
                                                    arg_79390, arg_79391)
  let {f32 res_79394, f32 res_79395} = lifted_33798(arg_79392, arg_79393)
  let {f32 d_79396} = res_79394
  let {f32 d_79397} = res_79395
  let {f32 arg_79398, f32 arg_79399} = lifted_33966(d0_79372, d0_79373)
  let {f32 res_79400, f32 res_79401} = lifted_33976(arg_79398, arg_79399,
                                                    d_79396, d_79397)
  let {f32 a_minus_79402} = res_79400
  let {f32 a_minus_79403} = res_79401
  let {f32 arg_79404, f32 arg_79405} = lifted_34016(a_minus_79402,
                                                    a_minus_79403)
  let {f32 arg_79406, f32 arg_79407} = lifted_34023(d0_79372, d0_79373)
  let {f32 arg_79408, f32 arg_79409} = lifted_34033(arg_79406, arg_79407,
                                                    d_79396, d_79397)
  let {f32 res_79410, f32 res_79411} = lifted_34073(arg_79404, arg_79405,
                                                    arg_79408, arg_79409)
  let {f32 g_79412} = res_79410
  let {f32 g_79413} = res_79411
  let {f32 arg_79414, f32 arg_79415} = lifted_34215(zero_79350, zero_79351)
  let {f32 arg_79416, f32 arg_79417} = lifted_34222(d_79396, d_79397)
  let {f32 arg_79418, f32 arg_79419} = lifted_34232(arg_79416, arg_79417,
                                                    ti_79356, ti_79357)
  let {f32 arg_79420, f32 arg_79421} = lifted_34308(arg_79414, arg_79415,
                                                    arg_79418, arg_79419)
  let {f32 res_79422, f32 res_79423} = lifted_34348(arg_79420, arg_79421)
  let {f32 e_79424} = res_79422
  let {f32 e_79425} = res_79423
  let {f32 arg_79426, f32 arg_79427} = lifted_34395(coeff1_79332, coeff1_79333)
  let {f32 arg_79428, f32 arg_79429} = lifted_34402(a_minus_79402,
                                                    a_minus_79403)
  let {f32 arg_79430, f32 arg_79431} = lifted_34412(arg_79428, arg_79429,
                                                    ti_79356, ti_79357)
  let {f32 arg_79432, f32 arg_79433} = lifted_34485(arg_79430, arg_79431)
  let {f32 arg_79434, f32 arg_79435} = lifted_34492(two_79348, two_79349)
  let {f32 arg_79436, f32 arg_79437} = lifted_34499(one_79345, one_79346)
  let {f32 arg_79438, f32 arg_79439} = lifted_34506(g_79412, g_79413)
  let {f32 arg_79440, f32 arg_79441} = lifted_34516(arg_79438, arg_79439,
                                                    e_79424, e_79425)
  let {f32 arg_79442, f32 arg_79443} = lifted_34592(arg_79436, arg_79437,
                                                    arg_79440, arg_79441)
  let {f32 arg_79444, f32 arg_79445} = lifted_34629(arg_79442, arg_79443)
  let {f32 arg_79446, f32 arg_79447} = lifted_34636(one_79345, one_79346)
  let {f32 arg_79448, f32 arg_79449} = lifted_34646(arg_79446, arg_79447,
                                                    g_79412, g_79413)
  let {f32 arg_79450, f32 arg_79451} = lifted_34686(arg_79444, arg_79445,
                                                    arg_79448, arg_79449)
  let {f32 arg_79452, f32 arg_79453} = lifted_34828(arg_79450, arg_79451)
  let {f32 arg_79454, f32 arg_79455} = lifted_34898(arg_79434, arg_79435,
                                                    arg_79452, arg_79453)
  let {f32 arg_79456, f32 arg_79457} = lifted_34974(arg_79432, arg_79433,
                                                    arg_79454, arg_79455)
  let {f32 arg_79458, f32 arg_79459} = lifted_35014(arg_79426, arg_79427,
                                                    arg_79456, arg_79457)
  let {f32 arg_79460, f32 arg_79461} = lifted_35087(arg_79458, arg_79459)
  let {f32 arg_79462, f32 arg_79463} = lifted_35094(coeff2_79334, coeff2_79335)
  let {f32 arg_79464, f32 arg_79465} = lifted_35104(arg_79462, arg_79463,
                                                    a_minus_79402,
                                                    a_minus_79403)
  let {f32 arg_79466, f32 arg_79467} = lifted_35177(arg_79464, arg_79465)
  let {f32 arg_79468, f32 arg_79469} = lifted_35184(one_79345, one_79346)
  let {f32 arg_79470, f32 arg_79471} = lifted_35194(arg_79468, arg_79469,
                                                    e_79424, e_79425)
  let {f32 arg_79472, f32 arg_79473} = lifted_35234(arg_79466, arg_79467,
                                                    arg_79470, arg_79471)
  let {f32 arg_79474, f32 arg_79475} = lifted_35307(arg_79472, arg_79473)
  let {f32 arg_79476, f32 arg_79477} = lifted_35314(one_79345, one_79346)
  let {f32 arg_79478, f32 arg_79479} = lifted_35321(g_79412, g_79413)
  let {f32 arg_79480, f32 arg_79481} = lifted_35331(arg_79478, arg_79479,
                                                    e_79424, e_79425)
  let {f32 arg_79482, f32 arg_79483} = lifted_35407(arg_79476, arg_79477,
                                                    arg_79480, arg_79481)
  let {f32 arg_79484, f32 arg_79485} = lifted_35447(arg_79474, arg_79475,
                                                    arg_79482, arg_79483)
  let {f32 arg_79486, f32 arg_79487} = lifted_35589(arg_79460, arg_79461,
                                                    arg_79484, arg_79485)
  let {f32 res_79488, f32 res_79489} = lifted_35629(arg_79486, arg_79487)
  in {res_79488, res_79489}
}

fun {f32, f32} lifted_35675(f32 x_79490, f32 x_79491) = {
  {x_79490, x_79491}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_35716(f32 coeff1_79492, f32 coeff1_79493,
                                           f32 coeff2_79494, f32 coeff2_79495,
                                           f32 etai2_79496, f32 etai2_79497,
                                           f32 etai_79498, f32 etai_79499,
                                           f32 i_79500, f32 i_79501,
                                           f32 kappai_79502, f32 kappai_79503,
                                           f32 one_79504, f32 one_79505,
                                           f32 rho_79506, f32 two_79507,
                                           f32 two_79508, f32 zero_79509,
                                           f32 zero_79510,
                                           f32 day_count_fraction_79511) = {
  {coeff1_79492, coeff1_79493, coeff2_79494, coeff2_79495,
   day_count_fraction_79511, etai2_79496, etai2_79497, etai_79498, etai_79499,
   i_79500, i_79501, kappai_79502, kappai_79503, one_79504, one_79505,
   rho_79506, two_79507, two_79508, zero_79509, zero_79510}
}

fun {f32} lifted_35738(f32 x_79512) = {
  let {f32 res_79513} = fsub32(0.0f32, x_79512)
  in {res_79513}
}

fun {f32} lifted_35742(f32 a_79514) = {
  {a_79514}
}

fun {f32, f32} lifted_35746(f32 a_79515, f32 b_79516) = {
  {a_79515, b_79516}
}

fun {f32} lifted_35795(i32 x_79517) = {
  let {f32 res_79518} = sitofp i32 x_79517 to f32
  in {res_79518}
}

fun {f32, f32} lifted_35793(f32 a_79519) = {
  let {f32 res_79520} = lifted_35795(0i32)
  in {a_79519, res_79520}
}

fun {f32, f32} lifted_35807(f32 x_79521, f32 x_79522) = {
  {x_79521, x_79522}
}

fun {f32} lifted_35814(i32 x_79523) = {
  let {f32 res_79524} = sitofp i32 x_79523 to f32
  in {res_79524}
}

fun {f32, f32} lifted_35812(f32 b_79525) = {
  let {f32 res_79526} = lifted_35814(0i32)
  in {res_79526, b_79525}
}

fun {f32, f32} lifted_35823(f32 x_79527, f32 x_79528) = {
  {x_79527, x_79528}
}

fun {f32, f32} lifted_35839(f32 a_79529, f32 b_79530) = {
  {a_79529, b_79530}
}

fun {f32} lifted_35851(f32 x_79531) = {
  {x_79531}
}

fun {f32} lifted_35855(f32 x_79532, f32 y_79533) = {
  let {f32 res_79534} = fmul32(x_79532, y_79533)
  in {res_79534}
}

fun {f32} lifted_35859(f32 x_79535) = {
  {x_79535}
}

fun {f32} lifted_35862(f32 x_79536) = {
  {x_79536}
}

fun {f32} lifted_35866(f32 x_79537, f32 y_79538) = {
  let {f32 res_79539} = fmul32(x_79537, y_79538)
  in {res_79539}
}

fun {f32} lifted_35871(f32 x_79540, f32 y_79541) = {
  let {f32 res_79542} = fsub32(x_79540, y_79541)
  in {res_79542}
}

fun {f32} lifted_35875(f32 x_79543) = {
  {x_79543}
}

fun {f32} lifted_35879(f32 x_79544, f32 y_79545) = {
  let {f32 res_79546} = fmul32(x_79544, y_79545)
  in {res_79546}
}

fun {f32} lifted_35883(f32 x_79547) = {
  {x_79547}
}

fun {f32} lifted_35886(f32 x_79548) = {
  {x_79548}
}

fun {f32} lifted_35890(f32 x_79549, f32 y_79550) = {
  let {f32 res_79551} = fmul32(x_79549, y_79550)
  in {res_79551}
}

fun {f32} lifted_35895(f32 x_79552, f32 y_79553) = {
  let {f32 res_79554} = fadd32(x_79552, y_79553)
  in {res_79554}
}

fun {f32, f32} lifted_35849(f32 a_79555, f32 b_79556, f32 c_79557,
                            f32 d_79558) = {
  let {f32 arg_79559} = lifted_35851(a_79555)
  let {f32 arg_79560} = lifted_35855(arg_79559, c_79557)
  let {f32 arg_79561} = lifted_35859(arg_79560)
  let {f32 arg_79562} = lifted_35862(b_79556)
  let {f32 arg_79563} = lifted_35866(arg_79562, d_79558)
  let {f32 res_79564} = lifted_35871(arg_79561, arg_79563)
  let {f32 arg_79565} = lifted_35875(b_79556)
  let {f32 arg_79566} = lifted_35879(arg_79565, c_79557)
  let {f32 arg_79567} = lifted_35883(arg_79566)
  let {f32 arg_79568} = lifted_35886(a_79555)
  let {f32 arg_79569} = lifted_35890(arg_79568, d_79558)
  let {f32 res_79570} = lifted_35895(arg_79567, arg_79569)
  in {res_79564, res_79570}
}

fun {f32, f32} lifted_35833(f32 x_79571, f32 x_79572, f32 y_79573,
                            f32 y_79574) = {
  let {f32 arg_79575, f32 arg_79576} = lifted_35839(x_79571, x_79572)
  let {f32 res_79577, f32 res_79578} = lifted_35849(arg_79575, arg_79576,
                                                    y_79573, y_79574)
  in {res_79577, res_79578}
}

fun {f32, f32} lifted_35906(f32 x_79579, f32 x_79580) = {
  {x_79579, x_79580}
}

fun {f32, f32} lifted_35922(f32 a_79581, f32 b_79582) = {
  {a_79581, b_79582}
}

fun {f32} lifted_35934(f32 x_79583) = {
  {x_79583}
}

fun {f32} lifted_35938(f32 x_79584, f32 y_79585) = {
  let {f32 res_79586} = fmul32(x_79584, y_79585)
  in {res_79586}
}

fun {f32} lifted_35942(f32 x_79587) = {
  {x_79587}
}

fun {f32} lifted_35945(f32 x_79588) = {
  {x_79588}
}

fun {f32} lifted_35949(f32 x_79589, f32 y_79590) = {
  let {f32 res_79591} = fmul32(x_79589, y_79590)
  in {res_79591}
}

fun {f32} lifted_35954(f32 x_79592, f32 y_79593) = {
  let {f32 res_79594} = fsub32(x_79592, y_79593)
  in {res_79594}
}

fun {f32} lifted_35958(f32 x_79595) = {
  {x_79595}
}

fun {f32} lifted_35962(f32 x_79596, f32 y_79597) = {
  let {f32 res_79598} = fmul32(x_79596, y_79597)
  in {res_79598}
}

fun {f32} lifted_35966(f32 x_79599) = {
  {x_79599}
}

fun {f32} lifted_35969(f32 x_79600) = {
  {x_79600}
}

fun {f32} lifted_35973(f32 x_79601, f32 y_79602) = {
  let {f32 res_79603} = fmul32(x_79601, y_79602)
  in {res_79603}
}

fun {f32} lifted_35978(f32 x_79604, f32 y_79605) = {
  let {f32 res_79606} = fadd32(x_79604, y_79605)
  in {res_79606}
}

fun {f32, f32} lifted_35932(f32 a_79607, f32 b_79608, f32 c_79609,
                            f32 d_79610) = {
  let {f32 arg_79611} = lifted_35934(a_79607)
  let {f32 arg_79612} = lifted_35938(arg_79611, c_79609)
  let {f32 arg_79613} = lifted_35942(arg_79612)
  let {f32 arg_79614} = lifted_35945(b_79608)
  let {f32 arg_79615} = lifted_35949(arg_79614, d_79610)
  let {f32 res_79616} = lifted_35954(arg_79613, arg_79615)
  let {f32 arg_79617} = lifted_35958(b_79608)
  let {f32 arg_79618} = lifted_35962(arg_79617, c_79609)
  let {f32 arg_79619} = lifted_35966(arg_79618)
  let {f32 arg_79620} = lifted_35969(a_79607)
  let {f32 arg_79621} = lifted_35973(arg_79620, d_79610)
  let {f32 res_79622} = lifted_35978(arg_79619, arg_79621)
  in {res_79616, res_79622}
}

fun {f32, f32} lifted_35916(f32 x_79623, f32 x_79624, f32 y_79625,
                            f32 y_79626) = {
  let {f32 arg_79627, f32 arg_79628} = lifted_35922(x_79623, x_79624)
  let {f32 res_79629, f32 res_79630} = lifted_35932(arg_79627, arg_79628,
                                                    y_79625, y_79626)
  in {res_79629, res_79630}
}

fun {f32, f32} lifted_35996(f32 a_79631, f32 b_79632) = {
  {a_79631, b_79632}
}

fun {f32} lifted_36006(f32 x_79633) = {
  {x_79633}
}

fun {f32} lifted_36010(f32 x_79634, f32 y_79635) = {
  let {f32 res_79636} = fsub32(x_79634, y_79635)
  in {res_79636}
}

fun {f32} lifted_36014(f32 x_79637) = {
  {x_79637}
}

fun {f32} lifted_36018(f32 x_79638, f32 y_79639) = {
  let {f32 res_79640} = fsub32(x_79638, y_79639)
  in {res_79640}
}

fun {f32, f32} lifted_36004(f32 a_79641, f32 b_79642, f32 c_79643,
                            f32 d_79644) = {
  let {f32 arg_79645} = lifted_36006(a_79641)
  let {f32 res_79646} = lifted_36010(arg_79645, c_79643)
  let {f32 arg_79647} = lifted_36014(b_79642)
  let {f32 res_79648} = lifted_36018(arg_79647, d_79644)
  in {res_79646, res_79648}
}

fun {f32, f32} lifted_35992(f32 x_79649, f32 x_79650, f32 y_79651,
                            f32 y_79652) = {
  let {f32 arg_79653, f32 arg_79654} = lifted_35996(x_79649, x_79650)
  let {f32 res_79655, f32 res_79656} = lifted_36004(arg_79653, arg_79654,
                                                    y_79651, y_79652)
  in {res_79655, res_79656}
}

fun {f32, f32} lifted_36032(f32 x_79657, f32 x_79658) = {
  {x_79657, x_79658}
}

fun {f32, f32} lifted_36048(f32 a_79659, f32 b_79660) = {
  {a_79659, b_79660}
}

fun {f32} lifted_36060(f32 x_79661) = {
  {x_79661}
}

fun {f32} lifted_36064(f32 x_79662, f32 y_79663) = {
  let {f32 res_79664} = fmul32(x_79662, y_79663)
  in {res_79664}
}

fun {f32} lifted_36068(f32 x_79665) = {
  {x_79665}
}

fun {f32} lifted_36071(f32 x_79666) = {
  {x_79666}
}

fun {f32} lifted_36075(f32 x_79667, f32 y_79668) = {
  let {f32 res_79669} = fmul32(x_79667, y_79668)
  in {res_79669}
}

fun {f32} lifted_36080(f32 x_79670, f32 y_79671) = {
  let {f32 res_79672} = fsub32(x_79670, y_79671)
  in {res_79672}
}

fun {f32} lifted_36084(f32 x_79673) = {
  {x_79673}
}

fun {f32} lifted_36088(f32 x_79674, f32 y_79675) = {
  let {f32 res_79676} = fmul32(x_79674, y_79675)
  in {res_79676}
}

fun {f32} lifted_36092(f32 x_79677) = {
  {x_79677}
}

fun {f32} lifted_36095(f32 x_79678) = {
  {x_79678}
}

fun {f32} lifted_36099(f32 x_79679, f32 y_79680) = {
  let {f32 res_79681} = fmul32(x_79679, y_79680)
  in {res_79681}
}

fun {f32} lifted_36104(f32 x_79682, f32 y_79683) = {
  let {f32 res_79684} = fadd32(x_79682, y_79683)
  in {res_79684}
}

fun {f32, f32} lifted_36058(f32 a_79685, f32 b_79686, f32 c_79687,
                            f32 d_79688) = {
  let {f32 arg_79689} = lifted_36060(a_79685)
  let {f32 arg_79690} = lifted_36064(arg_79689, c_79687)
  let {f32 arg_79691} = lifted_36068(arg_79690)
  let {f32 arg_79692} = lifted_36071(b_79686)
  let {f32 arg_79693} = lifted_36075(arg_79692, d_79688)
  let {f32 res_79694} = lifted_36080(arg_79691, arg_79693)
  let {f32 arg_79695} = lifted_36084(b_79686)
  let {f32 arg_79696} = lifted_36088(arg_79695, c_79687)
  let {f32 arg_79697} = lifted_36092(arg_79696)
  let {f32 arg_79698} = lifted_36095(a_79685)
  let {f32 arg_79699} = lifted_36099(arg_79698, d_79688)
  let {f32 res_79700} = lifted_36104(arg_79697, arg_79699)
  in {res_79694, res_79700}
}

fun {f32, f32} lifted_36042(f32 x_79701, f32 x_79702, f32 y_79703,
                            f32 y_79704) = {
  let {f32 arg_79705, f32 arg_79706} = lifted_36048(x_79701, x_79702)
  let {f32 res_79707, f32 res_79708} = lifted_36058(arg_79705, arg_79706,
                                                    y_79703, y_79704)
  in {res_79707, res_79708}
}

fun {f32, f32} lifted_36115(f32 x_79709, f32 x_79710) = {
  {x_79709, x_79710}
}

fun {f32, f32} lifted_36122(f32 x_79711, f32 x_79712) = {
  {x_79711, x_79712}
}

fun {f32, f32} lifted_36129(f32 x_79713, f32 x_79714) = {
  {x_79713, x_79714}
}

fun {f32, f32} lifted_36136(f32 x_79715, f32 x_79716) = {
  {x_79715, x_79716}
}

fun {f32, f32} lifted_36150(f32 a_79717, f32 b_79718) = {
  {a_79717, b_79718}
}

fun {f32} lifted_36160(f32 x_79719) = {
  {x_79719}
}

fun {f32} lifted_36164(f32 x_79720, f32 y_79721) = {
  let {f32 res_79722} = fadd32(x_79720, y_79721)
  in {res_79722}
}

fun {f32} lifted_36168(f32 x_79723) = {
  {x_79723}
}

fun {f32} lifted_36172(f32 x_79724, f32 y_79725) = {
  let {f32 res_79726} = fadd32(x_79724, y_79725)
  in {res_79726}
}

fun {f32, f32} lifted_36158(f32 a_79727, f32 b_79728, f32 c_79729,
                            f32 d_79730) = {
  let {f32 arg_79731} = lifted_36160(a_79727)
  let {f32 res_79732} = lifted_36164(arg_79731, c_79729)
  let {f32 arg_79733} = lifted_36168(b_79728)
  let {f32 res_79734} = lifted_36172(arg_79733, d_79730)
  in {res_79732, res_79734}
}

fun {f32, f32} lifted_36146(f32 x_79735, f32 x_79736, f32 y_79737,
                            f32 y_79738) = {
  let {f32 arg_79739, f32 arg_79740} = lifted_36150(x_79735, x_79736)
  let {f32 res_79741, f32 res_79742} = lifted_36158(arg_79739, arg_79740,
                                                    y_79737, y_79738)
  in {res_79741, res_79742}
}

fun {f32, f32} lifted_36192(f32 a_79743, f32 b_79744) = {
  {a_79743, b_79744}
}

fun {f32} lifted_36204(f32 x_79745) = {
  {x_79745}
}

fun {f32} lifted_36208(f32 x_79746, f32 y_79747) = {
  let {f32 res_79748} = fmul32(x_79746, y_79747)
  in {res_79748}
}

fun {f32} lifted_36212(f32 x_79749) = {
  {x_79749}
}

fun {f32} lifted_36215(f32 x_79750) = {
  {x_79750}
}

fun {f32} lifted_36219(f32 x_79751, f32 y_79752) = {
  let {f32 res_79753} = fmul32(x_79751, y_79752)
  in {res_79753}
}

fun {f32} lifted_36224(f32 x_79754, f32 y_79755) = {
  let {f32 res_79756} = fsub32(x_79754, y_79755)
  in {res_79756}
}

fun {f32} lifted_36228(f32 x_79757) = {
  {x_79757}
}

fun {f32} lifted_36232(f32 x_79758, f32 y_79759) = {
  let {f32 res_79760} = fmul32(x_79758, y_79759)
  in {res_79760}
}

fun {f32} lifted_36236(f32 x_79761) = {
  {x_79761}
}

fun {f32} lifted_36239(f32 x_79762) = {
  {x_79762}
}

fun {f32} lifted_36243(f32 x_79763, f32 y_79764) = {
  let {f32 res_79765} = fmul32(x_79763, y_79764)
  in {res_79765}
}

fun {f32} lifted_36248(f32 x_79766, f32 y_79767) = {
  let {f32 res_79768} = fadd32(x_79766, y_79767)
  in {res_79768}
}

fun {f32, f32} lifted_36202(f32 a_79769, f32 b_79770, f32 c_79771,
                            f32 d_79772) = {
  let {f32 arg_79773} = lifted_36204(a_79769)
  let {f32 arg_79774} = lifted_36208(arg_79773, c_79771)
  let {f32 arg_79775} = lifted_36212(arg_79774)
  let {f32 arg_79776} = lifted_36215(b_79770)
  let {f32 arg_79777} = lifted_36219(arg_79776, d_79772)
  let {f32 res_79778} = lifted_36224(arg_79775, arg_79777)
  let {f32 arg_79779} = lifted_36228(b_79770)
  let {f32 arg_79780} = lifted_36232(arg_79779, c_79771)
  let {f32 arg_79781} = lifted_36236(arg_79780)
  let {f32 arg_79782} = lifted_36239(a_79769)
  let {f32 arg_79783} = lifted_36243(arg_79782, d_79772)
  let {f32 res_79784} = lifted_36248(arg_79781, arg_79783)
  in {res_79778, res_79784}
}

fun {f32, f32} lifted_36186(f32 x_79785, f32 x_79786, f32 y_79787,
                            f32 y_79788) = {
  let {f32 arg_79789, f32 arg_79790} = lifted_36192(x_79785, x_79786)
  let {f32 res_79791, f32 res_79792} = lifted_36202(arg_79789, arg_79790,
                                                    y_79787, y_79788)
  in {res_79791, res_79792}
}

fun {f32, f32} lifted_36268(f32 a_79793, f32 b_79794) = {
  {a_79793, b_79794}
}

fun {f32} lifted_36280(f32 x_79795) = {
  {x_79795}
}

fun {f32} lifted_36284(f32 x_79796, f32 y_79797) = {
  let {f32 res_79798} = fmul32(x_79796, y_79797)
  in {res_79798}
}

fun {f32} lifted_36288(f32 x_79799) = {
  {x_79799}
}

fun {f32} lifted_36291(f32 x_79800) = {
  {x_79800}
}

fun {f32} lifted_36295(f32 x_79801, f32 y_79802) = {
  let {f32 res_79803} = fmul32(x_79801, y_79802)
  in {res_79803}
}

fun {f32} lifted_36300(f32 x_79804, f32 y_79805) = {
  let {f32 res_79806} = fsub32(x_79804, y_79805)
  in {res_79806}
}

fun {f32} lifted_36304(f32 x_79807) = {
  {x_79807}
}

fun {f32} lifted_36308(f32 x_79808, f32 y_79809) = {
  let {f32 res_79810} = fmul32(x_79808, y_79809)
  in {res_79810}
}

fun {f32} lifted_36312(f32 x_79811) = {
  {x_79811}
}

fun {f32} lifted_36315(f32 x_79812) = {
  {x_79812}
}

fun {f32} lifted_36319(f32 x_79813, f32 y_79814) = {
  let {f32 res_79815} = fmul32(x_79813, y_79814)
  in {res_79815}
}

fun {f32} lifted_36324(f32 x_79816, f32 y_79817) = {
  let {f32 res_79818} = fadd32(x_79816, y_79817)
  in {res_79818}
}

fun {f32, f32} lifted_36278(f32 a_79819, f32 b_79820, f32 c_79821,
                            f32 d_79822) = {
  let {f32 arg_79823} = lifted_36280(a_79819)
  let {f32 arg_79824} = lifted_36284(arg_79823, c_79821)
  let {f32 arg_79825} = lifted_36288(arg_79824)
  let {f32 arg_79826} = lifted_36291(b_79820)
  let {f32 arg_79827} = lifted_36295(arg_79826, d_79822)
  let {f32 res_79828} = lifted_36300(arg_79825, arg_79827)
  let {f32 arg_79829} = lifted_36304(b_79820)
  let {f32 arg_79830} = lifted_36308(arg_79829, c_79821)
  let {f32 arg_79831} = lifted_36312(arg_79830)
  let {f32 arg_79832} = lifted_36315(a_79819)
  let {f32 arg_79833} = lifted_36319(arg_79832, d_79822)
  let {f32 res_79834} = lifted_36324(arg_79831, arg_79833)
  in {res_79828, res_79834}
}

fun {f32, f32} lifted_36262(f32 x_79835, f32 x_79836, f32 y_79837,
                            f32 y_79838) = {
  let {f32 arg_79839, f32 arg_79840} = lifted_36268(x_79835, x_79836)
  let {f32 res_79841, f32 res_79842} = lifted_36278(arg_79839, arg_79840,
                                                    y_79837, y_79838)
  in {res_79841, res_79842}
}

fun {f32, f32} lifted_36342(f32 a_79843, f32 b_79844) = {
  {a_79843, b_79844}
}

fun {f32} lifted_36352(f32 x_79845) = {
  {x_79845}
}

fun {f32} lifted_36356(f32 x_79846, f32 y_79847) = {
  let {f32 res_79848} = fadd32(x_79846, y_79847)
  in {res_79848}
}

fun {f32} lifted_36360(f32 x_79849) = {
  {x_79849}
}

fun {f32} lifted_36364(f32 x_79850, f32 y_79851) = {
  let {f32 res_79852} = fadd32(x_79850, y_79851)
  in {res_79852}
}

fun {f32, f32} lifted_36350(f32 a_79853, f32 b_79854, f32 c_79855,
                            f32 d_79856) = {
  let {f32 arg_79857} = lifted_36352(a_79853)
  let {f32 res_79858} = lifted_36356(arg_79857, c_79855)
  let {f32 arg_79859} = lifted_36360(b_79854)
  let {f32 res_79860} = lifted_36364(arg_79859, d_79856)
  in {res_79858, res_79860}
}

fun {f32, f32} lifted_36338(f32 x_79861, f32 x_79862, f32 y_79863,
                            f32 y_79864) = {
  let {f32 arg_79865, f32 arg_79866} = lifted_36342(x_79861, x_79862)
  let {f32 res_79867, f32 res_79868} = lifted_36350(arg_79865, arg_79866,
                                                    y_79863, y_79864)
  in {res_79867, res_79868}
}

fun {f32} lifted_36383(f32 x_79869) = {
  {x_79869}
}

fun {f32} lifted_36386(f32 x_79870) = {
  {x_79870}
}

fun {f32} lifted_36390(f32 x_79871, f32 y_79872) = {
  let {f32 res_79873} = fmul32(x_79871, y_79872)
  in {res_79873}
}

fun {f32} lifted_36394(f32 x_79874) = {
  {x_79874}
}

fun {f32} lifted_36397(f32 x_79875) = {
  {x_79875}
}

fun {f32} lifted_36401(f32 x_79876, f32 y_79877) = {
  let {f32 res_79878} = fmul32(x_79876, y_79877)
  in {res_79878}
}

fun {f32} lifted_36406(f32 x_79879, f32 y_79880) = {
  let {f32 res_79881} = fadd32(x_79879, y_79880)
  in {res_79881}
}

fun {f32} lifted_36410(f32 x_79882) = {
  let {f32 res_79883} = sqrt32(x_79882)
  in {res_79883}
}

fun {f32} lifted_36415(f32 x_79884, f32 y_79885) = {
  let {f32 res_79886} = fadd32(x_79884, y_79885)
  in {res_79886}
}

fun {f32} lifted_36419(f32 x_79887) = {
  {x_79887}
}

fun {f32} lifted_36422(i32 x_79888) = {
  let {f32 res_79889} = sitofp i32 x_79888 to f32
  in {res_79889}
}

fun {f32} lifted_36427(f32 x_79890, f32 y_79891) = {
  let {f32 res_79892} = fdiv32(x_79890, y_79891)
  in {res_79892}
}

fun {f32} lifted_36431(f32 x_79893) = {
  let {f32 res_79894} = sqrt32(x_79893)
  in {res_79894}
}

fun {f32} lifted_36440(f32 x_79895) = {
  {x_79895}
}

fun {bool} lifted_36444(f32 x_79896, f32 y_79897) = {
  let {bool res_79898} = lt32(x_79896, y_79897)
  in {res_79898}
}

fun {f32} lifted_36449(f32 x_79899) = {
  {x_79899}
}

fun {bool} lifted_36453(f32 x_79900, f32 y_79901) = {
  let {bool res_79902} = eq_f32(x_79900, y_79901)
  in {res_79902}
}

fun {f32} lifted_36438(f32 x_79903) = {
  let {f32 arg_79904} = lifted_36440(x_79903)
  let {bool cond_79905} = lifted_36444(arg_79904, 0.0f32)
  let {f32 res_79906} =
    -- Branch returns: {f32}
    if cond_79905
    then {
      let {f32 res_79907} = fsub32(0.0f32, 1.0f32)
      in {res_79907}
    } else {
      let {f32 arg_79908} = lifted_36449(x_79903)
      let {bool cond_79909} = lifted_36453(arg_79908, 0.0f32)
      let {f32 res_79910} =
        -- Branch returns: {f32}
        if cond_79909
        then {0.0f32} else {1.0f32}
      in {res_79910}
    }
  in {res_79906}
}

fun {i32} lifted_36460(f32 x_79911) = {
  let {i32 res_79912} = fptosi f32 x_79911 to i32
  in {res_79912}
}

fun {f32} lifted_36464(i32 x_79913) = {
  let {f32 res_79914} = sitofp i32 x_79913 to f32
  in {res_79914}
}

fun {f32} lifted_36468(f32 x_79915) = {
  {x_79915}
}

fun {f32} lifted_36471(i32 x_79916) = {
  let {f32 res_79917} = sitofp i32 x_79916 to f32
  in {res_79917}
}

fun {f32} lifted_36475(f32 x_79918) = {
  {x_79918}
}

fun {f32} lifted_36479(f32 x_79919, f32 y_79920) = {
  let {f32 res_79921} = fsub32(x_79919, y_79920)
  in {res_79921}
}

fun {f32} lifted_36483(f32 x_79922) = {
  {x_79922}
}

fun {f32} lifted_36486(f32 x_79923) = {
  {x_79923}
}

fun {f32} lifted_36490(f32 x_79924, f32 y_79925) = {
  let {f32 res_79926} = fmul32(x_79924, y_79925)
  in {res_79926}
}

fun {f32} lifted_36494(f32 x_79927) = {
  {x_79927}
}

fun {f32} lifted_36497(f32 x_79928) = {
  {x_79928}
}

fun {f32} lifted_36501(f32 x_79929, f32 y_79930) = {
  let {f32 res_79931} = fmul32(x_79929, y_79930)
  in {res_79931}
}

fun {f32} lifted_36506(f32 x_79932, f32 y_79933) = {
  let {f32 res_79934} = fadd32(x_79932, y_79933)
  in {res_79934}
}

fun {f32} lifted_36510(f32 x_79935) = {
  let {f32 res_79936} = sqrt32(x_79935)
  in {res_79936}
}

fun {f32} lifted_36515(f32 x_79937, f32 y_79938) = {
  let {f32 res_79939} = fadd32(x_79937, y_79938)
  in {res_79939}
}

fun {f32} lifted_36519(f32 x_79940) = {
  {x_79940}
}

fun {f32} lifted_36522(i32 x_79941) = {
  let {f32 res_79942} = sitofp i32 x_79941 to f32
  in {res_79942}
}

fun {f32} lifted_36527(f32 x_79943, f32 y_79944) = {
  let {f32 res_79945} = fdiv32(x_79943, y_79944)
  in {res_79945}
}

fun {f32} lifted_36531(f32 x_79946) = {
  let {f32 res_79947} = sqrt32(x_79946)
  in {res_79947}
}

fun {f32} lifted_36536(f32 x_79948, f32 y_79949) = {
  let {f32 res_79950} = fmul32(x_79948, y_79949)
  in {res_79950}
}

fun {f32, f32} lifted_36381(f32 a_79951, f32 b_79952) = {
  let {f32 arg_79953} = lifted_36383(a_79951)
  let {f32 arg_79954} = lifted_36386(a_79951)
  let {f32 arg_79955} = lifted_36390(arg_79954, a_79951)
  let {f32 arg_79956} = lifted_36394(arg_79955)
  let {f32 arg_79957} = lifted_36397(b_79952)
  let {f32 arg_79958} = lifted_36401(arg_79957, b_79952)
  let {f32 arg_79959} = lifted_36406(arg_79956, arg_79958)
  let {f32 arg_79960} = lifted_36410(arg_79959)
  let {f32 arg_79961} = lifted_36415(arg_79953, arg_79960)
  let {f32 arg_79962} = lifted_36419(arg_79961)
  let {f32 arg_79963} = lifted_36422(2i32)
  let {f32 arg_79964} = lifted_36427(arg_79962, arg_79963)
  let {f32 res_79965} = lifted_36431(arg_79964)
  let {f32 gamma_79966} = res_79965
  let {f32 arg_79967} = lifted_36438(b_79952)
  let {i32 arg_79968} = lifted_36460(arg_79967)
  let {f32 arg_79969} = lifted_36464(arg_79968)
  let {f32 arg_79970} = lifted_36468(arg_79969)
  let {f32 arg_79971} = lifted_36471(0i32)
  let {f32 arg_79972} = lifted_36475(arg_79971)
  let {f32 arg_79973} = lifted_36479(arg_79972, a_79951)
  let {f32 arg_79974} = lifted_36483(arg_79973)
  let {f32 arg_79975} = lifted_36486(a_79951)
  let {f32 arg_79976} = lifted_36490(arg_79975, a_79951)
  let {f32 arg_79977} = lifted_36494(arg_79976)
  let {f32 arg_79978} = lifted_36497(b_79952)
  let {f32 arg_79979} = lifted_36501(arg_79978, b_79952)
  let {f32 arg_79980} = lifted_36506(arg_79977, arg_79979)
  let {f32 arg_79981} = lifted_36510(arg_79980)
  let {f32 arg_79982} = lifted_36515(arg_79974, arg_79981)
  let {f32 arg_79983} = lifted_36519(arg_79982)
  let {f32 arg_79984} = lifted_36522(2i32)
  let {f32 arg_79985} = lifted_36527(arg_79983, arg_79984)
  let {f32 arg_79986} = lifted_36531(arg_79985)
  let {f32 res_79987} = lifted_36536(arg_79970, arg_79986)
  let {f32 delta_79988} = res_79987
  in {gamma_79966, delta_79988}
}

fun {f32, f32} lifted_36549(f32 x_79989, f32 x_79990) = {
  {x_79989, x_79990}
}

fun {f32, f32} lifted_36563(f32 a_79991, f32 b_79992) = {
  {a_79991, b_79992}
}

fun {f32} lifted_36573(f32 x_79993) = {
  {x_79993}
}

fun {f32} lifted_36577(f32 x_79994, f32 y_79995) = {
  let {f32 res_79996} = fsub32(x_79994, y_79995)
  in {res_79996}
}

fun {f32} lifted_36581(f32 x_79997) = {
  {x_79997}
}

fun {f32} lifted_36585(f32 x_79998, f32 y_79999) = {
  let {f32 res_80000} = fsub32(x_79998, y_79999)
  in {res_80000}
}

fun {f32, f32} lifted_36571(f32 a_80001, f32 b_80002, f32 c_80003,
                            f32 d_80004) = {
  let {f32 arg_80005} = lifted_36573(a_80001)
  let {f32 res_80006} = lifted_36577(arg_80005, c_80003)
  let {f32 arg_80007} = lifted_36581(b_80002)
  let {f32 res_80008} = lifted_36585(arg_80007, d_80004)
  in {res_80006, res_80008}
}

fun {f32, f32} lifted_36559(f32 x_80009, f32 x_80010, f32 y_80011,
                            f32 y_80012) = {
  let {f32 arg_80013, f32 arg_80014} = lifted_36563(x_80009, x_80010)
  let {f32 res_80015, f32 res_80016} = lifted_36571(arg_80013, arg_80014,
                                                    y_80011, y_80012)
  in {res_80015, res_80016}
}

fun {f32, f32} lifted_36599(f32 x_80017, f32 x_80018) = {
  {x_80017, x_80018}
}

fun {f32, f32} lifted_36606(f32 x_80019, f32 x_80020) = {
  {x_80019, x_80020}
}

fun {f32, f32} lifted_36620(f32 a_80021, f32 b_80022) = {
  {a_80021, b_80022}
}

fun {f32} lifted_36630(f32 x_80023) = {
  {x_80023}
}

fun {f32} lifted_36634(f32 x_80024, f32 y_80025) = {
  let {f32 res_80026} = fadd32(x_80024, y_80025)
  in {res_80026}
}

fun {f32} lifted_36638(f32 x_80027) = {
  {x_80027}
}

fun {f32} lifted_36642(f32 x_80028, f32 y_80029) = {
  let {f32 res_80030} = fadd32(x_80028, y_80029)
  in {res_80030}
}

fun {f32, f32} lifted_36628(f32 a_80031, f32 b_80032, f32 c_80033,
                            f32 d_80034) = {
  let {f32 arg_80035} = lifted_36630(a_80031)
  let {f32 res_80036} = lifted_36634(arg_80035, c_80033)
  let {f32 arg_80037} = lifted_36638(b_80032)
  let {f32 res_80038} = lifted_36642(arg_80037, d_80034)
  in {res_80036, res_80038}
}

fun {f32, f32} lifted_36616(f32 x_80039, f32 x_80040, f32 y_80041,
                            f32 y_80042) = {
  let {f32 arg_80043, f32 arg_80044} = lifted_36620(x_80039, x_80040)
  let {f32 res_80045, f32 res_80046} = lifted_36628(arg_80043, arg_80044,
                                                    y_80041, y_80042)
  in {res_80045, res_80046}
}

fun {f32, f32} lifted_36663(f32 a_80047, f32 b_80048) = {
  {a_80047, b_80048}
}

fun {f32} lifted_36676(f32 x_80049) = {
  {x_80049}
}

fun {f32} lifted_36680(f32 x_80050, f32 y_80051) = {
  let {f32 res_80052} = fmul32(x_80050, y_80051)
  in {res_80052}
}

fun {f32} lifted_36684(f32 x_80053) = {
  {x_80053}
}

fun {f32} lifted_36687(f32 x_80054) = {
  {x_80054}
}

fun {f32} lifted_36691(f32 x_80055, f32 y_80056) = {
  let {f32 res_80057} = fmul32(x_80055, y_80056)
  in {res_80057}
}

fun {f32} lifted_36696(f32 x_80058, f32 y_80059) = {
  let {f32 res_80060} = fadd32(x_80058, y_80059)
  in {res_80060}
}

fun {f32} lifted_36700(f32 x_80061) = {
  {x_80061}
}

fun {f32} lifted_36703(f32 x_80062) = {
  {x_80062}
}

fun {f32} lifted_36707(f32 x_80063, f32 y_80064) = {
  let {f32 res_80065} = fmul32(x_80063, y_80064)
  in {res_80065}
}

fun {f32} lifted_36711(f32 x_80066) = {
  {x_80066}
}

fun {f32} lifted_36714(f32 x_80067) = {
  {x_80067}
}

fun {f32} lifted_36718(f32 x_80068, f32 y_80069) = {
  let {f32 res_80070} = fmul32(x_80068, y_80069)
  in {res_80070}
}

fun {f32} lifted_36723(f32 x_80071, f32 y_80072) = {
  let {f32 res_80073} = fadd32(x_80071, y_80072)
  in {res_80073}
}

fun {f32} lifted_36728(f32 x_80074, f32 y_80075) = {
  let {f32 res_80076} = fdiv32(x_80074, y_80075)
  in {res_80076}
}

fun {f32} lifted_36732(f32 x_80077) = {
  {x_80077}
}

fun {f32} lifted_36736(f32 x_80078, f32 y_80079) = {
  let {f32 res_80080} = fmul32(x_80078, y_80079)
  in {res_80080}
}

fun {f32} lifted_36740(f32 x_80081) = {
  {x_80081}
}

fun {f32} lifted_36743(f32 x_80082) = {
  {x_80082}
}

fun {f32} lifted_36747(f32 x_80083, f32 y_80084) = {
  let {f32 res_80085} = fmul32(x_80083, y_80084)
  in {res_80085}
}

fun {f32} lifted_36752(f32 x_80086, f32 y_80087) = {
  let {f32 res_80088} = fsub32(x_80086, y_80087)
  in {res_80088}
}

fun {f32} lifted_36756(f32 x_80089) = {
  {x_80089}
}

fun {f32} lifted_36759(f32 x_80090) = {
  {x_80090}
}

fun {f32} lifted_36763(f32 x_80091, f32 y_80092) = {
  let {f32 res_80093} = fmul32(x_80091, y_80092)
  in {res_80093}
}

fun {f32} lifted_36767(f32 x_80094) = {
  {x_80094}
}

fun {f32} lifted_36770(f32 x_80095) = {
  {x_80095}
}

fun {f32} lifted_36774(f32 x_80096, f32 y_80097) = {
  let {f32 res_80098} = fmul32(x_80096, y_80097)
  in {res_80098}
}

fun {f32} lifted_36779(f32 x_80099, f32 y_80100) = {
  let {f32 res_80101} = fadd32(x_80099, y_80100)
  in {res_80101}
}

fun {f32} lifted_36784(f32 x_80102, f32 y_80103) = {
  let {f32 res_80104} = fdiv32(x_80102, y_80103)
  in {res_80104}
}

fun {f32, f32} lifted_36674(f32 a_80105, f32 b_80106, f32 c_80107,
                            f32 d_80108) = {
  let {f32 arg_80109} = lifted_36676(a_80105)
  let {f32 arg_80110} = lifted_36680(arg_80109, c_80107)
  let {f32 arg_80111} = lifted_36684(arg_80110)
  let {f32 arg_80112} = lifted_36687(b_80106)
  let {f32 arg_80113} = lifted_36691(arg_80112, d_80108)
  let {f32 arg_80114} = lifted_36696(arg_80111, arg_80113)
  let {f32 arg_80115} = lifted_36700(arg_80114)
  let {f32 arg_80116} = lifted_36703(c_80107)
  let {f32 arg_80117} = lifted_36707(arg_80116, c_80107)
  let {f32 arg_80118} = lifted_36711(arg_80117)
  let {f32 arg_80119} = lifted_36714(d_80108)
  let {f32 arg_80120} = lifted_36718(arg_80119, d_80108)
  let {f32 arg_80121} = lifted_36723(arg_80118, arg_80120)
  let {f32 res_80122} = lifted_36728(arg_80115, arg_80121)
  let {f32 arg_80123} = lifted_36732(b_80106)
  let {f32 arg_80124} = lifted_36736(arg_80123, c_80107)
  let {f32 arg_80125} = lifted_36740(arg_80124)
  let {f32 arg_80126} = lifted_36743(a_80105)
  let {f32 arg_80127} = lifted_36747(arg_80126, d_80108)
  let {f32 arg_80128} = lifted_36752(arg_80125, arg_80127)
  let {f32 arg_80129} = lifted_36756(arg_80128)
  let {f32 arg_80130} = lifted_36759(c_80107)
  let {f32 arg_80131} = lifted_36763(arg_80130, c_80107)
  let {f32 arg_80132} = lifted_36767(arg_80131)
  let {f32 arg_80133} = lifted_36770(d_80108)
  let {f32 arg_80134} = lifted_36774(arg_80133, d_80108)
  let {f32 arg_80135} = lifted_36779(arg_80132, arg_80134)
  let {f32 res_80136} = lifted_36784(arg_80129, arg_80135)
  in {res_80122, res_80136}
}

fun {f32, f32} lifted_36656(f32 x_80137, f32 x_80138, f32 y_80139,
                            f32 y_80140) = {
  let {f32 arg_80141, f32 arg_80142} = lifted_36663(x_80137, x_80138)
  let {f32 res_80143, f32 res_80144} = lifted_36674(arg_80141, arg_80142,
                                                    y_80139, y_80140)
  in {res_80143, res_80144}
}

fun {f32, f32} lifted_36798(f32 x_80145, f32 x_80146) = {
  {x_80145, x_80146}
}

fun {f32, f32} lifted_36805(f32 x_80147, f32 x_80148) = {
  {x_80147, x_80148}
}

fun {f32, f32} lifted_36821(f32 a_80149, f32 b_80150) = {
  {a_80149, b_80150}
}

fun {f32} lifted_36833(f32 x_80151) = {
  {x_80151}
}

fun {f32} lifted_36837(f32 x_80152, f32 y_80153) = {
  let {f32 res_80154} = fmul32(x_80152, y_80153)
  in {res_80154}
}

fun {f32} lifted_36841(f32 x_80155) = {
  {x_80155}
}

fun {f32} lifted_36844(f32 x_80156) = {
  {x_80156}
}

fun {f32} lifted_36848(f32 x_80157, f32 y_80158) = {
  let {f32 res_80159} = fmul32(x_80157, y_80158)
  in {res_80159}
}

fun {f32} lifted_36853(f32 x_80160, f32 y_80161) = {
  let {f32 res_80162} = fsub32(x_80160, y_80161)
  in {res_80162}
}

fun {f32} lifted_36857(f32 x_80163) = {
  {x_80163}
}

fun {f32} lifted_36861(f32 x_80164, f32 y_80165) = {
  let {f32 res_80166} = fmul32(x_80164, y_80165)
  in {res_80166}
}

fun {f32} lifted_36865(f32 x_80167) = {
  {x_80167}
}

fun {f32} lifted_36868(f32 x_80168) = {
  {x_80168}
}

fun {f32} lifted_36872(f32 x_80169, f32 y_80170) = {
  let {f32 res_80171} = fmul32(x_80169, y_80170)
  in {res_80171}
}

fun {f32} lifted_36877(f32 x_80172, f32 y_80173) = {
  let {f32 res_80174} = fadd32(x_80172, y_80173)
  in {res_80174}
}

fun {f32, f32} lifted_36831(f32 a_80175, f32 b_80176, f32 c_80177,
                            f32 d_80178) = {
  let {f32 arg_80179} = lifted_36833(a_80175)
  let {f32 arg_80180} = lifted_36837(arg_80179, c_80177)
  let {f32 arg_80181} = lifted_36841(arg_80180)
  let {f32 arg_80182} = lifted_36844(b_80176)
  let {f32 arg_80183} = lifted_36848(arg_80182, d_80178)
  let {f32 res_80184} = lifted_36853(arg_80181, arg_80183)
  let {f32 arg_80185} = lifted_36857(b_80176)
  let {f32 arg_80186} = lifted_36861(arg_80185, c_80177)
  let {f32 arg_80187} = lifted_36865(arg_80186)
  let {f32 arg_80188} = lifted_36868(a_80175)
  let {f32 arg_80189} = lifted_36872(arg_80188, d_80178)
  let {f32 res_80190} = lifted_36877(arg_80187, arg_80189)
  in {res_80184, res_80190}
}

fun {f32, f32} lifted_36815(f32 x_80191, f32 x_80192, f32 y_80193,
                            f32 y_80194) = {
  let {f32 arg_80195, f32 arg_80196} = lifted_36821(x_80191, x_80192)
  let {f32 res_80197, f32 res_80198} = lifted_36831(arg_80195, arg_80196,
                                                    y_80193, y_80194)
  in {res_80197, res_80198}
}

fun {f32, f32} lifted_36895(f32 a_80199, f32 b_80200) = {
  {a_80199, b_80200}
}

fun {f32} lifted_36905(f32 x_80201) = {
  {x_80201}
}

fun {f32} lifted_36909(f32 x_80202, f32 y_80203) = {
  let {f32 res_80204} = fsub32(x_80202, y_80203)
  in {res_80204}
}

fun {f32} lifted_36913(f32 x_80205) = {
  {x_80205}
}

fun {f32} lifted_36917(f32 x_80206, f32 y_80207) = {
  let {f32 res_80208} = fsub32(x_80206, y_80207)
  in {res_80208}
}

fun {f32, f32} lifted_36903(f32 a_80209, f32 b_80210, f32 c_80211,
                            f32 d_80212) = {
  let {f32 arg_80213} = lifted_36905(a_80209)
  let {f32 res_80214} = lifted_36909(arg_80213, c_80211)
  let {f32 arg_80215} = lifted_36913(b_80210)
  let {f32 res_80216} = lifted_36917(arg_80215, d_80212)
  in {res_80214, res_80216}
}

fun {f32, f32} lifted_36891(f32 x_80217, f32 x_80218, f32 y_80219,
                            f32 y_80220) = {
  let {f32 arg_80221, f32 arg_80222} = lifted_36895(x_80217, x_80218)
  let {f32 res_80223, f32 res_80224} = lifted_36903(arg_80221, arg_80222,
                                                    y_80219, y_80220)
  in {res_80223, res_80224}
}

fun {f32} lifted_36933(f32 x_80225) = {
  let {f32 res_80226} = exp32(x_80225)
  in {res_80226}
}

fun {f32} lifted_36938(f32 x_80227) = {
  {x_80227}
}

fun {f32} lifted_36941(f32 x_80228) = {
  let {f32 res_80229} = cos32(x_80228)
  in {res_80229}
}

fun {f32} lifted_36946(f32 x_80230, f32 y_80231) = {
  let {f32 res_80232} = fmul32(x_80230, y_80231)
  in {res_80232}
}

fun {f32} lifted_36950(f32 a_80233) = {
  {a_80233}
}

fun {f32} lifted_36953(f32 x_80234) = {
  {x_80234}
}

fun {f32} lifted_36956(f32 x_80235) = {
  let {f32 res_80236} = sin32(x_80235)
  in {res_80236}
}

fun {f32} lifted_36961(f32 x_80237, f32 y_80238) = {
  let {f32 res_80239} = fmul32(x_80237, y_80238)
  in {res_80239}
}

fun {f32, f32} lifted_36966(f32 a_80240, f32 b_80241) = {
  {a_80240, b_80241}
}

fun {f32, f32} lifted_36931(f32 a_80242, f32 b_80243) = {
  let {f32 res_80244} = lifted_36933(a_80242)
  let {f32 expx_80245} = res_80244
  let {f32 arg_80246} = lifted_36938(expx_80245)
  let {f32 arg_80247} = lifted_36941(b_80243)
  let {f32 arg_80248} = lifted_36946(arg_80246, arg_80247)
  let {f32 arg_80249} = lifted_36950(arg_80248)
  let {f32 arg_80250} = lifted_36953(expx_80245)
  let {f32 arg_80251} = lifted_36956(b_80243)
  let {f32 arg_80252} = lifted_36961(arg_80250, arg_80251)
  let {f32 res_80253, f32 res_80254} = lifted_36966(arg_80249, arg_80252)
  in {res_80253, res_80254}
}

fun {f32, f32} lifted_36978(f32 x_80255, f32 x_80256) = {
  {x_80255, x_80256}
}

fun {f32, f32} lifted_36985(f32 x_80257, f32 x_80258) = {
  {x_80257, x_80258}
}

fun {f32, f32} lifted_37001(f32 a_80259, f32 b_80260) = {
  {a_80259, b_80260}
}

fun {f32} lifted_37013(f32 x_80261) = {
  {x_80261}
}

fun {f32} lifted_37017(f32 x_80262, f32 y_80263) = {
  let {f32 res_80264} = fmul32(x_80262, y_80263)
  in {res_80264}
}

fun {f32} lifted_37021(f32 x_80265) = {
  {x_80265}
}

fun {f32} lifted_37024(f32 x_80266) = {
  {x_80266}
}

fun {f32} lifted_37028(f32 x_80267, f32 y_80268) = {
  let {f32 res_80269} = fmul32(x_80267, y_80268)
  in {res_80269}
}

fun {f32} lifted_37033(f32 x_80270, f32 y_80271) = {
  let {f32 res_80272} = fsub32(x_80270, y_80271)
  in {res_80272}
}

fun {f32} lifted_37037(f32 x_80273) = {
  {x_80273}
}

fun {f32} lifted_37041(f32 x_80274, f32 y_80275) = {
  let {f32 res_80276} = fmul32(x_80274, y_80275)
  in {res_80276}
}

fun {f32} lifted_37045(f32 x_80277) = {
  {x_80277}
}

fun {f32} lifted_37048(f32 x_80278) = {
  {x_80278}
}

fun {f32} lifted_37052(f32 x_80279, f32 y_80280) = {
  let {f32 res_80281} = fmul32(x_80279, y_80280)
  in {res_80281}
}

fun {f32} lifted_37057(f32 x_80282, f32 y_80283) = {
  let {f32 res_80284} = fadd32(x_80282, y_80283)
  in {res_80284}
}

fun {f32, f32} lifted_37011(f32 a_80285, f32 b_80286, f32 c_80287,
                            f32 d_80288) = {
  let {f32 arg_80289} = lifted_37013(a_80285)
  let {f32 arg_80290} = lifted_37017(arg_80289, c_80287)
  let {f32 arg_80291} = lifted_37021(arg_80290)
  let {f32 arg_80292} = lifted_37024(b_80286)
  let {f32 arg_80293} = lifted_37028(arg_80292, d_80288)
  let {f32 res_80294} = lifted_37033(arg_80291, arg_80293)
  let {f32 arg_80295} = lifted_37037(b_80286)
  let {f32 arg_80296} = lifted_37041(arg_80295, c_80287)
  let {f32 arg_80297} = lifted_37045(arg_80296)
  let {f32 arg_80298} = lifted_37048(a_80285)
  let {f32 arg_80299} = lifted_37052(arg_80298, d_80288)
  let {f32 res_80300} = lifted_37057(arg_80297, arg_80299)
  in {res_80294, res_80300}
}

fun {f32, f32} lifted_36995(f32 x_80301, f32 x_80302, f32 y_80303,
                            f32 y_80304) = {
  let {f32 arg_80305, f32 arg_80306} = lifted_37001(x_80301, x_80302)
  let {f32 res_80307, f32 res_80308} = lifted_37011(arg_80305, arg_80306,
                                                    y_80303, y_80304)
  in {res_80307, res_80308}
}

fun {f32, f32} lifted_37068(f32 x_80309, f32 x_80310) = {
  {x_80309, x_80310}
}

fun {f32, f32} lifted_37075(f32 x_80311, f32 x_80312) = {
  {x_80311, x_80312}
}

fun {f32, f32} lifted_37082(f32 x_80313, f32 x_80314) = {
  {x_80313, x_80314}
}

fun {f32, f32} lifted_37089(f32 x_80315, f32 x_80316) = {
  {x_80315, x_80316}
}

fun {f32, f32} lifted_37105(f32 a_80317, f32 b_80318) = {
  {a_80317, b_80318}
}

fun {f32} lifted_37117(f32 x_80319) = {
  {x_80319}
}

fun {f32} lifted_37121(f32 x_80320, f32 y_80321) = {
  let {f32 res_80322} = fmul32(x_80320, y_80321)
  in {res_80322}
}

fun {f32} lifted_37125(f32 x_80323) = {
  {x_80323}
}

fun {f32} lifted_37128(f32 x_80324) = {
  {x_80324}
}

fun {f32} lifted_37132(f32 x_80325, f32 y_80326) = {
  let {f32 res_80327} = fmul32(x_80325, y_80326)
  in {res_80327}
}

fun {f32} lifted_37137(f32 x_80328, f32 y_80329) = {
  let {f32 res_80330} = fsub32(x_80328, y_80329)
  in {res_80330}
}

fun {f32} lifted_37141(f32 x_80331) = {
  {x_80331}
}

fun {f32} lifted_37145(f32 x_80332, f32 y_80333) = {
  let {f32 res_80334} = fmul32(x_80332, y_80333)
  in {res_80334}
}

fun {f32} lifted_37149(f32 x_80335) = {
  {x_80335}
}

fun {f32} lifted_37152(f32 x_80336) = {
  {x_80336}
}

fun {f32} lifted_37156(f32 x_80337, f32 y_80338) = {
  let {f32 res_80339} = fmul32(x_80337, y_80338)
  in {res_80339}
}

fun {f32} lifted_37161(f32 x_80340, f32 y_80341) = {
  let {f32 res_80342} = fadd32(x_80340, y_80341)
  in {res_80342}
}

fun {f32, f32} lifted_37115(f32 a_80343, f32 b_80344, f32 c_80345,
                            f32 d_80346) = {
  let {f32 arg_80347} = lifted_37117(a_80343)
  let {f32 arg_80348} = lifted_37121(arg_80347, c_80345)
  let {f32 arg_80349} = lifted_37125(arg_80348)
  let {f32 arg_80350} = lifted_37128(b_80344)
  let {f32 arg_80351} = lifted_37132(arg_80350, d_80346)
  let {f32 res_80352} = lifted_37137(arg_80349, arg_80351)
  let {f32 arg_80353} = lifted_37141(b_80344)
  let {f32 arg_80354} = lifted_37145(arg_80353, c_80345)
  let {f32 arg_80355} = lifted_37149(arg_80354)
  let {f32 arg_80356} = lifted_37152(a_80343)
  let {f32 arg_80357} = lifted_37156(arg_80356, d_80346)
  let {f32 res_80358} = lifted_37161(arg_80355, arg_80357)
  in {res_80352, res_80358}
}

fun {f32, f32} lifted_37099(f32 x_80359, f32 x_80360, f32 y_80361,
                            f32 y_80362) = {
  let {f32 arg_80363, f32 arg_80364} = lifted_37105(x_80359, x_80360)
  let {f32 res_80365, f32 res_80366} = lifted_37115(arg_80363, arg_80364,
                                                    y_80361, y_80362)
  in {res_80365, res_80366}
}

fun {f32, f32} lifted_37179(f32 a_80367, f32 b_80368) = {
  {a_80367, b_80368}
}

fun {f32} lifted_37189(f32 x_80369) = {
  {x_80369}
}

fun {f32} lifted_37193(f32 x_80370, f32 y_80371) = {
  let {f32 res_80372} = fsub32(x_80370, y_80371)
  in {res_80372}
}

fun {f32} lifted_37197(f32 x_80373) = {
  {x_80373}
}

fun {f32} lifted_37201(f32 x_80374, f32 y_80375) = {
  let {f32 res_80376} = fsub32(x_80374, y_80375)
  in {res_80376}
}

fun {f32, f32} lifted_37187(f32 a_80377, f32 b_80378, f32 c_80379,
                            f32 d_80380) = {
  let {f32 arg_80381} = lifted_37189(a_80377)
  let {f32 res_80382} = lifted_37193(arg_80381, c_80379)
  let {f32 arg_80383} = lifted_37197(b_80378)
  let {f32 res_80384} = lifted_37201(arg_80383, d_80380)
  in {res_80382, res_80384}
}

fun {f32, f32} lifted_37175(f32 x_80385, f32 x_80386, f32 y_80387,
                            f32 y_80388) = {
  let {f32 arg_80389, f32 arg_80390} = lifted_37179(x_80385, x_80386)
  let {f32 res_80391, f32 res_80392} = lifted_37187(arg_80389, arg_80390,
                                                    y_80387, y_80388)
  in {res_80391, res_80392}
}

fun {f32, f32} lifted_37212(f32 x_80393, f32 x_80394) = {
  {x_80393, x_80394}
}

fun {f32, f32} lifted_37219(f32 x_80395, f32 x_80396) = {
  {x_80395, x_80396}
}

fun {f32, f32} lifted_37233(f32 a_80397, f32 b_80398) = {
  {a_80397, b_80398}
}

fun {f32} lifted_37243(f32 x_80399) = {
  {x_80399}
}

fun {f32} lifted_37247(f32 x_80400, f32 y_80401) = {
  let {f32 res_80402} = fsub32(x_80400, y_80401)
  in {res_80402}
}

fun {f32} lifted_37251(f32 x_80403) = {
  {x_80403}
}

fun {f32} lifted_37255(f32 x_80404, f32 y_80405) = {
  let {f32 res_80406} = fsub32(x_80404, y_80405)
  in {res_80406}
}

fun {f32, f32} lifted_37241(f32 a_80407, f32 b_80408, f32 c_80409,
                            f32 d_80410) = {
  let {f32 arg_80411} = lifted_37243(a_80407)
  let {f32 res_80412} = lifted_37247(arg_80411, c_80409)
  let {f32 arg_80413} = lifted_37251(b_80408)
  let {f32 res_80414} = lifted_37255(arg_80413, d_80410)
  in {res_80412, res_80414}
}

fun {f32, f32} lifted_37229(f32 x_80415, f32 x_80416, f32 y_80417,
                            f32 y_80418) = {
  let {f32 arg_80419, f32 arg_80420} = lifted_37233(x_80415, x_80416)
  let {f32 res_80421, f32 res_80422} = lifted_37241(arg_80419, arg_80420,
                                                    y_80417, y_80418)
  in {res_80421, res_80422}
}

fun {f32, f32} lifted_37276(f32 a_80423, f32 b_80424) = {
  {a_80423, b_80424}
}

fun {f32} lifted_37289(f32 x_80425) = {
  {x_80425}
}

fun {f32} lifted_37293(f32 x_80426, f32 y_80427) = {
  let {f32 res_80428} = fmul32(x_80426, y_80427)
  in {res_80428}
}

fun {f32} lifted_37297(f32 x_80429) = {
  {x_80429}
}

fun {f32} lifted_37300(f32 x_80430) = {
  {x_80430}
}

fun {f32} lifted_37304(f32 x_80431, f32 y_80432) = {
  let {f32 res_80433} = fmul32(x_80431, y_80432)
  in {res_80433}
}

fun {f32} lifted_37309(f32 x_80434, f32 y_80435) = {
  let {f32 res_80436} = fadd32(x_80434, y_80435)
  in {res_80436}
}

fun {f32} lifted_37313(f32 x_80437) = {
  {x_80437}
}

fun {f32} lifted_37316(f32 x_80438) = {
  {x_80438}
}

fun {f32} lifted_37320(f32 x_80439, f32 y_80440) = {
  let {f32 res_80441} = fmul32(x_80439, y_80440)
  in {res_80441}
}

fun {f32} lifted_37324(f32 x_80442) = {
  {x_80442}
}

fun {f32} lifted_37327(f32 x_80443) = {
  {x_80443}
}

fun {f32} lifted_37331(f32 x_80444, f32 y_80445) = {
  let {f32 res_80446} = fmul32(x_80444, y_80445)
  in {res_80446}
}

fun {f32} lifted_37336(f32 x_80447, f32 y_80448) = {
  let {f32 res_80449} = fadd32(x_80447, y_80448)
  in {res_80449}
}

fun {f32} lifted_37341(f32 x_80450, f32 y_80451) = {
  let {f32 res_80452} = fdiv32(x_80450, y_80451)
  in {res_80452}
}

fun {f32} lifted_37345(f32 x_80453) = {
  {x_80453}
}

fun {f32} lifted_37349(f32 x_80454, f32 y_80455) = {
  let {f32 res_80456} = fmul32(x_80454, y_80455)
  in {res_80456}
}

fun {f32} lifted_37353(f32 x_80457) = {
  {x_80457}
}

fun {f32} lifted_37356(f32 x_80458) = {
  {x_80458}
}

fun {f32} lifted_37360(f32 x_80459, f32 y_80460) = {
  let {f32 res_80461} = fmul32(x_80459, y_80460)
  in {res_80461}
}

fun {f32} lifted_37365(f32 x_80462, f32 y_80463) = {
  let {f32 res_80464} = fsub32(x_80462, y_80463)
  in {res_80464}
}

fun {f32} lifted_37369(f32 x_80465) = {
  {x_80465}
}

fun {f32} lifted_37372(f32 x_80466) = {
  {x_80466}
}

fun {f32} lifted_37376(f32 x_80467, f32 y_80468) = {
  let {f32 res_80469} = fmul32(x_80467, y_80468)
  in {res_80469}
}

fun {f32} lifted_37380(f32 x_80470) = {
  {x_80470}
}

fun {f32} lifted_37383(f32 x_80471) = {
  {x_80471}
}

fun {f32} lifted_37387(f32 x_80472, f32 y_80473) = {
  let {f32 res_80474} = fmul32(x_80472, y_80473)
  in {res_80474}
}

fun {f32} lifted_37392(f32 x_80475, f32 y_80476) = {
  let {f32 res_80477} = fadd32(x_80475, y_80476)
  in {res_80477}
}

fun {f32} lifted_37397(f32 x_80478, f32 y_80479) = {
  let {f32 res_80480} = fdiv32(x_80478, y_80479)
  in {res_80480}
}

fun {f32, f32} lifted_37287(f32 a_80481, f32 b_80482, f32 c_80483,
                            f32 d_80484) = {
  let {f32 arg_80485} = lifted_37289(a_80481)
  let {f32 arg_80486} = lifted_37293(arg_80485, c_80483)
  let {f32 arg_80487} = lifted_37297(arg_80486)
  let {f32 arg_80488} = lifted_37300(b_80482)
  let {f32 arg_80489} = lifted_37304(arg_80488, d_80484)
  let {f32 arg_80490} = lifted_37309(arg_80487, arg_80489)
  let {f32 arg_80491} = lifted_37313(arg_80490)
  let {f32 arg_80492} = lifted_37316(c_80483)
  let {f32 arg_80493} = lifted_37320(arg_80492, c_80483)
  let {f32 arg_80494} = lifted_37324(arg_80493)
  let {f32 arg_80495} = lifted_37327(d_80484)
  let {f32 arg_80496} = lifted_37331(arg_80495, d_80484)
  let {f32 arg_80497} = lifted_37336(arg_80494, arg_80496)
  let {f32 res_80498} = lifted_37341(arg_80491, arg_80497)
  let {f32 arg_80499} = lifted_37345(b_80482)
  let {f32 arg_80500} = lifted_37349(arg_80499, c_80483)
  let {f32 arg_80501} = lifted_37353(arg_80500)
  let {f32 arg_80502} = lifted_37356(a_80481)
  let {f32 arg_80503} = lifted_37360(arg_80502, d_80484)
  let {f32 arg_80504} = lifted_37365(arg_80501, arg_80503)
  let {f32 arg_80505} = lifted_37369(arg_80504)
  let {f32 arg_80506} = lifted_37372(c_80483)
  let {f32 arg_80507} = lifted_37376(arg_80506, c_80483)
  let {f32 arg_80508} = lifted_37380(arg_80507)
  let {f32 arg_80509} = lifted_37383(d_80484)
  let {f32 arg_80510} = lifted_37387(arg_80509, d_80484)
  let {f32 arg_80511} = lifted_37392(arg_80508, arg_80510)
  let {f32 res_80512} = lifted_37397(arg_80505, arg_80511)
  in {res_80498, res_80512}
}

fun {f32, f32} lifted_37269(f32 x_80513, f32 x_80514, f32 y_80515,
                            f32 y_80516) = {
  let {f32 arg_80517, f32 arg_80518} = lifted_37276(x_80513, x_80514)
  let {f32 res_80519, f32 res_80520} = lifted_37287(arg_80517, arg_80518,
                                                    y_80515, y_80516)
  in {res_80519, res_80520}
}

fun {f32} lifted_37419(f32 x_80521) = {
  {x_80521}
}

fun {f32} lifted_37423(f32 x_80522, f32 y_80523) = {
  let {f32 res_80524} = fmul32(x_80522, y_80523)
  in {res_80524}
}

fun {f32} lifted_37427(f32 x_80525) = {
  {x_80525}
}

fun {f32} lifted_37430(f32 x_80526) = {
  {x_80526}
}

fun {f32} lifted_37434(f32 x_80527, f32 y_80528) = {
  let {f32 res_80529} = fmul32(x_80527, y_80528)
  in {res_80529}
}

fun {f32} lifted_37439(f32 x_80530, f32 y_80531) = {
  let {f32 res_80532} = fadd32(x_80530, y_80531)
  in {res_80532}
}

fun {f32} lifted_37443(f32 x_80533) = {
  let {f32 res_80534} = sqrt32(x_80533)
  in {res_80534}
}

fun {f32} lifted_37417(f32 a_80535, f32 b_80536) = {
  let {f32 arg_80537} = lifted_37419(a_80535)
  let {f32 arg_80538} = lifted_37423(arg_80537, a_80535)
  let {f32 arg_80539} = lifted_37427(arg_80538)
  let {f32 arg_80540} = lifted_37430(b_80536)
  let {f32 arg_80541} = lifted_37434(arg_80540, b_80536)
  let {f32 arg_80542} = lifted_37439(arg_80539, arg_80541)
  let {f32 res_80543} = lifted_37443(arg_80542)
  in {res_80543}
}

fun {f32} lifted_37448(f32 x_80544) = {
  let {f32 res_80545} = log32(x_80544)
  in {res_80545}
}

fun {f32} lifted_37452(f32 a_80546) = {
  {a_80546}
}

fun {f32} lifted_37459(f32 x_80547) = {
  {x_80547}
}

fun {f32} lifted_37463(f32 x_80548, f32 y_80549) = {
  let {f32 res_80550} = atan2_32(x_80548, y_80549)
  in {res_80550}
}

fun {f32} lifted_37457(f32 a_80551, f32 b_80552) = {
  let {f32 arg_80553} = lifted_37459(b_80552)
  let {f32 res_80554} = lifted_37463(arg_80553, a_80551)
  in {res_80554}
}

fun {f32, f32} lifted_37469(f32 a_80555, f32 b_80556) = {
  {a_80555, b_80556}
}

fun {f32, f32} lifted_37411(f32 z_80557, f32 z_80558) = {
  let {f32 arg_80559} = lifted_37417(z_80557, z_80558)
  let {f32 arg_80560} = lifted_37448(arg_80559)
  let {f32 arg_80561} = lifted_37452(arg_80560)
  let {f32 arg_80562} = lifted_37457(z_80557, z_80558)
  let {f32 res_80563, f32 res_80564} = lifted_37469(arg_80561, arg_80562)
  in {res_80563, res_80564}
}

fun {f32, f32} lifted_37487(f32 a_80565, f32 b_80566) = {
  {a_80565, b_80566}
}

fun {f32} lifted_37499(f32 x_80567) = {
  {x_80567}
}

fun {f32} lifted_37503(f32 x_80568, f32 y_80569) = {
  let {f32 res_80570} = fmul32(x_80568, y_80569)
  in {res_80570}
}

fun {f32} lifted_37507(f32 x_80571) = {
  {x_80571}
}

fun {f32} lifted_37510(f32 x_80572) = {
  {x_80572}
}

fun {f32} lifted_37514(f32 x_80573, f32 y_80574) = {
  let {f32 res_80575} = fmul32(x_80573, y_80574)
  in {res_80575}
}

fun {f32} lifted_37519(f32 x_80576, f32 y_80577) = {
  let {f32 res_80578} = fsub32(x_80576, y_80577)
  in {res_80578}
}

fun {f32} lifted_37523(f32 x_80579) = {
  {x_80579}
}

fun {f32} lifted_37527(f32 x_80580, f32 y_80581) = {
  let {f32 res_80582} = fmul32(x_80580, y_80581)
  in {res_80582}
}

fun {f32} lifted_37531(f32 x_80583) = {
  {x_80583}
}

fun {f32} lifted_37534(f32 x_80584) = {
  {x_80584}
}

fun {f32} lifted_37538(f32 x_80585, f32 y_80586) = {
  let {f32 res_80587} = fmul32(x_80585, y_80586)
  in {res_80587}
}

fun {f32} lifted_37543(f32 x_80588, f32 y_80589) = {
  let {f32 res_80590} = fadd32(x_80588, y_80589)
  in {res_80590}
}

fun {f32, f32} lifted_37497(f32 a_80591, f32 b_80592, f32 c_80593,
                            f32 d_80594) = {
  let {f32 arg_80595} = lifted_37499(a_80591)
  let {f32 arg_80596} = lifted_37503(arg_80595, c_80593)
  let {f32 arg_80597} = lifted_37507(arg_80596)
  let {f32 arg_80598} = lifted_37510(b_80592)
  let {f32 arg_80599} = lifted_37514(arg_80598, d_80594)
  let {f32 res_80600} = lifted_37519(arg_80597, arg_80599)
  let {f32 arg_80601} = lifted_37523(b_80592)
  let {f32 arg_80602} = lifted_37527(arg_80601, c_80593)
  let {f32 arg_80603} = lifted_37531(arg_80602)
  let {f32 arg_80604} = lifted_37534(a_80591)
  let {f32 arg_80605} = lifted_37538(arg_80604, d_80594)
  let {f32 res_80606} = lifted_37543(arg_80603, arg_80605)
  in {res_80600, res_80606}
}

fun {f32, f32} lifted_37481(f32 x_80607, f32 x_80608, f32 y_80609,
                            f32 y_80610) = {
  let {f32 arg_80611, f32 arg_80612} = lifted_37487(x_80607, x_80608)
  let {f32 res_80613, f32 res_80614} = lifted_37497(arg_80611, arg_80612,
                                                    y_80609, y_80610)
  in {res_80613, res_80614}
}

fun {f32, f32} lifted_37561(f32 a_80615, f32 b_80616) = {
  {a_80615, b_80616}
}

fun {f32} lifted_37571(f32 x_80617) = {
  {x_80617}
}

fun {f32} lifted_37575(f32 x_80618, f32 y_80619) = {
  let {f32 res_80620} = fsub32(x_80618, y_80619)
  in {res_80620}
}

fun {f32} lifted_37579(f32 x_80621) = {
  {x_80621}
}

fun {f32} lifted_37583(f32 x_80622, f32 y_80623) = {
  let {f32 res_80624} = fsub32(x_80622, y_80623)
  in {res_80624}
}

fun {f32, f32} lifted_37569(f32 a_80625, f32 b_80626, f32 c_80627,
                            f32 d_80628) = {
  let {f32 arg_80629} = lifted_37571(a_80625)
  let {f32 res_80630} = lifted_37575(arg_80629, c_80627)
  let {f32 arg_80631} = lifted_37579(b_80626)
  let {f32 res_80632} = lifted_37583(arg_80631, d_80628)
  in {res_80630, res_80632}
}

fun {f32, f32} lifted_37557(f32 x_80633, f32 x_80634, f32 y_80635,
                            f32 y_80636) = {
  let {f32 arg_80637, f32 arg_80638} = lifted_37561(x_80633, x_80634)
  let {f32 res_80639, f32 res_80640} = lifted_37569(arg_80637, arg_80638,
                                                    y_80635, y_80636)
  in {res_80639, res_80640}
}

fun {f32, f32} lifted_37603(f32 a_80641, f32 b_80642) = {
  {a_80641, b_80642}
}

fun {f32} lifted_37615(f32 x_80643) = {
  {x_80643}
}

fun {f32} lifted_37619(f32 x_80644, f32 y_80645) = {
  let {f32 res_80646} = fmul32(x_80644, y_80645)
  in {res_80646}
}

fun {f32} lifted_37623(f32 x_80647) = {
  {x_80647}
}

fun {f32} lifted_37626(f32 x_80648) = {
  {x_80648}
}

fun {f32} lifted_37630(f32 x_80649, f32 y_80650) = {
  let {f32 res_80651} = fmul32(x_80649, y_80650)
  in {res_80651}
}

fun {f32} lifted_37635(f32 x_80652, f32 y_80653) = {
  let {f32 res_80654} = fsub32(x_80652, y_80653)
  in {res_80654}
}

fun {f32} lifted_37639(f32 x_80655) = {
  {x_80655}
}

fun {f32} lifted_37643(f32 x_80656, f32 y_80657) = {
  let {f32 res_80658} = fmul32(x_80656, y_80657)
  in {res_80658}
}

fun {f32} lifted_37647(f32 x_80659) = {
  {x_80659}
}

fun {f32} lifted_37650(f32 x_80660) = {
  {x_80660}
}

fun {f32} lifted_37654(f32 x_80661, f32 y_80662) = {
  let {f32 res_80663} = fmul32(x_80661, y_80662)
  in {res_80663}
}

fun {f32} lifted_37659(f32 x_80664, f32 y_80665) = {
  let {f32 res_80666} = fadd32(x_80664, y_80665)
  in {res_80666}
}

fun {f32, f32} lifted_37613(f32 a_80667, f32 b_80668, f32 c_80669,
                            f32 d_80670) = {
  let {f32 arg_80671} = lifted_37615(a_80667)
  let {f32 arg_80672} = lifted_37619(arg_80671, c_80669)
  let {f32 arg_80673} = lifted_37623(arg_80672)
  let {f32 arg_80674} = lifted_37626(b_80668)
  let {f32 arg_80675} = lifted_37630(arg_80674, d_80670)
  let {f32 res_80676} = lifted_37635(arg_80673, arg_80675)
  let {f32 arg_80677} = lifted_37639(b_80668)
  let {f32 arg_80678} = lifted_37643(arg_80677, c_80669)
  let {f32 arg_80679} = lifted_37647(arg_80678)
  let {f32 arg_80680} = lifted_37650(a_80667)
  let {f32 arg_80681} = lifted_37654(arg_80680, d_80670)
  let {f32 res_80682} = lifted_37659(arg_80679, arg_80681)
  in {res_80676, res_80682}
}

fun {f32, f32} lifted_37597(f32 x_80683, f32 x_80684, f32 y_80685,
                            f32 y_80686) = {
  let {f32 arg_80687, f32 arg_80688} = lifted_37603(x_80683, x_80684)
  let {f32 res_80689, f32 res_80690} = lifted_37613(arg_80687, arg_80688,
                                                    y_80685, y_80686)
  in {res_80689, res_80690}
}

fun {f32, f32} lifted_37670(f32 x_80691, f32 x_80692) = {
  {x_80691, x_80692}
}

fun {f32, f32} lifted_37677(f32 x_80693, f32 x_80694) = {
  {x_80693, x_80694}
}

fun {f32, f32} lifted_37693(f32 a_80695, f32 b_80696) = {
  {a_80695, b_80696}
}

fun {f32} lifted_37705(f32 x_80697) = {
  {x_80697}
}

fun {f32} lifted_37709(f32 x_80698, f32 y_80699) = {
  let {f32 res_80700} = fmul32(x_80698, y_80699)
  in {res_80700}
}

fun {f32} lifted_37713(f32 x_80701) = {
  {x_80701}
}

fun {f32} lifted_37716(f32 x_80702) = {
  {x_80702}
}

fun {f32} lifted_37720(f32 x_80703, f32 y_80704) = {
  let {f32 res_80705} = fmul32(x_80703, y_80704)
  in {res_80705}
}

fun {f32} lifted_37725(f32 x_80706, f32 y_80707) = {
  let {f32 res_80708} = fsub32(x_80706, y_80707)
  in {res_80708}
}

fun {f32} lifted_37729(f32 x_80709) = {
  {x_80709}
}

fun {f32} lifted_37733(f32 x_80710, f32 y_80711) = {
  let {f32 res_80712} = fmul32(x_80710, y_80711)
  in {res_80712}
}

fun {f32} lifted_37737(f32 x_80713) = {
  {x_80713}
}

fun {f32} lifted_37740(f32 x_80714) = {
  {x_80714}
}

fun {f32} lifted_37744(f32 x_80715, f32 y_80716) = {
  let {f32 res_80717} = fmul32(x_80715, y_80716)
  in {res_80717}
}

fun {f32} lifted_37749(f32 x_80718, f32 y_80719) = {
  let {f32 res_80720} = fadd32(x_80718, y_80719)
  in {res_80720}
}

fun {f32, f32} lifted_37703(f32 a_80721, f32 b_80722, f32 c_80723,
                            f32 d_80724) = {
  let {f32 arg_80725} = lifted_37705(a_80721)
  let {f32 arg_80726} = lifted_37709(arg_80725, c_80723)
  let {f32 arg_80727} = lifted_37713(arg_80726)
  let {f32 arg_80728} = lifted_37716(b_80722)
  let {f32 arg_80729} = lifted_37720(arg_80728, d_80724)
  let {f32 res_80730} = lifted_37725(arg_80727, arg_80729)
  let {f32 arg_80731} = lifted_37729(b_80722)
  let {f32 arg_80732} = lifted_37733(arg_80731, c_80723)
  let {f32 arg_80733} = lifted_37737(arg_80732)
  let {f32 arg_80734} = lifted_37740(a_80721)
  let {f32 arg_80735} = lifted_37744(arg_80734, d_80724)
  let {f32 res_80736} = lifted_37749(arg_80733, arg_80735)
  in {res_80730, res_80736}
}

fun {f32, f32} lifted_37687(f32 x_80737, f32 x_80738, f32 y_80739,
                            f32 y_80740) = {
  let {f32 arg_80741, f32 arg_80742} = lifted_37693(x_80737, x_80738)
  let {f32 res_80743, f32 res_80744} = lifted_37703(arg_80741, arg_80742,
                                                    y_80739, y_80740)
  in {res_80743, res_80744}
}

fun {f32, f32} lifted_37760(f32 x_80745, f32 x_80746) = {
  {x_80745, x_80746}
}

fun {f32, f32} lifted_37767(f32 x_80747, f32 x_80748) = {
  {x_80747, x_80748}
}

fun {f32, f32} lifted_37781(f32 a_80749, f32 b_80750) = {
  {a_80749, b_80750}
}

fun {f32} lifted_37791(f32 x_80751) = {
  {x_80751}
}

fun {f32} lifted_37795(f32 x_80752, f32 y_80753) = {
  let {f32 res_80754} = fsub32(x_80752, y_80753)
  in {res_80754}
}

fun {f32} lifted_37799(f32 x_80755) = {
  {x_80755}
}

fun {f32} lifted_37803(f32 x_80756, f32 y_80757) = {
  let {f32 res_80758} = fsub32(x_80756, y_80757)
  in {res_80758}
}

fun {f32, f32} lifted_37789(f32 a_80759, f32 b_80760, f32 c_80761,
                            f32 d_80762) = {
  let {f32 arg_80763} = lifted_37791(a_80759)
  let {f32 res_80764} = lifted_37795(arg_80763, c_80761)
  let {f32 arg_80765} = lifted_37799(b_80760)
  let {f32 res_80766} = lifted_37803(arg_80765, d_80762)
  in {res_80764, res_80766}
}

fun {f32, f32} lifted_37777(f32 x_80767, f32 x_80768, f32 y_80769,
                            f32 y_80770) = {
  let {f32 arg_80771, f32 arg_80772} = lifted_37781(x_80767, x_80768)
  let {f32 res_80773, f32 res_80774} = lifted_37789(arg_80771, arg_80772,
                                                    y_80769, y_80770)
  in {res_80773, res_80774}
}

fun {f32, f32} lifted_37823(f32 a_80775, f32 b_80776) = {
  {a_80775, b_80776}
}

fun {f32} lifted_37835(f32 x_80777) = {
  {x_80777}
}

fun {f32} lifted_37839(f32 x_80778, f32 y_80779) = {
  let {f32 res_80780} = fmul32(x_80778, y_80779)
  in {res_80780}
}

fun {f32} lifted_37843(f32 x_80781) = {
  {x_80781}
}

fun {f32} lifted_37846(f32 x_80782) = {
  {x_80782}
}

fun {f32} lifted_37850(f32 x_80783, f32 y_80784) = {
  let {f32 res_80785} = fmul32(x_80783, y_80784)
  in {res_80785}
}

fun {f32} lifted_37855(f32 x_80786, f32 y_80787) = {
  let {f32 res_80788} = fsub32(x_80786, y_80787)
  in {res_80788}
}

fun {f32} lifted_37859(f32 x_80789) = {
  {x_80789}
}

fun {f32} lifted_37863(f32 x_80790, f32 y_80791) = {
  let {f32 res_80792} = fmul32(x_80790, y_80791)
  in {res_80792}
}

fun {f32} lifted_37867(f32 x_80793) = {
  {x_80793}
}

fun {f32} lifted_37870(f32 x_80794) = {
  {x_80794}
}

fun {f32} lifted_37874(f32 x_80795, f32 y_80796) = {
  let {f32 res_80797} = fmul32(x_80795, y_80796)
  in {res_80797}
}

fun {f32} lifted_37879(f32 x_80798, f32 y_80799) = {
  let {f32 res_80800} = fadd32(x_80798, y_80799)
  in {res_80800}
}

fun {f32, f32} lifted_37833(f32 a_80801, f32 b_80802, f32 c_80803,
                            f32 d_80804) = {
  let {f32 arg_80805} = lifted_37835(a_80801)
  let {f32 arg_80806} = lifted_37839(arg_80805, c_80803)
  let {f32 arg_80807} = lifted_37843(arg_80806)
  let {f32 arg_80808} = lifted_37846(b_80802)
  let {f32 arg_80809} = lifted_37850(arg_80808, d_80804)
  let {f32 res_80810} = lifted_37855(arg_80807, arg_80809)
  let {f32 arg_80811} = lifted_37859(b_80802)
  let {f32 arg_80812} = lifted_37863(arg_80811, c_80803)
  let {f32 arg_80813} = lifted_37867(arg_80812)
  let {f32 arg_80814} = lifted_37870(a_80801)
  let {f32 arg_80815} = lifted_37874(arg_80814, d_80804)
  let {f32 res_80816} = lifted_37879(arg_80813, arg_80815)
  in {res_80810, res_80816}
}

fun {f32, f32} lifted_37817(f32 x_80817, f32 x_80818, f32 y_80819,
                            f32 y_80820) = {
  let {f32 arg_80821, f32 arg_80822} = lifted_37823(x_80817, x_80818)
  let {f32 res_80823, f32 res_80824} = lifted_37833(arg_80821, arg_80822,
                                                    y_80819, y_80820)
  in {res_80823, res_80824}
}

fun {f32, f32} lifted_37890(f32 x_80825, f32 x_80826) = {
  {x_80825, x_80826}
}

fun {f32, f32} lifted_37897(f32 x_80827, f32 x_80828) = {
  {x_80827, x_80828}
}

fun {f32, f32} lifted_37904(f32 x_80829, f32 x_80830) = {
  {x_80829, x_80830}
}

fun {f32, f32} lifted_37920(f32 a_80831, f32 b_80832) = {
  {a_80831, b_80832}
}

fun {f32} lifted_37932(f32 x_80833) = {
  {x_80833}
}

fun {f32} lifted_37936(f32 x_80834, f32 y_80835) = {
  let {f32 res_80836} = fmul32(x_80834, y_80835)
  in {res_80836}
}

fun {f32} lifted_37940(f32 x_80837) = {
  {x_80837}
}

fun {f32} lifted_37943(f32 x_80838) = {
  {x_80838}
}

fun {f32} lifted_37947(f32 x_80839, f32 y_80840) = {
  let {f32 res_80841} = fmul32(x_80839, y_80840)
  in {res_80841}
}

fun {f32} lifted_37952(f32 x_80842, f32 y_80843) = {
  let {f32 res_80844} = fsub32(x_80842, y_80843)
  in {res_80844}
}

fun {f32} lifted_37956(f32 x_80845) = {
  {x_80845}
}

fun {f32} lifted_37960(f32 x_80846, f32 y_80847) = {
  let {f32 res_80848} = fmul32(x_80846, y_80847)
  in {res_80848}
}

fun {f32} lifted_37964(f32 x_80849) = {
  {x_80849}
}

fun {f32} lifted_37967(f32 x_80850) = {
  {x_80850}
}

fun {f32} lifted_37971(f32 x_80851, f32 y_80852) = {
  let {f32 res_80853} = fmul32(x_80851, y_80852)
  in {res_80853}
}

fun {f32} lifted_37976(f32 x_80854, f32 y_80855) = {
  let {f32 res_80856} = fadd32(x_80854, y_80855)
  in {res_80856}
}

fun {f32, f32} lifted_37930(f32 a_80857, f32 b_80858, f32 c_80859,
                            f32 d_80860) = {
  let {f32 arg_80861} = lifted_37932(a_80857)
  let {f32 arg_80862} = lifted_37936(arg_80861, c_80859)
  let {f32 arg_80863} = lifted_37940(arg_80862)
  let {f32 arg_80864} = lifted_37943(b_80858)
  let {f32 arg_80865} = lifted_37947(arg_80864, d_80860)
  let {f32 res_80866} = lifted_37952(arg_80863, arg_80865)
  let {f32 arg_80867} = lifted_37956(b_80858)
  let {f32 arg_80868} = lifted_37960(arg_80867, c_80859)
  let {f32 arg_80869} = lifted_37964(arg_80868)
  let {f32 arg_80870} = lifted_37967(a_80857)
  let {f32 arg_80871} = lifted_37971(arg_80870, d_80860)
  let {f32 res_80872} = lifted_37976(arg_80869, arg_80871)
  in {res_80866, res_80872}
}

fun {f32, f32} lifted_37914(f32 x_80873, f32 x_80874, f32 y_80875,
                            f32 y_80876) = {
  let {f32 arg_80877, f32 arg_80878} = lifted_37920(x_80873, x_80874)
  let {f32 res_80879, f32 res_80880} = lifted_37930(arg_80877, arg_80878,
                                                    y_80875, y_80876)
  in {res_80879, res_80880}
}

fun {f32, f32} lifted_37994(f32 a_80881, f32 b_80882) = {
  {a_80881, b_80882}
}

fun {f32} lifted_38004(f32 x_80883) = {
  {x_80883}
}

fun {f32} lifted_38008(f32 x_80884, f32 y_80885) = {
  let {f32 res_80886} = fsub32(x_80884, y_80885)
  in {res_80886}
}

fun {f32} lifted_38012(f32 x_80887) = {
  {x_80887}
}

fun {f32} lifted_38016(f32 x_80888, f32 y_80889) = {
  let {f32 res_80890} = fsub32(x_80888, y_80889)
  in {res_80890}
}

fun {f32, f32} lifted_38002(f32 a_80891, f32 b_80892, f32 c_80893,
                            f32 d_80894) = {
  let {f32 arg_80895} = lifted_38004(a_80891)
  let {f32 res_80896} = lifted_38008(arg_80895, c_80893)
  let {f32 arg_80897} = lifted_38012(b_80892)
  let {f32 res_80898} = lifted_38016(arg_80897, d_80894)
  in {res_80896, res_80898}
}

fun {f32, f32} lifted_37990(f32 x_80899, f32 x_80900, f32 y_80901,
                            f32 y_80902) = {
  let {f32 arg_80903, f32 arg_80904} = lifted_37994(x_80899, x_80900)
  let {f32 res_80905, f32 res_80906} = lifted_38002(arg_80903, arg_80904,
                                                    y_80901, y_80902)
  in {res_80905, res_80906}
}

fun {f32, f32} lifted_38037(f32 a_80907, f32 b_80908) = {
  {a_80907, b_80908}
}

fun {f32} lifted_38050(f32 x_80909) = {
  {x_80909}
}

fun {f32} lifted_38054(f32 x_80910, f32 y_80911) = {
  let {f32 res_80912} = fmul32(x_80910, y_80911)
  in {res_80912}
}

fun {f32} lifted_38058(f32 x_80913) = {
  {x_80913}
}

fun {f32} lifted_38061(f32 x_80914) = {
  {x_80914}
}

fun {f32} lifted_38065(f32 x_80915, f32 y_80916) = {
  let {f32 res_80917} = fmul32(x_80915, y_80916)
  in {res_80917}
}

fun {f32} lifted_38070(f32 x_80918, f32 y_80919) = {
  let {f32 res_80920} = fadd32(x_80918, y_80919)
  in {res_80920}
}

fun {f32} lifted_38074(f32 x_80921) = {
  {x_80921}
}

fun {f32} lifted_38077(f32 x_80922) = {
  {x_80922}
}

fun {f32} lifted_38081(f32 x_80923, f32 y_80924) = {
  let {f32 res_80925} = fmul32(x_80923, y_80924)
  in {res_80925}
}

fun {f32} lifted_38085(f32 x_80926) = {
  {x_80926}
}

fun {f32} lifted_38088(f32 x_80927) = {
  {x_80927}
}

fun {f32} lifted_38092(f32 x_80928, f32 y_80929) = {
  let {f32 res_80930} = fmul32(x_80928, y_80929)
  in {res_80930}
}

fun {f32} lifted_38097(f32 x_80931, f32 y_80932) = {
  let {f32 res_80933} = fadd32(x_80931, y_80932)
  in {res_80933}
}

fun {f32} lifted_38102(f32 x_80934, f32 y_80935) = {
  let {f32 res_80936} = fdiv32(x_80934, y_80935)
  in {res_80936}
}

fun {f32} lifted_38106(f32 x_80937) = {
  {x_80937}
}

fun {f32} lifted_38110(f32 x_80938, f32 y_80939) = {
  let {f32 res_80940} = fmul32(x_80938, y_80939)
  in {res_80940}
}

fun {f32} lifted_38114(f32 x_80941) = {
  {x_80941}
}

fun {f32} lifted_38117(f32 x_80942) = {
  {x_80942}
}

fun {f32} lifted_38121(f32 x_80943, f32 y_80944) = {
  let {f32 res_80945} = fmul32(x_80943, y_80944)
  in {res_80945}
}

fun {f32} lifted_38126(f32 x_80946, f32 y_80947) = {
  let {f32 res_80948} = fsub32(x_80946, y_80947)
  in {res_80948}
}

fun {f32} lifted_38130(f32 x_80949) = {
  {x_80949}
}

fun {f32} lifted_38133(f32 x_80950) = {
  {x_80950}
}

fun {f32} lifted_38137(f32 x_80951, f32 y_80952) = {
  let {f32 res_80953} = fmul32(x_80951, y_80952)
  in {res_80953}
}

fun {f32} lifted_38141(f32 x_80954) = {
  {x_80954}
}

fun {f32} lifted_38144(f32 x_80955) = {
  {x_80955}
}

fun {f32} lifted_38148(f32 x_80956, f32 y_80957) = {
  let {f32 res_80958} = fmul32(x_80956, y_80957)
  in {res_80958}
}

fun {f32} lifted_38153(f32 x_80959, f32 y_80960) = {
  let {f32 res_80961} = fadd32(x_80959, y_80960)
  in {res_80961}
}

fun {f32} lifted_38158(f32 x_80962, f32 y_80963) = {
  let {f32 res_80964} = fdiv32(x_80962, y_80963)
  in {res_80964}
}

fun {f32, f32} lifted_38048(f32 a_80965, f32 b_80966, f32 c_80967,
                            f32 d_80968) = {
  let {f32 arg_80969} = lifted_38050(a_80965)
  let {f32 arg_80970} = lifted_38054(arg_80969, c_80967)
  let {f32 arg_80971} = lifted_38058(arg_80970)
  let {f32 arg_80972} = lifted_38061(b_80966)
  let {f32 arg_80973} = lifted_38065(arg_80972, d_80968)
  let {f32 arg_80974} = lifted_38070(arg_80971, arg_80973)
  let {f32 arg_80975} = lifted_38074(arg_80974)
  let {f32 arg_80976} = lifted_38077(c_80967)
  let {f32 arg_80977} = lifted_38081(arg_80976, c_80967)
  let {f32 arg_80978} = lifted_38085(arg_80977)
  let {f32 arg_80979} = lifted_38088(d_80968)
  let {f32 arg_80980} = lifted_38092(arg_80979, d_80968)
  let {f32 arg_80981} = lifted_38097(arg_80978, arg_80980)
  let {f32 res_80982} = lifted_38102(arg_80975, arg_80981)
  let {f32 arg_80983} = lifted_38106(b_80966)
  let {f32 arg_80984} = lifted_38110(arg_80983, c_80967)
  let {f32 arg_80985} = lifted_38114(arg_80984)
  let {f32 arg_80986} = lifted_38117(a_80965)
  let {f32 arg_80987} = lifted_38121(arg_80986, d_80968)
  let {f32 arg_80988} = lifted_38126(arg_80985, arg_80987)
  let {f32 arg_80989} = lifted_38130(arg_80988)
  let {f32 arg_80990} = lifted_38133(c_80967)
  let {f32 arg_80991} = lifted_38137(arg_80990, c_80967)
  let {f32 arg_80992} = lifted_38141(arg_80991)
  let {f32 arg_80993} = lifted_38144(d_80968)
  let {f32 arg_80994} = lifted_38148(arg_80993, d_80968)
  let {f32 arg_80995} = lifted_38153(arg_80992, arg_80994)
  let {f32 res_80996} = lifted_38158(arg_80989, arg_80995)
  in {res_80982, res_80996}
}

fun {f32, f32} lifted_38030(f32 x_80997, f32 x_80998, f32 y_80999,
                            f32 y_81000) = {
  let {f32 arg_81001, f32 arg_81002} = lifted_38037(x_80997, x_80998)
  let {f32 res_81003, f32 res_81004} = lifted_38048(arg_81001, arg_81002,
                                                    y_80999, y_81000)
  in {res_81003, res_81004}
}

fun {f32, f32} lifted_38176(f32 a_81005, f32 b_81006) = {
  {a_81005, b_81006}
}

fun {f32} lifted_38186(f32 x_81007) = {
  {x_81007}
}

fun {f32} lifted_38190(f32 x_81008, f32 y_81009) = {
  let {f32 res_81010} = fadd32(x_81008, y_81009)
  in {res_81010}
}

fun {f32} lifted_38194(f32 x_81011) = {
  {x_81011}
}

fun {f32} lifted_38198(f32 x_81012, f32 y_81013) = {
  let {f32 res_81014} = fadd32(x_81012, y_81013)
  in {res_81014}
}

fun {f32, f32} lifted_38184(f32 a_81015, f32 b_81016, f32 c_81017,
                            f32 d_81018) = {
  let {f32 arg_81019} = lifted_38186(a_81015)
  let {f32 res_81020} = lifted_38190(arg_81019, c_81017)
  let {f32 arg_81021} = lifted_38194(b_81016)
  let {f32 res_81022} = lifted_38198(arg_81021, d_81018)
  in {res_81020, res_81022}
}

fun {f32, f32} lifted_38172(f32 x_81023, f32 x_81024, f32 y_81025,
                            f32 y_81026) = {
  let {f32 arg_81027, f32 arg_81028} = lifted_38176(x_81023, x_81024)
  let {f32 res_81029, f32 res_81030} = lifted_38184(arg_81027, arg_81028,
                                                    y_81025, y_81026)
  in {res_81029, res_81030}
}

fun {f32} lifted_38214(f32 x_81031) = {
  let {f32 res_81032} = exp32(x_81031)
  in {res_81032}
}

fun {f32} lifted_38219(f32 x_81033) = {
  {x_81033}
}

fun {f32} lifted_38222(f32 x_81034) = {
  let {f32 res_81035} = cos32(x_81034)
  in {res_81035}
}

fun {f32} lifted_38227(f32 x_81036, f32 y_81037) = {
  let {f32 res_81038} = fmul32(x_81036, y_81037)
  in {res_81038}
}

fun {f32} lifted_38231(f32 a_81039) = {
  {a_81039}
}

fun {f32} lifted_38234(f32 x_81040) = {
  {x_81040}
}

fun {f32} lifted_38237(f32 x_81041) = {
  let {f32 res_81042} = sin32(x_81041)
  in {res_81042}
}

fun {f32} lifted_38242(f32 x_81043, f32 y_81044) = {
  let {f32 res_81045} = fmul32(x_81043, y_81044)
  in {res_81045}
}

fun {f32, f32} lifted_38247(f32 a_81046, f32 b_81047) = {
  {a_81046, b_81047}
}

fun {f32, f32} lifted_38212(f32 a_81048, f32 b_81049) = {
  let {f32 res_81050} = lifted_38214(a_81048)
  let {f32 expx_81051} = res_81050
  let {f32 arg_81052} = lifted_38219(expx_81051)
  let {f32 arg_81053} = lifted_38222(b_81049)
  let {f32 arg_81054} = lifted_38227(arg_81052, arg_81053)
  let {f32 arg_81055} = lifted_38231(arg_81054)
  let {f32 arg_81056} = lifted_38234(expx_81051)
  let {f32 arg_81057} = lifted_38237(b_81049)
  let {f32 arg_81058} = lifted_38242(arg_81056, arg_81057)
  let {f32 res_81059, f32 res_81060} = lifted_38247(arg_81055, arg_81058)
  in {res_81059, res_81060}
}

fun {f32, f32} lifted_35790(f32 coeff1_81061, f32 coeff1_81062,
                            f32 coeff2_81063, f32 coeff2_81064,
                            f32 day_count_fraction_81065, f32 etai2_81066,
                            f32 etai2_81067, f32 etai_81068, f32 etai_81069,
                            f32 i_81070, f32 i_81071, f32 kappai_81072,
                            f32 kappai_81073, f32 one_81074, f32 one_81075,
                            f32 rho_81076, f32 two_81077, f32 two_81078,
                            f32 zero_81079, f32 zero_81080, f32 xi_81081,
                            f32 xi_81082) = {
  let {f32 res_81083, f32 res_81084} = lifted_35793(day_count_fraction_81065)
  let {f32 ti_81085} = res_81083
  let {f32 ti_81086} = res_81084
  let {f32 arg_81087, f32 arg_81088} = lifted_35807(kappai_81072, kappai_81073)
  let {f32 arg_81089, f32 arg_81090} = lifted_35812(rho_81076)
  let {f32 arg_81091, f32 arg_81092} = lifted_35823(arg_81089, arg_81090)
  let {f32 arg_81093, f32 arg_81094} = lifted_35833(arg_81091, arg_81092,
                                                    etai_81068, etai_81069)
  let {f32 arg_81095, f32 arg_81096} = lifted_35906(arg_81093, arg_81094)
  let {f32 arg_81097, f32 arg_81098} = lifted_35916(arg_81095, arg_81096,
                                                    xi_81081, xi_81082)
  let {f32 res_81099, f32 res_81100} = lifted_35992(arg_81087, arg_81088,
                                                    arg_81097, arg_81098)
  let {f32 d0_81101} = res_81099
  let {f32 d0_81102} = res_81100
  let {f32 arg_81103, f32 arg_81104} = lifted_36032(d0_81101, d0_81102)
  let {f32 arg_81105, f32 arg_81106} = lifted_36042(arg_81103, arg_81104,
                                                    d0_81101, d0_81102)
  let {f32 arg_81107, f32 arg_81108} = lifted_36115(arg_81105, arg_81106)
  let {f32 arg_81109, f32 arg_81110} = lifted_36122(etai2_81066, etai2_81067)
  let {f32 arg_81111, f32 arg_81112} = lifted_36129(xi_81081, xi_81082)
  let {f32 arg_81113, f32 arg_81114} = lifted_36136(i_81070, i_81071)
  let {f32 arg_81115, f32 arg_81116} = lifted_36146(arg_81113, arg_81114,
                                                    xi_81081, xi_81082)
  let {f32 arg_81117, f32 arg_81118} = lifted_36186(arg_81111, arg_81112,
                                                    arg_81115, arg_81116)
  let {f32 arg_81119, f32 arg_81120} = lifted_36262(arg_81109, arg_81110,
                                                    arg_81117, arg_81118)
  let {f32 arg_81121, f32 arg_81122} = lifted_36338(arg_81107, arg_81108,
                                                    arg_81119, arg_81120)
  let {f32 res_81123, f32 res_81124} = lifted_36381(arg_81121, arg_81122)
  let {f32 d_81125} = res_81123
  let {f32 d_81126} = res_81124
  let {f32 arg_81127, f32 arg_81128} = lifted_36549(d0_81101, d0_81102)
  let {f32 res_81129, f32 res_81130} = lifted_36559(arg_81127, arg_81128,
                                                    d_81125, d_81126)
  let {f32 a_minus_81131} = res_81129
  let {f32 a_minus_81132} = res_81130
  let {f32 arg_81133, f32 arg_81134} = lifted_36599(a_minus_81131,
                                                    a_minus_81132)
  let {f32 arg_81135, f32 arg_81136} = lifted_36606(d0_81101, d0_81102)
  let {f32 arg_81137, f32 arg_81138} = lifted_36616(arg_81135, arg_81136,
                                                    d_81125, d_81126)
  let {f32 res_81139, f32 res_81140} = lifted_36656(arg_81133, arg_81134,
                                                    arg_81137, arg_81138)
  let {f32 g_81141} = res_81139
  let {f32 g_81142} = res_81140
  let {f32 arg_81143, f32 arg_81144} = lifted_36798(zero_81079, zero_81080)
  let {f32 arg_81145, f32 arg_81146} = lifted_36805(d_81125, d_81126)
  let {f32 arg_81147, f32 arg_81148} = lifted_36815(arg_81145, arg_81146,
                                                    ti_81085, ti_81086)
  let {f32 arg_81149, f32 arg_81150} = lifted_36891(arg_81143, arg_81144,
                                                    arg_81147, arg_81148)
  let {f32 res_81151, f32 res_81152} = lifted_36931(arg_81149, arg_81150)
  let {f32 e_81153} = res_81151
  let {f32 e_81154} = res_81152
  let {f32 arg_81155, f32 arg_81156} = lifted_36978(coeff1_81061, coeff1_81062)
  let {f32 arg_81157, f32 arg_81158} = lifted_36985(a_minus_81131,
                                                    a_minus_81132)
  let {f32 arg_81159, f32 arg_81160} = lifted_36995(arg_81157, arg_81158,
                                                    ti_81085, ti_81086)
  let {f32 arg_81161, f32 arg_81162} = lifted_37068(arg_81159, arg_81160)
  let {f32 arg_81163, f32 arg_81164} = lifted_37075(two_81077, two_81078)
  let {f32 arg_81165, f32 arg_81166} = lifted_37082(one_81074, one_81075)
  let {f32 arg_81167, f32 arg_81168} = lifted_37089(g_81141, g_81142)
  let {f32 arg_81169, f32 arg_81170} = lifted_37099(arg_81167, arg_81168,
                                                    e_81153, e_81154)
  let {f32 arg_81171, f32 arg_81172} = lifted_37175(arg_81165, arg_81166,
                                                    arg_81169, arg_81170)
  let {f32 arg_81173, f32 arg_81174} = lifted_37212(arg_81171, arg_81172)
  let {f32 arg_81175, f32 arg_81176} = lifted_37219(one_81074, one_81075)
  let {f32 arg_81177, f32 arg_81178} = lifted_37229(arg_81175, arg_81176,
                                                    g_81141, g_81142)
  let {f32 arg_81179, f32 arg_81180} = lifted_37269(arg_81173, arg_81174,
                                                    arg_81177, arg_81178)
  let {f32 arg_81181, f32 arg_81182} = lifted_37411(arg_81179, arg_81180)
  let {f32 arg_81183, f32 arg_81184} = lifted_37481(arg_81163, arg_81164,
                                                    arg_81181, arg_81182)
  let {f32 arg_81185, f32 arg_81186} = lifted_37557(arg_81161, arg_81162,
                                                    arg_81183, arg_81184)
  let {f32 arg_81187, f32 arg_81188} = lifted_37597(arg_81155, arg_81156,
                                                    arg_81185, arg_81186)
  let {f32 arg_81189, f32 arg_81190} = lifted_37670(arg_81187, arg_81188)
  let {f32 arg_81191, f32 arg_81192} = lifted_37677(coeff2_81063, coeff2_81064)
  let {f32 arg_81193, f32 arg_81194} = lifted_37687(arg_81191, arg_81192,
                                                    a_minus_81131,
                                                    a_minus_81132)
  let {f32 arg_81195, f32 arg_81196} = lifted_37760(arg_81193, arg_81194)
  let {f32 arg_81197, f32 arg_81198} = lifted_37767(one_81074, one_81075)
  let {f32 arg_81199, f32 arg_81200} = lifted_37777(arg_81197, arg_81198,
                                                    e_81153, e_81154)
  let {f32 arg_81201, f32 arg_81202} = lifted_37817(arg_81195, arg_81196,
                                                    arg_81199, arg_81200)
  let {f32 arg_81203, f32 arg_81204} = lifted_37890(arg_81201, arg_81202)
  let {f32 arg_81205, f32 arg_81206} = lifted_37897(one_81074, one_81075)
  let {f32 arg_81207, f32 arg_81208} = lifted_37904(g_81141, g_81142)
  let {f32 arg_81209, f32 arg_81210} = lifted_37914(arg_81207, arg_81208,
                                                    e_81153, e_81154)
  let {f32 arg_81211, f32 arg_81212} = lifted_37990(arg_81205, arg_81206,
                                                    arg_81209, arg_81210)
  let {f32 arg_81213, f32 arg_81214} = lifted_38030(arg_81203, arg_81204,
                                                    arg_81211, arg_81212)
  let {f32 arg_81215, f32 arg_81216} = lifted_38172(arg_81189, arg_81190,
                                                    arg_81213, arg_81214)
  let {f32 res_81217, f32 res_81218} = lifted_38212(arg_81215, arg_81216)
  in {res_81217, res_81218}
}

fun {f32, f32} lifted_38265(f32 a_81219, f32 b_81220) = {
  {a_81219, b_81220}
}

fun {f32} lifted_38275(f32 x_81221) = {
  {x_81221}
}

fun {f32} lifted_38279(f32 x_81222, f32 y_81223) = {
  let {f32 res_81224} = fsub32(x_81222, y_81223)
  in {res_81224}
}

fun {f32} lifted_38283(f32 x_81225) = {
  {x_81225}
}

fun {f32} lifted_38287(f32 x_81226, f32 y_81227) = {
  let {f32 res_81228} = fsub32(x_81226, y_81227)
  in {res_81228}
}

fun {f32, f32} lifted_38273(f32 a_81229, f32 b_81230, f32 c_81231,
                            f32 d_81232) = {
  let {f32 arg_81233} = lifted_38275(a_81229)
  let {f32 res_81234} = lifted_38279(arg_81233, c_81231)
  let {f32 arg_81235} = lifted_38283(b_81230)
  let {f32 res_81236} = lifted_38287(arg_81235, d_81232)
  in {res_81234, res_81236}
}

fun {f32, f32} lifted_38261(f32 x_81237, f32 x_81238, f32 y_81239,
                            f32 y_81240) = {
  let {f32 arg_81241, f32 arg_81242} = lifted_38265(x_81237, x_81238)
  let {f32 res_81243, f32 res_81244} = lifted_38273(arg_81241, arg_81242,
                                                    y_81239, y_81240)
  in {res_81243, res_81244}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_38335(f32 coeff1_81245, f32 coeff1_81246,
                                           f32 coeff2_81247, f32 coeff2_81248,
                                           f32 etai2_81249, f32 etai2_81250,
                                           f32 etai_81251, f32 etai_81252,
                                           f32 i_81253, f32 i_81254,
                                           f32 kappai_81255, f32 kappai_81256,
                                           f32 one_81257, f32 one_81258,
                                           f32 rho_81259, f32 two_81260,
                                           f32 two_81261, f32 zero_81262,
                                           f32 zero_81263,
                                           f32 day_count_fraction_81264) = {
  {coeff1_81245, coeff1_81246, coeff2_81247, coeff2_81248,
   day_count_fraction_81264, etai2_81249, etai2_81250, etai_81251, etai_81252,
   i_81253, i_81254, kappai_81255, kappai_81256, one_81257, one_81258,
   rho_81259, two_81260, two_81261, zero_81262, zero_81263}
}

fun {f32} lifted_38357(f32 x_81265) = {
  {x_81265}
}

fun {f32} lifted_38361(f32 x_81266, f32 y_81267) = {
  let {f32 res_81268} = fadd32(x_81266, y_81267)
  in {res_81268}
}

fun {f32} lifted_38368(i32 x_81269) = {
  let {f32 res_81270} = sitofp i32 x_81269 to f32
  in {res_81270}
}

fun {f32, f32} lifted_38366(f32 b_81271) = {
  let {f32 res_81272} = lifted_38368(0i32)
  in {res_81272, b_81271}
}

fun {f32} lifted_38419(i32 x_81273) = {
  let {f32 res_81274} = sitofp i32 x_81273 to f32
  in {res_81274}
}

fun {f32, f32} lifted_38417(f32 a_81275) = {
  let {f32 res_81276} = lifted_38419(0i32)
  in {a_81275, res_81276}
}

fun {f32, f32} lifted_38431(f32 x_81277, f32 x_81278) = {
  {x_81277, x_81278}
}

fun {f32} lifted_38438(i32 x_81279) = {
  let {f32 res_81280} = sitofp i32 x_81279 to f32
  in {res_81280}
}

fun {f32, f32} lifted_38436(f32 b_81281) = {
  let {f32 res_81282} = lifted_38438(0i32)
  in {res_81282, b_81281}
}

fun {f32, f32} lifted_38447(f32 x_81283, f32 x_81284) = {
  {x_81283, x_81284}
}

fun {f32, f32} lifted_38463(f32 a_81285, f32 b_81286) = {
  {a_81285, b_81286}
}

fun {f32} lifted_38475(f32 x_81287) = {
  {x_81287}
}

fun {f32} lifted_38479(f32 x_81288, f32 y_81289) = {
  let {f32 res_81290} = fmul32(x_81288, y_81289)
  in {res_81290}
}

fun {f32} lifted_38483(f32 x_81291) = {
  {x_81291}
}

fun {f32} lifted_38486(f32 x_81292) = {
  {x_81292}
}

fun {f32} lifted_38490(f32 x_81293, f32 y_81294) = {
  let {f32 res_81295} = fmul32(x_81293, y_81294)
  in {res_81295}
}

fun {f32} lifted_38495(f32 x_81296, f32 y_81297) = {
  let {f32 res_81298} = fsub32(x_81296, y_81297)
  in {res_81298}
}

fun {f32} lifted_38499(f32 x_81299) = {
  {x_81299}
}

fun {f32} lifted_38503(f32 x_81300, f32 y_81301) = {
  let {f32 res_81302} = fmul32(x_81300, y_81301)
  in {res_81302}
}

fun {f32} lifted_38507(f32 x_81303) = {
  {x_81303}
}

fun {f32} lifted_38510(f32 x_81304) = {
  {x_81304}
}

fun {f32} lifted_38514(f32 x_81305, f32 y_81306) = {
  let {f32 res_81307} = fmul32(x_81305, y_81306)
  in {res_81307}
}

fun {f32} lifted_38519(f32 x_81308, f32 y_81309) = {
  let {f32 res_81310} = fadd32(x_81308, y_81309)
  in {res_81310}
}

fun {f32, f32} lifted_38473(f32 a_81311, f32 b_81312, f32 c_81313,
                            f32 d_81314) = {
  let {f32 arg_81315} = lifted_38475(a_81311)
  let {f32 arg_81316} = lifted_38479(arg_81315, c_81313)
  let {f32 arg_81317} = lifted_38483(arg_81316)
  let {f32 arg_81318} = lifted_38486(b_81312)
  let {f32 arg_81319} = lifted_38490(arg_81318, d_81314)
  let {f32 res_81320} = lifted_38495(arg_81317, arg_81319)
  let {f32 arg_81321} = lifted_38499(b_81312)
  let {f32 arg_81322} = lifted_38503(arg_81321, c_81313)
  let {f32 arg_81323} = lifted_38507(arg_81322)
  let {f32 arg_81324} = lifted_38510(a_81311)
  let {f32 arg_81325} = lifted_38514(arg_81324, d_81314)
  let {f32 res_81326} = lifted_38519(arg_81323, arg_81325)
  in {res_81320, res_81326}
}

fun {f32, f32} lifted_38457(f32 x_81327, f32 x_81328, f32 y_81329,
                            f32 y_81330) = {
  let {f32 arg_81331, f32 arg_81332} = lifted_38463(x_81327, x_81328)
  let {f32 res_81333, f32 res_81334} = lifted_38473(arg_81331, arg_81332,
                                                    y_81329, y_81330)
  in {res_81333, res_81334}
}

fun {f32, f32} lifted_38530(f32 x_81335, f32 x_81336) = {
  {x_81335, x_81336}
}

fun {f32, f32} lifted_38546(f32 a_81337, f32 b_81338) = {
  {a_81337, b_81338}
}

fun {f32} lifted_38558(f32 x_81339) = {
  {x_81339}
}

fun {f32} lifted_38562(f32 x_81340, f32 y_81341) = {
  let {f32 res_81342} = fmul32(x_81340, y_81341)
  in {res_81342}
}

fun {f32} lifted_38566(f32 x_81343) = {
  {x_81343}
}

fun {f32} lifted_38569(f32 x_81344) = {
  {x_81344}
}

fun {f32} lifted_38573(f32 x_81345, f32 y_81346) = {
  let {f32 res_81347} = fmul32(x_81345, y_81346)
  in {res_81347}
}

fun {f32} lifted_38578(f32 x_81348, f32 y_81349) = {
  let {f32 res_81350} = fsub32(x_81348, y_81349)
  in {res_81350}
}

fun {f32} lifted_38582(f32 x_81351) = {
  {x_81351}
}

fun {f32} lifted_38586(f32 x_81352, f32 y_81353) = {
  let {f32 res_81354} = fmul32(x_81352, y_81353)
  in {res_81354}
}

fun {f32} lifted_38590(f32 x_81355) = {
  {x_81355}
}

fun {f32} lifted_38593(f32 x_81356) = {
  {x_81356}
}

fun {f32} lifted_38597(f32 x_81357, f32 y_81358) = {
  let {f32 res_81359} = fmul32(x_81357, y_81358)
  in {res_81359}
}

fun {f32} lifted_38602(f32 x_81360, f32 y_81361) = {
  let {f32 res_81362} = fadd32(x_81360, y_81361)
  in {res_81362}
}

fun {f32, f32} lifted_38556(f32 a_81363, f32 b_81364, f32 c_81365,
                            f32 d_81366) = {
  let {f32 arg_81367} = lifted_38558(a_81363)
  let {f32 arg_81368} = lifted_38562(arg_81367, c_81365)
  let {f32 arg_81369} = lifted_38566(arg_81368)
  let {f32 arg_81370} = lifted_38569(b_81364)
  let {f32 arg_81371} = lifted_38573(arg_81370, d_81366)
  let {f32 res_81372} = lifted_38578(arg_81369, arg_81371)
  let {f32 arg_81373} = lifted_38582(b_81364)
  let {f32 arg_81374} = lifted_38586(arg_81373, c_81365)
  let {f32 arg_81375} = lifted_38590(arg_81374)
  let {f32 arg_81376} = lifted_38593(a_81363)
  let {f32 arg_81377} = lifted_38597(arg_81376, d_81366)
  let {f32 res_81378} = lifted_38602(arg_81375, arg_81377)
  in {res_81372, res_81378}
}

fun {f32, f32} lifted_38540(f32 x_81379, f32 x_81380, f32 y_81381,
                            f32 y_81382) = {
  let {f32 arg_81383, f32 arg_81384} = lifted_38546(x_81379, x_81380)
  let {f32 res_81385, f32 res_81386} = lifted_38556(arg_81383, arg_81384,
                                                    y_81381, y_81382)
  in {res_81385, res_81386}
}

fun {f32, f32} lifted_38620(f32 a_81387, f32 b_81388) = {
  {a_81387, b_81388}
}

fun {f32} lifted_38630(f32 x_81389) = {
  {x_81389}
}

fun {f32} lifted_38634(f32 x_81390, f32 y_81391) = {
  let {f32 res_81392} = fsub32(x_81390, y_81391)
  in {res_81392}
}

fun {f32} lifted_38638(f32 x_81393) = {
  {x_81393}
}

fun {f32} lifted_38642(f32 x_81394, f32 y_81395) = {
  let {f32 res_81396} = fsub32(x_81394, y_81395)
  in {res_81396}
}

fun {f32, f32} lifted_38628(f32 a_81397, f32 b_81398, f32 c_81399,
                            f32 d_81400) = {
  let {f32 arg_81401} = lifted_38630(a_81397)
  let {f32 res_81402} = lifted_38634(arg_81401, c_81399)
  let {f32 arg_81403} = lifted_38638(b_81398)
  let {f32 res_81404} = lifted_38642(arg_81403, d_81400)
  in {res_81402, res_81404}
}

fun {f32, f32} lifted_38616(f32 x_81405, f32 x_81406, f32 y_81407,
                            f32 y_81408) = {
  let {f32 arg_81409, f32 arg_81410} = lifted_38620(x_81405, x_81406)
  let {f32 res_81411, f32 res_81412} = lifted_38628(arg_81409, arg_81410,
                                                    y_81407, y_81408)
  in {res_81411, res_81412}
}

fun {f32, f32} lifted_38656(f32 x_81413, f32 x_81414) = {
  {x_81413, x_81414}
}

fun {f32, f32} lifted_38672(f32 a_81415, f32 b_81416) = {
  {a_81415, b_81416}
}

fun {f32} lifted_38684(f32 x_81417) = {
  {x_81417}
}

fun {f32} lifted_38688(f32 x_81418, f32 y_81419) = {
  let {f32 res_81420} = fmul32(x_81418, y_81419)
  in {res_81420}
}

fun {f32} lifted_38692(f32 x_81421) = {
  {x_81421}
}

fun {f32} lifted_38695(f32 x_81422) = {
  {x_81422}
}

fun {f32} lifted_38699(f32 x_81423, f32 y_81424) = {
  let {f32 res_81425} = fmul32(x_81423, y_81424)
  in {res_81425}
}

fun {f32} lifted_38704(f32 x_81426, f32 y_81427) = {
  let {f32 res_81428} = fsub32(x_81426, y_81427)
  in {res_81428}
}

fun {f32} lifted_38708(f32 x_81429) = {
  {x_81429}
}

fun {f32} lifted_38712(f32 x_81430, f32 y_81431) = {
  let {f32 res_81432} = fmul32(x_81430, y_81431)
  in {res_81432}
}

fun {f32} lifted_38716(f32 x_81433) = {
  {x_81433}
}

fun {f32} lifted_38719(f32 x_81434) = {
  {x_81434}
}

fun {f32} lifted_38723(f32 x_81435, f32 y_81436) = {
  let {f32 res_81437} = fmul32(x_81435, y_81436)
  in {res_81437}
}

fun {f32} lifted_38728(f32 x_81438, f32 y_81439) = {
  let {f32 res_81440} = fadd32(x_81438, y_81439)
  in {res_81440}
}

fun {f32, f32} lifted_38682(f32 a_81441, f32 b_81442, f32 c_81443,
                            f32 d_81444) = {
  let {f32 arg_81445} = lifted_38684(a_81441)
  let {f32 arg_81446} = lifted_38688(arg_81445, c_81443)
  let {f32 arg_81447} = lifted_38692(arg_81446)
  let {f32 arg_81448} = lifted_38695(b_81442)
  let {f32 arg_81449} = lifted_38699(arg_81448, d_81444)
  let {f32 res_81450} = lifted_38704(arg_81447, arg_81449)
  let {f32 arg_81451} = lifted_38708(b_81442)
  let {f32 arg_81452} = lifted_38712(arg_81451, c_81443)
  let {f32 arg_81453} = lifted_38716(arg_81452)
  let {f32 arg_81454} = lifted_38719(a_81441)
  let {f32 arg_81455} = lifted_38723(arg_81454, d_81444)
  let {f32 res_81456} = lifted_38728(arg_81453, arg_81455)
  in {res_81450, res_81456}
}

fun {f32, f32} lifted_38666(f32 x_81457, f32 x_81458, f32 y_81459,
                            f32 y_81460) = {
  let {f32 arg_81461, f32 arg_81462} = lifted_38672(x_81457, x_81458)
  let {f32 res_81463, f32 res_81464} = lifted_38682(arg_81461, arg_81462,
                                                    y_81459, y_81460)
  in {res_81463, res_81464}
}

fun {f32, f32} lifted_38739(f32 x_81465, f32 x_81466) = {
  {x_81465, x_81466}
}

fun {f32, f32} lifted_38746(f32 x_81467, f32 x_81468) = {
  {x_81467, x_81468}
}

fun {f32, f32} lifted_38753(f32 x_81469, f32 x_81470) = {
  {x_81469, x_81470}
}

fun {f32, f32} lifted_38760(f32 x_81471, f32 x_81472) = {
  {x_81471, x_81472}
}

fun {f32, f32} lifted_38774(f32 a_81473, f32 b_81474) = {
  {a_81473, b_81474}
}

fun {f32} lifted_38784(f32 x_81475) = {
  {x_81475}
}

fun {f32} lifted_38788(f32 x_81476, f32 y_81477) = {
  let {f32 res_81478} = fadd32(x_81476, y_81477)
  in {res_81478}
}

fun {f32} lifted_38792(f32 x_81479) = {
  {x_81479}
}

fun {f32} lifted_38796(f32 x_81480, f32 y_81481) = {
  let {f32 res_81482} = fadd32(x_81480, y_81481)
  in {res_81482}
}

fun {f32, f32} lifted_38782(f32 a_81483, f32 b_81484, f32 c_81485,
                            f32 d_81486) = {
  let {f32 arg_81487} = lifted_38784(a_81483)
  let {f32 res_81488} = lifted_38788(arg_81487, c_81485)
  let {f32 arg_81489} = lifted_38792(b_81484)
  let {f32 res_81490} = lifted_38796(arg_81489, d_81486)
  in {res_81488, res_81490}
}

fun {f32, f32} lifted_38770(f32 x_81491, f32 x_81492, f32 y_81493,
                            f32 y_81494) = {
  let {f32 arg_81495, f32 arg_81496} = lifted_38774(x_81491, x_81492)
  let {f32 res_81497, f32 res_81498} = lifted_38782(arg_81495, arg_81496,
                                                    y_81493, y_81494)
  in {res_81497, res_81498}
}

fun {f32, f32} lifted_38816(f32 a_81499, f32 b_81500) = {
  {a_81499, b_81500}
}

fun {f32} lifted_38828(f32 x_81501) = {
  {x_81501}
}

fun {f32} lifted_38832(f32 x_81502, f32 y_81503) = {
  let {f32 res_81504} = fmul32(x_81502, y_81503)
  in {res_81504}
}

fun {f32} lifted_38836(f32 x_81505) = {
  {x_81505}
}

fun {f32} lifted_38839(f32 x_81506) = {
  {x_81506}
}

fun {f32} lifted_38843(f32 x_81507, f32 y_81508) = {
  let {f32 res_81509} = fmul32(x_81507, y_81508)
  in {res_81509}
}

fun {f32} lifted_38848(f32 x_81510, f32 y_81511) = {
  let {f32 res_81512} = fsub32(x_81510, y_81511)
  in {res_81512}
}

fun {f32} lifted_38852(f32 x_81513) = {
  {x_81513}
}

fun {f32} lifted_38856(f32 x_81514, f32 y_81515) = {
  let {f32 res_81516} = fmul32(x_81514, y_81515)
  in {res_81516}
}

fun {f32} lifted_38860(f32 x_81517) = {
  {x_81517}
}

fun {f32} lifted_38863(f32 x_81518) = {
  {x_81518}
}

fun {f32} lifted_38867(f32 x_81519, f32 y_81520) = {
  let {f32 res_81521} = fmul32(x_81519, y_81520)
  in {res_81521}
}

fun {f32} lifted_38872(f32 x_81522, f32 y_81523) = {
  let {f32 res_81524} = fadd32(x_81522, y_81523)
  in {res_81524}
}

fun {f32, f32} lifted_38826(f32 a_81525, f32 b_81526, f32 c_81527,
                            f32 d_81528) = {
  let {f32 arg_81529} = lifted_38828(a_81525)
  let {f32 arg_81530} = lifted_38832(arg_81529, c_81527)
  let {f32 arg_81531} = lifted_38836(arg_81530)
  let {f32 arg_81532} = lifted_38839(b_81526)
  let {f32 arg_81533} = lifted_38843(arg_81532, d_81528)
  let {f32 res_81534} = lifted_38848(arg_81531, arg_81533)
  let {f32 arg_81535} = lifted_38852(b_81526)
  let {f32 arg_81536} = lifted_38856(arg_81535, c_81527)
  let {f32 arg_81537} = lifted_38860(arg_81536)
  let {f32 arg_81538} = lifted_38863(a_81525)
  let {f32 arg_81539} = lifted_38867(arg_81538, d_81528)
  let {f32 res_81540} = lifted_38872(arg_81537, arg_81539)
  in {res_81534, res_81540}
}

fun {f32, f32} lifted_38810(f32 x_81541, f32 x_81542, f32 y_81543,
                            f32 y_81544) = {
  let {f32 arg_81545, f32 arg_81546} = lifted_38816(x_81541, x_81542)
  let {f32 res_81547, f32 res_81548} = lifted_38826(arg_81545, arg_81546,
                                                    y_81543, y_81544)
  in {res_81547, res_81548}
}

fun {f32, f32} lifted_38892(f32 a_81549, f32 b_81550) = {
  {a_81549, b_81550}
}

fun {f32} lifted_38904(f32 x_81551) = {
  {x_81551}
}

fun {f32} lifted_38908(f32 x_81552, f32 y_81553) = {
  let {f32 res_81554} = fmul32(x_81552, y_81553)
  in {res_81554}
}

fun {f32} lifted_38912(f32 x_81555) = {
  {x_81555}
}

fun {f32} lifted_38915(f32 x_81556) = {
  {x_81556}
}

fun {f32} lifted_38919(f32 x_81557, f32 y_81558) = {
  let {f32 res_81559} = fmul32(x_81557, y_81558)
  in {res_81559}
}

fun {f32} lifted_38924(f32 x_81560, f32 y_81561) = {
  let {f32 res_81562} = fsub32(x_81560, y_81561)
  in {res_81562}
}

fun {f32} lifted_38928(f32 x_81563) = {
  {x_81563}
}

fun {f32} lifted_38932(f32 x_81564, f32 y_81565) = {
  let {f32 res_81566} = fmul32(x_81564, y_81565)
  in {res_81566}
}

fun {f32} lifted_38936(f32 x_81567) = {
  {x_81567}
}

fun {f32} lifted_38939(f32 x_81568) = {
  {x_81568}
}

fun {f32} lifted_38943(f32 x_81569, f32 y_81570) = {
  let {f32 res_81571} = fmul32(x_81569, y_81570)
  in {res_81571}
}

fun {f32} lifted_38948(f32 x_81572, f32 y_81573) = {
  let {f32 res_81574} = fadd32(x_81572, y_81573)
  in {res_81574}
}

fun {f32, f32} lifted_38902(f32 a_81575, f32 b_81576, f32 c_81577,
                            f32 d_81578) = {
  let {f32 arg_81579} = lifted_38904(a_81575)
  let {f32 arg_81580} = lifted_38908(arg_81579, c_81577)
  let {f32 arg_81581} = lifted_38912(arg_81580)
  let {f32 arg_81582} = lifted_38915(b_81576)
  let {f32 arg_81583} = lifted_38919(arg_81582, d_81578)
  let {f32 res_81584} = lifted_38924(arg_81581, arg_81583)
  let {f32 arg_81585} = lifted_38928(b_81576)
  let {f32 arg_81586} = lifted_38932(arg_81585, c_81577)
  let {f32 arg_81587} = lifted_38936(arg_81586)
  let {f32 arg_81588} = lifted_38939(a_81575)
  let {f32 arg_81589} = lifted_38943(arg_81588, d_81578)
  let {f32 res_81590} = lifted_38948(arg_81587, arg_81589)
  in {res_81584, res_81590}
}

fun {f32, f32} lifted_38886(f32 x_81591, f32 x_81592, f32 y_81593,
                            f32 y_81594) = {
  let {f32 arg_81595, f32 arg_81596} = lifted_38892(x_81591, x_81592)
  let {f32 res_81597, f32 res_81598} = lifted_38902(arg_81595, arg_81596,
                                                    y_81593, y_81594)
  in {res_81597, res_81598}
}

fun {f32, f32} lifted_38966(f32 a_81599, f32 b_81600) = {
  {a_81599, b_81600}
}

fun {f32} lifted_38976(f32 x_81601) = {
  {x_81601}
}

fun {f32} lifted_38980(f32 x_81602, f32 y_81603) = {
  let {f32 res_81604} = fadd32(x_81602, y_81603)
  in {res_81604}
}

fun {f32} lifted_38984(f32 x_81605) = {
  {x_81605}
}

fun {f32} lifted_38988(f32 x_81606, f32 y_81607) = {
  let {f32 res_81608} = fadd32(x_81606, y_81607)
  in {res_81608}
}

fun {f32, f32} lifted_38974(f32 a_81609, f32 b_81610, f32 c_81611,
                            f32 d_81612) = {
  let {f32 arg_81613} = lifted_38976(a_81609)
  let {f32 res_81614} = lifted_38980(arg_81613, c_81611)
  let {f32 arg_81615} = lifted_38984(b_81610)
  let {f32 res_81616} = lifted_38988(arg_81615, d_81612)
  in {res_81614, res_81616}
}

fun {f32, f32} lifted_38962(f32 x_81617, f32 x_81618, f32 y_81619,
                            f32 y_81620) = {
  let {f32 arg_81621, f32 arg_81622} = lifted_38966(x_81617, x_81618)
  let {f32 res_81623, f32 res_81624} = lifted_38974(arg_81621, arg_81622,
                                                    y_81619, y_81620)
  in {res_81623, res_81624}
}

fun {f32} lifted_39007(f32 x_81625) = {
  {x_81625}
}

fun {f32} lifted_39010(f32 x_81626) = {
  {x_81626}
}

fun {f32} lifted_39014(f32 x_81627, f32 y_81628) = {
  let {f32 res_81629} = fmul32(x_81627, y_81628)
  in {res_81629}
}

fun {f32} lifted_39018(f32 x_81630) = {
  {x_81630}
}

fun {f32} lifted_39021(f32 x_81631) = {
  {x_81631}
}

fun {f32} lifted_39025(f32 x_81632, f32 y_81633) = {
  let {f32 res_81634} = fmul32(x_81632, y_81633)
  in {res_81634}
}

fun {f32} lifted_39030(f32 x_81635, f32 y_81636) = {
  let {f32 res_81637} = fadd32(x_81635, y_81636)
  in {res_81637}
}

fun {f32} lifted_39034(f32 x_81638) = {
  let {f32 res_81639} = sqrt32(x_81638)
  in {res_81639}
}

fun {f32} lifted_39039(f32 x_81640, f32 y_81641) = {
  let {f32 res_81642} = fadd32(x_81640, y_81641)
  in {res_81642}
}

fun {f32} lifted_39043(f32 x_81643) = {
  {x_81643}
}

fun {f32} lifted_39046(i32 x_81644) = {
  let {f32 res_81645} = sitofp i32 x_81644 to f32
  in {res_81645}
}

fun {f32} lifted_39051(f32 x_81646, f32 y_81647) = {
  let {f32 res_81648} = fdiv32(x_81646, y_81647)
  in {res_81648}
}

fun {f32} lifted_39055(f32 x_81649) = {
  let {f32 res_81650} = sqrt32(x_81649)
  in {res_81650}
}

fun {f32} lifted_39064(f32 x_81651) = {
  {x_81651}
}

fun {bool} lifted_39068(f32 x_81652, f32 y_81653) = {
  let {bool res_81654} = lt32(x_81652, y_81653)
  in {res_81654}
}

fun {f32} lifted_39073(f32 x_81655) = {
  {x_81655}
}

fun {bool} lifted_39077(f32 x_81656, f32 y_81657) = {
  let {bool res_81658} = eq_f32(x_81656, y_81657)
  in {res_81658}
}

fun {f32} lifted_39062(f32 x_81659) = {
  let {f32 arg_81660} = lifted_39064(x_81659)
  let {bool cond_81661} = lifted_39068(arg_81660, 0.0f32)
  let {f32 res_81662} =
    -- Branch returns: {f32}
    if cond_81661
    then {
      let {f32 res_81663} = fsub32(0.0f32, 1.0f32)
      in {res_81663}
    } else {
      let {f32 arg_81664} = lifted_39073(x_81659)
      let {bool cond_81665} = lifted_39077(arg_81664, 0.0f32)
      let {f32 res_81666} =
        -- Branch returns: {f32}
        if cond_81665
        then {0.0f32} else {1.0f32}
      in {res_81666}
    }
  in {res_81662}
}

fun {i32} lifted_39084(f32 x_81667) = {
  let {i32 res_81668} = fptosi f32 x_81667 to i32
  in {res_81668}
}

fun {f32} lifted_39088(i32 x_81669) = {
  let {f32 res_81670} = sitofp i32 x_81669 to f32
  in {res_81670}
}

fun {f32} lifted_39092(f32 x_81671) = {
  {x_81671}
}

fun {f32} lifted_39095(i32 x_81672) = {
  let {f32 res_81673} = sitofp i32 x_81672 to f32
  in {res_81673}
}

fun {f32} lifted_39099(f32 x_81674) = {
  {x_81674}
}

fun {f32} lifted_39103(f32 x_81675, f32 y_81676) = {
  let {f32 res_81677} = fsub32(x_81675, y_81676)
  in {res_81677}
}

fun {f32} lifted_39107(f32 x_81678) = {
  {x_81678}
}

fun {f32} lifted_39110(f32 x_81679) = {
  {x_81679}
}

fun {f32} lifted_39114(f32 x_81680, f32 y_81681) = {
  let {f32 res_81682} = fmul32(x_81680, y_81681)
  in {res_81682}
}

fun {f32} lifted_39118(f32 x_81683) = {
  {x_81683}
}

fun {f32} lifted_39121(f32 x_81684) = {
  {x_81684}
}

fun {f32} lifted_39125(f32 x_81685, f32 y_81686) = {
  let {f32 res_81687} = fmul32(x_81685, y_81686)
  in {res_81687}
}

fun {f32} lifted_39130(f32 x_81688, f32 y_81689) = {
  let {f32 res_81690} = fadd32(x_81688, y_81689)
  in {res_81690}
}

fun {f32} lifted_39134(f32 x_81691) = {
  let {f32 res_81692} = sqrt32(x_81691)
  in {res_81692}
}

fun {f32} lifted_39139(f32 x_81693, f32 y_81694) = {
  let {f32 res_81695} = fadd32(x_81693, y_81694)
  in {res_81695}
}

fun {f32} lifted_39143(f32 x_81696) = {
  {x_81696}
}

fun {f32} lifted_39146(i32 x_81697) = {
  let {f32 res_81698} = sitofp i32 x_81697 to f32
  in {res_81698}
}

fun {f32} lifted_39151(f32 x_81699, f32 y_81700) = {
  let {f32 res_81701} = fdiv32(x_81699, y_81700)
  in {res_81701}
}

fun {f32} lifted_39155(f32 x_81702) = {
  let {f32 res_81703} = sqrt32(x_81702)
  in {res_81703}
}

fun {f32} lifted_39160(f32 x_81704, f32 y_81705) = {
  let {f32 res_81706} = fmul32(x_81704, y_81705)
  in {res_81706}
}

fun {f32, f32} lifted_39005(f32 a_81707, f32 b_81708) = {
  let {f32 arg_81709} = lifted_39007(a_81707)
  let {f32 arg_81710} = lifted_39010(a_81707)
  let {f32 arg_81711} = lifted_39014(arg_81710, a_81707)
  let {f32 arg_81712} = lifted_39018(arg_81711)
  let {f32 arg_81713} = lifted_39021(b_81708)
  let {f32 arg_81714} = lifted_39025(arg_81713, b_81708)
  let {f32 arg_81715} = lifted_39030(arg_81712, arg_81714)
  let {f32 arg_81716} = lifted_39034(arg_81715)
  let {f32 arg_81717} = lifted_39039(arg_81709, arg_81716)
  let {f32 arg_81718} = lifted_39043(arg_81717)
  let {f32 arg_81719} = lifted_39046(2i32)
  let {f32 arg_81720} = lifted_39051(arg_81718, arg_81719)
  let {f32 res_81721} = lifted_39055(arg_81720)
  let {f32 gamma_81722} = res_81721
  let {f32 arg_81723} = lifted_39062(b_81708)
  let {i32 arg_81724} = lifted_39084(arg_81723)
  let {f32 arg_81725} = lifted_39088(arg_81724)
  let {f32 arg_81726} = lifted_39092(arg_81725)
  let {f32 arg_81727} = lifted_39095(0i32)
  let {f32 arg_81728} = lifted_39099(arg_81727)
  let {f32 arg_81729} = lifted_39103(arg_81728, a_81707)
  let {f32 arg_81730} = lifted_39107(arg_81729)
  let {f32 arg_81731} = lifted_39110(a_81707)
  let {f32 arg_81732} = lifted_39114(arg_81731, a_81707)
  let {f32 arg_81733} = lifted_39118(arg_81732)
  let {f32 arg_81734} = lifted_39121(b_81708)
  let {f32 arg_81735} = lifted_39125(arg_81734, b_81708)
  let {f32 arg_81736} = lifted_39130(arg_81733, arg_81735)
  let {f32 arg_81737} = lifted_39134(arg_81736)
  let {f32 arg_81738} = lifted_39139(arg_81730, arg_81737)
  let {f32 arg_81739} = lifted_39143(arg_81738)
  let {f32 arg_81740} = lifted_39146(2i32)
  let {f32 arg_81741} = lifted_39151(arg_81739, arg_81740)
  let {f32 arg_81742} = lifted_39155(arg_81741)
  let {f32 res_81743} = lifted_39160(arg_81726, arg_81742)
  let {f32 delta_81744} = res_81743
  in {gamma_81722, delta_81744}
}

fun {f32, f32} lifted_39173(f32 x_81745, f32 x_81746) = {
  {x_81745, x_81746}
}

fun {f32, f32} lifted_39187(f32 a_81747, f32 b_81748) = {
  {a_81747, b_81748}
}

fun {f32} lifted_39197(f32 x_81749) = {
  {x_81749}
}

fun {f32} lifted_39201(f32 x_81750, f32 y_81751) = {
  let {f32 res_81752} = fsub32(x_81750, y_81751)
  in {res_81752}
}

fun {f32} lifted_39205(f32 x_81753) = {
  {x_81753}
}

fun {f32} lifted_39209(f32 x_81754, f32 y_81755) = {
  let {f32 res_81756} = fsub32(x_81754, y_81755)
  in {res_81756}
}

fun {f32, f32} lifted_39195(f32 a_81757, f32 b_81758, f32 c_81759,
                            f32 d_81760) = {
  let {f32 arg_81761} = lifted_39197(a_81757)
  let {f32 res_81762} = lifted_39201(arg_81761, c_81759)
  let {f32 arg_81763} = lifted_39205(b_81758)
  let {f32 res_81764} = lifted_39209(arg_81763, d_81760)
  in {res_81762, res_81764}
}

fun {f32, f32} lifted_39183(f32 x_81765, f32 x_81766, f32 y_81767,
                            f32 y_81768) = {
  let {f32 arg_81769, f32 arg_81770} = lifted_39187(x_81765, x_81766)
  let {f32 res_81771, f32 res_81772} = lifted_39195(arg_81769, arg_81770,
                                                    y_81767, y_81768)
  in {res_81771, res_81772}
}

fun {f32, f32} lifted_39223(f32 x_81773, f32 x_81774) = {
  {x_81773, x_81774}
}

fun {f32, f32} lifted_39230(f32 x_81775, f32 x_81776) = {
  {x_81775, x_81776}
}

fun {f32, f32} lifted_39244(f32 a_81777, f32 b_81778) = {
  {a_81777, b_81778}
}

fun {f32} lifted_39254(f32 x_81779) = {
  {x_81779}
}

fun {f32} lifted_39258(f32 x_81780, f32 y_81781) = {
  let {f32 res_81782} = fadd32(x_81780, y_81781)
  in {res_81782}
}

fun {f32} lifted_39262(f32 x_81783) = {
  {x_81783}
}

fun {f32} lifted_39266(f32 x_81784, f32 y_81785) = {
  let {f32 res_81786} = fadd32(x_81784, y_81785)
  in {res_81786}
}

fun {f32, f32} lifted_39252(f32 a_81787, f32 b_81788, f32 c_81789,
                            f32 d_81790) = {
  let {f32 arg_81791} = lifted_39254(a_81787)
  let {f32 res_81792} = lifted_39258(arg_81791, c_81789)
  let {f32 arg_81793} = lifted_39262(b_81788)
  let {f32 res_81794} = lifted_39266(arg_81793, d_81790)
  in {res_81792, res_81794}
}

fun {f32, f32} lifted_39240(f32 x_81795, f32 x_81796, f32 y_81797,
                            f32 y_81798) = {
  let {f32 arg_81799, f32 arg_81800} = lifted_39244(x_81795, x_81796)
  let {f32 res_81801, f32 res_81802} = lifted_39252(arg_81799, arg_81800,
                                                    y_81797, y_81798)
  in {res_81801, res_81802}
}

fun {f32, f32} lifted_39287(f32 a_81803, f32 b_81804) = {
  {a_81803, b_81804}
}

fun {f32} lifted_39300(f32 x_81805) = {
  {x_81805}
}

fun {f32} lifted_39304(f32 x_81806, f32 y_81807) = {
  let {f32 res_81808} = fmul32(x_81806, y_81807)
  in {res_81808}
}

fun {f32} lifted_39308(f32 x_81809) = {
  {x_81809}
}

fun {f32} lifted_39311(f32 x_81810) = {
  {x_81810}
}

fun {f32} lifted_39315(f32 x_81811, f32 y_81812) = {
  let {f32 res_81813} = fmul32(x_81811, y_81812)
  in {res_81813}
}

fun {f32} lifted_39320(f32 x_81814, f32 y_81815) = {
  let {f32 res_81816} = fadd32(x_81814, y_81815)
  in {res_81816}
}

fun {f32} lifted_39324(f32 x_81817) = {
  {x_81817}
}

fun {f32} lifted_39327(f32 x_81818) = {
  {x_81818}
}

fun {f32} lifted_39331(f32 x_81819, f32 y_81820) = {
  let {f32 res_81821} = fmul32(x_81819, y_81820)
  in {res_81821}
}

fun {f32} lifted_39335(f32 x_81822) = {
  {x_81822}
}

fun {f32} lifted_39338(f32 x_81823) = {
  {x_81823}
}

fun {f32} lifted_39342(f32 x_81824, f32 y_81825) = {
  let {f32 res_81826} = fmul32(x_81824, y_81825)
  in {res_81826}
}

fun {f32} lifted_39347(f32 x_81827, f32 y_81828) = {
  let {f32 res_81829} = fadd32(x_81827, y_81828)
  in {res_81829}
}

fun {f32} lifted_39352(f32 x_81830, f32 y_81831) = {
  let {f32 res_81832} = fdiv32(x_81830, y_81831)
  in {res_81832}
}

fun {f32} lifted_39356(f32 x_81833) = {
  {x_81833}
}

fun {f32} lifted_39360(f32 x_81834, f32 y_81835) = {
  let {f32 res_81836} = fmul32(x_81834, y_81835)
  in {res_81836}
}

fun {f32} lifted_39364(f32 x_81837) = {
  {x_81837}
}

fun {f32} lifted_39367(f32 x_81838) = {
  {x_81838}
}

fun {f32} lifted_39371(f32 x_81839, f32 y_81840) = {
  let {f32 res_81841} = fmul32(x_81839, y_81840)
  in {res_81841}
}

fun {f32} lifted_39376(f32 x_81842, f32 y_81843) = {
  let {f32 res_81844} = fsub32(x_81842, y_81843)
  in {res_81844}
}

fun {f32} lifted_39380(f32 x_81845) = {
  {x_81845}
}

fun {f32} lifted_39383(f32 x_81846) = {
  {x_81846}
}

fun {f32} lifted_39387(f32 x_81847, f32 y_81848) = {
  let {f32 res_81849} = fmul32(x_81847, y_81848)
  in {res_81849}
}

fun {f32} lifted_39391(f32 x_81850) = {
  {x_81850}
}

fun {f32} lifted_39394(f32 x_81851) = {
  {x_81851}
}

fun {f32} lifted_39398(f32 x_81852, f32 y_81853) = {
  let {f32 res_81854} = fmul32(x_81852, y_81853)
  in {res_81854}
}

fun {f32} lifted_39403(f32 x_81855, f32 y_81856) = {
  let {f32 res_81857} = fadd32(x_81855, y_81856)
  in {res_81857}
}

fun {f32} lifted_39408(f32 x_81858, f32 y_81859) = {
  let {f32 res_81860} = fdiv32(x_81858, y_81859)
  in {res_81860}
}

fun {f32, f32} lifted_39298(f32 a_81861, f32 b_81862, f32 c_81863,
                            f32 d_81864) = {
  let {f32 arg_81865} = lifted_39300(a_81861)
  let {f32 arg_81866} = lifted_39304(arg_81865, c_81863)
  let {f32 arg_81867} = lifted_39308(arg_81866)
  let {f32 arg_81868} = lifted_39311(b_81862)
  let {f32 arg_81869} = lifted_39315(arg_81868, d_81864)
  let {f32 arg_81870} = lifted_39320(arg_81867, arg_81869)
  let {f32 arg_81871} = lifted_39324(arg_81870)
  let {f32 arg_81872} = lifted_39327(c_81863)
  let {f32 arg_81873} = lifted_39331(arg_81872, c_81863)
  let {f32 arg_81874} = lifted_39335(arg_81873)
  let {f32 arg_81875} = lifted_39338(d_81864)
  let {f32 arg_81876} = lifted_39342(arg_81875, d_81864)
  let {f32 arg_81877} = lifted_39347(arg_81874, arg_81876)
  let {f32 res_81878} = lifted_39352(arg_81871, arg_81877)
  let {f32 arg_81879} = lifted_39356(b_81862)
  let {f32 arg_81880} = lifted_39360(arg_81879, c_81863)
  let {f32 arg_81881} = lifted_39364(arg_81880)
  let {f32 arg_81882} = lifted_39367(a_81861)
  let {f32 arg_81883} = lifted_39371(arg_81882, d_81864)
  let {f32 arg_81884} = lifted_39376(arg_81881, arg_81883)
  let {f32 arg_81885} = lifted_39380(arg_81884)
  let {f32 arg_81886} = lifted_39383(c_81863)
  let {f32 arg_81887} = lifted_39387(arg_81886, c_81863)
  let {f32 arg_81888} = lifted_39391(arg_81887)
  let {f32 arg_81889} = lifted_39394(d_81864)
  let {f32 arg_81890} = lifted_39398(arg_81889, d_81864)
  let {f32 arg_81891} = lifted_39403(arg_81888, arg_81890)
  let {f32 res_81892} = lifted_39408(arg_81885, arg_81891)
  in {res_81878, res_81892}
}

fun {f32, f32} lifted_39280(f32 x_81893, f32 x_81894, f32 y_81895,
                            f32 y_81896) = {
  let {f32 arg_81897, f32 arg_81898} = lifted_39287(x_81893, x_81894)
  let {f32 res_81899, f32 res_81900} = lifted_39298(arg_81897, arg_81898,
                                                    y_81895, y_81896)
  in {res_81899, res_81900}
}

fun {f32, f32} lifted_39422(f32 x_81901, f32 x_81902) = {
  {x_81901, x_81902}
}

fun {f32, f32} lifted_39429(f32 x_81903, f32 x_81904) = {
  {x_81903, x_81904}
}

fun {f32, f32} lifted_39445(f32 a_81905, f32 b_81906) = {
  {a_81905, b_81906}
}

fun {f32} lifted_39457(f32 x_81907) = {
  {x_81907}
}

fun {f32} lifted_39461(f32 x_81908, f32 y_81909) = {
  let {f32 res_81910} = fmul32(x_81908, y_81909)
  in {res_81910}
}

fun {f32} lifted_39465(f32 x_81911) = {
  {x_81911}
}

fun {f32} lifted_39468(f32 x_81912) = {
  {x_81912}
}

fun {f32} lifted_39472(f32 x_81913, f32 y_81914) = {
  let {f32 res_81915} = fmul32(x_81913, y_81914)
  in {res_81915}
}

fun {f32} lifted_39477(f32 x_81916, f32 y_81917) = {
  let {f32 res_81918} = fsub32(x_81916, y_81917)
  in {res_81918}
}

fun {f32} lifted_39481(f32 x_81919) = {
  {x_81919}
}

fun {f32} lifted_39485(f32 x_81920, f32 y_81921) = {
  let {f32 res_81922} = fmul32(x_81920, y_81921)
  in {res_81922}
}

fun {f32} lifted_39489(f32 x_81923) = {
  {x_81923}
}

fun {f32} lifted_39492(f32 x_81924) = {
  {x_81924}
}

fun {f32} lifted_39496(f32 x_81925, f32 y_81926) = {
  let {f32 res_81927} = fmul32(x_81925, y_81926)
  in {res_81927}
}

fun {f32} lifted_39501(f32 x_81928, f32 y_81929) = {
  let {f32 res_81930} = fadd32(x_81928, y_81929)
  in {res_81930}
}

fun {f32, f32} lifted_39455(f32 a_81931, f32 b_81932, f32 c_81933,
                            f32 d_81934) = {
  let {f32 arg_81935} = lifted_39457(a_81931)
  let {f32 arg_81936} = lifted_39461(arg_81935, c_81933)
  let {f32 arg_81937} = lifted_39465(arg_81936)
  let {f32 arg_81938} = lifted_39468(b_81932)
  let {f32 arg_81939} = lifted_39472(arg_81938, d_81934)
  let {f32 res_81940} = lifted_39477(arg_81937, arg_81939)
  let {f32 arg_81941} = lifted_39481(b_81932)
  let {f32 arg_81942} = lifted_39485(arg_81941, c_81933)
  let {f32 arg_81943} = lifted_39489(arg_81942)
  let {f32 arg_81944} = lifted_39492(a_81931)
  let {f32 arg_81945} = lifted_39496(arg_81944, d_81934)
  let {f32 res_81946} = lifted_39501(arg_81943, arg_81945)
  in {res_81940, res_81946}
}

fun {f32, f32} lifted_39439(f32 x_81947, f32 x_81948, f32 y_81949,
                            f32 y_81950) = {
  let {f32 arg_81951, f32 arg_81952} = lifted_39445(x_81947, x_81948)
  let {f32 res_81953, f32 res_81954} = lifted_39455(arg_81951, arg_81952,
                                                    y_81949, y_81950)
  in {res_81953, res_81954}
}

fun {f32, f32} lifted_39519(f32 a_81955, f32 b_81956) = {
  {a_81955, b_81956}
}

fun {f32} lifted_39529(f32 x_81957) = {
  {x_81957}
}

fun {f32} lifted_39533(f32 x_81958, f32 y_81959) = {
  let {f32 res_81960} = fsub32(x_81958, y_81959)
  in {res_81960}
}

fun {f32} lifted_39537(f32 x_81961) = {
  {x_81961}
}

fun {f32} lifted_39541(f32 x_81962, f32 y_81963) = {
  let {f32 res_81964} = fsub32(x_81962, y_81963)
  in {res_81964}
}

fun {f32, f32} lifted_39527(f32 a_81965, f32 b_81966, f32 c_81967,
                            f32 d_81968) = {
  let {f32 arg_81969} = lifted_39529(a_81965)
  let {f32 res_81970} = lifted_39533(arg_81969, c_81967)
  let {f32 arg_81971} = lifted_39537(b_81966)
  let {f32 res_81972} = lifted_39541(arg_81971, d_81968)
  in {res_81970, res_81972}
}

fun {f32, f32} lifted_39515(f32 x_81973, f32 x_81974, f32 y_81975,
                            f32 y_81976) = {
  let {f32 arg_81977, f32 arg_81978} = lifted_39519(x_81973, x_81974)
  let {f32 res_81979, f32 res_81980} = lifted_39527(arg_81977, arg_81978,
                                                    y_81975, y_81976)
  in {res_81979, res_81980}
}

fun {f32} lifted_39557(f32 x_81981) = {
  let {f32 res_81982} = exp32(x_81981)
  in {res_81982}
}

fun {f32} lifted_39562(f32 x_81983) = {
  {x_81983}
}

fun {f32} lifted_39565(f32 x_81984) = {
  let {f32 res_81985} = cos32(x_81984)
  in {res_81985}
}

fun {f32} lifted_39570(f32 x_81986, f32 y_81987) = {
  let {f32 res_81988} = fmul32(x_81986, y_81987)
  in {res_81988}
}

fun {f32} lifted_39574(f32 a_81989) = {
  {a_81989}
}

fun {f32} lifted_39577(f32 x_81990) = {
  {x_81990}
}

fun {f32} lifted_39580(f32 x_81991) = {
  let {f32 res_81992} = sin32(x_81991)
  in {res_81992}
}

fun {f32} lifted_39585(f32 x_81993, f32 y_81994) = {
  let {f32 res_81995} = fmul32(x_81993, y_81994)
  in {res_81995}
}

fun {f32, f32} lifted_39590(f32 a_81996, f32 b_81997) = {
  {a_81996, b_81997}
}

fun {f32, f32} lifted_39555(f32 a_81998, f32 b_81999) = {
  let {f32 res_82000} = lifted_39557(a_81998)
  let {f32 expx_82001} = res_82000
  let {f32 arg_82002} = lifted_39562(expx_82001)
  let {f32 arg_82003} = lifted_39565(b_81999)
  let {f32 arg_82004} = lifted_39570(arg_82002, arg_82003)
  let {f32 arg_82005} = lifted_39574(arg_82004)
  let {f32 arg_82006} = lifted_39577(expx_82001)
  let {f32 arg_82007} = lifted_39580(b_81999)
  let {f32 arg_82008} = lifted_39585(arg_82006, arg_82007)
  let {f32 res_82009, f32 res_82010} = lifted_39590(arg_82005, arg_82008)
  in {res_82009, res_82010}
}

fun {f32, f32} lifted_39602(f32 x_82011, f32 x_82012) = {
  {x_82011, x_82012}
}

fun {f32, f32} lifted_39609(f32 x_82013, f32 x_82014) = {
  {x_82013, x_82014}
}

fun {f32, f32} lifted_39625(f32 a_82015, f32 b_82016) = {
  {a_82015, b_82016}
}

fun {f32} lifted_39637(f32 x_82017) = {
  {x_82017}
}

fun {f32} lifted_39641(f32 x_82018, f32 y_82019) = {
  let {f32 res_82020} = fmul32(x_82018, y_82019)
  in {res_82020}
}

fun {f32} lifted_39645(f32 x_82021) = {
  {x_82021}
}

fun {f32} lifted_39648(f32 x_82022) = {
  {x_82022}
}

fun {f32} lifted_39652(f32 x_82023, f32 y_82024) = {
  let {f32 res_82025} = fmul32(x_82023, y_82024)
  in {res_82025}
}

fun {f32} lifted_39657(f32 x_82026, f32 y_82027) = {
  let {f32 res_82028} = fsub32(x_82026, y_82027)
  in {res_82028}
}

fun {f32} lifted_39661(f32 x_82029) = {
  {x_82029}
}

fun {f32} lifted_39665(f32 x_82030, f32 y_82031) = {
  let {f32 res_82032} = fmul32(x_82030, y_82031)
  in {res_82032}
}

fun {f32} lifted_39669(f32 x_82033) = {
  {x_82033}
}

fun {f32} lifted_39672(f32 x_82034) = {
  {x_82034}
}

fun {f32} lifted_39676(f32 x_82035, f32 y_82036) = {
  let {f32 res_82037} = fmul32(x_82035, y_82036)
  in {res_82037}
}

fun {f32} lifted_39681(f32 x_82038, f32 y_82039) = {
  let {f32 res_82040} = fadd32(x_82038, y_82039)
  in {res_82040}
}

fun {f32, f32} lifted_39635(f32 a_82041, f32 b_82042, f32 c_82043,
                            f32 d_82044) = {
  let {f32 arg_82045} = lifted_39637(a_82041)
  let {f32 arg_82046} = lifted_39641(arg_82045, c_82043)
  let {f32 arg_82047} = lifted_39645(arg_82046)
  let {f32 arg_82048} = lifted_39648(b_82042)
  let {f32 arg_82049} = lifted_39652(arg_82048, d_82044)
  let {f32 res_82050} = lifted_39657(arg_82047, arg_82049)
  let {f32 arg_82051} = lifted_39661(b_82042)
  let {f32 arg_82052} = lifted_39665(arg_82051, c_82043)
  let {f32 arg_82053} = lifted_39669(arg_82052)
  let {f32 arg_82054} = lifted_39672(a_82041)
  let {f32 arg_82055} = lifted_39676(arg_82054, d_82044)
  let {f32 res_82056} = lifted_39681(arg_82053, arg_82055)
  in {res_82050, res_82056}
}

fun {f32, f32} lifted_39619(f32 x_82057, f32 x_82058, f32 y_82059,
                            f32 y_82060) = {
  let {f32 arg_82061, f32 arg_82062} = lifted_39625(x_82057, x_82058)
  let {f32 res_82063, f32 res_82064} = lifted_39635(arg_82061, arg_82062,
                                                    y_82059, y_82060)
  in {res_82063, res_82064}
}

fun {f32, f32} lifted_39692(f32 x_82065, f32 x_82066) = {
  {x_82065, x_82066}
}

fun {f32, f32} lifted_39699(f32 x_82067, f32 x_82068) = {
  {x_82067, x_82068}
}

fun {f32, f32} lifted_39706(f32 x_82069, f32 x_82070) = {
  {x_82069, x_82070}
}

fun {f32, f32} lifted_39713(f32 x_82071, f32 x_82072) = {
  {x_82071, x_82072}
}

fun {f32, f32} lifted_39729(f32 a_82073, f32 b_82074) = {
  {a_82073, b_82074}
}

fun {f32} lifted_39741(f32 x_82075) = {
  {x_82075}
}

fun {f32} lifted_39745(f32 x_82076, f32 y_82077) = {
  let {f32 res_82078} = fmul32(x_82076, y_82077)
  in {res_82078}
}

fun {f32} lifted_39749(f32 x_82079) = {
  {x_82079}
}

fun {f32} lifted_39752(f32 x_82080) = {
  {x_82080}
}

fun {f32} lifted_39756(f32 x_82081, f32 y_82082) = {
  let {f32 res_82083} = fmul32(x_82081, y_82082)
  in {res_82083}
}

fun {f32} lifted_39761(f32 x_82084, f32 y_82085) = {
  let {f32 res_82086} = fsub32(x_82084, y_82085)
  in {res_82086}
}

fun {f32} lifted_39765(f32 x_82087) = {
  {x_82087}
}

fun {f32} lifted_39769(f32 x_82088, f32 y_82089) = {
  let {f32 res_82090} = fmul32(x_82088, y_82089)
  in {res_82090}
}

fun {f32} lifted_39773(f32 x_82091) = {
  {x_82091}
}

fun {f32} lifted_39776(f32 x_82092) = {
  {x_82092}
}

fun {f32} lifted_39780(f32 x_82093, f32 y_82094) = {
  let {f32 res_82095} = fmul32(x_82093, y_82094)
  in {res_82095}
}

fun {f32} lifted_39785(f32 x_82096, f32 y_82097) = {
  let {f32 res_82098} = fadd32(x_82096, y_82097)
  in {res_82098}
}

fun {f32, f32} lifted_39739(f32 a_82099, f32 b_82100, f32 c_82101,
                            f32 d_82102) = {
  let {f32 arg_82103} = lifted_39741(a_82099)
  let {f32 arg_82104} = lifted_39745(arg_82103, c_82101)
  let {f32 arg_82105} = lifted_39749(arg_82104)
  let {f32 arg_82106} = lifted_39752(b_82100)
  let {f32 arg_82107} = lifted_39756(arg_82106, d_82102)
  let {f32 res_82108} = lifted_39761(arg_82105, arg_82107)
  let {f32 arg_82109} = lifted_39765(b_82100)
  let {f32 arg_82110} = lifted_39769(arg_82109, c_82101)
  let {f32 arg_82111} = lifted_39773(arg_82110)
  let {f32 arg_82112} = lifted_39776(a_82099)
  let {f32 arg_82113} = lifted_39780(arg_82112, d_82102)
  let {f32 res_82114} = lifted_39785(arg_82111, arg_82113)
  in {res_82108, res_82114}
}

fun {f32, f32} lifted_39723(f32 x_82115, f32 x_82116, f32 y_82117,
                            f32 y_82118) = {
  let {f32 arg_82119, f32 arg_82120} = lifted_39729(x_82115, x_82116)
  let {f32 res_82121, f32 res_82122} = lifted_39739(arg_82119, arg_82120,
                                                    y_82117, y_82118)
  in {res_82121, res_82122}
}

fun {f32, f32} lifted_39803(f32 a_82123, f32 b_82124) = {
  {a_82123, b_82124}
}

fun {f32} lifted_39813(f32 x_82125) = {
  {x_82125}
}

fun {f32} lifted_39817(f32 x_82126, f32 y_82127) = {
  let {f32 res_82128} = fsub32(x_82126, y_82127)
  in {res_82128}
}

fun {f32} lifted_39821(f32 x_82129) = {
  {x_82129}
}

fun {f32} lifted_39825(f32 x_82130, f32 y_82131) = {
  let {f32 res_82132} = fsub32(x_82130, y_82131)
  in {res_82132}
}

fun {f32, f32} lifted_39811(f32 a_82133, f32 b_82134, f32 c_82135,
                            f32 d_82136) = {
  let {f32 arg_82137} = lifted_39813(a_82133)
  let {f32 res_82138} = lifted_39817(arg_82137, c_82135)
  let {f32 arg_82139} = lifted_39821(b_82134)
  let {f32 res_82140} = lifted_39825(arg_82139, d_82136)
  in {res_82138, res_82140}
}

fun {f32, f32} lifted_39799(f32 x_82141, f32 x_82142, f32 y_82143,
                            f32 y_82144) = {
  let {f32 arg_82145, f32 arg_82146} = lifted_39803(x_82141, x_82142)
  let {f32 res_82147, f32 res_82148} = lifted_39811(arg_82145, arg_82146,
                                                    y_82143, y_82144)
  in {res_82147, res_82148}
}

fun {f32, f32} lifted_39836(f32 x_82149, f32 x_82150) = {
  {x_82149, x_82150}
}

fun {f32, f32} lifted_39843(f32 x_82151, f32 x_82152) = {
  {x_82151, x_82152}
}

fun {f32, f32} lifted_39857(f32 a_82153, f32 b_82154) = {
  {a_82153, b_82154}
}

fun {f32} lifted_39867(f32 x_82155) = {
  {x_82155}
}

fun {f32} lifted_39871(f32 x_82156, f32 y_82157) = {
  let {f32 res_82158} = fsub32(x_82156, y_82157)
  in {res_82158}
}

fun {f32} lifted_39875(f32 x_82159) = {
  {x_82159}
}

fun {f32} lifted_39879(f32 x_82160, f32 y_82161) = {
  let {f32 res_82162} = fsub32(x_82160, y_82161)
  in {res_82162}
}

fun {f32, f32} lifted_39865(f32 a_82163, f32 b_82164, f32 c_82165,
                            f32 d_82166) = {
  let {f32 arg_82167} = lifted_39867(a_82163)
  let {f32 res_82168} = lifted_39871(arg_82167, c_82165)
  let {f32 arg_82169} = lifted_39875(b_82164)
  let {f32 res_82170} = lifted_39879(arg_82169, d_82166)
  in {res_82168, res_82170}
}

fun {f32, f32} lifted_39853(f32 x_82171, f32 x_82172, f32 y_82173,
                            f32 y_82174) = {
  let {f32 arg_82175, f32 arg_82176} = lifted_39857(x_82171, x_82172)
  let {f32 res_82177, f32 res_82178} = lifted_39865(arg_82175, arg_82176,
                                                    y_82173, y_82174)
  in {res_82177, res_82178}
}

fun {f32, f32} lifted_39900(f32 a_82179, f32 b_82180) = {
  {a_82179, b_82180}
}

fun {f32} lifted_39913(f32 x_82181) = {
  {x_82181}
}

fun {f32} lifted_39917(f32 x_82182, f32 y_82183) = {
  let {f32 res_82184} = fmul32(x_82182, y_82183)
  in {res_82184}
}

fun {f32} lifted_39921(f32 x_82185) = {
  {x_82185}
}

fun {f32} lifted_39924(f32 x_82186) = {
  {x_82186}
}

fun {f32} lifted_39928(f32 x_82187, f32 y_82188) = {
  let {f32 res_82189} = fmul32(x_82187, y_82188)
  in {res_82189}
}

fun {f32} lifted_39933(f32 x_82190, f32 y_82191) = {
  let {f32 res_82192} = fadd32(x_82190, y_82191)
  in {res_82192}
}

fun {f32} lifted_39937(f32 x_82193) = {
  {x_82193}
}

fun {f32} lifted_39940(f32 x_82194) = {
  {x_82194}
}

fun {f32} lifted_39944(f32 x_82195, f32 y_82196) = {
  let {f32 res_82197} = fmul32(x_82195, y_82196)
  in {res_82197}
}

fun {f32} lifted_39948(f32 x_82198) = {
  {x_82198}
}

fun {f32} lifted_39951(f32 x_82199) = {
  {x_82199}
}

fun {f32} lifted_39955(f32 x_82200, f32 y_82201) = {
  let {f32 res_82202} = fmul32(x_82200, y_82201)
  in {res_82202}
}

fun {f32} lifted_39960(f32 x_82203, f32 y_82204) = {
  let {f32 res_82205} = fadd32(x_82203, y_82204)
  in {res_82205}
}

fun {f32} lifted_39965(f32 x_82206, f32 y_82207) = {
  let {f32 res_82208} = fdiv32(x_82206, y_82207)
  in {res_82208}
}

fun {f32} lifted_39969(f32 x_82209) = {
  {x_82209}
}

fun {f32} lifted_39973(f32 x_82210, f32 y_82211) = {
  let {f32 res_82212} = fmul32(x_82210, y_82211)
  in {res_82212}
}

fun {f32} lifted_39977(f32 x_82213) = {
  {x_82213}
}

fun {f32} lifted_39980(f32 x_82214) = {
  {x_82214}
}

fun {f32} lifted_39984(f32 x_82215, f32 y_82216) = {
  let {f32 res_82217} = fmul32(x_82215, y_82216)
  in {res_82217}
}

fun {f32} lifted_39989(f32 x_82218, f32 y_82219) = {
  let {f32 res_82220} = fsub32(x_82218, y_82219)
  in {res_82220}
}

fun {f32} lifted_39993(f32 x_82221) = {
  {x_82221}
}

fun {f32} lifted_39996(f32 x_82222) = {
  {x_82222}
}

fun {f32} lifted_40000(f32 x_82223, f32 y_82224) = {
  let {f32 res_82225} = fmul32(x_82223, y_82224)
  in {res_82225}
}

fun {f32} lifted_40004(f32 x_82226) = {
  {x_82226}
}

fun {f32} lifted_40007(f32 x_82227) = {
  {x_82227}
}

fun {f32} lifted_40011(f32 x_82228, f32 y_82229) = {
  let {f32 res_82230} = fmul32(x_82228, y_82229)
  in {res_82230}
}

fun {f32} lifted_40016(f32 x_82231, f32 y_82232) = {
  let {f32 res_82233} = fadd32(x_82231, y_82232)
  in {res_82233}
}

fun {f32} lifted_40021(f32 x_82234, f32 y_82235) = {
  let {f32 res_82236} = fdiv32(x_82234, y_82235)
  in {res_82236}
}

fun {f32, f32} lifted_39911(f32 a_82237, f32 b_82238, f32 c_82239,
                            f32 d_82240) = {
  let {f32 arg_82241} = lifted_39913(a_82237)
  let {f32 arg_82242} = lifted_39917(arg_82241, c_82239)
  let {f32 arg_82243} = lifted_39921(arg_82242)
  let {f32 arg_82244} = lifted_39924(b_82238)
  let {f32 arg_82245} = lifted_39928(arg_82244, d_82240)
  let {f32 arg_82246} = lifted_39933(arg_82243, arg_82245)
  let {f32 arg_82247} = lifted_39937(arg_82246)
  let {f32 arg_82248} = lifted_39940(c_82239)
  let {f32 arg_82249} = lifted_39944(arg_82248, c_82239)
  let {f32 arg_82250} = lifted_39948(arg_82249)
  let {f32 arg_82251} = lifted_39951(d_82240)
  let {f32 arg_82252} = lifted_39955(arg_82251, d_82240)
  let {f32 arg_82253} = lifted_39960(arg_82250, arg_82252)
  let {f32 res_82254} = lifted_39965(arg_82247, arg_82253)
  let {f32 arg_82255} = lifted_39969(b_82238)
  let {f32 arg_82256} = lifted_39973(arg_82255, c_82239)
  let {f32 arg_82257} = lifted_39977(arg_82256)
  let {f32 arg_82258} = lifted_39980(a_82237)
  let {f32 arg_82259} = lifted_39984(arg_82258, d_82240)
  let {f32 arg_82260} = lifted_39989(arg_82257, arg_82259)
  let {f32 arg_82261} = lifted_39993(arg_82260)
  let {f32 arg_82262} = lifted_39996(c_82239)
  let {f32 arg_82263} = lifted_40000(arg_82262, c_82239)
  let {f32 arg_82264} = lifted_40004(arg_82263)
  let {f32 arg_82265} = lifted_40007(d_82240)
  let {f32 arg_82266} = lifted_40011(arg_82265, d_82240)
  let {f32 arg_82267} = lifted_40016(arg_82264, arg_82266)
  let {f32 res_82268} = lifted_40021(arg_82261, arg_82267)
  in {res_82254, res_82268}
}

fun {f32, f32} lifted_39893(f32 x_82269, f32 x_82270, f32 y_82271,
                            f32 y_82272) = {
  let {f32 arg_82273, f32 arg_82274} = lifted_39900(x_82269, x_82270)
  let {f32 res_82275, f32 res_82276} = lifted_39911(arg_82273, arg_82274,
                                                    y_82271, y_82272)
  in {res_82275, res_82276}
}

fun {f32} lifted_40043(f32 x_82277) = {
  {x_82277}
}

fun {f32} lifted_40047(f32 x_82278, f32 y_82279) = {
  let {f32 res_82280} = fmul32(x_82278, y_82279)
  in {res_82280}
}

fun {f32} lifted_40051(f32 x_82281) = {
  {x_82281}
}

fun {f32} lifted_40054(f32 x_82282) = {
  {x_82282}
}

fun {f32} lifted_40058(f32 x_82283, f32 y_82284) = {
  let {f32 res_82285} = fmul32(x_82283, y_82284)
  in {res_82285}
}

fun {f32} lifted_40063(f32 x_82286, f32 y_82287) = {
  let {f32 res_82288} = fadd32(x_82286, y_82287)
  in {res_82288}
}

fun {f32} lifted_40067(f32 x_82289) = {
  let {f32 res_82290} = sqrt32(x_82289)
  in {res_82290}
}

fun {f32} lifted_40041(f32 a_82291, f32 b_82292) = {
  let {f32 arg_82293} = lifted_40043(a_82291)
  let {f32 arg_82294} = lifted_40047(arg_82293, a_82291)
  let {f32 arg_82295} = lifted_40051(arg_82294)
  let {f32 arg_82296} = lifted_40054(b_82292)
  let {f32 arg_82297} = lifted_40058(arg_82296, b_82292)
  let {f32 arg_82298} = lifted_40063(arg_82295, arg_82297)
  let {f32 res_82299} = lifted_40067(arg_82298)
  in {res_82299}
}

fun {f32} lifted_40072(f32 x_82300) = {
  let {f32 res_82301} = log32(x_82300)
  in {res_82301}
}

fun {f32} lifted_40076(f32 a_82302) = {
  {a_82302}
}

fun {f32} lifted_40083(f32 x_82303) = {
  {x_82303}
}

fun {f32} lifted_40087(f32 x_82304, f32 y_82305) = {
  let {f32 res_82306} = atan2_32(x_82304, y_82305)
  in {res_82306}
}

fun {f32} lifted_40081(f32 a_82307, f32 b_82308) = {
  let {f32 arg_82309} = lifted_40083(b_82308)
  let {f32 res_82310} = lifted_40087(arg_82309, a_82307)
  in {res_82310}
}

fun {f32, f32} lifted_40093(f32 a_82311, f32 b_82312) = {
  {a_82311, b_82312}
}

fun {f32, f32} lifted_40035(f32 z_82313, f32 z_82314) = {
  let {f32 arg_82315} = lifted_40041(z_82313, z_82314)
  let {f32 arg_82316} = lifted_40072(arg_82315)
  let {f32 arg_82317} = lifted_40076(arg_82316)
  let {f32 arg_82318} = lifted_40081(z_82313, z_82314)
  let {f32 res_82319, f32 res_82320} = lifted_40093(arg_82317, arg_82318)
  in {res_82319, res_82320}
}

fun {f32, f32} lifted_40111(f32 a_82321, f32 b_82322) = {
  {a_82321, b_82322}
}

fun {f32} lifted_40123(f32 x_82323) = {
  {x_82323}
}

fun {f32} lifted_40127(f32 x_82324, f32 y_82325) = {
  let {f32 res_82326} = fmul32(x_82324, y_82325)
  in {res_82326}
}

fun {f32} lifted_40131(f32 x_82327) = {
  {x_82327}
}

fun {f32} lifted_40134(f32 x_82328) = {
  {x_82328}
}

fun {f32} lifted_40138(f32 x_82329, f32 y_82330) = {
  let {f32 res_82331} = fmul32(x_82329, y_82330)
  in {res_82331}
}

fun {f32} lifted_40143(f32 x_82332, f32 y_82333) = {
  let {f32 res_82334} = fsub32(x_82332, y_82333)
  in {res_82334}
}

fun {f32} lifted_40147(f32 x_82335) = {
  {x_82335}
}

fun {f32} lifted_40151(f32 x_82336, f32 y_82337) = {
  let {f32 res_82338} = fmul32(x_82336, y_82337)
  in {res_82338}
}

fun {f32} lifted_40155(f32 x_82339) = {
  {x_82339}
}

fun {f32} lifted_40158(f32 x_82340) = {
  {x_82340}
}

fun {f32} lifted_40162(f32 x_82341, f32 y_82342) = {
  let {f32 res_82343} = fmul32(x_82341, y_82342)
  in {res_82343}
}

fun {f32} lifted_40167(f32 x_82344, f32 y_82345) = {
  let {f32 res_82346} = fadd32(x_82344, y_82345)
  in {res_82346}
}

fun {f32, f32} lifted_40121(f32 a_82347, f32 b_82348, f32 c_82349,
                            f32 d_82350) = {
  let {f32 arg_82351} = lifted_40123(a_82347)
  let {f32 arg_82352} = lifted_40127(arg_82351, c_82349)
  let {f32 arg_82353} = lifted_40131(arg_82352)
  let {f32 arg_82354} = lifted_40134(b_82348)
  let {f32 arg_82355} = lifted_40138(arg_82354, d_82350)
  let {f32 res_82356} = lifted_40143(arg_82353, arg_82355)
  let {f32 arg_82357} = lifted_40147(b_82348)
  let {f32 arg_82358} = lifted_40151(arg_82357, c_82349)
  let {f32 arg_82359} = lifted_40155(arg_82358)
  let {f32 arg_82360} = lifted_40158(a_82347)
  let {f32 arg_82361} = lifted_40162(arg_82360, d_82350)
  let {f32 res_82362} = lifted_40167(arg_82359, arg_82361)
  in {res_82356, res_82362}
}

fun {f32, f32} lifted_40105(f32 x_82363, f32 x_82364, f32 y_82365,
                            f32 y_82366) = {
  let {f32 arg_82367, f32 arg_82368} = lifted_40111(x_82363, x_82364)
  let {f32 res_82369, f32 res_82370} = lifted_40121(arg_82367, arg_82368,
                                                    y_82365, y_82366)
  in {res_82369, res_82370}
}

fun {f32, f32} lifted_40185(f32 a_82371, f32 b_82372) = {
  {a_82371, b_82372}
}

fun {f32} lifted_40195(f32 x_82373) = {
  {x_82373}
}

fun {f32} lifted_40199(f32 x_82374, f32 y_82375) = {
  let {f32 res_82376} = fsub32(x_82374, y_82375)
  in {res_82376}
}

fun {f32} lifted_40203(f32 x_82377) = {
  {x_82377}
}

fun {f32} lifted_40207(f32 x_82378, f32 y_82379) = {
  let {f32 res_82380} = fsub32(x_82378, y_82379)
  in {res_82380}
}

fun {f32, f32} lifted_40193(f32 a_82381, f32 b_82382, f32 c_82383,
                            f32 d_82384) = {
  let {f32 arg_82385} = lifted_40195(a_82381)
  let {f32 res_82386} = lifted_40199(arg_82385, c_82383)
  let {f32 arg_82387} = lifted_40203(b_82382)
  let {f32 res_82388} = lifted_40207(arg_82387, d_82384)
  in {res_82386, res_82388}
}

fun {f32, f32} lifted_40181(f32 x_82389, f32 x_82390, f32 y_82391,
                            f32 y_82392) = {
  let {f32 arg_82393, f32 arg_82394} = lifted_40185(x_82389, x_82390)
  let {f32 res_82395, f32 res_82396} = lifted_40193(arg_82393, arg_82394,
                                                    y_82391, y_82392)
  in {res_82395, res_82396}
}

fun {f32, f32} lifted_40227(f32 a_82397, f32 b_82398) = {
  {a_82397, b_82398}
}

fun {f32} lifted_40239(f32 x_82399) = {
  {x_82399}
}

fun {f32} lifted_40243(f32 x_82400, f32 y_82401) = {
  let {f32 res_82402} = fmul32(x_82400, y_82401)
  in {res_82402}
}

fun {f32} lifted_40247(f32 x_82403) = {
  {x_82403}
}

fun {f32} lifted_40250(f32 x_82404) = {
  {x_82404}
}

fun {f32} lifted_40254(f32 x_82405, f32 y_82406) = {
  let {f32 res_82407} = fmul32(x_82405, y_82406)
  in {res_82407}
}

fun {f32} lifted_40259(f32 x_82408, f32 y_82409) = {
  let {f32 res_82410} = fsub32(x_82408, y_82409)
  in {res_82410}
}

fun {f32} lifted_40263(f32 x_82411) = {
  {x_82411}
}

fun {f32} lifted_40267(f32 x_82412, f32 y_82413) = {
  let {f32 res_82414} = fmul32(x_82412, y_82413)
  in {res_82414}
}

fun {f32} lifted_40271(f32 x_82415) = {
  {x_82415}
}

fun {f32} lifted_40274(f32 x_82416) = {
  {x_82416}
}

fun {f32} lifted_40278(f32 x_82417, f32 y_82418) = {
  let {f32 res_82419} = fmul32(x_82417, y_82418)
  in {res_82419}
}

fun {f32} lifted_40283(f32 x_82420, f32 y_82421) = {
  let {f32 res_82422} = fadd32(x_82420, y_82421)
  in {res_82422}
}

fun {f32, f32} lifted_40237(f32 a_82423, f32 b_82424, f32 c_82425,
                            f32 d_82426) = {
  let {f32 arg_82427} = lifted_40239(a_82423)
  let {f32 arg_82428} = lifted_40243(arg_82427, c_82425)
  let {f32 arg_82429} = lifted_40247(arg_82428)
  let {f32 arg_82430} = lifted_40250(b_82424)
  let {f32 arg_82431} = lifted_40254(arg_82430, d_82426)
  let {f32 res_82432} = lifted_40259(arg_82429, arg_82431)
  let {f32 arg_82433} = lifted_40263(b_82424)
  let {f32 arg_82434} = lifted_40267(arg_82433, c_82425)
  let {f32 arg_82435} = lifted_40271(arg_82434)
  let {f32 arg_82436} = lifted_40274(a_82423)
  let {f32 arg_82437} = lifted_40278(arg_82436, d_82426)
  let {f32 res_82438} = lifted_40283(arg_82435, arg_82437)
  in {res_82432, res_82438}
}

fun {f32, f32} lifted_40221(f32 x_82439, f32 x_82440, f32 y_82441,
                            f32 y_82442) = {
  let {f32 arg_82443, f32 arg_82444} = lifted_40227(x_82439, x_82440)
  let {f32 res_82445, f32 res_82446} = lifted_40237(arg_82443, arg_82444,
                                                    y_82441, y_82442)
  in {res_82445, res_82446}
}

fun {f32, f32} lifted_40294(f32 x_82447, f32 x_82448) = {
  {x_82447, x_82448}
}

fun {f32, f32} lifted_40301(f32 x_82449, f32 x_82450) = {
  {x_82449, x_82450}
}

fun {f32, f32} lifted_40317(f32 a_82451, f32 b_82452) = {
  {a_82451, b_82452}
}

fun {f32} lifted_40329(f32 x_82453) = {
  {x_82453}
}

fun {f32} lifted_40333(f32 x_82454, f32 y_82455) = {
  let {f32 res_82456} = fmul32(x_82454, y_82455)
  in {res_82456}
}

fun {f32} lifted_40337(f32 x_82457) = {
  {x_82457}
}

fun {f32} lifted_40340(f32 x_82458) = {
  {x_82458}
}

fun {f32} lifted_40344(f32 x_82459, f32 y_82460) = {
  let {f32 res_82461} = fmul32(x_82459, y_82460)
  in {res_82461}
}

fun {f32} lifted_40349(f32 x_82462, f32 y_82463) = {
  let {f32 res_82464} = fsub32(x_82462, y_82463)
  in {res_82464}
}

fun {f32} lifted_40353(f32 x_82465) = {
  {x_82465}
}

fun {f32} lifted_40357(f32 x_82466, f32 y_82467) = {
  let {f32 res_82468} = fmul32(x_82466, y_82467)
  in {res_82468}
}

fun {f32} lifted_40361(f32 x_82469) = {
  {x_82469}
}

fun {f32} lifted_40364(f32 x_82470) = {
  {x_82470}
}

fun {f32} lifted_40368(f32 x_82471, f32 y_82472) = {
  let {f32 res_82473} = fmul32(x_82471, y_82472)
  in {res_82473}
}

fun {f32} lifted_40373(f32 x_82474, f32 y_82475) = {
  let {f32 res_82476} = fadd32(x_82474, y_82475)
  in {res_82476}
}

fun {f32, f32} lifted_40327(f32 a_82477, f32 b_82478, f32 c_82479,
                            f32 d_82480) = {
  let {f32 arg_82481} = lifted_40329(a_82477)
  let {f32 arg_82482} = lifted_40333(arg_82481, c_82479)
  let {f32 arg_82483} = lifted_40337(arg_82482)
  let {f32 arg_82484} = lifted_40340(b_82478)
  let {f32 arg_82485} = lifted_40344(arg_82484, d_82480)
  let {f32 res_82486} = lifted_40349(arg_82483, arg_82485)
  let {f32 arg_82487} = lifted_40353(b_82478)
  let {f32 arg_82488} = lifted_40357(arg_82487, c_82479)
  let {f32 arg_82489} = lifted_40361(arg_82488)
  let {f32 arg_82490} = lifted_40364(a_82477)
  let {f32 arg_82491} = lifted_40368(arg_82490, d_82480)
  let {f32 res_82492} = lifted_40373(arg_82489, arg_82491)
  in {res_82486, res_82492}
}

fun {f32, f32} lifted_40311(f32 x_82493, f32 x_82494, f32 y_82495,
                            f32 y_82496) = {
  let {f32 arg_82497, f32 arg_82498} = lifted_40317(x_82493, x_82494)
  let {f32 res_82499, f32 res_82500} = lifted_40327(arg_82497, arg_82498,
                                                    y_82495, y_82496)
  in {res_82499, res_82500}
}

fun {f32, f32} lifted_40384(f32 x_82501, f32 x_82502) = {
  {x_82501, x_82502}
}

fun {f32, f32} lifted_40391(f32 x_82503, f32 x_82504) = {
  {x_82503, x_82504}
}

fun {f32, f32} lifted_40405(f32 a_82505, f32 b_82506) = {
  {a_82505, b_82506}
}

fun {f32} lifted_40415(f32 x_82507) = {
  {x_82507}
}

fun {f32} lifted_40419(f32 x_82508, f32 y_82509) = {
  let {f32 res_82510} = fsub32(x_82508, y_82509)
  in {res_82510}
}

fun {f32} lifted_40423(f32 x_82511) = {
  {x_82511}
}

fun {f32} lifted_40427(f32 x_82512, f32 y_82513) = {
  let {f32 res_82514} = fsub32(x_82512, y_82513)
  in {res_82514}
}

fun {f32, f32} lifted_40413(f32 a_82515, f32 b_82516, f32 c_82517,
                            f32 d_82518) = {
  let {f32 arg_82519} = lifted_40415(a_82515)
  let {f32 res_82520} = lifted_40419(arg_82519, c_82517)
  let {f32 arg_82521} = lifted_40423(b_82516)
  let {f32 res_82522} = lifted_40427(arg_82521, d_82518)
  in {res_82520, res_82522}
}

fun {f32, f32} lifted_40401(f32 x_82523, f32 x_82524, f32 y_82525,
                            f32 y_82526) = {
  let {f32 arg_82527, f32 arg_82528} = lifted_40405(x_82523, x_82524)
  let {f32 res_82529, f32 res_82530} = lifted_40413(arg_82527, arg_82528,
                                                    y_82525, y_82526)
  in {res_82529, res_82530}
}

fun {f32, f32} lifted_40447(f32 a_82531, f32 b_82532) = {
  {a_82531, b_82532}
}

fun {f32} lifted_40459(f32 x_82533) = {
  {x_82533}
}

fun {f32} lifted_40463(f32 x_82534, f32 y_82535) = {
  let {f32 res_82536} = fmul32(x_82534, y_82535)
  in {res_82536}
}

fun {f32} lifted_40467(f32 x_82537) = {
  {x_82537}
}

fun {f32} lifted_40470(f32 x_82538) = {
  {x_82538}
}

fun {f32} lifted_40474(f32 x_82539, f32 y_82540) = {
  let {f32 res_82541} = fmul32(x_82539, y_82540)
  in {res_82541}
}

fun {f32} lifted_40479(f32 x_82542, f32 y_82543) = {
  let {f32 res_82544} = fsub32(x_82542, y_82543)
  in {res_82544}
}

fun {f32} lifted_40483(f32 x_82545) = {
  {x_82545}
}

fun {f32} lifted_40487(f32 x_82546, f32 y_82547) = {
  let {f32 res_82548} = fmul32(x_82546, y_82547)
  in {res_82548}
}

fun {f32} lifted_40491(f32 x_82549) = {
  {x_82549}
}

fun {f32} lifted_40494(f32 x_82550) = {
  {x_82550}
}

fun {f32} lifted_40498(f32 x_82551, f32 y_82552) = {
  let {f32 res_82553} = fmul32(x_82551, y_82552)
  in {res_82553}
}

fun {f32} lifted_40503(f32 x_82554, f32 y_82555) = {
  let {f32 res_82556} = fadd32(x_82554, y_82555)
  in {res_82556}
}

fun {f32, f32} lifted_40457(f32 a_82557, f32 b_82558, f32 c_82559,
                            f32 d_82560) = {
  let {f32 arg_82561} = lifted_40459(a_82557)
  let {f32 arg_82562} = lifted_40463(arg_82561, c_82559)
  let {f32 arg_82563} = lifted_40467(arg_82562)
  let {f32 arg_82564} = lifted_40470(b_82558)
  let {f32 arg_82565} = lifted_40474(arg_82564, d_82560)
  let {f32 res_82566} = lifted_40479(arg_82563, arg_82565)
  let {f32 arg_82567} = lifted_40483(b_82558)
  let {f32 arg_82568} = lifted_40487(arg_82567, c_82559)
  let {f32 arg_82569} = lifted_40491(arg_82568)
  let {f32 arg_82570} = lifted_40494(a_82557)
  let {f32 arg_82571} = lifted_40498(arg_82570, d_82560)
  let {f32 res_82572} = lifted_40503(arg_82569, arg_82571)
  in {res_82566, res_82572}
}

fun {f32, f32} lifted_40441(f32 x_82573, f32 x_82574, f32 y_82575,
                            f32 y_82576) = {
  let {f32 arg_82577, f32 arg_82578} = lifted_40447(x_82573, x_82574)
  let {f32 res_82579, f32 res_82580} = lifted_40457(arg_82577, arg_82578,
                                                    y_82575, y_82576)
  in {res_82579, res_82580}
}

fun {f32, f32} lifted_40514(f32 x_82581, f32 x_82582) = {
  {x_82581, x_82582}
}

fun {f32, f32} lifted_40521(f32 x_82583, f32 x_82584) = {
  {x_82583, x_82584}
}

fun {f32, f32} lifted_40528(f32 x_82585, f32 x_82586) = {
  {x_82585, x_82586}
}

fun {f32, f32} lifted_40544(f32 a_82587, f32 b_82588) = {
  {a_82587, b_82588}
}

fun {f32} lifted_40556(f32 x_82589) = {
  {x_82589}
}

fun {f32} lifted_40560(f32 x_82590, f32 y_82591) = {
  let {f32 res_82592} = fmul32(x_82590, y_82591)
  in {res_82592}
}

fun {f32} lifted_40564(f32 x_82593) = {
  {x_82593}
}

fun {f32} lifted_40567(f32 x_82594) = {
  {x_82594}
}

fun {f32} lifted_40571(f32 x_82595, f32 y_82596) = {
  let {f32 res_82597} = fmul32(x_82595, y_82596)
  in {res_82597}
}

fun {f32} lifted_40576(f32 x_82598, f32 y_82599) = {
  let {f32 res_82600} = fsub32(x_82598, y_82599)
  in {res_82600}
}

fun {f32} lifted_40580(f32 x_82601) = {
  {x_82601}
}

fun {f32} lifted_40584(f32 x_82602, f32 y_82603) = {
  let {f32 res_82604} = fmul32(x_82602, y_82603)
  in {res_82604}
}

fun {f32} lifted_40588(f32 x_82605) = {
  {x_82605}
}

fun {f32} lifted_40591(f32 x_82606) = {
  {x_82606}
}

fun {f32} lifted_40595(f32 x_82607, f32 y_82608) = {
  let {f32 res_82609} = fmul32(x_82607, y_82608)
  in {res_82609}
}

fun {f32} lifted_40600(f32 x_82610, f32 y_82611) = {
  let {f32 res_82612} = fadd32(x_82610, y_82611)
  in {res_82612}
}

fun {f32, f32} lifted_40554(f32 a_82613, f32 b_82614, f32 c_82615,
                            f32 d_82616) = {
  let {f32 arg_82617} = lifted_40556(a_82613)
  let {f32 arg_82618} = lifted_40560(arg_82617, c_82615)
  let {f32 arg_82619} = lifted_40564(arg_82618)
  let {f32 arg_82620} = lifted_40567(b_82614)
  let {f32 arg_82621} = lifted_40571(arg_82620, d_82616)
  let {f32 res_82622} = lifted_40576(arg_82619, arg_82621)
  let {f32 arg_82623} = lifted_40580(b_82614)
  let {f32 arg_82624} = lifted_40584(arg_82623, c_82615)
  let {f32 arg_82625} = lifted_40588(arg_82624)
  let {f32 arg_82626} = lifted_40591(a_82613)
  let {f32 arg_82627} = lifted_40595(arg_82626, d_82616)
  let {f32 res_82628} = lifted_40600(arg_82625, arg_82627)
  in {res_82622, res_82628}
}

fun {f32, f32} lifted_40538(f32 x_82629, f32 x_82630, f32 y_82631,
                            f32 y_82632) = {
  let {f32 arg_82633, f32 arg_82634} = lifted_40544(x_82629, x_82630)
  let {f32 res_82635, f32 res_82636} = lifted_40554(arg_82633, arg_82634,
                                                    y_82631, y_82632)
  in {res_82635, res_82636}
}

fun {f32, f32} lifted_40618(f32 a_82637, f32 b_82638) = {
  {a_82637, b_82638}
}

fun {f32} lifted_40628(f32 x_82639) = {
  {x_82639}
}

fun {f32} lifted_40632(f32 x_82640, f32 y_82641) = {
  let {f32 res_82642} = fsub32(x_82640, y_82641)
  in {res_82642}
}

fun {f32} lifted_40636(f32 x_82643) = {
  {x_82643}
}

fun {f32} lifted_40640(f32 x_82644, f32 y_82645) = {
  let {f32 res_82646} = fsub32(x_82644, y_82645)
  in {res_82646}
}

fun {f32, f32} lifted_40626(f32 a_82647, f32 b_82648, f32 c_82649,
                            f32 d_82650) = {
  let {f32 arg_82651} = lifted_40628(a_82647)
  let {f32 res_82652} = lifted_40632(arg_82651, c_82649)
  let {f32 arg_82653} = lifted_40636(b_82648)
  let {f32 res_82654} = lifted_40640(arg_82653, d_82650)
  in {res_82652, res_82654}
}

fun {f32, f32} lifted_40614(f32 x_82655, f32 x_82656, f32 y_82657,
                            f32 y_82658) = {
  let {f32 arg_82659, f32 arg_82660} = lifted_40618(x_82655, x_82656)
  let {f32 res_82661, f32 res_82662} = lifted_40626(arg_82659, arg_82660,
                                                    y_82657, y_82658)
  in {res_82661, res_82662}
}

fun {f32, f32} lifted_40661(f32 a_82663, f32 b_82664) = {
  {a_82663, b_82664}
}

fun {f32} lifted_40674(f32 x_82665) = {
  {x_82665}
}

fun {f32} lifted_40678(f32 x_82666, f32 y_82667) = {
  let {f32 res_82668} = fmul32(x_82666, y_82667)
  in {res_82668}
}

fun {f32} lifted_40682(f32 x_82669) = {
  {x_82669}
}

fun {f32} lifted_40685(f32 x_82670) = {
  {x_82670}
}

fun {f32} lifted_40689(f32 x_82671, f32 y_82672) = {
  let {f32 res_82673} = fmul32(x_82671, y_82672)
  in {res_82673}
}

fun {f32} lifted_40694(f32 x_82674, f32 y_82675) = {
  let {f32 res_82676} = fadd32(x_82674, y_82675)
  in {res_82676}
}

fun {f32} lifted_40698(f32 x_82677) = {
  {x_82677}
}

fun {f32} lifted_40701(f32 x_82678) = {
  {x_82678}
}

fun {f32} lifted_40705(f32 x_82679, f32 y_82680) = {
  let {f32 res_82681} = fmul32(x_82679, y_82680)
  in {res_82681}
}

fun {f32} lifted_40709(f32 x_82682) = {
  {x_82682}
}

fun {f32} lifted_40712(f32 x_82683) = {
  {x_82683}
}

fun {f32} lifted_40716(f32 x_82684, f32 y_82685) = {
  let {f32 res_82686} = fmul32(x_82684, y_82685)
  in {res_82686}
}

fun {f32} lifted_40721(f32 x_82687, f32 y_82688) = {
  let {f32 res_82689} = fadd32(x_82687, y_82688)
  in {res_82689}
}

fun {f32} lifted_40726(f32 x_82690, f32 y_82691) = {
  let {f32 res_82692} = fdiv32(x_82690, y_82691)
  in {res_82692}
}

fun {f32} lifted_40730(f32 x_82693) = {
  {x_82693}
}

fun {f32} lifted_40734(f32 x_82694, f32 y_82695) = {
  let {f32 res_82696} = fmul32(x_82694, y_82695)
  in {res_82696}
}

fun {f32} lifted_40738(f32 x_82697) = {
  {x_82697}
}

fun {f32} lifted_40741(f32 x_82698) = {
  {x_82698}
}

fun {f32} lifted_40745(f32 x_82699, f32 y_82700) = {
  let {f32 res_82701} = fmul32(x_82699, y_82700)
  in {res_82701}
}

fun {f32} lifted_40750(f32 x_82702, f32 y_82703) = {
  let {f32 res_82704} = fsub32(x_82702, y_82703)
  in {res_82704}
}

fun {f32} lifted_40754(f32 x_82705) = {
  {x_82705}
}

fun {f32} lifted_40757(f32 x_82706) = {
  {x_82706}
}

fun {f32} lifted_40761(f32 x_82707, f32 y_82708) = {
  let {f32 res_82709} = fmul32(x_82707, y_82708)
  in {res_82709}
}

fun {f32} lifted_40765(f32 x_82710) = {
  {x_82710}
}

fun {f32} lifted_40768(f32 x_82711) = {
  {x_82711}
}

fun {f32} lifted_40772(f32 x_82712, f32 y_82713) = {
  let {f32 res_82714} = fmul32(x_82712, y_82713)
  in {res_82714}
}

fun {f32} lifted_40777(f32 x_82715, f32 y_82716) = {
  let {f32 res_82717} = fadd32(x_82715, y_82716)
  in {res_82717}
}

fun {f32} lifted_40782(f32 x_82718, f32 y_82719) = {
  let {f32 res_82720} = fdiv32(x_82718, y_82719)
  in {res_82720}
}

fun {f32, f32} lifted_40672(f32 a_82721, f32 b_82722, f32 c_82723,
                            f32 d_82724) = {
  let {f32 arg_82725} = lifted_40674(a_82721)
  let {f32 arg_82726} = lifted_40678(arg_82725, c_82723)
  let {f32 arg_82727} = lifted_40682(arg_82726)
  let {f32 arg_82728} = lifted_40685(b_82722)
  let {f32 arg_82729} = lifted_40689(arg_82728, d_82724)
  let {f32 arg_82730} = lifted_40694(arg_82727, arg_82729)
  let {f32 arg_82731} = lifted_40698(arg_82730)
  let {f32 arg_82732} = lifted_40701(c_82723)
  let {f32 arg_82733} = lifted_40705(arg_82732, c_82723)
  let {f32 arg_82734} = lifted_40709(arg_82733)
  let {f32 arg_82735} = lifted_40712(d_82724)
  let {f32 arg_82736} = lifted_40716(arg_82735, d_82724)
  let {f32 arg_82737} = lifted_40721(arg_82734, arg_82736)
  let {f32 res_82738} = lifted_40726(arg_82731, arg_82737)
  let {f32 arg_82739} = lifted_40730(b_82722)
  let {f32 arg_82740} = lifted_40734(arg_82739, c_82723)
  let {f32 arg_82741} = lifted_40738(arg_82740)
  let {f32 arg_82742} = lifted_40741(a_82721)
  let {f32 arg_82743} = lifted_40745(arg_82742, d_82724)
  let {f32 arg_82744} = lifted_40750(arg_82741, arg_82743)
  let {f32 arg_82745} = lifted_40754(arg_82744)
  let {f32 arg_82746} = lifted_40757(c_82723)
  let {f32 arg_82747} = lifted_40761(arg_82746, c_82723)
  let {f32 arg_82748} = lifted_40765(arg_82747)
  let {f32 arg_82749} = lifted_40768(d_82724)
  let {f32 arg_82750} = lifted_40772(arg_82749, d_82724)
  let {f32 arg_82751} = lifted_40777(arg_82748, arg_82750)
  let {f32 res_82752} = lifted_40782(arg_82745, arg_82751)
  in {res_82738, res_82752}
}

fun {f32, f32} lifted_40654(f32 x_82753, f32 x_82754, f32 y_82755,
                            f32 y_82756) = {
  let {f32 arg_82757, f32 arg_82758} = lifted_40661(x_82753, x_82754)
  let {f32 res_82759, f32 res_82760} = lifted_40672(arg_82757, arg_82758,
                                                    y_82755, y_82756)
  in {res_82759, res_82760}
}

fun {f32, f32} lifted_40800(f32 a_82761, f32 b_82762) = {
  {a_82761, b_82762}
}

fun {f32} lifted_40810(f32 x_82763) = {
  {x_82763}
}

fun {f32} lifted_40814(f32 x_82764, f32 y_82765) = {
  let {f32 res_82766} = fadd32(x_82764, y_82765)
  in {res_82766}
}

fun {f32} lifted_40818(f32 x_82767) = {
  {x_82767}
}

fun {f32} lifted_40822(f32 x_82768, f32 y_82769) = {
  let {f32 res_82770} = fadd32(x_82768, y_82769)
  in {res_82770}
}

fun {f32, f32} lifted_40808(f32 a_82771, f32 b_82772, f32 c_82773,
                            f32 d_82774) = {
  let {f32 arg_82775} = lifted_40810(a_82771)
  let {f32 res_82776} = lifted_40814(arg_82775, c_82773)
  let {f32 arg_82777} = lifted_40818(b_82772)
  let {f32 res_82778} = lifted_40822(arg_82777, d_82774)
  in {res_82776, res_82778}
}

fun {f32, f32} lifted_40796(f32 x_82779, f32 x_82780, f32 y_82781,
                            f32 y_82782) = {
  let {f32 arg_82783, f32 arg_82784} = lifted_40800(x_82779, x_82780)
  let {f32 res_82785, f32 res_82786} = lifted_40808(arg_82783, arg_82784,
                                                    y_82781, y_82782)
  in {res_82785, res_82786}
}

fun {f32} lifted_40838(f32 x_82787) = {
  let {f32 res_82788} = exp32(x_82787)
  in {res_82788}
}

fun {f32} lifted_40843(f32 x_82789) = {
  {x_82789}
}

fun {f32} lifted_40846(f32 x_82790) = {
  let {f32 res_82791} = cos32(x_82790)
  in {res_82791}
}

fun {f32} lifted_40851(f32 x_82792, f32 y_82793) = {
  let {f32 res_82794} = fmul32(x_82792, y_82793)
  in {res_82794}
}

fun {f32} lifted_40855(f32 a_82795) = {
  {a_82795}
}

fun {f32} lifted_40858(f32 x_82796) = {
  {x_82796}
}

fun {f32} lifted_40861(f32 x_82797) = {
  let {f32 res_82798} = sin32(x_82797)
  in {res_82798}
}

fun {f32} lifted_40866(f32 x_82799, f32 y_82800) = {
  let {f32 res_82801} = fmul32(x_82799, y_82800)
  in {res_82801}
}

fun {f32, f32} lifted_40871(f32 a_82802, f32 b_82803) = {
  {a_82802, b_82803}
}

fun {f32, f32} lifted_40836(f32 a_82804, f32 b_82805) = {
  let {f32 res_82806} = lifted_40838(a_82804)
  let {f32 expx_82807} = res_82806
  let {f32 arg_82808} = lifted_40843(expx_82807)
  let {f32 arg_82809} = lifted_40846(b_82805)
  let {f32 arg_82810} = lifted_40851(arg_82808, arg_82809)
  let {f32 arg_82811} = lifted_40855(arg_82810)
  let {f32 arg_82812} = lifted_40858(expx_82807)
  let {f32 arg_82813} = lifted_40861(b_82805)
  let {f32 arg_82814} = lifted_40866(arg_82812, arg_82813)
  let {f32 res_82815, f32 res_82816} = lifted_40871(arg_82811, arg_82814)
  in {res_82815, res_82816}
}

fun {f32, f32} lifted_38414(f32 coeff1_82817, f32 coeff1_82818,
                            f32 coeff2_82819, f32 coeff2_82820,
                            f32 day_count_fraction_82821, f32 etai2_82822,
                            f32 etai2_82823, f32 etai_82824, f32 etai_82825,
                            f32 i_82826, f32 i_82827, f32 kappai_82828,
                            f32 kappai_82829, f32 one_82830, f32 one_82831,
                            f32 rho_82832, f32 two_82833, f32 two_82834,
                            f32 zero_82835, f32 zero_82836, f32 xi_82837,
                            f32 xi_82838) = {
  let {f32 res_82839, f32 res_82840} = lifted_38417(day_count_fraction_82821)
  let {f32 ti_82841} = res_82839
  let {f32 ti_82842} = res_82840
  let {f32 arg_82843, f32 arg_82844} = lifted_38431(kappai_82828, kappai_82829)
  let {f32 arg_82845, f32 arg_82846} = lifted_38436(rho_82832)
  let {f32 arg_82847, f32 arg_82848} = lifted_38447(arg_82845, arg_82846)
  let {f32 arg_82849, f32 arg_82850} = lifted_38457(arg_82847, arg_82848,
                                                    etai_82824, etai_82825)
  let {f32 arg_82851, f32 arg_82852} = lifted_38530(arg_82849, arg_82850)
  let {f32 arg_82853, f32 arg_82854} = lifted_38540(arg_82851, arg_82852,
                                                    xi_82837, xi_82838)
  let {f32 res_82855, f32 res_82856} = lifted_38616(arg_82843, arg_82844,
                                                    arg_82853, arg_82854)
  let {f32 d0_82857} = res_82855
  let {f32 d0_82858} = res_82856
  let {f32 arg_82859, f32 arg_82860} = lifted_38656(d0_82857, d0_82858)
  let {f32 arg_82861, f32 arg_82862} = lifted_38666(arg_82859, arg_82860,
                                                    d0_82857, d0_82858)
  let {f32 arg_82863, f32 arg_82864} = lifted_38739(arg_82861, arg_82862)
  let {f32 arg_82865, f32 arg_82866} = lifted_38746(etai2_82822, etai2_82823)
  let {f32 arg_82867, f32 arg_82868} = lifted_38753(xi_82837, xi_82838)
  let {f32 arg_82869, f32 arg_82870} = lifted_38760(i_82826, i_82827)
  let {f32 arg_82871, f32 arg_82872} = lifted_38770(arg_82869, arg_82870,
                                                    xi_82837, xi_82838)
  let {f32 arg_82873, f32 arg_82874} = lifted_38810(arg_82867, arg_82868,
                                                    arg_82871, arg_82872)
  let {f32 arg_82875, f32 arg_82876} = lifted_38886(arg_82865, arg_82866,
                                                    arg_82873, arg_82874)
  let {f32 arg_82877, f32 arg_82878} = lifted_38962(arg_82863, arg_82864,
                                                    arg_82875, arg_82876)
  let {f32 res_82879, f32 res_82880} = lifted_39005(arg_82877, arg_82878)
  let {f32 d_82881} = res_82879
  let {f32 d_82882} = res_82880
  let {f32 arg_82883, f32 arg_82884} = lifted_39173(d0_82857, d0_82858)
  let {f32 res_82885, f32 res_82886} = lifted_39183(arg_82883, arg_82884,
                                                    d_82881, d_82882)
  let {f32 a_minus_82887} = res_82885
  let {f32 a_minus_82888} = res_82886
  let {f32 arg_82889, f32 arg_82890} = lifted_39223(a_minus_82887,
                                                    a_minus_82888)
  let {f32 arg_82891, f32 arg_82892} = lifted_39230(d0_82857, d0_82858)
  let {f32 arg_82893, f32 arg_82894} = lifted_39240(arg_82891, arg_82892,
                                                    d_82881, d_82882)
  let {f32 res_82895, f32 res_82896} = lifted_39280(arg_82889, arg_82890,
                                                    arg_82893, arg_82894)
  let {f32 g_82897} = res_82895
  let {f32 g_82898} = res_82896
  let {f32 arg_82899, f32 arg_82900} = lifted_39422(zero_82835, zero_82836)
  let {f32 arg_82901, f32 arg_82902} = lifted_39429(d_82881, d_82882)
  let {f32 arg_82903, f32 arg_82904} = lifted_39439(arg_82901, arg_82902,
                                                    ti_82841, ti_82842)
  let {f32 arg_82905, f32 arg_82906} = lifted_39515(arg_82899, arg_82900,
                                                    arg_82903, arg_82904)
  let {f32 res_82907, f32 res_82908} = lifted_39555(arg_82905, arg_82906)
  let {f32 e_82909} = res_82907
  let {f32 e_82910} = res_82908
  let {f32 arg_82911, f32 arg_82912} = lifted_39602(coeff1_82817, coeff1_82818)
  let {f32 arg_82913, f32 arg_82914} = lifted_39609(a_minus_82887,
                                                    a_minus_82888)
  let {f32 arg_82915, f32 arg_82916} = lifted_39619(arg_82913, arg_82914,
                                                    ti_82841, ti_82842)
  let {f32 arg_82917, f32 arg_82918} = lifted_39692(arg_82915, arg_82916)
  let {f32 arg_82919, f32 arg_82920} = lifted_39699(two_82833, two_82834)
  let {f32 arg_82921, f32 arg_82922} = lifted_39706(one_82830, one_82831)
  let {f32 arg_82923, f32 arg_82924} = lifted_39713(g_82897, g_82898)
  let {f32 arg_82925, f32 arg_82926} = lifted_39723(arg_82923, arg_82924,
                                                    e_82909, e_82910)
  let {f32 arg_82927, f32 arg_82928} = lifted_39799(arg_82921, arg_82922,
                                                    arg_82925, arg_82926)
  let {f32 arg_82929, f32 arg_82930} = lifted_39836(arg_82927, arg_82928)
  let {f32 arg_82931, f32 arg_82932} = lifted_39843(one_82830, one_82831)
  let {f32 arg_82933, f32 arg_82934} = lifted_39853(arg_82931, arg_82932,
                                                    g_82897, g_82898)
  let {f32 arg_82935, f32 arg_82936} = lifted_39893(arg_82929, arg_82930,
                                                    arg_82933, arg_82934)
  let {f32 arg_82937, f32 arg_82938} = lifted_40035(arg_82935, arg_82936)
  let {f32 arg_82939, f32 arg_82940} = lifted_40105(arg_82919, arg_82920,
                                                    arg_82937, arg_82938)
  let {f32 arg_82941, f32 arg_82942} = lifted_40181(arg_82917, arg_82918,
                                                    arg_82939, arg_82940)
  let {f32 arg_82943, f32 arg_82944} = lifted_40221(arg_82911, arg_82912,
                                                    arg_82941, arg_82942)
  let {f32 arg_82945, f32 arg_82946} = lifted_40294(arg_82943, arg_82944)
  let {f32 arg_82947, f32 arg_82948} = lifted_40301(coeff2_82819, coeff2_82820)
  let {f32 arg_82949, f32 arg_82950} = lifted_40311(arg_82947, arg_82948,
                                                    a_minus_82887,
                                                    a_minus_82888)
  let {f32 arg_82951, f32 arg_82952} = lifted_40384(arg_82949, arg_82950)
  let {f32 arg_82953, f32 arg_82954} = lifted_40391(one_82830, one_82831)
  let {f32 arg_82955, f32 arg_82956} = lifted_40401(arg_82953, arg_82954,
                                                    e_82909, e_82910)
  let {f32 arg_82957, f32 arg_82958} = lifted_40441(arg_82951, arg_82952,
                                                    arg_82955, arg_82956)
  let {f32 arg_82959, f32 arg_82960} = lifted_40514(arg_82957, arg_82958)
  let {f32 arg_82961, f32 arg_82962} = lifted_40521(one_82830, one_82831)
  let {f32 arg_82963, f32 arg_82964} = lifted_40528(g_82897, g_82898)
  let {f32 arg_82965, f32 arg_82966} = lifted_40538(arg_82963, arg_82964,
                                                    e_82909, e_82910)
  let {f32 arg_82967, f32 arg_82968} = lifted_40614(arg_82961, arg_82962,
                                                    arg_82965, arg_82966)
  let {f32 arg_82969, f32 arg_82970} = lifted_40654(arg_82959, arg_82960,
                                                    arg_82967, arg_82968)
  let {f32 arg_82971, f32 arg_82972} = lifted_40796(arg_82945, arg_82946,
                                                    arg_82969, arg_82970)
  let {f32 res_82973, f32 res_82974} = lifted_40836(arg_82971, arg_82972)
  in {res_82973, res_82974}
}

fun {f32, f32} lifted_40882(f32 x_82975, f32 x_82976) = {
  {x_82975, x_82976}
}

fun {f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32,
     f32, f32, f32, f32, f32} lifted_40923(f32 coeff1_82977, f32 coeff1_82978,
                                           f32 coeff2_82979, f32 coeff2_82980,
                                           f32 etai2_82981, f32 etai2_82982,
                                           f32 etai_82983, f32 etai_82984,
                                           f32 i_82985, f32 i_82986,
                                           f32 kappai_82987, f32 kappai_82988,
                                           f32 one_82989, f32 one_82990,
                                           f32 rho_82991, f32 two_82992,
                                           f32 two_82993, f32 zero_82994,
                                           f32 zero_82995,
                                           f32 day_count_fraction_82996) = {
  {coeff1_82977, coeff1_82978, coeff2_82979, coeff2_82980,
   day_count_fraction_82996, etai2_82981, etai2_82982, etai_82983, etai_82984,
   i_82985, i_82986, kappai_82987, kappai_82988, one_82989, one_82990,
   rho_82991, two_82992, two_82993, zero_82994, zero_82995}
}

fun {f32} lifted_40945(f32 x_82997) = {
  {x_82997}
}

fun {f32} lifted_40949(f32 x_82998, f32 y_82999) = {
  let {f32 res_83000} = fsub32(x_82998, y_82999)
  in {res_83000}
}

fun {f32} lifted_40956(i32 x_83001) = {
  let {f32 res_83002} = sitofp i32 x_83001 to f32
  in {res_83002}
}

fun {f32, f32} lifted_40954(f32 b_83003) = {
  let {f32 res_83004} = lifted_40956(0i32)
  in {res_83004, b_83003}
}

fun {f32} lifted_41007(i32 x_83005) = {
  let {f32 res_83006} = sitofp i32 x_83005 to f32
  in {res_83006}
}

fun {f32, f32} lifted_41005(f32 a_83007) = {
  let {f32 res_83008} = lifted_41007(0i32)
  in {a_83007, res_83008}
}

fun {f32, f32} lifted_41019(f32 x_83009, f32 x_83010) = {
  {x_83009, x_83010}
}

fun {f32} lifted_41026(i32 x_83011) = {
  let {f32 res_83012} = sitofp i32 x_83011 to f32
  in {res_83012}
}

fun {f32, f32} lifted_41024(f32 b_83013) = {
  let {f32 res_83014} = lifted_41026(0i32)
  in {res_83014, b_83013}
}

fun {f32, f32} lifted_41035(f32 x_83015, f32 x_83016) = {
  {x_83015, x_83016}
}

fun {f32, f32} lifted_41051(f32 a_83017, f32 b_83018) = {
  {a_83017, b_83018}
}

fun {f32} lifted_41063(f32 x_83019) = {
  {x_83019}
}

fun {f32} lifted_41067(f32 x_83020, f32 y_83021) = {
  let {f32 res_83022} = fmul32(x_83020, y_83021)
  in {res_83022}
}

fun {f32} lifted_41071(f32 x_83023) = {
  {x_83023}
}

fun {f32} lifted_41074(f32 x_83024) = {
  {x_83024}
}

fun {f32} lifted_41078(f32 x_83025, f32 y_83026) = {
  let {f32 res_83027} = fmul32(x_83025, y_83026)
  in {res_83027}
}

fun {f32} lifted_41083(f32 x_83028, f32 y_83029) = {
  let {f32 res_83030} = fsub32(x_83028, y_83029)
  in {res_83030}
}

fun {f32} lifted_41087(f32 x_83031) = {
  {x_83031}
}

fun {f32} lifted_41091(f32 x_83032, f32 y_83033) = {
  let {f32 res_83034} = fmul32(x_83032, y_83033)
  in {res_83034}
}

fun {f32} lifted_41095(f32 x_83035) = {
  {x_83035}
}

fun {f32} lifted_41098(f32 x_83036) = {
  {x_83036}
}

fun {f32} lifted_41102(f32 x_83037, f32 y_83038) = {
  let {f32 res_83039} = fmul32(x_83037, y_83038)
  in {res_83039}
}

fun {f32} lifted_41107(f32 x_83040, f32 y_83041) = {
  let {f32 res_83042} = fadd32(x_83040, y_83041)
  in {res_83042}
}

fun {f32, f32} lifted_41061(f32 a_83043, f32 b_83044, f32 c_83045,
                            f32 d_83046) = {
  let {f32 arg_83047} = lifted_41063(a_83043)
  let {f32 arg_83048} = lifted_41067(arg_83047, c_83045)
  let {f32 arg_83049} = lifted_41071(arg_83048)
  let {f32 arg_83050} = lifted_41074(b_83044)
  let {f32 arg_83051} = lifted_41078(arg_83050, d_83046)
  let {f32 res_83052} = lifted_41083(arg_83049, arg_83051)
  let {f32 arg_83053} = lifted_41087(b_83044)
  let {f32 arg_83054} = lifted_41091(arg_83053, c_83045)
  let {f32 arg_83055} = lifted_41095(arg_83054)
  let {f32 arg_83056} = lifted_41098(a_83043)
  let {f32 arg_83057} = lifted_41102(arg_83056, d_83046)
  let {f32 res_83058} = lifted_41107(arg_83055, arg_83057)
  in {res_83052, res_83058}
}

fun {f32, f32} lifted_41045(f32 x_83059, f32 x_83060, f32 y_83061,
                            f32 y_83062) = {
  let {f32 arg_83063, f32 arg_83064} = lifted_41051(x_83059, x_83060)
  let {f32 res_83065, f32 res_83066} = lifted_41061(arg_83063, arg_83064,
                                                    y_83061, y_83062)
  in {res_83065, res_83066}
}

fun {f32, f32} lifted_41118(f32 x_83067, f32 x_83068) = {
  {x_83067, x_83068}
}

fun {f32, f32} lifted_41134(f32 a_83069, f32 b_83070) = {
  {a_83069, b_83070}
}

fun {f32} lifted_41146(f32 x_83071) = {
  {x_83071}
}

fun {f32} lifted_41150(f32 x_83072, f32 y_83073) = {
  let {f32 res_83074} = fmul32(x_83072, y_83073)
  in {res_83074}
}

fun {f32} lifted_41154(f32 x_83075) = {
  {x_83075}
}

fun {f32} lifted_41157(f32 x_83076) = {
  {x_83076}
}

fun {f32} lifted_41161(f32 x_83077, f32 y_83078) = {
  let {f32 res_83079} = fmul32(x_83077, y_83078)
  in {res_83079}
}

fun {f32} lifted_41166(f32 x_83080, f32 y_83081) = {
  let {f32 res_83082} = fsub32(x_83080, y_83081)
  in {res_83082}
}

fun {f32} lifted_41170(f32 x_83083) = {
  {x_83083}
}

fun {f32} lifted_41174(f32 x_83084, f32 y_83085) = {
  let {f32 res_83086} = fmul32(x_83084, y_83085)
  in {res_83086}
}

fun {f32} lifted_41178(f32 x_83087) = {
  {x_83087}
}

fun {f32} lifted_41181(f32 x_83088) = {
  {x_83088}
}

fun {f32} lifted_41185(f32 x_83089, f32 y_83090) = {
  let {f32 res_83091} = fmul32(x_83089, y_83090)
  in {res_83091}
}

fun {f32} lifted_41190(f32 x_83092, f32 y_83093) = {
  let {f32 res_83094} = fadd32(x_83092, y_83093)
  in {res_83094}
}

fun {f32, f32} lifted_41144(f32 a_83095, f32 b_83096, f32 c_83097,
                            f32 d_83098) = {
  let {f32 arg_83099} = lifted_41146(a_83095)
  let {f32 arg_83100} = lifted_41150(arg_83099, c_83097)
  let {f32 arg_83101} = lifted_41154(arg_83100)
  let {f32 arg_83102} = lifted_41157(b_83096)
  let {f32 arg_83103} = lifted_41161(arg_83102, d_83098)
  let {f32 res_83104} = lifted_41166(arg_83101, arg_83103)
  let {f32 arg_83105} = lifted_41170(b_83096)
  let {f32 arg_83106} = lifted_41174(arg_83105, c_83097)
  let {f32 arg_83107} = lifted_41178(arg_83106)
  let {f32 arg_83108} = lifted_41181(a_83095)
  let {f32 arg_83109} = lifted_41185(arg_83108, d_83098)
  let {f32 res_83110} = lifted_41190(arg_83107, arg_83109)
  in {res_83104, res_83110}
}

fun {f32, f32} lifted_41128(f32 x_83111, f32 x_83112, f32 y_83113,
                            f32 y_83114) = {
  let {f32 arg_83115, f32 arg_83116} = lifted_41134(x_83111, x_83112)
  let {f32 res_83117, f32 res_83118} = lifted_41144(arg_83115, arg_83116,
                                                    y_83113, y_83114)
  in {res_83117, res_83118}
}

fun {f32, f32} lifted_41208(f32 a_83119, f32 b_83120) = {
  {a_83119, b_83120}
}

fun {f32} lifted_41218(f32 x_83121) = {
  {x_83121}
}

fun {f32} lifted_41222(f32 x_83122, f32 y_83123) = {
  let {f32 res_83124} = fsub32(x_83122, y_83123)
  in {res_83124}
}

fun {f32} lifted_41226(f32 x_83125) = {
  {x_83125}
}

fun {f32} lifted_41230(f32 x_83126, f32 y_83127) = {
  let {f32 res_83128} = fsub32(x_83126, y_83127)
  in {res_83128}
}

fun {f32, f32} lifted_41216(f32 a_83129, f32 b_83130, f32 c_83131,
                            f32 d_83132) = {
  let {f32 arg_83133} = lifted_41218(a_83129)
  let {f32 res_83134} = lifted_41222(arg_83133, c_83131)
  let {f32 arg_83135} = lifted_41226(b_83130)
  let {f32 res_83136} = lifted_41230(arg_83135, d_83132)
  in {res_83134, res_83136}
}

fun {f32, f32} lifted_41204(f32 x_83137, f32 x_83138, f32 y_83139,
                            f32 y_83140) = {
  let {f32 arg_83141, f32 arg_83142} = lifted_41208(x_83137, x_83138)
  let {f32 res_83143, f32 res_83144} = lifted_41216(arg_83141, arg_83142,
                                                    y_83139, y_83140)
  in {res_83143, res_83144}
}

fun {f32, f32} lifted_41244(f32 x_83145, f32 x_83146) = {
  {x_83145, x_83146}
}

fun {f32, f32} lifted_41260(f32 a_83147, f32 b_83148) = {
  {a_83147, b_83148}
}

fun {f32} lifted_41272(f32 x_83149) = {
  {x_83149}
}

fun {f32} lifted_41276(f32 x_83150, f32 y_83151) = {
  let {f32 res_83152} = fmul32(x_83150, y_83151)
  in {res_83152}
}

fun {f32} lifted_41280(f32 x_83153) = {
  {x_83153}
}

fun {f32} lifted_41283(f32 x_83154) = {
  {x_83154}
}

fun {f32} lifted_41287(f32 x_83155, f32 y_83156) = {
  let {f32 res_83157} = fmul32(x_83155, y_83156)
  in {res_83157}
}

fun {f32} lifted_41292(f32 x_83158, f32 y_83159) = {
  let {f32 res_83160} = fsub32(x_83158, y_83159)
  in {res_83160}
}

fun {f32} lifted_41296(f32 x_83161) = {
  {x_83161}
}

fun {f32} lifted_41300(f32 x_83162, f32 y_83163) = {
  let {f32 res_83164} = fmul32(x_83162, y_83163)
  in {res_83164}
}

fun {f32} lifted_41304(f32 x_83165) = {
  {x_83165}
}

fun {f32} lifted_41307(f32 x_83166) = {
  {x_83166}
}

fun {f32} lifted_41311(f32 x_83167, f32 y_83168) = {
  let {f32 res_83169} = fmul32(x_83167, y_83168)
  in {res_83169}
}

fun {f32} lifted_41316(f32 x_83170, f32 y_83171) = {
  let {f32 res_83172} = fadd32(x_83170, y_83171)
  in {res_83172}
}

fun {f32, f32} lifted_41270(f32 a_83173, f32 b_83174, f32 c_83175,
                            f32 d_83176) = {
  let {f32 arg_83177} = lifted_41272(a_83173)
  let {f32 arg_83178} = lifted_41276(arg_83177, c_83175)
  let {f32 arg_83179} = lifted_41280(arg_83178)
  let {f32 arg_83180} = lifted_41283(b_83174)
  let {f32 arg_83181} = lifted_41287(arg_83180, d_83176)
  let {f32 res_83182} = lifted_41292(arg_83179, arg_83181)
  let {f32 arg_83183} = lifted_41296(b_83174)
  let {f32 arg_83184} = lifted_41300(arg_83183, c_83175)
  let {f32 arg_83185} = lifted_41304(arg_83184)
  let {f32 arg_83186} = lifted_41307(a_83173)
  let {f32 arg_83187} = lifted_41311(arg_83186, d_83176)
  let {f32 res_83188} = lifted_41316(arg_83185, arg_83187)
  in {res_83182, res_83188}
}

fun {f32, f32} lifted_41254(f32 x_83189, f32 x_83190, f32 y_83191,
                            f32 y_83192) = {
  let {f32 arg_83193, f32 arg_83194} = lifted_41260(x_83189, x_83190)
  let {f32 res_83195, f32 res_83196} = lifted_41270(arg_83193, arg_83194,
                                                    y_83191, y_83192)
  in {res_83195, res_83196}
}

fun {f32, f32} lifted_41327(f32 x_83197, f32 x_83198) = {
  {x_83197, x_83198}
}

fun {f32, f32} lifted_41334(f32 x_83199, f32 x_83200) = {
  {x_83199, x_83200}
}

fun {f32, f32} lifted_41341(f32 x_83201, f32 x_83202) = {
  {x_83201, x_83202}
}

fun {f32, f32} lifted_41348(f32 x_83203, f32 x_83204) = {
  {x_83203, x_83204}
}

fun {f32, f32} lifted_41362(f32 a_83205, f32 b_83206) = {
  {a_83205, b_83206}
}

fun {f32} lifted_41372(f32 x_83207) = {
  {x_83207}
}

fun {f32} lifted_41376(f32 x_83208, f32 y_83209) = {
  let {f32 res_83210} = fadd32(x_83208, y_83209)
  in {res_83210}
}

fun {f32} lifted_41380(f32 x_83211) = {
  {x_83211}
}

fun {f32} lifted_41384(f32 x_83212, f32 y_83213) = {
  let {f32 res_83214} = fadd32(x_83212, y_83213)
  in {res_83214}
}

fun {f32, f32} lifted_41370(f32 a_83215, f32 b_83216, f32 c_83217,
                            f32 d_83218) = {
  let {f32 arg_83219} = lifted_41372(a_83215)
  let {f32 res_83220} = lifted_41376(arg_83219, c_83217)
  let {f32 arg_83221} = lifted_41380(b_83216)
  let {f32 res_83222} = lifted_41384(arg_83221, d_83218)
  in {res_83220, res_83222}
}

fun {f32, f32} lifted_41358(f32 x_83223, f32 x_83224, f32 y_83225,
                            f32 y_83226) = {
  let {f32 arg_83227, f32 arg_83228} = lifted_41362(x_83223, x_83224)
  let {f32 res_83229, f32 res_83230} = lifted_41370(arg_83227, arg_83228,
                                                    y_83225, y_83226)
  in {res_83229, res_83230}
}

fun {f32, f32} lifted_41404(f32 a_83231, f32 b_83232) = {
  {a_83231, b_83232}
}

fun {f32} lifted_41416(f32 x_83233) = {
  {x_83233}
}

fun {f32} lifted_41420(f32 x_83234, f32 y_83235) = {
  let {f32 res_83236} = fmul32(x_83234, y_83235)
  in {res_83236}
}

fun {f32} lifted_41424(f32 x_83237) = {
  {x_83237}
}

fun {f32} lifted_41427(f32 x_83238) = {
  {x_83238}
}

fun {f32} lifted_41431(f32 x_83239, f32 y_83240) = {
  let {f32 res_83241} = fmul32(x_83239, y_83240)
  in {res_83241}
}

fun {f32} lifted_41436(f32 x_83242, f32 y_83243) = {
  let {f32 res_83244} = fsub32(x_83242, y_83243)
  in {res_83244}
}

fun {f32} lifted_41440(f32 x_83245) = {
  {x_83245}
}

fun {f32} lifted_41444(f32 x_83246, f32 y_83247) = {
  let {f32 res_83248} = fmul32(x_83246, y_83247)
  in {res_83248}
}

fun {f32} lifted_41448(f32 x_83249) = {
  {x_83249}
}

fun {f32} lifted_41451(f32 x_83250) = {
  {x_83250}
}

fun {f32} lifted_41455(f32 x_83251, f32 y_83252) = {
  let {f32 res_83253} = fmul32(x_83251, y_83252)
  in {res_83253}
}

fun {f32} lifted_41460(f32 x_83254, f32 y_83255) = {
  let {f32 res_83256} = fadd32(x_83254, y_83255)
  in {res_83256}
}

fun {f32, f32} lifted_41414(f32 a_83257, f32 b_83258, f32 c_83259,
                            f32 d_83260) = {
  let {f32 arg_83261} = lifted_41416(a_83257)
  let {f32 arg_83262} = lifted_41420(arg_83261, c_83259)
  let {f32 arg_83263} = lifted_41424(arg_83262)
  let {f32 arg_83264} = lifted_41427(b_83258)
  let {f32 arg_83265} = lifted_41431(arg_83264, d_83260)
  let {f32 res_83266} = lifted_41436(arg_83263, arg_83265)
  let {f32 arg_83267} = lifted_41440(b_83258)
  let {f32 arg_83268} = lifted_41444(arg_83267, c_83259)
  let {f32 arg_83269} = lifted_41448(arg_83268)
  let {f32 arg_83270} = lifted_41451(a_83257)
  let {f32 arg_83271} = lifted_41455(arg_83270, d_83260)
  let {f32 res_83272} = lifted_41460(arg_83269, arg_83271)
  in {res_83266, res_83272}
}

fun {f32, f32} lifted_41398(f32 x_83273, f32 x_83274, f32 y_83275,
                            f32 y_83276) = {
  let {f32 arg_83277, f32 arg_83278} = lifted_41404(x_83273, x_83274)
  let {f32 res_83279, f32 res_83280} = lifted_41414(arg_83277, arg_83278,
                                                    y_83275, y_83276)
  in {res_83279, res_83280}
}

fun {f32, f32} lifted_41480(f32 a_83281, f32 b_83282) = {
  {a_83281, b_83282}
}

fun {f32} lifted_41492(f32 x_83283) = {
  {x_83283}
}

fun {f32} lifted_41496(f32 x_83284, f32 y_83285) = {
  let {f32 res_83286} = fmul32(x_83284, y_83285)
  in {res_83286}
}

fun {f32} lifted_41500(f32 x_83287) = {
  {x_83287}
}

fun {f32} lifted_41503(f32 x_83288) = {
  {x_83288}
}

fun {f32} lifted_41507(f32 x_83289, f32 y_83290) = {
  let {f32 res_83291} = fmul32(x_83289, y_83290)
  in {res_83291}
}

fun {f32} lifted_41512(f32 x_83292, f32 y_83293) = {
  let {f32 res_83294} = fsub32(x_83292, y_83293)
  in {res_83294}
}

fun {f32} lifted_41516(f32 x_83295) = {
  {x_83295}
}

fun {f32} lifted_41520(f32 x_83296, f32 y_83297) = {
  let {f32 res_83298} = fmul32(x_83296, y_83297)
  in {res_83298}
}

fun {f32} lifted_41524(f32 x_83299) = {
  {x_83299}
}

fun {f32} lifted_41527(f32 x_83300) = {
  {x_83300}
}

fun {f32} lifted_41531(f32 x_83301, f32 y_83302) = {
  let {f32 res_83303} = fmul32(x_83301, y_83302)
  in {res_83303}
}

fun {f32} lifted_41536(f32 x_83304, f32 y_83305) = {
  let {f32 res_83306} = fadd32(x_83304, y_83305)
  in {res_83306}
}

fun {f32, f32} lifted_41490(f32 a_83307, f32 b_83308, f32 c_83309,
                            f32 d_83310) = {
  let {f32 arg_83311} = lifted_41492(a_83307)
  let {f32 arg_83312} = lifted_41496(arg_83311, c_83309)
  let {f32 arg_83313} = lifted_41500(arg_83312)
  let {f32 arg_83314} = lifted_41503(b_83308)
  let {f32 arg_83315} = lifted_41507(arg_83314, d_83310)
  let {f32 res_83316} = lifted_41512(arg_83313, arg_83315)
  let {f32 arg_83317} = lifted_41516(b_83308)
  let {f32 arg_83318} = lifted_41520(arg_83317, c_83309)
  let {f32 arg_83319} = lifted_41524(arg_83318)
  let {f32 arg_83320} = lifted_41527(a_83307)
  let {f32 arg_83321} = lifted_41531(arg_83320, d_83310)
  let {f32 res_83322} = lifted_41536(arg_83319, arg_83321)
  in {res_83316, res_83322}
}

fun {f32, f32} lifted_41474(f32 x_83323, f32 x_83324, f32 y_83325,
                            f32 y_83326) = {
  let {f32 arg_83327, f32 arg_83328} = lifted_41480(x_83323, x_83324)
  let {f32 res_83329, f32 res_83330} = lifted_41490(arg_83327, arg_83328,
                                                    y_83325, y_83326)
  in {res_83329, res_83330}
}

fun {f32, f32} lifted_41554(f32 a_83331, f32 b_83332) = {
  {a_83331, b_83332}
}

fun {f32} lifted_41564(f32 x_83333) = {
  {x_83333}
}

fun {f32} lifted_41568(f32 x_83334, f32 y_83335) = {
  let {f32 res_83336} = fadd32(x_83334, y_83335)
  in {res_83336}
}

fun {f32} lifted_41572(f32 x_83337) = {
  {x_83337}
}

fun {f32} lifted_41576(f32 x_83338, f32 y_83339) = {
  let {f32 res_83340} = fadd32(x_83338, y_83339)
  in {res_83340}
}

fun {f32, f32} lifted_41562(f32 a_83341, f32 b_83342, f32 c_83343,
                            f32 d_83344) = {
  let {f32 arg_83345} = lifted_41564(a_83341)
  let {f32 res_83346} = lifted_41568(arg_83345, c_83343)
  let {f32 arg_83347} = lifted_41572(b_83342)
  let {f32 res_83348} = lifted_41576(arg_83347, d_83344)
  in {res_83346, res_83348}
}

fun {f32, f32} lifted_41550(f32 x_83349, f32 x_83350, f32 y_83351,
                            f32 y_83352) = {
  let {f32 arg_83353, f32 arg_83354} = lifted_41554(x_83349, x_83350)
  let {f32 res_83355, f32 res_83356} = lifted_41562(arg_83353, arg_83354,
                                                    y_83351, y_83352)
  in {res_83355, res_83356}
}

fun {f32} lifted_41595(f32 x_83357) = {
  {x_83357}
}

fun {f32} lifted_41598(f32 x_83358) = {
  {x_83358}
}

fun {f32} lifted_41602(f32 x_83359, f32 y_83360) = {
  let {f32 res_83361} = fmul32(x_83359, y_83360)
  in {res_83361}
}

fun {f32} lifted_41606(f32 x_83362) = {
  {x_83362}
}

fun {f32} lifted_41609(f32 x_83363) = {
  {x_83363}
}

fun {f32} lifted_41613(f32 x_83364, f32 y_83365) = {
  let {f32 res_83366} = fmul32(x_83364, y_83365)
  in {res_83366}
}

fun {f32} lifted_41618(f32 x_83367, f32 y_83368) = {
  let {f32 res_83369} = fadd32(x_83367, y_83368)
  in {res_83369}
}

fun {f32} lifted_41622(f32 x_83370) = {
  let {f32 res_83371} = sqrt32(x_83370)
  in {res_83371}
}

fun {f32} lifted_41627(f32 x_83372, f32 y_83373) = {
  let {f32 res_83374} = fadd32(x_83372, y_83373)
  in {res_83374}
}

fun {f32} lifted_41631(f32 x_83375) = {
  {x_83375}
}

fun {f32} lifted_41634(i32 x_83376) = {
  let {f32 res_83377} = sitofp i32 x_83376 to f32
  in {res_83377}
}

fun {f32} lifted_41639(f32 x_83378, f32 y_83379) = {
  let {f32 res_83380} = fdiv32(x_83378, y_83379)
  in {res_83380}
}

fun {f32} lifted_41643(f32 x_83381) = {
  let {f32 res_83382} = sqrt32(x_83381)
  in {res_83382}
}

fun {f32} lifted_41652(f32 x_83383) = {
  {x_83383}
}

fun {bool} lifted_41656(f32 x_83384, f32 y_83385) = {
  let {bool res_83386} = lt32(x_83384, y_83385)
  in {res_83386}
}

fun {f32} lifted_41661(f32 x_83387) = {
  {x_83387}
}

fun {bool} lifted_41665(f32 x_83388, f32 y_83389) = {
  let {bool res_83390} = eq_f32(x_83388, y_83389)
  in {res_83390}
}

fun {f32} lifted_41650(f32 x_83391) = {
  let {f32 arg_83392} = lifted_41652(x_83391)
  let {bool cond_83393} = lifted_41656(arg_83392, 0.0f32)
  let {f32 res_83394} =
    -- Branch returns: {f32}
    if cond_83393
    then {
      let {f32 res_83395} = fsub32(0.0f32, 1.0f32)
      in {res_83395}
    } else {
      let {f32 arg_83396} = lifted_41661(x_83391)
      let {bool cond_83397} = lifted_41665(arg_83396, 0.0f32)
      let {f32 res_83398} =
        -- Branch returns: {f32}
        if cond_83397
        then {0.0f32} else {1.0f32}
      in {res_83398}
    }
  in {res_83394}
}

fun {i32} lifted_41672(f32 x_83399) = {
  let {i32 res_83400} = fptosi f32 x_83399 to i32
  in {res_83400}
}

fun {f32} lifted_41676(i32 x_83401) = {
  let {f32 res_83402} = sitofp i32 x_83401 to f32
  in {res_83402}
}

fun {f32} lifted_41680(f32 x_83403) = {
  {x_83403}
}

fun {f32} lifted_41683(i32 x_83404) = {
  let {f32 res_83405} = sitofp i32 x_83404 to f32
  in {res_83405}
}

fun {f32} lifted_41687(f32 x_83406) = {
  {x_83406}
}

fun {f32} lifted_41691(f32 x_83407, f32 y_83408) = {
  let {f32 res_83409} = fsub32(x_83407, y_83408)
  in {res_83409}
}

fun {f32} lifted_41695(f32 x_83410) = {
  {x_83410}
}

fun {f32} lifted_41698(f32 x_83411) = {
  {x_83411}
}

fun {f32} lifted_41702(f32 x_83412, f32 y_83413) = {
  let {f32 res_83414} = fmul32(x_83412, y_83413)
  in {res_83414}
}

fun {f32} lifted_41706(f32 x_83415) = {
  {x_83415}
}

fun {f32} lifted_41709(f32 x_83416) = {
  {x_83416}
}

fun {f32} lifted_41713(f32 x_83417, f32 y_83418) = {
  let {f32 res_83419} = fmul32(x_83417, y_83418)
  in {res_83419}
}

fun {f32} lifted_41718(f32 x_83420, f32 y_83421) = {
  let {f32 res_83422} = fadd32(x_83420, y_83421)
  in {res_83422}
}

fun {f32} lifted_41722(f32 x_83423) = {
  let {f32 res_83424} = sqrt32(x_83423)
  in {res_83424}
}

fun {f32} lifted_41727(f32 x_83425, f32 y_83426) = {
  let {f32 res_83427} = fadd32(x_83425, y_83426)
  in {res_83427}
}

fun {f32} lifted_41731(f32 x_83428) = {
  {x_83428}
}

fun {f32} lifted_41734(i32 x_83429) = {
  let {f32 res_83430} = sitofp i32 x_83429 to f32
  in {res_83430}
}

fun {f32} lifted_41739(f32 x_83431, f32 y_83432) = {
  let {f32 res_83433} = fdiv32(x_83431, y_83432)
  in {res_83433}
}

fun {f32} lifted_41743(f32 x_83434) = {
  let {f32 res_83435} = sqrt32(x_83434)
  in {res_83435}
}

fun {f32} lifted_41748(f32 x_83436, f32 y_83437) = {
  let {f32 res_83438} = fmul32(x_83436, y_83437)
  in {res_83438}
}

fun {f32, f32} lifted_41593(f32 a_83439, f32 b_83440) = {
  let {f32 arg_83441} = lifted_41595(a_83439)
  let {f32 arg_83442} = lifted_41598(a_83439)
  let {f32 arg_83443} = lifted_41602(arg_83442, a_83439)
  let {f32 arg_83444} = lifted_41606(arg_83443)
  let {f32 arg_83445} = lifted_41609(b_83440)
  let {f32 arg_83446} = lifted_41613(arg_83445, b_83440)
  let {f32 arg_83447} = lifted_41618(arg_83444, arg_83446)
  let {f32 arg_83448} = lifted_41622(arg_83447)
  let {f32 arg_83449} = lifted_41627(arg_83441, arg_83448)
  let {f32 arg_83450} = lifted_41631(arg_83449)
  let {f32 arg_83451} = lifted_41634(2i32)
  let {f32 arg_83452} = lifted_41639(arg_83450, arg_83451)
  let {f32 res_83453} = lifted_41643(arg_83452)
  let {f32 gamma_83454} = res_83453
  let {f32 arg_83455} = lifted_41650(b_83440)
  let {i32 arg_83456} = lifted_41672(arg_83455)
  let {f32 arg_83457} = lifted_41676(arg_83456)
  let {f32 arg_83458} = lifted_41680(arg_83457)
  let {f32 arg_83459} = lifted_41683(0i32)
  let {f32 arg_83460} = lifted_41687(arg_83459)
  let {f32 arg_83461} = lifted_41691(arg_83460, a_83439)
  let {f32 arg_83462} = lifted_41695(arg_83461)
  let {f32 arg_83463} = lifted_41698(a_83439)
  let {f32 arg_83464} = lifted_41702(arg_83463, a_83439)
  let {f32 arg_83465} = lifted_41706(arg_83464)
  let {f32 arg_83466} = lifted_41709(b_83440)
  let {f32 arg_83467} = lifted_41713(arg_83466, b_83440)
  let {f32 arg_83468} = lifted_41718(arg_83465, arg_83467)
  let {f32 arg_83469} = lifted_41722(arg_83468)
  let {f32 arg_83470} = lifted_41727(arg_83462, arg_83469)
  let {f32 arg_83471} = lifted_41731(arg_83470)
  let {f32 arg_83472} = lifted_41734(2i32)
  let {f32 arg_83473} = lifted_41739(arg_83471, arg_83472)
  let {f32 arg_83474} = lifted_41743(arg_83473)
  let {f32 res_83475} = lifted_41748(arg_83458, arg_83474)
  let {f32 delta_83476} = res_83475
  in {gamma_83454, delta_83476}
}

fun {f32, f32} lifted_41761(f32 x_83477, f32 x_83478) = {
  {x_83477, x_83478}
}

fun {f32, f32} lifted_41775(f32 a_83479, f32 b_83480) = {
  {a_83479, b_83480}
}

fun {f32} lifted_41785(f32 x_83481) = {
  {x_83481}
}

fun {f32} lifted_41789(f32 x_83482, f32 y_83483) = {
  let {f32 res_83484} = fsub32(x_83482, y_83483)
  in {res_83484}
}

fun {f32} lifted_41793(f32 x_83485) = {
  {x_83485}
}

fun {f32} lifted_41797(f32 x_83486, f32 y_83487) = {
  let {f32 res_83488} = fsub32(x_83486, y_83487)
  in {res_83488}
}

fun {f32, f32} lifted_41783(f32 a_83489, f32 b_83490, f32 c_83491,
                            f32 d_83492) = {
  let {f32 arg_83493} = lifted_41785(a_83489)
  let {f32 res_83494} = lifted_41789(arg_83493, c_83491)
  let {f32 arg_83495} = lifted_41793(b_83490)
  let {f32 res_83496} = lifted_41797(arg_83495, d_83492)
  in {res_83494, res_83496}
}

fun {f32, f32} lifted_41771(f32 x_83497, f32 x_83498, f32 y_83499,
                            f32 y_83500) = {
  let {f32 arg_83501, f32 arg_83502} = lifted_41775(x_83497, x_83498)
  let {f32 res_83503, f32 res_83504} = lifted_41783(arg_83501, arg_83502,
                                                    y_83499, y_83500)
  in {res_83503, res_83504}
}

fun {f32, f32} lifted_41811(f32 x_83505, f32 x_83506) = {
  {x_83505, x_83506}
}

fun {f32, f32} lifted_41818(f32 x_83507, f32 x_83508) = {
  {x_83507, x_83508}
}

fun {f32, f32} lifted_41832(f32 a_83509, f32 b_83510) = {
  {a_83509, b_83510}
}

fun {f32} lifted_41842(f32 x_83511) = {
  {x_83511}
}

fun {f32} lifted_41846(f32 x_83512, f32 y_83513) = {
  let {f32 res_83514} = fadd32(x_83512, y_83513)
  in {res_83514}
}

fun {f32} lifted_41850(f32 x_83515) = {
  {x_83515}
}

fun {f32} lifted_41854(f32 x_83516, f32 y_83517) = {
  let {f32 res_83518} = fadd32(x_83516, y_83517)
  in {res_83518}
}

fun {f32, f32} lifted_41840(f32 a_83519, f32 b_83520, f32 c_83521,
                            f32 d_83522) = {
  let {f32 arg_83523} = lifted_41842(a_83519)
  let {f32 res_83524} = lifted_41846(arg_83523, c_83521)
  let {f32 arg_83525} = lifted_41850(b_83520)
  let {f32 res_83526} = lifted_41854(arg_83525, d_83522)
  in {res_83524, res_83526}
}

fun {f32, f32} lifted_41828(f32 x_83527, f32 x_83528, f32 y_83529,
                            f32 y_83530) = {
  let {f32 arg_83531, f32 arg_83532} = lifted_41832(x_83527, x_83528)
  let {f32 res_83533, f32 res_83534} = lifted_41840(arg_83531, arg_83532,
                                                    y_83529, y_83530)
  in {res_83533, res_83534}
}

fun {f32, f32} lifted_41875(f32 a_83535, f32 b_83536) = {
  {a_83535, b_83536}
}

fun {f32} lifted_41888(f32 x_83537) = {
  {x_83537}
}

fun {f32} lifted_41892(f32 x_83538, f32 y_83539) = {
  let {f32 res_83540} = fmul32(x_83538, y_83539)
  in {res_83540}
}

fun {f32} lifted_41896(f32 x_83541) = {
  {x_83541}
}

fun {f32} lifted_41899(f32 x_83542) = {
  {x_83542}
}

fun {f32} lifted_41903(f32 x_83543, f32 y_83544) = {
  let {f32 res_83545} = fmul32(x_83543, y_83544)
  in {res_83545}
}

fun {f32} lifted_41908(f32 x_83546, f32 y_83547) = {
  let {f32 res_83548} = fadd32(x_83546, y_83547)
  in {res_83548}
}

fun {f32} lifted_41912(f32 x_83549) = {
  {x_83549}
}

fun {f32} lifted_41915(f32 x_83550) = {
  {x_83550}
}

fun {f32} lifted_41919(f32 x_83551, f32 y_83552) = {
  let {f32 res_83553} = fmul32(x_83551, y_83552)
  in {res_83553}
}

fun {f32} lifted_41923(f32 x_83554) = {
  {x_83554}
}

fun {f32} lifted_41926(f32 x_83555) = {
  {x_83555}
}

fun {f32} lifted_41930(f32 x_83556, f32 y_83557) = {
  let {f32 res_83558} = fmul32(x_83556, y_83557)
  in {res_83558}
}

fun {f32} lifted_41935(f32 x_83559, f32 y_83560) = {
  let {f32 res_83561} = fadd32(x_83559, y_83560)
  in {res_83561}
}

fun {f32} lifted_41940(f32 x_83562, f32 y_83563) = {
  let {f32 res_83564} = fdiv32(x_83562, y_83563)
  in {res_83564}
}

fun {f32} lifted_41944(f32 x_83565) = {
  {x_83565}
}

fun {f32} lifted_41948(f32 x_83566, f32 y_83567) = {
  let {f32 res_83568} = fmul32(x_83566, y_83567)
  in {res_83568}
}

fun {f32} lifted_41952(f32 x_83569) = {
  {x_83569}
}

fun {f32} lifted_41955(f32 x_83570) = {
  {x_83570}
}

fun {f32} lifted_41959(f32 x_83571, f32 y_83572) = {
  let {f32 res_83573} = fmul32(x_83571, y_83572)
  in {res_83573}
}

fun {f32} lifted_41964(f32 x_83574, f32 y_83575) = {
  let {f32 res_83576} = fsub32(x_83574, y_83575)
  in {res_83576}
}

fun {f32} lifted_41968(f32 x_83577) = {
  {x_83577}
}

fun {f32} lifted_41971(f32 x_83578) = {
  {x_83578}
}

fun {f32} lifted_41975(f32 x_83579, f32 y_83580) = {
  let {f32 res_83581} = fmul32(x_83579, y_83580)
  in {res_83581}
}

fun {f32} lifted_41979(f32 x_83582) = {
  {x_83582}
}

fun {f32} lifted_41982(f32 x_83583) = {
  {x_83583}
}

fun {f32} lifted_41986(f32 x_83584, f32 y_83585) = {
  let {f32 res_83586} = fmul32(x_83584, y_83585)
  in {res_83586}
}

fun {f32} lifted_41991(f32 x_83587, f32 y_83588) = {
  let {f32 res_83589} = fadd32(x_83587, y_83588)
  in {res_83589}
}

fun {f32} lifted_41996(f32 x_83590, f32 y_83591) = {
  let {f32 res_83592} = fdiv32(x_83590, y_83591)
  in {res_83592}
}

fun {f32, f32} lifted_41886(f32 a_83593, f32 b_83594, f32 c_83595,
                            f32 d_83596) = {
  let {f32 arg_83597} = lifted_41888(a_83593)
  let {f32 arg_83598} = lifted_41892(arg_83597, c_83595)
  let {f32 arg_83599} = lifted_41896(arg_83598)
  let {f32 arg_83600} = lifted_41899(b_83594)
  let {f32 arg_83601} = lifted_41903(arg_83600, d_83596)
  let {f32 arg_83602} = lifted_41908(arg_83599, arg_83601)
  let {f32 arg_83603} = lifted_41912(arg_83602)
  let {f32 arg_83604} = lifted_41915(c_83595)
  let {f32 arg_83605} = lifted_41919(arg_83604, c_83595)
  let {f32 arg_83606} = lifted_41923(arg_83605)
  let {f32 arg_83607} = lifted_41926(d_83596)
  let {f32 arg_83608} = lifted_41930(arg_83607, d_83596)
  let {f32 arg_83609} = lifted_41935(arg_83606, arg_83608)
  let {f32 res_83610} = lifted_41940(arg_83603, arg_83609)
  let {f32 arg_83611} = lifted_41944(b_83594)
  let {f32 arg_83612} = lifted_41948(arg_83611, c_83595)
  let {f32 arg_83613} = lifted_41952(arg_83612)
  let {f32 arg_83614} = lifted_41955(a_83593)
  let {f32 arg_83615} = lifted_41959(arg_83614, d_83596)
  let {f32 arg_83616} = lifted_41964(arg_83613, arg_83615)
  let {f32 arg_83617} = lifted_41968(arg_83616)
  let {f32 arg_83618} = lifted_41971(c_83595)
  let {f32 arg_83619} = lifted_41975(arg_83618, c_83595)
  let {f32 arg_83620} = lifted_41979(arg_83619)
  let {f32 arg_83621} = lifted_41982(d_83596)
  let {f32 arg_83622} = lifted_41986(arg_83621, d_83596)
  let {f32 arg_83623} = lifted_41991(arg_83620, arg_83622)
  let {f32 res_83624} = lifted_41996(arg_83617, arg_83623)
  in {res_83610, res_83624}
}

fun {f32, f32} lifted_41868(f32 x_83625, f32 x_83626, f32 y_83627,
                            f32 y_83628) = {
  let {f32 arg_83629, f32 arg_83630} = lifted_41875(x_83625, x_83626)
  let {f32 res_83631, f32 res_83632} = lifted_41886(arg_83629, arg_83630,
                                                    y_83627, y_83628)
  in {res_83631, res_83632}
}

fun {f32, f32} lifted_42010(f32 x_83633, f32 x_83634) = {
  {x_83633, x_83634}
}

fun {f32, f32} lifted_42017(f32 x_83635, f32 x_83636) = {
  {x_83635, x_83636}
}

fun {f32, f32} lifted_42033(f32 a_83637, f32 b_83638) = {
  {a_83637, b_83638}
}

fun {f32} lifted_42045(f32 x_83639) = {
  {x_83639}
}

fun {f32} lifted_42049(f32 x_83640, f32 y_83641) = {
  let {f32 res_83642} = fmul32(x_83640, y_83641)
  in {res_83642}
}

fun {f32} lifted_42053(f32 x_83643) = {
  {x_83643}
}

fun {f32} lifted_42056(f32 x_83644) = {
  {x_83644}
}

fun {f32} lifted_42060(f32 x_83645, f32 y_83646) = {
  let {f32 res_83647} = fmul32(x_83645, y_83646)
  in {res_83647}
}

fun {f32} lifted_42065(f32 x_83648, f32 y_83649) = {
  let {f32 res_83650} = fsub32(x_83648, y_83649)
  in {res_83650}
}

fun {f32} lifted_42069(f32 x_83651) = {
  {x_83651}
}

fun {f32} lifted_42073(f32 x_83652, f32 y_83653) = {
  let {f32 res_83654} = fmul32(x_83652, y_83653)
  in {res_83654}
}

fun {f32} lifted_42077(f32 x_83655) = {
  {x_83655}
}

fun {f32} lifted_42080(f32 x_83656) = {
  {x_83656}
}

fun {f32} lifted_42084(f32 x_83657, f32 y_83658) = {
  let {f32 res_83659} = fmul32(x_83657, y_83658)
  in {res_83659}
}

fun {f32} lifted_42089(f32 x_83660, f32 y_83661) = {
  let {f32 res_83662} = fadd32(x_83660, y_83661)
  in {res_83662}
}

fun {f32, f32} lifted_42043(f32 a_83663, f32 b_83664, f32 c_83665,
                            f32 d_83666) = {
  let {f32 arg_83667} = lifted_42045(a_83663)
  let {f32 arg_83668} = lifted_42049(arg_83667, c_83665)
  let {f32 arg_83669} = lifted_42053(arg_83668)
  let {f32 arg_83670} = lifted_42056(b_83664)
  let {f32 arg_83671} = lifted_42060(arg_83670, d_83666)
  let {f32 res_83672} = lifted_42065(arg_83669, arg_83671)
  let {f32 arg_83673} = lifted_42069(b_83664)
  let {f32 arg_83674} = lifted_42073(arg_83673, c_83665)
  let {f32 arg_83675} = lifted_42077(arg_83674)
  let {f32 arg_83676} = lifted_42080(a_83663)
  let {f32 arg_83677} = lifted_42084(arg_83676, d_83666)
  let {f32 res_83678} = lifted_42089(arg_83675, arg_83677)
  in {res_83672, res_83678}
}

fun {f32, f32} lifted_42027(f32 x_83679, f32 x_83680, f32 y_83681,
                            f32 y_83682) = {
  let {f32 arg_83683, f32 arg_83684} = lifted_42033(x_83679, x_83680)
  let {f32 res_83685, f32 res_83686} = lifted_42043(arg_83683, arg_83684,
                                                    y_83681, y_83682)
  in {res_83685, res_83686}
}

fun {f32, f32} lifted_42107(f32 a_83687, f32 b_83688) = {
  {a_83687, b_83688}
}

fun {f32} lifted_42117(f32 x_83689) = {
  {x_83689}
}

fun {f32} lifted_42121(f32 x_83690, f32 y_83691) = {
  let {f32 res_83692} = fsub32(x_83690, y_83691)
  in {res_83692}
}

fun {f32} lifted_42125(f32 x_83693) = {
  {x_83693}
}

fun {f32} lifted_42129(f32 x_83694, f32 y_83695) = {
  let {f32 res_83696} = fsub32(x_83694, y_83695)
  in {res_83696}
}

fun {f32, f32} lifted_42115(f32 a_83697, f32 b_83698, f32 c_83699,
                            f32 d_83700) = {
  let {f32 arg_83701} = lifted_42117(a_83697)
  let {f32 res_83702} = lifted_42121(arg_83701, c_83699)
  let {f32 arg_83703} = lifted_42125(b_83698)
  let {f32 res_83704} = lifted_42129(arg_83703, d_83700)
  in {res_83702, res_83704}
}

fun {f32, f32} lifted_42103(f32 x_83705, f32 x_83706, f32 y_83707,
                            f32 y_83708) = {
  let {f32 arg_83709, f32 arg_83710} = lifted_42107(x_83705, x_83706)
  let {f32 res_83711, f32 res_83712} = lifted_42115(arg_83709, arg_83710,
                                                    y_83707, y_83708)
  in {res_83711, res_83712}
}

fun {f32} lifted_42145(f32 x_83713) = {
  let {f32 res_83714} = exp32(x_83713)
  in {res_83714}
}

fun {f32} lifted_42150(f32 x_83715) = {
  {x_83715}
}

fun {f32} lifted_42153(f32 x_83716) = {
  let {f32 res_83717} = cos32(x_83716)
  in {res_83717}
}

fun {f32} lifted_42158(f32 x_83718, f32 y_83719) = {
  let {f32 res_83720} = fmul32(x_83718, y_83719)
  in {res_83720}
}

fun {f32} lifted_42162(f32 a_83721) = {
  {a_83721}
}

fun {f32} lifted_42165(f32 x_83722) = {
  {x_83722}
}

fun {f32} lifted_42168(f32 x_83723) = {
  let {f32 res_83724} = sin32(x_83723)
  in {res_83724}
}

fun {f32} lifted_42173(f32 x_83725, f32 y_83726) = {
  let {f32 res_83727} = fmul32(x_83725, y_83726)
  in {res_83727}
}

fun {f32, f32} lifted_42178(f32 a_83728, f32 b_83729) = {
  {a_83728, b_83729}
}

fun {f32, f32} lifted_42143(f32 a_83730, f32 b_83731) = {
  let {f32 res_83732} = lifted_42145(a_83730)
  let {f32 expx_83733} = res_83732
  let {f32 arg_83734} = lifted_42150(expx_83733)
  let {f32 arg_83735} = lifted_42153(b_83731)
  let {f32 arg_83736} = lifted_42158(arg_83734, arg_83735)
  let {f32 arg_83737} = lifted_42162(arg_83736)
  let {f32 arg_83738} = lifted_42165(expx_83733)
  let {f32 arg_83739} = lifted_42168(b_83731)
  let {f32 arg_83740} = lifted_42173(arg_83738, arg_83739)
  let {f32 res_83741, f32 res_83742} = lifted_42178(arg_83737, arg_83740)
  in {res_83741, res_83742}
}

fun {f32, f32} lifted_42190(f32 x_83743, f32 x_83744) = {
  {x_83743, x_83744}
}

fun {f32, f32} lifted_42197(f32 x_83745, f32 x_83746) = {
  {x_83745, x_83746}
}

fun {f32, f32} lifted_42213(f32 a_83747, f32 b_83748) = {
  {a_83747, b_83748}
}

fun {f32} lifted_42225(f32 x_83749) = {
  {x_83749}
}

fun {f32} lifted_42229(f32 x_83750, f32 y_83751) = {
  let {f32 res_83752} = fmul32(x_83750, y_83751)
  in {res_83752}
}

fun {f32} lifted_42233(f32 x_83753) = {
  {x_83753}
}

fun {f32} lifted_42236(f32 x_83754) = {
  {x_83754}
}

fun {f32} lifted_42240(f32 x_83755, f32 y_83756) = {
  let {f32 res_83757} = fmul32(x_83755, y_83756)
  in {res_83757}
}

fun {f32} lifted_42245(f32 x_83758, f32 y_83759) = {
  let {f32 res_83760} = fsub32(x_83758, y_83759)
  in {res_83760}
}

fun {f32} lifted_42249(f32 x_83761) = {
  {x_83761}
}

fun {f32} lifted_42253(f32 x_83762, f32 y_83763) = {
  let {f32 res_83764} = fmul32(x_83762, y_83763)
  in {res_83764}
}

fun {f32} lifted_42257(f32 x_83765) = {
  {x_83765}
}

fun {f32} lifted_42260(f32 x_83766) = {
  {x_83766}
}

fun {f32} lifted_42264(f32 x_83767, f32 y_83768) = {
  let {f32 res_83769} = fmul32(x_83767, y_83768)
  in {res_83769}
}

fun {f32} lifted_42269(f32 x_83770, f32 y_83771) = {
  let {f32 res_83772} = fadd32(x_83770, y_83771)
  in {res_83772}
}

fun {f32, f32} lifted_42223(f32 a_83773, f32 b_83774, f32 c_83775,
                            f32 d_83776) = {
  let {f32 arg_83777} = lifted_42225(a_83773)
  let {f32 arg_83778} = lifted_42229(arg_83777, c_83775)
  let {f32 arg_83779} = lifted_42233(arg_83778)
  let {f32 arg_83780} = lifted_42236(b_83774)
  let {f32 arg_83781} = lifted_42240(arg_83780, d_83776)
  let {f32 res_83782} = lifted_42245(arg_83779, arg_83781)
  let {f32 arg_83783} = lifted_42249(b_83774)
  let {f32 arg_83784} = lifted_42253(arg_83783, c_83775)
  let {f32 arg_83785} = lifted_42257(arg_83784)
  let {f32 arg_83786} = lifted_42260(a_83773)
  let {f32 arg_83787} = lifted_42264(arg_83786, d_83776)
  let {f32 res_83788} = lifted_42269(arg_83785, arg_83787)
  in {res_83782, res_83788}
}

fun {f32, f32} lifted_42207(f32 x_83789, f32 x_83790, f32 y_83791,
                            f32 y_83792) = {
  let {f32 arg_83793, f32 arg_83794} = lifted_42213(x_83789, x_83790)
  let {f32 res_83795, f32 res_83796} = lifted_42223(arg_83793, arg_83794,
                                                    y_83791, y_83792)
  in {res_83795, res_83796}
}

fun {f32, f32} lifted_42280(f32 x_83797, f32 x_83798) = {
  {x_83797, x_83798}
}

fun {f32, f32} lifted_42287(f32 x_83799, f32 x_83800) = {
  {x_83799, x_83800}
}

fun {f32, f32} lifted_42294(f32 x_83801, f32 x_83802) = {
  {x_83801, x_83802}
}

fun {f32, f32} lifted_42301(f32 x_83803, f32 x_83804) = {
  {x_83803, x_83804}
}

fun {f32, f32} lifted_42317(f32 a_83805, f32 b_83806) = {
  {a_83805, b_83806}
}

fun {f32} lifted_42329(f32 x_83807) = {
  {x_83807}
}

fun {f32} lifted_42333(f32 x_83808, f32 y_83809) = {
  let {f32 res_83810} = fmul32(x_83808, y_83809)
  in {res_83810}
}

fun {f32} lifted_42337(f32 x_83811) = {
  {x_83811}
}

fun {f32} lifted_42340(f32 x_83812) = {
  {x_83812}
}

fun {f32} lifted_42344(f32 x_83813, f32 y_83814) = {
  let {f32 res_83815} = fmul32(x_83813, y_83814)
  in {res_83815}
}

fun {f32} lifted_42349(f32 x_83816, f32 y_83817) = {
  let {f32 res_83818} = fsub32(x_83816, y_83817)
  in {res_83818}
}

fun {f32} lifted_42353(f32 x_83819) = {
  {x_83819}
}

fun {f32} lifted_42357(f32 x_83820, f32 y_83821) = {
  let {f32 res_83822} = fmul32(x_83820, y_83821)
  in {res_83822}
}

fun {f32} lifted_42361(f32 x_83823) = {
  {x_83823}
}

fun {f32} lifted_42364(f32 x_83824) = {
  {x_83824}
}

fun {f32} lifted_42368(f32 x_83825, f32 y_83826) = {
  let {f32 res_83827} = fmul32(x_83825, y_83826)
  in {res_83827}
}

fun {f32} lifted_42373(f32 x_83828, f32 y_83829) = {
  let {f32 res_83830} = fadd32(x_83828, y_83829)
  in {res_83830}
}

fun {f32, f32} lifted_42327(f32 a_83831, f32 b_83832, f32 c_83833,
                            f32 d_83834) = {
  let {f32 arg_83835} = lifted_42329(a_83831)
  let {f32 arg_83836} = lifted_42333(arg_83835, c_83833)
  let {f32 arg_83837} = lifted_42337(arg_83836)
  let {f32 arg_83838} = lifted_42340(b_83832)
  let {f32 arg_83839} = lifted_42344(arg_83838, d_83834)
  let {f32 res_83840} = lifted_42349(arg_83837, arg_83839)
  let {f32 arg_83841} = lifted_42353(b_83832)
  let {f32 arg_83842} = lifted_42357(arg_83841, c_83833)
  let {f32 arg_83843} = lifted_42361(arg_83842)
  let {f32 arg_83844} = lifted_42364(a_83831)
  let {f32 arg_83845} = lifted_42368(arg_83844, d_83834)
  let {f32 res_83846} = lifted_42373(arg_83843, arg_83845)
  in {res_83840, res_83846}
}

fun {f32, f32} lifted_42311(f32 x_83847, f32 x_83848, f32 y_83849,
                            f32 y_83850) = {
  let {f32 arg_83851, f32 arg_83852} = lifted_42317(x_83847, x_83848)
  let {f32 res_83853, f32 res_83854} = lifted_42327(arg_83851, arg_83852,
                                                    y_83849, y_83850)
  in {res_83853, res_83854}
}

fun {f32, f32} lifted_42391(f32 a_83855, f32 b_83856) = {
  {a_83855, b_83856}
}

fun {f32} lifted_42401(f32 x_83857) = {
  {x_83857}
}

fun {f32} lifted_42405(f32 x_83858, f32 y_83859) = {
  let {f32 res_83860} = fsub32(x_83858, y_83859)
  in {res_83860}
}

fun {f32} lifted_42409(f32 x_83861) = {
  {x_83861}
}

fun {f32} lifted_42413(f32 x_83862, f32 y_83863) = {
  let {f32 res_83864} = fsub32(x_83862, y_83863)
  in {res_83864}
}

fun {f32, f32} lifted_42399(f32 a_83865, f32 b_83866, f32 c_83867,
                            f32 d_83868) = {
  let {f32 arg_83869} = lifted_42401(a_83865)
  let {f32 res_83870} = lifted_42405(arg_83869, c_83867)
  let {f32 arg_83871} = lifted_42409(b_83866)
  let {f32 res_83872} = lifted_42413(arg_83871, d_83868)
  in {res_83870, res_83872}
}

fun {f32, f32} lifted_42387(f32 x_83873, f32 x_83874, f32 y_83875,
                            f32 y_83876) = {
  let {f32 arg_83877, f32 arg_83878} = lifted_42391(x_83873, x_83874)
  let {f32 res_83879, f32 res_83880} = lifted_42399(arg_83877, arg_83878,
                                                    y_83875, y_83876)
  in {res_83879, res_83880}
}

fun {f32, f32} lifted_42424(f32 x_83881, f32 x_83882) = {
  {x_83881, x_83882}
}

fun {f32, f32} lifted_42431(f32 x_83883, f32 x_83884) = {
  {x_83883, x_83884}
}

fun {f32, f32} lifted_42445(f32 a_83885, f32 b_83886) = {
  {a_83885, b_83886}
}

fun {f32} lifted_42455(f32 x_83887) = {
  {x_83887}
}

fun {f32} lifted_42459(f32 x_83888, f32 y_83889) = {
  let {f32 res_83890} = fsub32(x_83888, y_83889)
  in {res_83890}
}

fun {f32} lifted_42463(f32 x_83891) = {
  {x_83891}
}

fun {f32} lifted_42467(f32 x_83892, f32 y_83893) = {
  let {f32 res_83894} = fsub32(x_83892, y_83893)
  in {res_83894}
}

fun {f32, f32} lifted_42453(f32 a_83895, f32 b_83896, f32 c_83897,
                            f32 d_83898) = {
  let {f32 arg_83899} = lifted_42455(a_83895)
  let {f32 res_83900} = lifted_42459(arg_83899, c_83897)
  let {f32 arg_83901} = lifted_42463(b_83896)
  let {f32 res_83902} = lifted_42467(arg_83901, d_83898)
  in {res_83900, res_83902}
}

fun {f32, f32} lifted_42441(f32 x_83903, f32 x_83904, f32 y_83905,
                            f32 y_83906) = {
  let {f32 arg_83907, f32 arg_83908} = lifted_42445(x_83903, x_83904)
  let {f32 res_83909, f32 res_83910} = lifted_42453(arg_83907, arg_83908,
                                                    y_83905, y_83906)
  in {res_83909, res_83910}
}

fun {f32, f32} lifted_42488(f32 a_83911, f32 b_83912) = {
  {a_83911, b_83912}
}

fun {f32} lifted_42501(f32 x_83913) = {
  {x_83913}
}

fun {f32} lifted_42505(f32 x_83914, f32 y_83915) = {
  let {f32 res_83916} = fmul32(x_83914, y_83915)
  in {res_83916}
}

fun {f32} lifted_42509(f32 x_83917) = {
  {x_83917}
}

fun {f32} lifted_42512(f32 x_83918) = {
  {x_83918}
}

fun {f32} lifted_42516(f32 x_83919, f32 y_83920) = {
  let {f32 res_83921} = fmul32(x_83919, y_83920)
  in {res_83921}
}

fun {f32} lifted_42521(f32 x_83922, f32 y_83923) = {
  let {f32 res_83924} = fadd32(x_83922, y_83923)
  in {res_83924}
}

fun {f32} lifted_42525(f32 x_83925) = {
  {x_83925}
}

fun {f32} lifted_42528(f32 x_83926) = {
  {x_83926}
}

fun {f32} lifted_42532(f32 x_83927, f32 y_83928) = {
  let {f32 res_83929} = fmul32(x_83927, y_83928)
  in {res_83929}
}

fun {f32} lifted_42536(f32 x_83930) = {
  {x_83930}
}

fun {f32} lifted_42539(f32 x_83931) = {
  {x_83931}
}

fun {f32} lifted_42543(f32 x_83932, f32 y_83933) = {
  let {f32 res_83934} = fmul32(x_83932, y_83933)
  in {res_83934}
}

fun {f32} lifted_42548(f32 x_83935, f32 y_83936) = {
  let {f32 res_83937} = fadd32(x_83935, y_83936)
  in {res_83937}
}

fun {f32} lifted_42553(f32 x_83938, f32 y_83939) = {
  let {f32 res_83940} = fdiv32(x_83938, y_83939)
  in {res_83940}
}

fun {f32} lifted_42557(f32 x_83941) = {
  {x_83941}
}

fun {f32} lifted_42561(f32 x_83942, f32 y_83943) = {
  let {f32 res_83944} = fmul32(x_83942, y_83943)
  in {res_83944}
}

fun {f32} lifted_42565(f32 x_83945) = {
  {x_83945}
}

fun {f32} lifted_42568(f32 x_83946) = {
  {x_83946}
}

fun {f32} lifted_42572(f32 x_83947, f32 y_83948) = {
  let {f32 res_83949} = fmul32(x_83947, y_83948)
  in {res_83949}
}

fun {f32} lifted_42577(f32 x_83950, f32 y_83951) = {
  let {f32 res_83952} = fsub32(x_83950, y_83951)
  in {res_83952}
}

fun {f32} lifted_42581(f32 x_83953) = {
  {x_83953}
}

fun {f32} lifted_42584(f32 x_83954) = {
  {x_83954}
}

fun {f32} lifted_42588(f32 x_83955, f32 y_83956) = {
  let {f32 res_83957} = fmul32(x_83955, y_83956)
  in {res_83957}
}

fun {f32} lifted_42592(f32 x_83958) = {
  {x_83958}
}

fun {f32} lifted_42595(f32 x_83959) = {
  {x_83959}
}

fun {f32} lifted_42599(f32 x_83960, f32 y_83961) = {
  let {f32 res_83962} = fmul32(x_83960, y_83961)
  in {res_83962}
}

fun {f32} lifted_42604(f32 x_83963, f32 y_83964) = {
  let {f32 res_83965} = fadd32(x_83963, y_83964)
  in {res_83965}
}

fun {f32} lifted_42609(f32 x_83966, f32 y_83967) = {
  let {f32 res_83968} = fdiv32(x_83966, y_83967)
  in {res_83968}
}

fun {f32, f32} lifted_42499(f32 a_83969, f32 b_83970, f32 c_83971,
                            f32 d_83972) = {
  let {f32 arg_83973} = lifted_42501(a_83969)
  let {f32 arg_83974} = lifted_42505(arg_83973, c_83971)
  let {f32 arg_83975} = lifted_42509(arg_83974)
  let {f32 arg_83976} = lifted_42512(b_83970)
  let {f32 arg_83977} = lifted_42516(arg_83976, d_83972)
  let {f32 arg_83978} = lifted_42521(arg_83975, arg_83977)
  let {f32 arg_83979} = lifted_42525(arg_83978)
  let {f32 arg_83980} = lifted_42528(c_83971)
  let {f32 arg_83981} = lifted_42532(arg_83980, c_83971)
  let {f32 arg_83982} = lifted_42536(arg_83981)
  let {f32 arg_83983} = lifted_42539(d_83972)
  let {f32 arg_83984} = lifted_42543(arg_83983, d_83972)
  let {f32 arg_83985} = lifted_42548(arg_83982, arg_83984)
  let {f32 res_83986} = lifted_42553(arg_83979, arg_83985)
  let {f32 arg_83987} = lifted_42557(b_83970)
  let {f32 arg_83988} = lifted_42561(arg_83987, c_83971)
  let {f32 arg_83989} = lifted_42565(arg_83988)
  let {f32 arg_83990} = lifted_42568(a_83969)
  let {f32 arg_83991} = lifted_42572(arg_83990, d_83972)
  let {f32 arg_83992} = lifted_42577(arg_83989, arg_83991)
  let {f32 arg_83993} = lifted_42581(arg_83992)
  let {f32 arg_83994} = lifted_42584(c_83971)
  let {f32 arg_83995} = lifted_42588(arg_83994, c_83971)
  let {f32 arg_83996} = lifted_42592(arg_83995)
  let {f32 arg_83997} = lifted_42595(d_83972)
  let {f32 arg_83998} = lifted_42599(arg_83997, d_83972)
  let {f32 arg_83999} = lifted_42604(arg_83996, arg_83998)
  let {f32 res_84000} = lifted_42609(arg_83993, arg_83999)
  in {res_83986, res_84000}
}

fun {f32, f32} lifted_42481(f32 x_84001, f32 x_84002, f32 y_84003,
                            f32 y_84004) = {
  let {f32 arg_84005, f32 arg_84006} = lifted_42488(x_84001, x_84002)
  let {f32 res_84007, f32 res_84008} = lifted_42499(arg_84005, arg_84006,
                                                    y_84003, y_84004)
  in {res_84007, res_84008}
}

fun {f32} lifted_42631(f32 x_84009) = {
  {x_84009}
}

fun {f32} lifted_42635(f32 x_84010, f32 y_84011) = {
  let {f32 res_84012} = fmul32(x_84010, y_84011)
  in {res_84012}
}

fun {f32} lifted_42639(f32 x_84013) = {
  {x_84013}
}

fun {f32} lifted_42642(f32 x_84014) = {
  {x_84014}
}

fun {f32} lifted_42646(f32 x_84015, f32 y_84016) = {
  let {f32 res_84017} = fmul32(x_84015, y_84016)
  in {res_84017}
}

fun {f32} lifted_42651(f32 x_84018, f32 y_84019) = {
  let {f32 res_84020} = fadd32(x_84018, y_84019)
  in {res_84020}
}

fun {f32} lifted_42655(f32 x_84021) = {
  let {f32 res_84022} = sqrt32(x_84021)
  in {res_84022}
}

fun {f32} lifted_42629(f32 a_84023, f32 b_84024) = {
  let {f32 arg_84025} = lifted_42631(a_84023)
  let {f32 arg_84026} = lifted_42635(arg_84025, a_84023)
  let {f32 arg_84027} = lifted_42639(arg_84026)
  let {f32 arg_84028} = lifted_42642(b_84024)
  let {f32 arg_84029} = lifted_42646(arg_84028, b_84024)
  let {f32 arg_84030} = lifted_42651(arg_84027, arg_84029)
  let {f32 res_84031} = lifted_42655(arg_84030)
  in {res_84031}
}

fun {f32} lifted_42660(f32 x_84032) = {
  let {f32 res_84033} = log32(x_84032)
  in {res_84033}
}

fun {f32} lifted_42664(f32 a_84034) = {
  {a_84034}
}

fun {f32} lifted_42671(f32 x_84035) = {
  {x_84035}
}

fun {f32} lifted_42675(f32 x_84036, f32 y_84037) = {
  let {f32 res_84038} = atan2_32(x_84036, y_84037)
  in {res_84038}
}

fun {f32} lifted_42669(f32 a_84039, f32 b_84040) = {
  let {f32 arg_84041} = lifted_42671(b_84040)
  let {f32 res_84042} = lifted_42675(arg_84041, a_84039)
  in {res_84042}
}

fun {f32, f32} lifted_42681(f32 a_84043, f32 b_84044) = {
  {a_84043, b_84044}
}

fun {f32, f32} lifted_42623(f32 z_84045, f32 z_84046) = {
  let {f32 arg_84047} = lifted_42629(z_84045, z_84046)
  let {f32 arg_84048} = lifted_42660(arg_84047)
  let {f32 arg_84049} = lifted_42664(arg_84048)
  let {f32 arg_84050} = lifted_42669(z_84045, z_84046)
  let {f32 res_84051, f32 res_84052} = lifted_42681(arg_84049, arg_84050)
  in {res_84051, res_84052}
}

fun {f32, f32} lifted_42699(f32 a_84053, f32 b_84054) = {
  {a_84053, b_84054}
}

fun {f32} lifted_42711(f32 x_84055) = {
  {x_84055}
}

fun {f32} lifted_42715(f32 x_84056, f32 y_84057) = {
  let {f32 res_84058} = fmul32(x_84056, y_84057)
  in {res_84058}
}

fun {f32} lifted_42719(f32 x_84059) = {
  {x_84059}
}

fun {f32} lifted_42722(f32 x_84060) = {
  {x_84060}
}

fun {f32} lifted_42726(f32 x_84061, f32 y_84062) = {
  let {f32 res_84063} = fmul32(x_84061, y_84062)
  in {res_84063}
}

fun {f32} lifted_42731(f32 x_84064, f32 y_84065) = {
  let {f32 res_84066} = fsub32(x_84064, y_84065)
  in {res_84066}
}

fun {f32} lifted_42735(f32 x_84067) = {
  {x_84067}
}

fun {f32} lifted_42739(f32 x_84068, f32 y_84069) = {
  let {f32 res_84070} = fmul32(x_84068, y_84069)
  in {res_84070}
}

fun {f32} lifted_42743(f32 x_84071) = {
  {x_84071}
}

fun {f32} lifted_42746(f32 x_84072) = {
  {x_84072}
}

fun {f32} lifted_42750(f32 x_84073, f32 y_84074) = {
  let {f32 res_84075} = fmul32(x_84073, y_84074)
  in {res_84075}
}

fun {f32} lifted_42755(f32 x_84076, f32 y_84077) = {
  let {f32 res_84078} = fadd32(x_84076, y_84077)
  in {res_84078}
}

fun {f32, f32} lifted_42709(f32 a_84079, f32 b_84080, f32 c_84081,
                            f32 d_84082) = {
  let {f32 arg_84083} = lifted_42711(a_84079)
  let {f32 arg_84084} = lifted_42715(arg_84083, c_84081)
  let {f32 arg_84085} = lifted_42719(arg_84084)
  let {f32 arg_84086} = lifted_42722(b_84080)
  let {f32 arg_84087} = lifted_42726(arg_84086, d_84082)
  let {f32 res_84088} = lifted_42731(arg_84085, arg_84087)
  let {f32 arg_84089} = lifted_42735(b_84080)
  let {f32 arg_84090} = lifted_42739(arg_84089, c_84081)
  let {f32 arg_84091} = lifted_42743(arg_84090)
  let {f32 arg_84092} = lifted_42746(a_84079)
  let {f32 arg_84093} = lifted_42750(arg_84092, d_84082)
  let {f32 res_84094} = lifted_42755(arg_84091, arg_84093)
  in {res_84088, res_84094}
}

fun {f32, f32} lifted_42693(f32 x_84095, f32 x_84096, f32 y_84097,
                            f32 y_84098) = {
  let {f32 arg_84099, f32 arg_84100} = lifted_42699(x_84095, x_84096)
  let {f32 res_84101, f32 res_84102} = lifted_42709(arg_84099, arg_84100,
                                                    y_84097, y_84098)
  in {res_84101, res_84102}
}

fun {f32, f32} lifted_42773(f32 a_84103, f32 b_84104) = {
  {a_84103, b_84104}
}

fun {f32} lifted_42783(f32 x_84105) = {
  {x_84105}
}

fun {f32} lifted_42787(f32 x_84106, f32 y_84107) = {
  let {f32 res_84108} = fsub32(x_84106, y_84107)
  in {res_84108}
}

fun {f32} lifted_42791(f32 x_84109) = {
  {x_84109}
}

fun {f32} lifted_42795(f32 x_84110, f32 y_84111) = {
  let {f32 res_84112} = fsub32(x_84110, y_84111)
  in {res_84112}
}

fun {f32, f32} lifted_42781(f32 a_84113, f32 b_84114, f32 c_84115,
                            f32 d_84116) = {
  let {f32 arg_84117} = lifted_42783(a_84113)
  let {f32 res_84118} = lifted_42787(arg_84117, c_84115)
  let {f32 arg_84119} = lifted_42791(b_84114)
  let {f32 res_84120} = lifted_42795(arg_84119, d_84116)
  in {res_84118, res_84120}
}

fun {f32, f32} lifted_42769(f32 x_84121, f32 x_84122, f32 y_84123,
                            f32 y_84124) = {
  let {f32 arg_84125, f32 arg_84126} = lifted_42773(x_84121, x_84122)
  let {f32 res_84127, f32 res_84128} = lifted_42781(arg_84125, arg_84126,
                                                    y_84123, y_84124)
  in {res_84127, res_84128}
}

fun {f32, f32} lifted_42815(f32 a_84129, f32 b_84130) = {
  {a_84129, b_84130}
}

fun {f32} lifted_42827(f32 x_84131) = {
  {x_84131}
}

fun {f32} lifted_42831(f32 x_84132, f32 y_84133) = {
  let {f32 res_84134} = fmul32(x_84132, y_84133)
  in {res_84134}
}

fun {f32} lifted_42835(f32 x_84135) = {
  {x_84135}
}

fun {f32} lifted_42838(f32 x_84136) = {
  {x_84136}
}

fun {f32} lifted_42842(f32 x_84137, f32 y_84138) = {
  let {f32 res_84139} = fmul32(x_84137, y_84138)
  in {res_84139}
}

fun {f32} lifted_42847(f32 x_84140, f32 y_84141) = {
  let {f32 res_84142} = fsub32(x_84140, y_84141)
  in {res_84142}
}

fun {f32} lifted_42851(f32 x_84143) = {
  {x_84143}
}

fun {f32} lifted_42855(f32 x_84144, f32 y_84145) = {
  let {f32 res_84146} = fmul32(x_84144, y_84145)
  in {res_84146}
}

fun {f32} lifted_42859(f32 x_84147) = {
  {x_84147}
}

fun {f32} lifted_42862(f32 x_84148) = {
  {x_84148}
}

fun {f32} lifted_42866(f32 x_84149, f32 y_84150) = {
  let {f32 res_84151} = fmul32(x_84149, y_84150)
  in {res_84151}
}

fun {f32} lifted_42871(f32 x_84152, f32 y_84153) = {
  let {f32 res_84154} = fadd32(x_84152, y_84153)
  in {res_84154}
}

fun {f32, f32} lifted_42825(f32 a_84155, f32 b_84156, f32 c_84157,
                            f32 d_84158) = {
  let {f32 arg_84159} = lifted_42827(a_84155)
  let {f32 arg_84160} = lifted_42831(arg_84159, c_84157)
  let {f32 arg_84161} = lifted_42835(arg_84160)
  let {f32 arg_84162} = lifted_42838(b_84156)
  let {f32 arg_84163} = lifted_42842(arg_84162, d_84158)
  let {f32 res_84164} = lifted_42847(arg_84161, arg_84163)
  let {f32 arg_84165} = lifted_42851(b_84156)
  let {f32 arg_84166} = lifted_42855(arg_84165, c_84157)
  let {f32 arg_84167} = lifted_42859(arg_84166)
  let {f32 arg_84168} = lifted_42862(a_84155)
  let {f32 arg_84169} = lifted_42866(arg_84168, d_84158)
  let {f32 res_84170} = lifted_42871(arg_84167, arg_84169)
  in {res_84164, res_84170}
}

fun {f32, f32} lifted_42809(f32 x_84171, f32 x_84172, f32 y_84173,
                            f32 y_84174) = {
  let {f32 arg_84175, f32 arg_84176} = lifted_42815(x_84171, x_84172)
  let {f32 res_84177, f32 res_84178} = lifted_42825(arg_84175, arg_84176,
                                                    y_84173, y_84174)
  in {res_84177, res_84178}
}

fun {f32, f32} lifted_42882(f32 x_84179, f32 x_84180) = {
  {x_84179, x_84180}
}

fun {f32, f32} lifted_42889(f32 x_84181, f32 x_84182) = {
  {x_84181, x_84182}
}

fun {f32, f32} lifted_42905(f32 a_84183, f32 b_84184) = {
  {a_84183, b_84184}
}

fun {f32} lifted_42917(f32 x_84185) = {
  {x_84185}
}

fun {f32} lifted_42921(f32 x_84186, f32 y_84187) = {
  let {f32 res_84188} = fmul32(x_84186, y_84187)
  in {res_84188}
}

fun {f32} lifted_42925(f32 x_84189) = {
  {x_84189}
}

fun {f32} lifted_42928(f32 x_84190) = {
  {x_84190}
}

fun {f32} lifted_42932(f32 x_84191, f32 y_84192) = {
  let {f32 res_84193} = fmul32(x_84191, y_84192)
  in {res_84193}
}

fun {f32} lifted_42937(f32 x_84194, f32 y_84195) = {
  let {f32 res_84196} = fsub32(x_84194, y_84195)
  in {res_84196}
}

fun {f32} lifted_42941(f32 x_84197) = {
  {x_84197}
}

fun {f32} lifted_42945(f32 x_84198, f32 y_84199) = {
  let {f32 res_84200} = fmul32(x_84198, y_84199)
  in {res_84200}
}

fun {f32} lifted_42949(f32 x_84201) = {
  {x_84201}
}

fun {f32} lifted_42952(f32 x_84202) = {
  {x_84202}
}

fun {f32} lifted_42956(f32 x_84203, f32 y_84204) = {
  let {f32 res_84205} = fmul32(x_84203, y_84204)
  in {res_84205}
}

fun {f32} lifted_42961(f32 x_84206, f32 y_84207) = {
  let {f32 res_84208} = fadd32(x_84206, y_84207)
  in {res_84208}
}

fun {f32, f32} lifted_42915(f32 a_84209, f32 b_84210, f32 c_84211,
                            f32 d_84212) = {
  let {f32 arg_84213} = lifted_42917(a_84209)
  let {f32 arg_84214} = lifted_42921(arg_84213, c_84211)
  let {f32 arg_84215} = lifted_42925(arg_84214)
  let {f32 arg_84216} = lifted_42928(b_84210)
  let {f32 arg_84217} = lifted_42932(arg_84216, d_84212)
  let {f32 res_84218} = lifted_42937(arg_84215, arg_84217)
  let {f32 arg_84219} = lifted_42941(b_84210)
  let {f32 arg_84220} = lifted_42945(arg_84219, c_84211)
  let {f32 arg_84221} = lifted_42949(arg_84220)
  let {f32 arg_84222} = lifted_42952(a_84209)
  let {f32 arg_84223} = lifted_42956(arg_84222, d_84212)
  let {f32 res_84224} = lifted_42961(arg_84221, arg_84223)
  in {res_84218, res_84224}
}

fun {f32, f32} lifted_42899(f32 x_84225, f32 x_84226, f32 y_84227,
                            f32 y_84228) = {
  let {f32 arg_84229, f32 arg_84230} = lifted_42905(x_84225, x_84226)
  let {f32 res_84231, f32 res_84232} = lifted_42915(arg_84229, arg_84230,
                                                    y_84227, y_84228)
  in {res_84231, res_84232}
}

fun {f32, f32} lifted_42972(f32 x_84233, f32 x_84234) = {
  {x_84233, x_84234}
}

fun {f32, f32} lifted_42979(f32 x_84235, f32 x_84236) = {
  {x_84235, x_84236}
}

fun {f32, f32} lifted_42993(f32 a_84237, f32 b_84238) = {
  {a_84237, b_84238}
}

fun {f32} lifted_43003(f32 x_84239) = {
  {x_84239}
}

fun {f32} lifted_43007(f32 x_84240, f32 y_84241) = {
  let {f32 res_84242} = fsub32(x_84240, y_84241)
  in {res_84242}
}

fun {f32} lifted_43011(f32 x_84243) = {
  {x_84243}
}

fun {f32} lifted_43015(f32 x_84244, f32 y_84245) = {
  let {f32 res_84246} = fsub32(x_84244, y_84245)
  in {res_84246}
}

fun {f32, f32} lifted_43001(f32 a_84247, f32 b_84248, f32 c_84249,
                            f32 d_84250) = {
  let {f32 arg_84251} = lifted_43003(a_84247)
  let {f32 res_84252} = lifted_43007(arg_84251, c_84249)
  let {f32 arg_84253} = lifted_43011(b_84248)
  let {f32 res_84254} = lifted_43015(arg_84253, d_84250)
  in {res_84252, res_84254}
}

fun {f32, f32} lifted_42989(f32 x_84255, f32 x_84256, f32 y_84257,
                            f32 y_84258) = {
  let {f32 arg_84259, f32 arg_84260} = lifted_42993(x_84255, x_84256)
  let {f32 res_84261, f32 res_84262} = lifted_43001(arg_84259, arg_84260,
                                                    y_84257, y_84258)
  in {res_84261, res_84262}
}

fun {f32, f32} lifted_43035(f32 a_84263, f32 b_84264) = {
  {a_84263, b_84264}
}

fun {f32} lifted_43047(f32 x_84265) = {
  {x_84265}
}

fun {f32} lifted_43051(f32 x_84266, f32 y_84267) = {
  let {f32 res_84268} = fmul32(x_84266, y_84267)
  in {res_84268}
}

fun {f32} lifted_43055(f32 x_84269) = {
  {x_84269}
}

fun {f32} lifted_43058(f32 x_84270) = {
  {x_84270}
}

fun {f32} lifted_43062(f32 x_84271, f32 y_84272) = {
  let {f32 res_84273} = fmul32(x_84271, y_84272)
  in {res_84273}
}

fun {f32} lifted_43067(f32 x_84274, f32 y_84275) = {
  let {f32 res_84276} = fsub32(x_84274, y_84275)
  in {res_84276}
}

fun {f32} lifted_43071(f32 x_84277) = {
  {x_84277}
}

fun {f32} lifted_43075(f32 x_84278, f32 y_84279) = {
  let {f32 res_84280} = fmul32(x_84278, y_84279)
  in {res_84280}
}

fun {f32} lifted_43079(f32 x_84281) = {
  {x_84281}
}

fun {f32} lifted_43082(f32 x_84282) = {
  {x_84282}
}

fun {f32} lifted_43086(f32 x_84283, f32 y_84284) = {
  let {f32 res_84285} = fmul32(x_84283, y_84284)
  in {res_84285}
}

fun {f32} lifted_43091(f32 x_84286, f32 y_84287) = {
  let {f32 res_84288} = fadd32(x_84286, y_84287)
  in {res_84288}
}

fun {f32, f32} lifted_43045(f32 a_84289, f32 b_84290, f32 c_84291,
                            f32 d_84292) = {
  let {f32 arg_84293} = lifted_43047(a_84289)
  let {f32 arg_84294} = lifted_43051(arg_84293, c_84291)
  let {f32 arg_84295} = lifted_43055(arg_84294)
  let {f32 arg_84296} = lifted_43058(b_84290)
  let {f32 arg_84297} = lifted_43062(arg_84296, d_84292)
  let {f32 res_84298} = lifted_43067(arg_84295, arg_84297)
  let {f32 arg_84299} = lifted_43071(b_84290)
  let {f32 arg_84300} = lifted_43075(arg_84299, c_84291)
  let {f32 arg_84301} = lifted_43079(arg_84300)
  let {f32 arg_84302} = lifted_43082(a_84289)
  let {f32 arg_84303} = lifted_43086(arg_84302, d_84292)
  let {f32 res_84304} = lifted_43091(arg_84301, arg_84303)
  in {res_84298, res_84304}
}

fun {f32, f32} lifted_43029(f32 x_84305, f32 x_84306, f32 y_84307,
                            f32 y_84308) = {
  let {f32 arg_84309, f32 arg_84310} = lifted_43035(x_84305, x_84306)
  let {f32 res_84311, f32 res_84312} = lifted_43045(arg_84309, arg_84310,
                                                    y_84307, y_84308)
  in {res_84311, res_84312}
}

fun {f32, f32} lifted_43102(f32 x_84313, f32 x_84314) = {
  {x_84313, x_84314}
}

fun {f32, f32} lifted_43109(f32 x_84315, f32 x_84316) = {
  {x_84315, x_84316}
}

fun {f32, f32} lifted_43116(f32 x_84317, f32 x_84318) = {
  {x_84317, x_84318}
}

fun {f32, f32} lifted_43132(f32 a_84319, f32 b_84320) = {
  {a_84319, b_84320}
}

fun {f32} lifted_43144(f32 x_84321) = {
  {x_84321}
}

fun {f32} lifted_43148(f32 x_84322, f32 y_84323) = {
  let {f32 res_84324} = fmul32(x_84322, y_84323)
  in {res_84324}
}

fun {f32} lifted_43152(f32 x_84325) = {
  {x_84325}
}

fun {f32} lifted_43155(f32 x_84326) = {
  {x_84326}
}

fun {f32} lifted_43159(f32 x_84327, f32 y_84328) = {
  let {f32 res_84329} = fmul32(x_84327, y_84328)
  in {res_84329}
}

fun {f32} lifted_43164(f32 x_84330, f32 y_84331) = {
  let {f32 res_84332} = fsub32(x_84330, y_84331)
  in {res_84332}
}

fun {f32} lifted_43168(f32 x_84333) = {
  {x_84333}
}

fun {f32} lifted_43172(f32 x_84334, f32 y_84335) = {
  let {f32 res_84336} = fmul32(x_84334, y_84335)
  in {res_84336}
}

fun {f32} lifted_43176(f32 x_84337) = {
  {x_84337}
}

fun {f32} lifted_43179(f32 x_84338) = {
  {x_84338}
}

fun {f32} lifted_43183(f32 x_84339, f32 y_84340) = {
  let {f32 res_84341} = fmul32(x_84339, y_84340)
  in {res_84341}
}

fun {f32} lifted_43188(f32 x_84342, f32 y_84343) = {
  let {f32 res_84344} = fadd32(x_84342, y_84343)
  in {res_84344}
}

fun {f32, f32} lifted_43142(f32 a_84345, f32 b_84346, f32 c_84347,
                            f32 d_84348) = {
  let {f32 arg_84349} = lifted_43144(a_84345)
  let {f32 arg_84350} = lifted_43148(arg_84349, c_84347)
  let {f32 arg_84351} = lifted_43152(arg_84350)
  let {f32 arg_84352} = lifted_43155(b_84346)
  let {f32 arg_84353} = lifted_43159(arg_84352, d_84348)
  let {f32 res_84354} = lifted_43164(arg_84351, arg_84353)
  let {f32 arg_84355} = lifted_43168(b_84346)
  let {f32 arg_84356} = lifted_43172(arg_84355, c_84347)
  let {f32 arg_84357} = lifted_43176(arg_84356)
  let {f32 arg_84358} = lifted_43179(a_84345)
  let {f32 arg_84359} = lifted_43183(arg_84358, d_84348)
  let {f32 res_84360} = lifted_43188(arg_84357, arg_84359)
  in {res_84354, res_84360}
}

fun {f32, f32} lifted_43126(f32 x_84361, f32 x_84362, f32 y_84363,
                            f32 y_84364) = {
  let {f32 arg_84365, f32 arg_84366} = lifted_43132(x_84361, x_84362)
  let {f32 res_84367, f32 res_84368} = lifted_43142(arg_84365, arg_84366,
                                                    y_84363, y_84364)
  in {res_84367, res_84368}
}

fun {f32, f32} lifted_43206(f32 a_84369, f32 b_84370) = {
  {a_84369, b_84370}
}

fun {f32} lifted_43216(f32 x_84371) = {
  {x_84371}
}

fun {f32} lifted_43220(f32 x_84372, f32 y_84373) = {
  let {f32 res_84374} = fsub32(x_84372, y_84373)
  in {res_84374}
}

fun {f32} lifted_43224(f32 x_84375) = {
  {x_8437