package float32

file_number 0 "/inputs/subtree/xls/dslx/stdlib/apfloat.x"
file_number 1 "/inputs/subtree/xls/dslx/stdlib/float32.x"
file_number 2 "/inputs/subtree/xls/dslx/stdlib/std.x"
file_number 3 "/inputs/subtree/xls/dslx/stdlib/abs_diff.x"

fn __apfloat__is_zero_or_subnormal__8_23(x: (bits[1], bits[8], bits[23]) id=1) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=4, pos=[(0,804,5)])
  literal.5: bits[8] = literal(value=0, id=5, pos=[(0,804,14)])
  EXP_SZ: bits[32] = literal(value=8, id=2, pos=[(0,802,28)])
  FRACTION_SZ: bits[32] = literal(value=23, id=3, pos=[(0,802,41)])
  ret eq.6: bits[1] = eq(x_bexp, literal.5, id=6, pos=[(0,804,5)])
}

fn __apfloat__zero__8_23(sign: bits[1] id=7) -> (bits[1], bits[8], bits[23]) {
  literal.10: bits[8] = literal(value=0, id=10, pos=[(0,131,47)])
  literal.11: bits[23] = literal(value=0, id=11, pos=[(0,131,73)])
  EXP_SZ: bits[32] = literal(value=8, id=8, pos=[(0,130,12)])
  FRACTION_SZ: bits[32] = literal(value=23, id=9, pos=[(0,130,25)])
  ret tuple.12: (bits[1], bits[8], bits[23]) = tuple(sign, literal.10, literal.11, id=12, pos=[(0,131,33)])
}

fn __apfloat__subnormals_to_zero__8_23(x: (bits[1], bits[8], bits[23]) id=13) -> (bits[1], bits[8], bits[23]) {
  x_sign: bits[1] = tuple_index(x, index=0, id=17, pos=[(0,809,60)])
  invoke.16: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=16, pos=[(0,809,27)])
  invoke.18: (bits[1], bits[8], bits[23]) = invoke(x_sign, to_apply=__apfloat__zero__8_23, id=18, pos=[(0,809,37)])
  EXP_SZ: bits[32] = literal(value=8, id=14, pos=[(0,807,26)])
  FRACTION_SZ: bits[32] = literal(value=23, id=15, pos=[(0,807,39)])
  ret sel.19: (bits[1], bits[8], bits[23]) = sel(invoke.16, cases=[x, invoke.18], id=19, pos=[(0,809,4)])
}

fn __float32__subnormals_to_zero(f: (bits[1], bits[8], bits[23]) id=20) -> (bits[1], bits[8], bits[23]) {
  F32_EXP_SZ: bits[32] = literal(value=8, id=21, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=22, pos=[(1,19,28)])
  ret invoke.23: (bits[1], bits[8], bits[23]) = invoke(f, to_apply=__apfloat__subnormals_to_zero__8_23, id=23, pos=[(1,78,31)])
}

fn __apfloat__flatten__8_23_32(x: (bits[1], bits[8], bits[23]) id=24) -> bits[32] {
  x_sign: bits[1] = tuple_index(x, index=0, id=28, pos=[(0,370,5)])
  x_bexp: bits[8] = tuple_index(x, index=1, id=29, pos=[(0,370,15)])
  concat.30: bits[9] = concat(x_sign, x_bexp, id=30, pos=[(0,370,5)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=31, pos=[(0,370,25)])
  EXP_SZ: bits[32] = literal(value=8, id=25, pos=[(0,368,15)])
  FRACTION_SZ: bits[32] = literal(value=23, id=26, pos=[(0,368,28)])
  TOTAL_SZ: bits[32] = literal(value=32, id=27, pos=[(0,368,46)])
  ret concat.32: bits[32] = concat(concat.30, x_fraction, id=32, pos=[(0,370,5)])
}

fn __float32__flatten(f: (bits[1], bits[8], bits[23]) id=33) -> bits[32] {
  F32_EXP_SZ: bits[32] = literal(value=8, id=34, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=35, pos=[(1,19,28)])
  ret invoke.36: bits[32] = invoke(f, to_apply=__apfloat__flatten__8_23_32, id=36, pos=[(1,59,61)])
}

fn __apfloat__unflatten__8_23_32(x: bits[32] id=37) -> (bits[1], bits[8], bits[23]) {
  EXP_SZ: bits[32] = literal(value=8, id=38, pos=[(0,374,17)])
  FRACTION_SZ: bits[32] = literal(value=23, id=39, pos=[(0,374,30)])
  SIGN_OFFSET: bits[32] = add(EXP_SZ, FRACTION_SZ, id=41, pos=[(0,376,29)])
  zero_ext.42: bits[32] = zero_ext(SIGN_OFFSET, new_bit_count=32, id=42)
  zero_ext.45: bits[32] = zero_ext(FRACTION_SZ, new_bit_count=32, id=45)
  shrl.43: bits[32] = shrl(x, zero_ext.42, id=43, pos=[(0,378,15)])
  shrl.46: bits[32] = shrl(x, zero_ext.45, id=46, pos=[(0,379,15)])
  bit_slice.44: bits[1] = bit_slice(shrl.43, start=0, width=1, id=44)
  bit_slice.47: bits[8] = bit_slice(shrl.46, start=0, width=8, id=47)
  bit_slice.48: bits[23] = bit_slice(x, start=0, width=23, id=48)
  TOTAL_SZ: bits[32] = literal(value=32, id=40, pos=[(0,374,48)])
  ret tuple.49: (bits[1], bits[8], bits[23]) = tuple(bit_slice.44, bit_slice.47, bit_slice.48, id=49, pos=[(0,377,33)])
}

fn __float32__unflatten(f: bits[32] id=50) -> (bits[1], bits[8], bits[23]) {
  F32_EXP_SZ: bits[32] = literal(value=8, id=51, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=52, pos=[(1,19,28)])
  ret invoke.53: (bits[1], bits[8], bits[23]) = invoke(f, to_apply=__apfloat__unflatten__8_23_32, id=53, pos=[(1,61,65)])
}

fn __std__mask_bits__8() -> bits[8] {
  literal.55: bits[8] = literal(value=0, id=55, pos=[(2,835,41)])
  X: bits[32] = literal(value=8, id=54, pos=[(2,835,17)])
  ret not.56: bits[8] = not(literal.55, id=56, pos=[(2,835,40)])
}

fn __apfloat__is_inf__8_23(x: (bits[1], bits[8], bits[23]) id=57) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=60, pos=[(0,96,6)])
  invoke.61: bits[8] = invoke(to_apply=__std__mask_bits__8, id=61, pos=[(0,96,29)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=63, pos=[(0,96,44)])
  literal.64: bits[23] = literal(value=0, id=64, pos=[(0,96,57)])
  eq.62: bits[1] = eq(x_bexp, invoke.61, id=62, pos=[(0,96,6)])
  eq.65: bits[1] = eq(x_fraction, literal.64, id=65, pos=[(0,96,44)])
  EXP_SZ: bits[32] = literal(value=8, id=58, pos=[(0,95,14)])
  FRACTION_SZ: bits[32] = literal(value=23, id=59, pos=[(0,95,27)])
  ret and.66: bits[1] = and(eq.62, eq.65, id=66, pos=[(0,96,6)])
}

fn __apfloat__is_nan__8_23(x: (bits[1], bits[8], bits[23]) id=67) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=70, pos=[(0,71,6)])
  invoke.71: bits[8] = invoke(to_apply=__std__mask_bits__8, id=71, pos=[(0,71,29)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=73, pos=[(0,71,44)])
  literal.74: bits[23] = literal(value=0, id=74, pos=[(0,71,57)])
  eq.72: bits[1] = eq(x_bexp, invoke.71, id=72, pos=[(0,71,6)])
  ne.75: bits[1] = ne(x_fraction, literal.74, id=75, pos=[(0,71,44)])
  EXP_SZ: bits[32] = literal(value=8, id=68, pos=[(0,70,14)])
  FRACTION_SZ: bits[32] = literal(value=23, id=69, pos=[(0,70,27)])
  ret and.76: bits[1] = and(eq.72, ne.75, id=76, pos=[(0,71,6)])
}

fn __apfloat__mul__8_23(x: (bits[1], bits[8], bits[23]) id=77, y: (bits[1], bits[8], bits[23]) id=78) -> (bits[1], bits[8], bits[23]) {
  FRACTION_SZ: bits[32] = literal(value=23, id=80, pos=[(0,3264,24)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=97, pos=[(0,3290,23)])
  literal.99: bits[48] = literal(value=1, id=99, pos=[(0,3291,22)])
  zero_ext.100: bits[48] = zero_ext(FRACTION_SZ, new_bit_count=48, id=100)
  y_fraction: bits[23] = tuple_index(y, index=2, id=103, pos=[(0,3292,23)])
  literal.105: bits[48] = literal(value=1, id=105, pos=[(0,3293,22)])
  zero_ext.106: bits[48] = zero_ext(FRACTION_SZ, new_bit_count=48, id=106)
  zero_ext.98: bits[48] = zero_ext(x_fraction, new_bit_count=48, id=98)
  shll.101: bits[48] = shll(literal.99, zero_ext.100, id=101, pos=[(0,3291,22)])
  zero_ext.104: bits[48] = zero_ext(y_fraction, new_bit_count=48, id=104)
  shll.107: bits[48] = shll(literal.105, zero_ext.106, id=107, pos=[(0,3293,22)])
  invoke.94: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=94, pos=[(0,3287,40)])
  invoke.95: bits[1] = invoke(y, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=95, pos=[(0,3287,67)])
  x_fraction__1: bits[48] = or(zero_ext.98, shll.101, id=102, pos=[(0,3290,23)])
  y_fraction__1: bits[48] = or(zero_ext.104, shll.107, id=108, pos=[(0,3292,23)])
  x_bexp: bits[8] = tuple_index(x, index=1, id=116, pos=[(0,3305,16)])
  y_bexp: bits[8] = tuple_index(y, index=1, id=118, pos=[(0,3305,45)])
  invoke.112: bits[8] = invoke(to_apply=__std__mask_bits__8, id=112, pos=[(0,3304,29)])
  has_0_arg: bits[1] = or(invoke.94, invoke.95, id=96, pos=[(0,3287,40)])
  umul.110: bits[48] = umul(x_fraction__1, y_fraction__1, id=110, pos=[(0,3296,63)])
  literal.109: bits[48] = literal(value=0, id=109, pos=[(0,3296,34)])
  zero_ext.117: bits[10] = zero_ext(x_bexp, new_bit_count=10, id=117)
  zero_ext.119: bits[10] = zero_ext(y_bexp, new_bit_count=10, id=119)
  zero_ext.113: bits[10] = zero_ext(invoke.112, new_bit_count=10, id=113)
  literal.114: bits[10] = literal(value=1, id=114, pos=[(0,3304,61)])
  fraction: bits[48] = sel(has_0_arg, cases=[umul.110, literal.109], id=111, pos=[(0,3296,19)])
  add.120: bits[10] = add(zero_ext.117, zero_ext.119, id=120, pos=[(0,3305,16)])
  bias: bits[10] = shra(zero_ext.113, literal.114, id=115, pos=[(0,3304,29)])
  bit_slice.124: bits[1] = bit_slice(fraction, start=47, width=1, id=124, pos=[(0,3320,33)])
  exp: bits[10] = sub(add.120, bias, id=121, pos=[(0,3305,16)])
  literal.122: bits[10] = literal(value=0, id=122, pos=[(0,3314,29)])
  fraction_shift: bits[48] = zero_ext(bit_slice.124, new_bit_count=48, id=125)
  bit_slice.126: bits[1] = bit_slice(fraction, start=0, width=1, id=126, pos=[(0,3325,25)])
  exp__1: bits[10] = sel(has_0_arg, cases=[exp, literal.122], id=123, pos=[(0,3314,14)])
  bit_slice.130: bits[10] = bit_slice(fraction_shift, start=0, width=10, id=130)
  fraction__1: bits[48] = shrl(fraction, fraction_shift, id=128, pos=[(0,3326,19)])
  sticky: bits[48] = zero_ext(bit_slice.126, new_bit_count=48, id=127)
  exp__2: bits[10] = add(exp__1, bit_slice.130, id=131, pos=[(0,3330,14)])
  literal.134: bits[10] = literal(value=0, id=134, pos=[(0,3342,29)])
  fraction__2: bits[48] = or(fraction__1, sticky, id=129, pos=[(0,3327,19)])
  literal.136: bits[48] = literal(value=1, id=136, pos=[(0,3342,60)])
  sle.135: bits[1] = sle(exp__2, literal.134, id=135, pos=[(0,3342,22)])
  shrl.137: bits[48] = shrl(fraction__2, literal.136, id=137, pos=[(0,3342,48)])
  bit_slice.132: bits[1] = bit_slice(fraction__2, start=0, width=1, id=132, pos=[(0,3341,25)])
  fraction__3: bits[48] = sel(sle.135, cases=[fraction__2, shrl.137], id=138, pos=[(0,3342,19)])
  sticky__1: bits[48] = zero_ext(bit_slice.132, new_bit_count=48, id=133)
  fraction__4: bits[48] = or(fraction__3, sticky__1, id=139, pos=[(0,3343,19)])
  bit_slice.141: bits[22] = bit_slice(fraction__4, start=0, width=22, id=141, pos=[(0,3354,31)])
  literal.142: bits[22] = literal(value=0, id=142, pos=[(0,3354,67)])
  zero_ext.153: bits[48] = zero_ext(FRACTION_SZ, new_bit_count=48, id=153)
  bit_slice.146: bits[22] = bit_slice(fraction__4, start=0, width=22, id=146, pos=[(0,3356,41)])
  literal.147: bits[22] = literal(value=0, id=147, pos=[(0,3357,32)])
  bit_slice.140: bits[1] = bit_slice(fraction__4, start=22, width=1, id=140, pos=[(0,3353,30)])
  eq.143: bits[1] = eq(bit_slice.141, literal.142, id=143, pos=[(0,3354,31)])
  shrl.154: bits[48] = shrl(fraction__4, zero_ext.153, id=154, pos=[(0,3364,20)])
  bit_slice.145: bits[1] = bit_slice(fraction__4, start=22, width=1, id=145, pos=[(0,3355,40)])
  ne.148: bits[1] = ne(bit_slice.146, literal.147, id=148, pos=[(0,3356,41)])
  is_half_way: bits[1] = and(bit_slice.140, eq.143, id=144, pos=[(0,3353,30)])
  bit_slice.150: bits[1] = bit_slice(fraction__4, start=23, width=1, id=150, pos=[(0,3359,45)])
  fraction__5: bits[23] = bit_slice(shrl.154, start=0, width=23, id=155)
  greater_than_half_way: bits[1] = and(bit_slice.145, ne.148, id=149, pos=[(0,3355,40)])
  and.151: bits[1] = and(is_half_way, bit_slice.150, id=151, pos=[(0,3359,23)])
  fraction__6: bits[24] = zero_ext(fraction__5, new_bit_count=24, id=156)
  literal.157: bits[24] = literal(value=1, id=157, pos=[(0,3366,47)])
  do_round_up: bits[1] = or(greater_than_half_way, and.151, id=152, pos=[(0,3358,22)])
  add.158: bits[24] = add(fraction__6, literal.157, id=158, pos=[(0,3366,36)])
  fraction__7: bits[24] = sel(do_round_up, cases=[fraction__6, add.158], id=159, pos=[(0,3366,19)])
  literal.161: bits[10] = literal(value=1, id=161, pos=[(0,3370,39)])
  bit_slice.160: bits[1] = bit_slice(fraction__7, start=23, width=1, id=160, pos=[(0,3370,25)])
  add.162: bits[10] = add(exp__2, literal.161, id=162, pos=[(0,3370,33)])
  exp__3: bits[10] = sel(bit_slice.160, cases=[exp__2, add.162], id=163, pos=[(0,3370,14)])
  literal.164: bits[10] = literal(value=0, id=164, pos=[(0,3371,30)])
  is_subnormal: bits[1] = sle(exp__3, literal.164, id=165, pos=[(0,3371,23)])
  result_exp: bits[9] = bit_slice(exp__3, start=0, width=9, id=169)
  literal.171: bits[9] = literal(value=0, id=171, pos=[(0,3380,39)])
  high_exp: bits[8] = invoke(to_apply=__std__mask_bits__8, id=175, pos=[(0,3384,33)])
  invoke.193: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=193, pos=[(0,3398,28)])
  invoke.194: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=194, pos=[(0,3398,62)])
  result_exp__1: bits[9] = sel(is_subnormal, cases=[result_exp, literal.171], id=172, pos=[(0,3380,21)])
  zero_ext.180: bits[9] = zero_ext(high_exp, new_bit_count=9, id=180)
  zero_ext.176: bits[9] = zero_ext(high_exp, new_bit_count=9, id=176)
  result_fraction: bits[23] = bit_slice(fraction__7, start=0, width=23, id=170)
  literal.173: bits[23] = literal(value=0, id=173, pos=[(0,3381,44)])
  invoke.190: bits[1] = invoke(x, to_apply=__apfloat__is_nan__8_23, id=190, pos=[(0,3397,28)])
  invoke.191: bits[1] = invoke(y, to_apply=__apfloat__is_nan__8_23, id=191, pos=[(0,3397,62)])
  has_inf_arg: bits[1] = or(invoke.193, invoke.194, id=195, pos=[(0,3398,28)])
  invoke.184: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=184, pos=[(0,3391,31)])
  invoke.185: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=185, pos=[(0,3391,65)])
  ult.181: bits[1] = ult(result_exp__1, zero_ext.180, id=181, pos=[(0,3388,11)])
  bit_slice.182: bits[8] = bit_slice(result_exp__1, start=0, width=8, id=182)
  ult.177: bits[1] = ult(result_exp__1, zero_ext.176, id=177, pos=[(0,3386,11)])
  literal.178: bits[23] = literal(value=0, id=178, pos=[(0,3386,78)])
  result_fraction__1: bits[23] = sel(is_subnormal, cases=[result_fraction, literal.173], id=174, pos=[(0,3381,26)])
  bit_slice.200: bits[23] = bit_slice(FRACTION_SZ, start=0, width=23, id=200)
  literal.201: bits[23] = literal(value=1, id=201, pos=[(0,3401,78)])
  has_nan_arg: bits[1] = or(invoke.190, invoke.191, id=192, pos=[(0,3397,28)])
  and.196: bits[1] = and(has_0_arg, has_inf_arg, id=196, pos=[(0,3399,40)])
  x_sign: bits[1] = tuple_index(x, index=0, id=166, pos=[(0,3374,23)])
  y_sign: bits[1] = tuple_index(y, index=0, id=167, pos=[(0,3374,33)])
  is_operand_inf: bits[1] = or(invoke.184, invoke.185, id=186, pos=[(0,3391,31)])
  result_exp__2: bits[8] = sel(ult.181, cases=[high_exp, bit_slice.182], id=183, pos=[(0,3388,8)])
  result_fraction__2: bits[23] = sel(ult.177, cases=[literal.178, result_fraction__1], id=179, pos=[(0,3386,8)])
  literal.188: bits[23] = literal(value=0, id=188, pos=[(0,3393,46)])
  literal.199: bits[23] = literal(value=1, id=199, pos=[(0,3401,23)])
  sub.202: bits[23] = sub(bit_slice.200, literal.201, id=202, pos=[(0,3401,45)])
  EXP_SZ: bits[32] = literal(value=8, id=79, pos=[(0,3264,11)])
  literal.81: bits[32] = literal(value=1, id=81, pos=[(0,3268,35)])
  is_result_nan: bits[1] = or(has_nan_arg, and.196, id=197, pos=[(0,3399,24)])
  result_sign: bits[1] = ne(x_sign, y_sign, id=168, pos=[(0,3374,23)])
  literal.205: bits[1] = literal(value=0, id=205, pos=[(0,3403,41)])
  result_exp__3: bits[8] = sel(is_operand_inf, cases=[result_exp__2, high_exp], id=187, pos=[(0,3392,21)])
  result_fraction__3: bits[23] = sel(is_operand_inf, cases=[result_fraction__2, literal.188], id=189, pos=[(0,3393,26)])
  nan_fraction: bits[23] = shll(literal.199, sub.202, id=203, pos=[(0,3401,23)])
  WIDE_EXP: bits[32] = add(EXP_SZ, literal.81, id=82, pos=[(0,3268,26)])
  literal.83: bits[32] = literal(value=1, id=83, pos=[(0,3270,39)])
  literal.85: bits[32] = literal(value=1, id=85, pos=[(0,3274,49)])
  add.87: bits[32] = add(FRACTION_SZ, FRACTION_SZ, id=87, pos=[(0,3278,31)])
  literal.88: bits[32] = literal(value=2, id=88, pos=[(0,3278,59)])
  literal.90: bits[32] = literal(value=1, id=90, pos=[(0,3280,53)])
  literal.92: bits[32] = literal(value=1, id=92, pos=[(0,3284,47)])
  result_sign__1: bits[1] = sel(is_result_nan, cases=[result_sign, literal.205], id=206, pos=[(0,3403,22)])
  result_exp__4: bits[8] = sel(is_result_nan, cases=[result_exp__3, high_exp], id=198, pos=[(0,3400,21)])
  result_fraction__4: bits[23] = sel(is_result_nan, cases=[result_fraction__3, nan_fraction], id=204, pos=[(0,3402,26)])
  SIGNED_EXP: bits[32] = add(WIDE_EXP, literal.83, id=84, pos=[(0,3270,28)])
  ROUNDING_FRACTION: bits[32] = add(FRACTION_SZ, literal.85, id=86, pos=[(0,3274,35)])
  WIDE_FRACTION: bits[32] = add(add.87, literal.88, id=89, pos=[(0,3278,31)])
  FRACTION_ROUNDING_BIT: bits[32] = sub(FRACTION_SZ, literal.90, id=91, pos=[(0,3280,39)])
  STICKY_FRACTION: bits[32] = add(FRACTION_SZ, literal.92, id=93, pos=[(0,3284,33)])
  ret tuple.207: (bits[1], bits[8], bits[23]) = tuple(result_sign__1, result_exp__4, result_fraction__4, id=207, pos=[(0,3405,33)])
}

fn __float32__mul(x: (bits[1], bits[8], bits[23]) id=208, y: (bits[1], bits[8], bits[23]) id=209) -> (bits[1], bits[8], bits[23]) {
  ret invoke.210: (bits[1], bits[8], bits[23]) = invoke(x, y, to_apply=__apfloat__mul__8_23, id=210, pos=[(1,367,48)])
}

fn __std__uadd_with_overflow__8_8_8_8_8(x: bits[8] id=211, y: bits[8] id=212) -> (bits[1], bits[8]) {
  x_extended: bits[9] = zero_ext(x, new_bit_count=9, id=218)
  y_extended: bits[9] = zero_ext(y, new_bit_count=9, id=219)
  full_result: bits[9] = add(x_extended, y_extended, id=220, pos=[(2,1119,45)])
  bit_slice.222: bits[1] = bit_slice(full_result, start=8, width=1, id=222, pos=[(2,1121,49)])
  overflow_detected: bits[1] = or_reduce(bit_slice.222, id=223, pos=[(2,1121,37)])
  narrowed_result: bits[8] = bit_slice(full_result, start=0, width=8, id=221)
  V: bits[32] = literal(value=8, id=213, pos=[(2,1113,5)])
  N: bits[32] = literal(value=8, id=214, pos=[(2,1113,13)])
  M: bits[32] = literal(value=8, id=215, pos=[(2,1113,21)])
  MAX_N_M: bits[32] = literal(value=8, id=216, pos=[(2,1113,29)])
  MAX_N_M_V: bits[32] = literal(value=8, id=217, pos=[(2,1113,57)])
  ret tuple.224: (bits[1], bits[8]) = tuple(overflow_detected, narrowed_result, id=224, pos=[(2,1123,4)])
}

fn __abs_diff__abs_diff__8(x: bits[8] id=225, y: bits[8] id=226) -> (bits[1], bits[8]) {
  ynot: bits[8] = not(y, id=228, pos=[(3,90,15)])
  invoke.229: (bits[1], bits[8]) = invoke(x, ynot, to_apply=__std__uadd_with_overflow__8_8_8_8_8, id=229, pos=[(3,91,63)])
  carry_out: bits[1] = tuple_index(invoke.229, index=0, id=230, pos=[(3,91,9)])
  nc: bits[1] = not(carry_out, id=232, pos=[(3,92,19)])
  z: bits[8] = tuple_index(invoke.229, index=1, id=231, pos=[(3,91,20)])
  xor_mask: bits[8] = sign_ext(nc, new_bit_count=8, id=234, pos=[(3,94,32)])
  result: bits[8] = xor(z, xor_mask, id=235, pos=[(3,95,18)])
  N: bits[32] = literal(value=8, id=227, pos=[(3,89,16)])
  literal.233: bits[8] = literal(value=0, id=233, pos=[(3,94,42)])
  ret tuple.236: (bits[1], bits[8]) = tuple(carry_out, result, id=236, pos=[(3,96,18)])
}

fn __abs_diff__is_x_larger__8(adr: (bits[1], bits[8]) id=237) -> bits[1] {
  N: bits[32] = literal(value=8, id=238, pos=[(3,47,19)])
  ret adr_correction: bits[1] = tuple_index(adr, index=0, id=239, pos=[(3,47,63)])
}

fn __abs_diff__to_corrected__8(adr: (bits[1], bits[8]) id=240) -> bits[8] {
  adr_correction: bits[1] = tuple_index(adr, index=0, id=243, pos=[(3,54,25)])
  adr_uncorrected: bits[8] = tuple_index(adr, index=1, id=242, pos=[(3,54,7)])
  zero_ext.244: bits[8] = zero_ext(adr_correction, new_bit_count=8, id=244)
  N: bits[32] = literal(value=8, id=241, pos=[(3,53,20)])
  ret add.245: bits[8] = add(adr_uncorrected, zero_ext.244, id=245, pos=[(3,54,7)])
}

fn __apfloat__sign_magnitude_difference__8(a: bits[8] id=246, b: bits[8] id=247) -> (bits[1], bits[8]) {
  abs_diff_result: (bits[1], bits[8]) = invoke(a, b, to_apply=__abs_diff__abs_diff__8, id=249, pos=[(0,3005,44)])
  invoke.250: bits[1] = invoke(abs_diff_result, to_apply=__abs_diff__is_x_larger__8, id=250, pos=[(0,3006,27)])
  not.251: bits[1] = not(invoke.250, id=251, pos=[(0,3006,5)])
  invoke.252: bits[8] = invoke(abs_diff_result, to_apply=__abs_diff__to_corrected__8, id=252, pos=[(0,3006,68)])
  WIDTH: bits[32] = literal(value=8, id=248, pos=[(0,3004,29)])
  ret tuple.253: (bits[1], bits[8]) = tuple(not.251, invoke.252, id=253, pos=[(0,3006,4)])
}

fn __std__keep_lsbs__8_28(x: bits[28] id=254, n: bits[8] id=255) -> bits[28] {
  literal.258: bits[28] = literal(value=268435455, id=258, pos=[(2,1411,19)])
  shll.259: bits[28] = shll(literal.258, n, id=259, pos=[(2,1411,19)])
  not.260: bits[28] = not(shll.259, id=260, pos=[(2,1411,8)])
  WIDTH: bits[32] = literal(value=28, id=256, pos=[(2,1410,17)])
  N_WIDTH: bits[32] = literal(value=8, id=257, pos=[(2,1410,29)])
  ret and.261: bits[28] = and(x, not.260, id=261, pos=[(2,1411,4)])
}

fn __std__or_reduce_lsb_impl__1_8_28(value: bits[28] id=262, n: bits[8] id=263) -> bits[1] {
  WIDTH: bits[32] = literal(value=28, id=265, pos=[(2,1497,42)])
  bit_slice.270: bits[8] = bit_slice(WIDTH, start=0, width=8, id=270)
  sub.271: bits[8] = sub(bit_slice.270, n, id=271, pos=[(2,1504,18)])
  shll.272: bits[28] = shll(value, sub.271, id=272, pos=[(2,1504,8)])
  literal.273: bits[28] = literal(value=0, id=273, pos=[(2,1504,47)])
  invoke.267: bits[28] = invoke(value, n, to_apply=__std__keep_lsbs__8_28, id=267, pos=[(2,1501,17)])
  literal.268: bits[28] = literal(value=0, id=268, pos=[(2,1501,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=264, pos=[(2,1497,22)])
  ne.274: bits[1] = ne(shll.272, literal.273, id=274, pos=[(2,1504,8)])
  ne.269: bits[1] = ne(invoke.267, literal.268, id=269, pos=[(2,1501,17)])
  N_WIDTH: bits[32] = literal(value=8, id=266, pos=[(2,1497,54)])
  ret sel.275: bits[1] = sel(DO_MASK_IMPL, cases=[ne.274, ne.269], id=275, pos=[(2,1499,4)])
}

fn __std__or_reduce_lsb__8_28(value: bits[28] id=276, n: bits[8] id=277) -> bits[1] {
  WIDTH: bits[32] = literal(value=28, id=278, pos=[(2,1527,21)])
  N_WIDTH: bits[32] = literal(value=8, id=279, pos=[(2,1527,33)])
  ret invoke.280: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_8_28, id=280, pos=[(2,1528,22)])
}

fn __apfloat__or_last_bit__28(value: bits[28] id=281, lsb: bits[1] id=282) -> bits[28] {
  bit_slice.285: bits[1] = bit_slice(value, start=0, width=1, id=285, pos=[(0,3049,40)])
  literal.284: bits[1] = literal(value=0, id=284, pos=[(0,3049,28)])
  or.286: bits[1] = or(bit_slice.285, lsb, id=286, pos=[(0,3049,40)])
  WIDTH: bits[32] = literal(value=28, id=283, pos=[(0,3048,15)])
  ret bit_slice_update.287: bits[28] = bit_slice_update(value, literal.284, or.286, id=287, pos=[(0,3049,20)])
}

fn __apfloat__or_last_bit__27(value: bits[27] id=288, lsb: bits[1] id=289) -> bits[27] {
  bit_slice.292: bits[1] = bit_slice(value, start=0, width=1, id=292, pos=[(0,3049,40)])
  literal.291: bits[1] = literal(value=0, id=291, pos=[(0,3049,28)])
  or.293: bits[1] = or(bit_slice.292, lsb, id=293, pos=[(0,3049,40)])
  WIDTH: bits[32] = literal(value=27, id=290, pos=[(0,3048,15)])
  ret bit_slice_update.294: bits[27] = bit_slice_update(value, literal.291, or.293, id=294, pos=[(0,3049,20)])
}

fn __std__clog2__32(x: bits[32] id=295) -> bits[32] {
  literal.300: bits[32] = literal(value=1, id=300, pos=[(2,716,49)])
  sub.301: bits[32] = sub(x, literal.300, id=301, pos=[(2,716,45)])
  reverse.302: bits[32] = reverse(sub.301, id=302, pos=[(2,716,44)])
  one_hot.303: bits[33] = one_hot(reverse.302, lsb_prio=true, id=303, pos=[(2,716,44)])
  N: bits[32] = literal(value=32, id=296, pos=[(2,715,13)])
  encode.304: bits[6] = encode(one_hot.303, id=304, pos=[(2,716,44)])
  literal.297: bits[32] = literal(value=1, id=297, pos=[(2,716,12)])
  zero_ext.299: bits[32] = zero_ext(N, new_bit_count=32, id=299)
  zero_ext.305: bits[32] = zero_ext(encode.304, new_bit_count=32, id=305, pos=[(2,716,44)])
  uge.298: bits[1] = uge(x, literal.297, id=298, pos=[(2,716,7)])
  literal.307: bits[32] = literal(value=0, id=307, pos=[(2,716,69)])
  sub.306: bits[32] = sub(zero_ext.299, zero_ext.305, id=306, pos=[(2,716,25)])
  ret sel.308: bits[32] = sel(uge.298, cases=[literal.307, sub.306], id=308, pos=[(2,716,4)])
}

fn ____std__pow__32_0_counted_for_0_body(i: bits[32] id=315, __loop_carry: (bits[32], bits[32], bits[32]) id=318) -> (bits[32], bits[32], bits[32]) {
  tuple_index.320: bits[32] = tuple_index(__loop_carry, index=0, id=320)
  literal.330: bits[32] = literal(value=1, id=330, pos=[(2,960,29)])
  literal.319: bits[1] = literal(value=1, id=319)
  literal.321: bits[1] = literal(value=1, id=321)
  literal.338: bits[32] = literal(value=0, id=338, pos=[(2,961,25)])
  tuple_index.323: bits[32] = tuple_index(__loop_carry, index=1, id=323)
  and.331: bits[32] = and(tuple_index.320, literal.330, id=331, pos=[(2,960,25)])
  literal.332: bits[32] = literal(value=1, id=332, pos=[(2,960,41)])
  tuple_index.326: bits[32] = tuple_index(__loop_carry, index=2, id=326)
  and.322: bits[1] = and(literal.319, literal.321, id=322)
  literal.324: bits[1] = literal(value=1, id=324)
  literal.336: bits[1] = literal(value=1, id=336, pos=[(2,961,14)])
  eq.339: bits[1] = eq(tuple_index.320, literal.338, id=339, pos=[(2,961,20)])
  umul.340: bits[32] = umul(tuple_index.323, tuple_index.323, id=340, pos=[(2,961,46)])
  eq.333: bits[1] = eq(and.331, literal.332, id=333, pos=[(2,960,25)])
  umul.334: bits[32] = umul(tuple_index.326, tuple_index.323, id=334, pos=[(2,960,51)])
  literal.316: bits[32] = literal(value=0, id=316)
  and.325: bits[1] = and(and.322, literal.324, id=325)
  literal.327: bits[1] = literal(value=1, id=327)
  shrl.337: bits[32] = shrl(tuple_index.320, literal.336, id=337, pos=[(2,961,9)])
  sel.341: bits[32] = sel(eq.339, cases=[umul.340, tuple_index.323], id=341, pos=[(2,961,17)])
  result: bits[32] = sel(eq.333, cases=[tuple_index.326, umul.334], id=335, pos=[(2,960,21)])
  add.317: bits[32] = add(i, literal.316, id=317)
  and.328: bits[1] = and(and.325, literal.327, id=328)
  literal.329: bits[32] = literal(value=32, id=329, pos=[(2,955,20)])
  ret tuple.342: (bits[32], bits[32], bits[32]) = tuple(shrl.337, sel.341, result, id=342, pos=[(2,961,8)])
}

fn __std__pow__32_0(x: bits[32] id=309, n: bits[32] id=310) -> bits[32] {
  result: bits[32] = literal(value=1, id=313, pos=[(2,956,17)])
  tuple.314: (bits[32], bits[32], bits[32]) = tuple(n, x, result, id=314, pos=[(2,962,6)])
  work: (bits[32], bits[32], bits[32]) = counted_for(tuple.314, trip_count=32, stride=1, body=____std__pow__32_0_counted_for_0_body, id=343)
  S: bits[1] = literal(value=0, id=311, pos=[(2,955,11)])
  N: bits[32] = literal(value=32, id=312, pos=[(2,955,20)])
  literal.344: bits[32] = literal(value=2, id=344, pos=[(2,963,9)])
  ret tuple_index.345: bits[32] = tuple_index(work, index=2, id=345, pos=[(2,963,8)])
}

fn __std__upow__32(x: bits[32] id=346, n: bits[32] id=347) -> bits[32] {
  N: bits[32] = literal(value=32, id=348, pos=[(2,966,12)])
  ret invoke.349: bits[32] = invoke(x, n, to_apply=__std__pow__32_0, id=349, pos=[(2,966,54)])
}

fn __std__next_pow2(n: bits[32] id=350) -> bits[32] {
  literal.351: bits[32] = literal(value=2, id=351, pos=[(2,1685,39)])
  invoke.352: bits[32] = invoke(n, to_apply=__std__clog2__32, id=352, pos=[(2,1685,51)])
  ret invoke.353: bits[32] = invoke(literal.351, invoke.352, to_apply=__std__upow__32, id=353, pos=[(2,1685,38)])
}

fn __std__mask_bits__4() -> bits[4] {
  literal.355: bits[4] = literal(value=0, id=355, pos=[(2,835,41)])
  X: bits[32] = literal(value=4, id=354, pos=[(2,835,17)])
  ret not.356: bits[4] = not(literal.355, id=356, pos=[(2,835,40)])
}

fn __std__clzt_pow2_1(value: bits[1] id=357) -> bits[1] {
  ret not.358: bits[1] = not(value, id=358, pos=[(2,1583,4)])
}

fn __std__combine_clzt_halfs__1(left: bits[1] id=359, right: bits[1] id=360) -> bits[2] {
  bit_slice.362: bits[1] = bit_slice(left, start=0, width=1, id=362, pos=[(2,1538,15)])
  bit_slice.363: bits[1] = bit_slice(right, start=0, width=1, id=363, pos=[(2,1538,27)])
  tuple.364: (bits[1], bits[1]) = tuple(bit_slice.362, bit_slice.363, id=364, pos=[(2,1538,10)])
  literal.378: bits[1] = literal(value=1, id=378, pos=[(2,1540,9)])
  tuple_index.377: bits[1] = tuple_index(tuple.364, index=0, id=377)
  literal.367: bits[1] = literal(value=1, id=367, pos=[(2,1539,9)])
  tuple_index.366: bits[1] = tuple_index(tuple.364, index=0, id=366)
  literal.376: bits[1] = literal(value=1, id=376)
  eq.379: bits[1] = eq(literal.378, tuple_index.377, id=379)
  literal.382: bits[1] = literal(value=0, id=382, pos=[(2,1540,15)])
  tuple_index.381: bits[1] = tuple_index(tuple.364, index=1, id=381)
  literal.365: bits[1] = literal(value=1, id=365)
  eq.368: bits[1] = eq(literal.367, tuple_index.366, id=368)
  literal.371: bits[1] = literal(value=1, id=371, pos=[(2,1539,15)])
  tuple_index.370: bits[1] = tuple_index(tuple.364, index=1, id=370)
  and.380: bits[1] = and(literal.376, eq.379, id=380)
  eq.383: bits[1] = eq(literal.382, tuple_index.381, id=383)
  and.369: bits[1] = and(literal.365, eq.368, id=369)
  eq.372: bits[1] = eq(literal.371, tuple_index.370, id=372)
  and.384: bits[1] = and(and.380, eq.383, id=384)
  and.373: bits[1] = and(and.369, eq.372, id=373)
  literal.374: bits[1] = literal(value=0, id=374, pos=[(2,1539,32)])
  literal.385: bits[2] = literal(value=1, id=385, pos=[(2,1540,24)])
  bit_slice.386: bits[0] = bit_slice(right, start=0, width=0, id=386, pos=[(2,1540,40)])
  literal.389: bits[1] = literal(value=0, id=389, pos=[(2,1541,13)])
  concat.391: bits[2] = concat(and.384, and.373, id=391)
  concat.375: bits[2] = concat(left, literal.374, id=375, pos=[(2,1539,24)])
  concat.387: bits[2] = concat(literal.385, bit_slice.386, id=387, pos=[(2,1540,24)])
  concat.390: bits[2] = concat(literal.389, left, id=390, pos=[(2,1541,13)])
  N: bits[32] = literal(value=1, id=361, pos=[(2,1537,22)])
  literal.388: bits[1] = literal(value=1, id=388, pos=[(2,1541,8)])
  ret priority_sel.392: bits[2] = priority_sel(concat.391, cases=[concat.375, concat.387], default=concat.390, id=392)
}

fn __std__clzt_pow2_2(value: bits[2] id=393) -> bits[2] {
  literal.394: bits[32] = literal(value=2, id=394, pos=[(2,1589,20)])
  literal.395: bits[1] = literal(value=1, id=395, pos=[(2,1589,29)])
  bit_slice.398: bits[1] = bit_slice(value, start=1, width=1, id=398, pos=[(2,1590,40)])
  bit_slice.400: bits[1] = bit_slice(value, start=0, width=1, id=400, pos=[(2,1590,70)])
  shrl.396: bits[32] = shrl(literal.394, literal.395, id=396, pos=[(2,1589,20)])
  invoke.399: bits[1] = invoke(bit_slice.398, to_apply=__std__clzt_pow2_1, id=399, pos=[(2,1590,34)])
  invoke.401: bits[1] = invoke(bit_slice.400, to_apply=__std__clzt_pow2_1, id=401, pos=[(2,1590,64)])
  N_HALF: bits[32] = zero_ext(shrl.396, new_bit_count=32, id=397)
  ret invoke.402: bits[2] = invoke(invoke.399, invoke.401, to_apply=__std__combine_clzt_halfs__1, id=402, pos=[(2,1590,22)])
}

fn __std__combine_clzt_halfs__2(left: bits[2] id=403, right: bits[2] id=404) -> bits[3] {
  bit_slice.406: bits[1] = bit_slice(left, start=1, width=1, id=406, pos=[(2,1538,15)])
  bit_slice.407: bits[1] = bit_slice(right, start=1, width=1, id=407, pos=[(2,1538,27)])
  tuple.408: (bits[1], bits[1]) = tuple(bit_slice.406, bit_slice.407, id=408, pos=[(2,1538,10)])
  literal.422: bits[1] = literal(value=1, id=422, pos=[(2,1540,9)])
  tuple_index.421: bits[1] = tuple_index(tuple.408, index=0, id=421)
  literal.411: bits[1] = literal(value=1, id=411, pos=[(2,1539,9)])
  tuple_index.410: bits[1] = tuple_index(tuple.408, index=0, id=410)
  literal.420: bits[1] = literal(value=1, id=420)
  eq.423: bits[1] = eq(literal.422, tuple_index.421, id=423)
  literal.426: bits[1] = literal(value=0, id=426, pos=[(2,1540,15)])
  tuple_index.425: bits[1] = tuple_index(tuple.408, index=1, id=425)
  literal.409: bits[1] = literal(value=1, id=409)
  eq.412: bits[1] = eq(literal.411, tuple_index.410, id=412)
  literal.415: bits[1] = literal(value=1, id=415, pos=[(2,1539,15)])
  tuple_index.414: bits[1] = tuple_index(tuple.408, index=1, id=414)
  and.424: bits[1] = and(literal.420, eq.423, id=424)
  eq.427: bits[1] = eq(literal.426, tuple_index.425, id=427)
  and.413: bits[1] = and(literal.409, eq.412, id=413)
  eq.416: bits[1] = eq(literal.415, tuple_index.414, id=416)
  and.428: bits[1] = and(and.424, eq.427, id=428)
  and.417: bits[1] = and(and.413, eq.416, id=417)
  literal.418: bits[1] = literal(value=0, id=418, pos=[(2,1539,32)])
  literal.429: bits[2] = literal(value=1, id=429, pos=[(2,1540,24)])
  bit_slice.430: bits[1] = bit_slice(right, start=0, width=1, id=430, pos=[(2,1540,40)])
  literal.433: bits[1] = literal(value=0, id=433, pos=[(2,1541,13)])
  concat.435: bits[2] = concat(and.428, and.417, id=435)
  concat.419: bits[3] = concat(left, literal.418, id=419, pos=[(2,1539,24)])
  concat.431: bits[3] = concat(literal.429, bit_slice.430, id=431, pos=[(2,1540,24)])
  concat.434: bits[3] = concat(literal.433, left, id=434, pos=[(2,1541,13)])
  N: bits[32] = literal(value=2, id=405, pos=[(2,1537,22)])
  literal.432: bits[1] = literal(value=1, id=432, pos=[(2,1541,8)])
  ret priority_sel.436: bits[3] = priority_sel(concat.435, cases=[concat.419, concat.431], default=concat.434, id=436)
}

fn __std__clzt_pow2_4(value: bits[4] id=437) -> bits[3] {
  literal.438: bits[32] = literal(value=4, id=438, pos=[(2,1594,20)])
  literal.439: bits[1] = literal(value=1, id=439, pos=[(2,1594,29)])
  bit_slice.442: bits[2] = bit_slice(value, start=2, width=2, id=442, pos=[(2,1595,40)])
  bit_slice.444: bits[2] = bit_slice(value, start=0, width=2, id=444, pos=[(2,1595,70)])
  shrl.440: bits[32] = shrl(literal.438, literal.439, id=440, pos=[(2,1594,20)])
  invoke.443: bits[2] = invoke(bit_slice.442, to_apply=__std__clzt_pow2_2, id=443, pos=[(2,1595,34)])
  invoke.445: bits[2] = invoke(bit_slice.444, to_apply=__std__clzt_pow2_2, id=445, pos=[(2,1595,64)])
  N_HALF: bits[32] = zero_ext(shrl.440, new_bit_count=32, id=441)
  ret invoke.446: bits[3] = invoke(invoke.443, invoke.445, to_apply=__std__combine_clzt_halfs__2, id=446, pos=[(2,1595,22)])
}

fn __std__combine_clzt_halfs__3(left: bits[3] id=447, right: bits[3] id=448) -> bits[4] {
  bit_slice.450: bits[1] = bit_slice(left, start=2, width=1, id=450, pos=[(2,1538,15)])
  bit_slice.451: bits[1] = bit_slice(right, start=2, width=1, id=451, pos=[(2,1538,27)])
  tuple.452: (bits[1], bits[1]) = tuple(bit_slice.450, bit_slice.451, id=452, pos=[(2,1538,10)])
  literal.466: bits[1] = literal(value=1, id=466, pos=[(2,1540,9)])
  tuple_index.465: bits[1] = tuple_index(tuple.452, index=0, id=465)
  literal.455: bits[1] = literal(value=1, id=455, pos=[(2,1539,9)])
  tuple_index.454: bits[1] = tuple_index(tuple.452, index=0, id=454)
  literal.464: bits[1] = literal(value=1, id=464)
  eq.467: bits[1] = eq(literal.466, tuple_index.465, id=467)
  literal.470: bits[1] = literal(value=0, id=470, pos=[(2,1540,15)])
  tuple_index.469: bits[1] = tuple_index(tuple.452, index=1, id=469)
  literal.453: bits[1] = literal(value=1, id=453)
  eq.456: bits[1] = eq(literal.455, tuple_index.454, id=456)
  literal.459: bits[1] = literal(value=1, id=459, pos=[(2,1539,15)])
  tuple_index.458: bits[1] = tuple_index(tuple.452, index=1, id=458)
  and.468: bits[1] = and(literal.464, eq.467, id=468)
  eq.471: bits[1] = eq(literal.470, tuple_index.469, id=471)
  and.457: bits[1] = and(literal.453, eq.456, id=457)
  eq.460: bits[1] = eq(literal.459, tuple_index.458, id=460)
  and.472: bits[1] = and(and.468, eq.471, id=472)
  and.461: bits[1] = and(and.457, eq.460, id=461)
  literal.462: bits[1] = literal(value=0, id=462, pos=[(2,1539,32)])
  literal.473: bits[2] = literal(value=1, id=473, pos=[(2,1540,24)])
  bit_slice.474: bits[2] = bit_slice(right, start=0, width=2, id=474, pos=[(2,1540,40)])
  literal.477: bits[1] = literal(value=0, id=477, pos=[(2,1541,13)])
  concat.479: bits[2] = concat(and.472, and.461, id=479)
  concat.463: bits[4] = concat(left, literal.462, id=463, pos=[(2,1539,24)])
  concat.475: bits[4] = concat(literal.473, bit_slice.474, id=475, pos=[(2,1540,24)])
  concat.478: bits[4] = concat(literal.477, left, id=478, pos=[(2,1541,13)])
  N: bits[32] = literal(value=3, id=449, pos=[(2,1537,22)])
  literal.476: bits[1] = literal(value=1, id=476, pos=[(2,1541,8)])
  ret priority_sel.480: bits[4] = priority_sel(concat.479, cases=[concat.463, concat.475], default=concat.478, id=480)
}

fn __std__clzt_pow2_8(value: bits[8] id=481) -> bits[4] {
  literal.482: bits[32] = literal(value=8, id=482, pos=[(2,1599,20)])
  literal.483: bits[1] = literal(value=1, id=483, pos=[(2,1599,29)])
  bit_slice.486: bits[4] = bit_slice(value, start=4, width=4, id=486, pos=[(2,1600,40)])
  bit_slice.488: bits[4] = bit_slice(value, start=0, width=4, id=488, pos=[(2,1600,70)])
  shrl.484: bits[32] = shrl(literal.482, literal.483, id=484, pos=[(2,1599,20)])
  invoke.487: bits[3] = invoke(bit_slice.486, to_apply=__std__clzt_pow2_4, id=487, pos=[(2,1600,34)])
  invoke.489: bits[3] = invoke(bit_slice.488, to_apply=__std__clzt_pow2_4, id=489, pos=[(2,1600,64)])
  N_HALF: bits[32] = zero_ext(shrl.484, new_bit_count=32, id=485)
  ret invoke.490: bits[4] = invoke(invoke.487, invoke.489, to_apply=__std__combine_clzt_halfs__3, id=490, pos=[(2,1600,22)])
}

fn __std__combine_clzt_halfs__4(left: bits[4] id=491, right: bits[4] id=492) -> bits[5] {
  bit_slice.494: bits[1] = bit_slice(left, start=3, width=1, id=494, pos=[(2,1538,15)])
  bit_slice.495: bits[1] = bit_slice(right, start=3, width=1, id=495, pos=[(2,1538,27)])
  tuple.496: (bits[1], bits[1]) = tuple(bit_slice.494, bit_slice.495, id=496, pos=[(2,1538,10)])
  literal.510: bits[1] = literal(value=1, id=510, pos=[(2,1540,9)])
  tuple_index.509: bits[1] = tuple_index(tuple.496, index=0, id=509)
  literal.499: bits[1] = literal(value=1, id=499, pos=[(2,1539,9)])
  tuple_index.498: bits[1] = tuple_index(tuple.496, index=0, id=498)
  literal.508: bits[1] = literal(value=1, id=508)
  eq.511: bits[1] = eq(literal.510, tuple_index.509, id=511)
  literal.514: bits[1] = literal(value=0, id=514, pos=[(2,1540,15)])
  tuple_index.513: bits[1] = tuple_index(tuple.496, index=1, id=513)
  literal.497: bits[1] = literal(value=1, id=497)
  eq.500: bits[1] = eq(literal.499, tuple_index.498, id=500)
  literal.503: bits[1] = literal(value=1, id=503, pos=[(2,1539,15)])
  tuple_index.502: bits[1] = tuple_index(tuple.496, index=1, id=502)
  and.512: bits[1] = and(literal.508, eq.511, id=512)
  eq.515: bits[1] = eq(literal.514, tuple_index.513, id=515)
  and.501: bits[1] = and(literal.497, eq.500, id=501)
  eq.504: bits[1] = eq(literal.503, tuple_index.502, id=504)
  and.516: bits[1] = and(and.512, eq.515, id=516)
  and.505: bits[1] = and(and.501, eq.504, id=505)
  literal.506: bits[1] = literal(value=0, id=506, pos=[(2,1539,32)])
  literal.517: bits[2] = literal(value=1, id=517, pos=[(2,1540,24)])
  bit_slice.518: bits[3] = bit_slice(right, start=0, width=3, id=518, pos=[(2,1540,40)])
  literal.521: bits[1] = literal(value=0, id=521, pos=[(2,1541,13)])
  concat.523: bits[2] = concat(and.516, and.505, id=523)
  concat.507: bits[5] = concat(left, literal.506, id=507, pos=[(2,1539,24)])
  concat.519: bits[5] = concat(literal.517, bit_slice.518, id=519, pos=[(2,1540,24)])
  concat.522: bits[5] = concat(literal.521, left, id=522, pos=[(2,1541,13)])
  N: bits[32] = literal(value=4, id=493, pos=[(2,1537,22)])
  literal.520: bits[1] = literal(value=1, id=520, pos=[(2,1541,8)])
  ret priority_sel.524: bits[5] = priority_sel(concat.523, cases=[concat.507, concat.519], default=concat.522, id=524)
}

fn __std__clzt_pow2_16(value: bits[16] id=525) -> bits[5] {
  literal.526: bits[32] = literal(value=16, id=526, pos=[(2,1604,20)])
  literal.527: bits[1] = literal(value=1, id=527, pos=[(2,1604,30)])
  bit_slice.530: bits[8] = bit_slice(value, start=8, width=8, id=530, pos=[(2,1605,40)])
  bit_slice.532: bits[8] = bit_slice(value, start=0, width=8, id=532, pos=[(2,1605,70)])
  shrl.528: bits[32] = shrl(literal.526, literal.527, id=528, pos=[(2,1604,20)])
  invoke.531: bits[4] = invoke(bit_slice.530, to_apply=__std__clzt_pow2_8, id=531, pos=[(2,1605,34)])
  invoke.533: bits[4] = invoke(bit_slice.532, to_apply=__std__clzt_pow2_8, id=533, pos=[(2,1605,64)])
  N_HALF: bits[32] = zero_ext(shrl.528, new_bit_count=32, id=529)
  ret invoke.534: bits[5] = invoke(invoke.531, invoke.533, to_apply=__std__combine_clzt_halfs__4, id=534, pos=[(2,1605,22)])
}

fn __std__combine_clzt_halfs__5(left: bits[5] id=535, right: bits[5] id=536) -> bits[6] {
  bit_slice.538: bits[1] = bit_slice(left, start=4, width=1, id=538, pos=[(2,1538,15)])
  bit_slice.539: bits[1] = bit_slice(right, start=4, width=1, id=539, pos=[(2,1538,27)])
  tuple.540: (bits[1], bits[1]) = tuple(bit_slice.538, bit_slice.539, id=540, pos=[(2,1538,10)])
  literal.554: bits[1] = literal(value=1, id=554, pos=[(2,1540,9)])
  tuple_index.553: bits[1] = tuple_index(tuple.540, index=0, id=553)
  literal.543: bits[1] = literal(value=1, id=543, pos=[(2,1539,9)])
  tuple_index.542: bits[1] = tuple_index(tuple.540, index=0, id=542)
  literal.552: bits[1] = literal(value=1, id=552)
  eq.555: bits[1] = eq(literal.554, tuple_index.553, id=555)
  literal.558: bits[1] = literal(value=0, id=558, pos=[(2,1540,15)])
  tuple_index.557: bits[1] = tuple_index(tuple.540, index=1, id=557)
  literal.541: bits[1] = literal(value=1, id=541)
  eq.544: bits[1] = eq(literal.543, tuple_index.542, id=544)
  literal.547: bits[1] = literal(value=1, id=547, pos=[(2,1539,15)])
  tuple_index.546: bits[1] = tuple_index(tuple.540, index=1, id=546)
  and.556: bits[1] = and(literal.552, eq.555, id=556)
  eq.559: bits[1] = eq(literal.558, tuple_index.557, id=559)
  and.545: bits[1] = and(literal.541, eq.544, id=545)
  eq.548: bits[1] = eq(literal.547, tuple_index.546, id=548)
  and.560: bits[1] = and(and.556, eq.559, id=560)
  and.549: bits[1] = and(and.545, eq.548, id=549)
  literal.550: bits[1] = literal(value=0, id=550, pos=[(2,1539,32)])
  literal.561: bits[2] = literal(value=1, id=561, pos=[(2,1540,24)])
  bit_slice.562: bits[4] = bit_slice(right, start=0, width=4, id=562, pos=[(2,1540,40)])
  literal.565: bits[1] = literal(value=0, id=565, pos=[(2,1541,13)])
  concat.567: bits[2] = concat(and.560, and.549, id=567)
  concat.551: bits[6] = concat(left, literal.550, id=551, pos=[(2,1539,24)])
  concat.563: bits[6] = concat(literal.561, bit_slice.562, id=563, pos=[(2,1540,24)])
  concat.566: bits[6] = concat(literal.565, left, id=566, pos=[(2,1541,13)])
  N: bits[32] = literal(value=5, id=537, pos=[(2,1537,22)])
  literal.564: bits[1] = literal(value=1, id=564, pos=[(2,1541,8)])
  ret priority_sel.568: bits[6] = priority_sel(concat.567, cases=[concat.551, concat.563], default=concat.566, id=568)
}

fn __std__clzt_pow2_32(value: bits[32] id=569) -> bits[6] {
  literal.570: bits[32] = literal(value=32, id=570, pos=[(2,1609,20)])
  literal.571: bits[1] = literal(value=1, id=571, pos=[(2,1609,30)])
  bit_slice.574: bits[16] = bit_slice(value, start=16, width=16, id=574, pos=[(2,1610,41)])
  bit_slice.576: bits[16] = bit_slice(value, start=0, width=16, id=576, pos=[(2,1610,72)])
  shrl.572: bits[32] = shrl(literal.570, literal.571, id=572, pos=[(2,1609,20)])
  invoke.575: bits[5] = invoke(bit_slice.574, to_apply=__std__clzt_pow2_16, id=575, pos=[(2,1610,35)])
  invoke.577: bits[5] = invoke(bit_slice.576, to_apply=__std__clzt_pow2_16, id=577, pos=[(2,1610,66)])
  N_HALF: bits[32] = zero_ext(shrl.572, new_bit_count=32, id=573)
  ret invoke.578: bits[6] = invoke(invoke.575, invoke.577, to_apply=__std__combine_clzt_halfs__5, id=578, pos=[(2,1610,22)])
}

fn __std__combine_clzt_halfs__6(left: bits[6] id=579, right: bits[6] id=580) -> bits[7] {
  bit_slice.582: bits[1] = bit_slice(left, start=5, width=1, id=582, pos=[(2,1538,15)])
  bit_slice.583: bits[1] = bit_slice(right, start=5, width=1, id=583, pos=[(2,1538,27)])
  tuple.584: (bits[1], bits[1]) = tuple(bit_slice.582, bit_slice.583, id=584, pos=[(2,1538,10)])
  literal.598: bits[1] = literal(value=1, id=598, pos=[(2,1540,9)])
  tuple_index.597: bits[1] = tuple_index(tuple.584, index=0, id=597)
  literal.587: bits[1] = literal(value=1, id=587, pos=[(2,1539,9)])
  tuple_index.586: bits[1] = tuple_index(tuple.584, index=0, id=586)
  literal.596: bits[1] = literal(value=1, id=596)
  eq.599: bits[1] = eq(literal.598, tuple_index.597, id=599)
  literal.602: bits[1] = literal(value=0, id=602, pos=[(2,1540,15)])
  tuple_index.601: bits[1] = tuple_index(tuple.584, index=1, id=601)
  literal.585: bits[1] = literal(value=1, id=585)
  eq.588: bits[1] = eq(literal.587, tuple_index.586, id=588)
  literal.591: bits[1] = literal(value=1, id=591, pos=[(2,1539,15)])
  tuple_index.590: bits[1] = tuple_index(tuple.584, index=1, id=590)
  and.600: bits[1] = and(literal.596, eq.599, id=600)
  eq.603: bits[1] = eq(literal.602, tuple_index.601, id=603)
  and.589: bits[1] = and(literal.585, eq.588, id=589)
  eq.592: bits[1] = eq(literal.591, tuple_index.590, id=592)
  and.604: bits[1] = and(and.600, eq.603, id=604)
  and.593: bits[1] = and(and.589, eq.592, id=593)
  literal.594: bits[1] = literal(value=0, id=594, pos=[(2,1539,32)])
  literal.605: bits[2] = literal(value=1, id=605, pos=[(2,1540,24)])
  bit_slice.606: bits[5] = bit_slice(right, start=0, width=5, id=606, pos=[(2,1540,40)])
  literal.609: bits[1] = literal(value=0, id=609, pos=[(2,1541,13)])
  concat.611: bits[2] = concat(and.604, and.593, id=611)
  concat.595: bits[7] = concat(left, literal.594, id=595, pos=[(2,1539,24)])
  concat.607: bits[7] = concat(literal.605, bit_slice.606, id=607, pos=[(2,1540,24)])
  concat.610: bits[7] = concat(literal.609, left, id=610, pos=[(2,1541,13)])
  N: bits[32] = literal(value=6, id=581, pos=[(2,1537,22)])
  literal.608: bits[1] = literal(value=1, id=608, pos=[(2,1541,8)])
  ret priority_sel.612: bits[7] = priority_sel(concat.611, cases=[concat.595, concat.607], default=concat.610, id=612)
}

fn __std__clzt_pow2_64(value: bits[64] id=613) -> bits[7] {
  literal.614: bits[32] = literal(value=64, id=614, pos=[(2,1614,20)])
  literal.615: bits[1] = literal(value=1, id=615, pos=[(2,1614,30)])
  bit_slice.618: bits[32] = bit_slice(value, start=32, width=32, id=618, pos=[(2,1615,41)])
  bit_slice.620: bits[32] = bit_slice(value, start=0, width=32, id=620, pos=[(2,1615,72)])
  shrl.616: bits[32] = shrl(literal.614, literal.615, id=616, pos=[(2,1614,20)])
  invoke.619: bits[6] = invoke(bit_slice.618, to_apply=__std__clzt_pow2_32, id=619, pos=[(2,1615,35)])
  invoke.621: bits[6] = invoke(bit_slice.620, to_apply=__std__clzt_pow2_32, id=621, pos=[(2,1615,66)])
  N_HALF: bits[32] = zero_ext(shrl.616, new_bit_count=32, id=617)
  ret invoke.622: bits[7] = invoke(invoke.619, invoke.621, to_apply=__std__combine_clzt_halfs__6, id=622, pos=[(2,1615,22)])
}

fn __std__combine_clzt_halfs__7(left: bits[7] id=623, right: bits[7] id=624) -> bits[8] {
  bit_slice.626: bits[1] = bit_slice(left, start=6, width=1, id=626, pos=[(2,1538,15)])
  bit_slice.627: bits[1] = bit_slice(right, start=6, width=1, id=627, pos=[(2,1538,27)])
  tuple.628: (bits[1], bits[1]) = tuple(bit_slice.626, bit_slice.627, id=628, pos=[(2,1538,10)])
  literal.642: bits[1] = literal(value=1, id=642, pos=[(2,1540,9)])
  tuple_index.641: bits[1] = tuple_index(tuple.628, index=0, id=641)
  literal.631: bits[1] = literal(value=1, id=631, pos=[(2,1539,9)])
  tuple_index.630: bits[1] = tuple_index(tuple.628, index=0, id=630)
  literal.640: bits[1] = literal(value=1, id=640)
  eq.643: bits[1] = eq(literal.642, tuple_index.641, id=643)
  literal.646: bits[1] = literal(value=0, id=646, pos=[(2,1540,15)])
  tuple_index.645: bits[1] = tuple_index(tuple.628, index=1, id=645)
  literal.629: bits[1] = literal(value=1, id=629)
  eq.632: bits[1] = eq(literal.631, tuple_index.630, id=632)
  literal.635: bits[1] = literal(value=1, id=635, pos=[(2,1539,15)])
  tuple_index.634: bits[1] = tuple_index(tuple.628, index=1, id=634)
  and.644: bits[1] = and(literal.640, eq.643, id=644)
  eq.647: bits[1] = eq(literal.646, tuple_index.645, id=647)
  and.633: bits[1] = and(literal.629, eq.632, id=633)
  eq.636: bits[1] = eq(literal.635, tuple_index.634, id=636)
  and.648: bits[1] = and(and.644, eq.647, id=648)
  and.637: bits[1] = and(and.633, eq.636, id=637)
  literal.638: bits[1] = literal(value=0, id=638, pos=[(2,1539,32)])
  literal.649: bits[2] = literal(value=1, id=649, pos=[(2,1540,24)])
  bit_slice.650: bits[6] = bit_slice(right, start=0, width=6, id=650, pos=[(2,1540,40)])
  literal.653: bits[1] = literal(value=0, id=653, pos=[(2,1541,13)])
  concat.655: bits[2] = concat(and.648, and.637, id=655)
  concat.639: bits[8] = concat(left, literal.638, id=639, pos=[(2,1539,24)])
  concat.651: bits[8] = concat(literal.649, bit_slice.650, id=651, pos=[(2,1540,24)])
  concat.654: bits[8] = concat(literal.653, left, id=654, pos=[(2,1541,13)])
  N: bits[32] = literal(value=7, id=625, pos=[(2,1537,22)])
  literal.652: bits[1] = literal(value=1, id=652, pos=[(2,1541,8)])
  ret priority_sel.656: bits[8] = priority_sel(concat.655, cases=[concat.639, concat.651], default=concat.654, id=656)
}

fn __std__clzt_pow2_128(value: bits[128] id=657) -> bits[8] {
  literal.658: bits[32] = literal(value=128, id=658, pos=[(2,1619,20)])
  literal.659: bits[1] = literal(value=1, id=659, pos=[(2,1619,31)])
  bit_slice.662: bits[64] = bit_slice(value, start=64, width=64, id=662, pos=[(2,1620,41)])
  bit_slice.664: bits[64] = bit_slice(value, start=0, width=64, id=664, pos=[(2,1620,72)])
  shrl.660: bits[32] = shrl(literal.658, literal.659, id=660, pos=[(2,1619,20)])
  invoke.663: bits[7] = invoke(bit_slice.662, to_apply=__std__clzt_pow2_64, id=663, pos=[(2,1620,35)])
  invoke.665: bits[7] = invoke(bit_slice.664, to_apply=__std__clzt_pow2_64, id=665, pos=[(2,1620,66)])
  N_HALF: bits[32] = zero_ext(shrl.660, new_bit_count=32, id=661)
  ret invoke.666: bits[8] = invoke(invoke.663, invoke.665, to_apply=__std__combine_clzt_halfs__7, id=666, pos=[(2,1620,22)])
}

fn __std__combine_clzt_halfs__8(left: bits[8] id=667, right: bits[8] id=668) -> bits[9] {
  bit_slice.670: bits[1] = bit_slice(left, start=7, width=1, id=670, pos=[(2,1538,15)])
  bit_slice.671: bits[1] = bit_slice(right, start=7, width=1, id=671, pos=[(2,1538,27)])
  tuple.672: (bits[1], bits[1]) = tuple(bit_slice.670, bit_slice.671, id=672, pos=[(2,1538,10)])
  literal.686: bits[1] = literal(value=1, id=686, pos=[(2,1540,9)])
  tuple_index.685: bits[1] = tuple_index(tuple.672, index=0, id=685)
  literal.675: bits[1] = literal(value=1, id=675, pos=[(2,1539,9)])
  tuple_index.674: bits[1] = tuple_index(tuple.672, index=0, id=674)
  literal.684: bits[1] = literal(value=1, id=684)
  eq.687: bits[1] = eq(literal.686, tuple_index.685, id=687)
  literal.690: bits[1] = literal(value=0, id=690, pos=[(2,1540,15)])
  tuple_index.689: bits[1] = tuple_index(tuple.672, index=1, id=689)
  literal.673: bits[1] = literal(value=1, id=673)
  eq.676: bits[1] = eq(literal.675, tuple_index.674, id=676)
  literal.679: bits[1] = literal(value=1, id=679, pos=[(2,1539,15)])
  tuple_index.678: bits[1] = tuple_index(tuple.672, index=1, id=678)
  and.688: bits[1] = and(literal.684, eq.687, id=688)
  eq.691: bits[1] = eq(literal.690, tuple_index.689, id=691)
  and.677: bits[1] = and(literal.673, eq.676, id=677)
  eq.680: bits[1] = eq(literal.679, tuple_index.678, id=680)
  and.692: bits[1] = and(and.688, eq.691, id=692)
  and.681: bits[1] = and(and.677, eq.680, id=681)
  literal.682: bits[1] = literal(value=0, id=682, pos=[(2,1539,32)])
  literal.693: bits[2] = literal(value=1, id=693, pos=[(2,1540,24)])
  bit_slice.694: bits[7] = bit_slice(right, start=0, width=7, id=694, pos=[(2,1540,40)])
  literal.697: bits[1] = literal(value=0, id=697, pos=[(2,1541,13)])
  concat.699: bits[2] = concat(and.692, and.681, id=699)
  concat.683: bits[9] = concat(left, literal.682, id=683, pos=[(2,1539,24)])
  concat.695: bits[9] = concat(literal.693, bit_slice.694, id=695, pos=[(2,1540,24)])
  concat.698: bits[9] = concat(literal.697, left, id=698, pos=[(2,1541,13)])
  N: bits[32] = literal(value=8, id=669, pos=[(2,1537,22)])
  literal.696: bits[1] = literal(value=1, id=696, pos=[(2,1541,8)])
  ret priority_sel.700: bits[9] = priority_sel(concat.699, cases=[concat.683, concat.695], default=concat.698, id=700)
}

fn __std__clzt_pow2_256(value: bits[256] id=701) -> bits[9] {
  literal.702: bits[32] = literal(value=256, id=702, pos=[(2,1624,20)])
  literal.703: bits[1] = literal(value=1, id=703, pos=[(2,1624,31)])
  bit_slice.706: bits[128] = bit_slice(value, start=128, width=128, id=706, pos=[(2,1625,42)])
  bit_slice.708: bits[128] = bit_slice(value, start=0, width=128, id=708, pos=[(2,1625,74)])
  shrl.704: bits[32] = shrl(literal.702, literal.703, id=704, pos=[(2,1624,20)])
  invoke.707: bits[8] = invoke(bit_slice.706, to_apply=__std__clzt_pow2_128, id=707, pos=[(2,1625,36)])
  invoke.709: bits[8] = invoke(bit_slice.708, to_apply=__std__clzt_pow2_128, id=709, pos=[(2,1625,68)])
  N_HALF: bits[32] = zero_ext(shrl.704, new_bit_count=32, id=705)
  ret invoke.710: bits[9] = invoke(invoke.707, invoke.709, to_apply=__std__combine_clzt_halfs__8, id=710, pos=[(2,1625,22)])
}

fn __std__combine_clzt_halfs__9(left: bits[9] id=711, right: bits[9] id=712) -> bits[10] {
  bit_slice.714: bits[1] = bit_slice(left, start=8, width=1, id=714, pos=[(2,1538,15)])
  bit_slice.715: bits[1] = bit_slice(right, start=8, width=1, id=715, pos=[(2,1538,27)])
  tuple.716: (bits[1], bits[1]) = tuple(bit_slice.714, bit_slice.715, id=716, pos=[(2,1538,10)])
  literal.730: bits[1] = literal(value=1, id=730, pos=[(2,1540,9)])
  tuple_index.729: bits[1] = tuple_index(tuple.716, index=0, id=729)
  literal.719: bits[1] = literal(value=1, id=719, pos=[(2,1539,9)])
  tuple_index.718: bits[1] = tuple_index(tuple.716, index=0, id=718)
  literal.728: bits[1] = literal(value=1, id=728)
  eq.731: bits[1] = eq(literal.730, tuple_index.729, id=731)
  literal.734: bits[1] = literal(value=0, id=734, pos=[(2,1540,15)])
  tuple_index.733: bits[1] = tuple_index(tuple.716, index=1, id=733)
  literal.717: bits[1] = literal(value=1, id=717)
  eq.720: bits[1] = eq(literal.719, tuple_index.718, id=720)
  literal.723: bits[1] = literal(value=1, id=723, pos=[(2,1539,15)])
  tuple_index.722: bits[1] = tuple_index(tuple.716, index=1, id=722)
  and.732: bits[1] = and(literal.728, eq.731, id=732)
  eq.735: bits[1] = eq(literal.734, tuple_index.733, id=735)
  and.721: bits[1] = and(literal.717, eq.720, id=721)
  eq.724: bits[1] = eq(literal.723, tuple_index.722, id=724)
  and.736: bits[1] = and(and.732, eq.735, id=736)
  and.725: bits[1] = and(and.721, eq.724, id=725)
  literal.726: bits[1] = literal(value=0, id=726, pos=[(2,1539,32)])
  literal.737: bits[2] = literal(value=1, id=737, pos=[(2,1540,24)])
  bit_slice.738: bits[8] = bit_slice(right, start=0, width=8, id=738, pos=[(2,1540,40)])
  literal.741: bits[1] = literal(value=0, id=741, pos=[(2,1541,13)])
  concat.743: bits[2] = concat(and.736, and.725, id=743)
  concat.727: bits[10] = concat(left, literal.726, id=727, pos=[(2,1539,24)])
  concat.739: bits[10] = concat(literal.737, bit_slice.738, id=739, pos=[(2,1540,24)])
  concat.742: bits[10] = concat(literal.741, left, id=742, pos=[(2,1541,13)])
  N: bits[32] = literal(value=9, id=713, pos=[(2,1537,22)])
  literal.740: bits[1] = literal(value=1, id=740, pos=[(2,1541,8)])
  ret priority_sel.744: bits[10] = priority_sel(concat.743, cases=[concat.727, concat.739], default=concat.742, id=744)
}

fn __std__clzt_pow2_512(value: bits[512] id=745) -> bits[10] {
  literal.746: bits[32] = literal(value=512, id=746, pos=[(2,1629,20)])
  literal.747: bits[1] = literal(value=1, id=747, pos=[(2,1629,31)])
  bit_slice.750: bits[256] = bit_slice(value, start=256, width=256, id=750, pos=[(2,1630,42)])
  bit_slice.752: bits[256] = bit_slice(value, start=0, width=256, id=752, pos=[(2,1630,74)])
  shrl.748: bits[32] = shrl(literal.746, literal.747, id=748, pos=[(2,1629,20)])
  invoke.751: bits[9] = invoke(bit_slice.750, to_apply=__std__clzt_pow2_256, id=751, pos=[(2,1630,36)])
  invoke.753: bits[9] = invoke(bit_slice.752, to_apply=__std__clzt_pow2_256, id=753, pos=[(2,1630,68)])
  N_HALF: bits[32] = zero_ext(shrl.748, new_bit_count=32, id=749)
  ret invoke.754: bits[10] = invoke(invoke.751, invoke.753, to_apply=__std__combine_clzt_halfs__9, id=754, pos=[(2,1630,22)])
}

fn __std__clzt_pow2__32_6(value: bits[32] id=755) -> bits[6] {
  reverse.809: bits[32] = reverse(value, id=809, pos=[(2,1649,16)])
  one_hot.810: bits[33] = one_hot(reverse.809, lsb_prio=true, id=810, pos=[(2,1649,16)])
  literal.803: bits[32] = literal(value=1, id=803, pos=[(2,1648,8)])
  N: bits[32] = literal(value=32, id=756, pos=[(2,1635,17)])
  literal.798: bits[32] = literal(value=2, id=798, pos=[(2,1647,8)])
  literal.793: bits[32] = literal(value=4, id=793, pos=[(2,1646,8)])
  literal.788: bits[32] = literal(value=8, id=788, pos=[(2,1645,8)])
  literal.783: bits[32] = literal(value=16, id=783, pos=[(2,1644,8)])
  literal.778: bits[32] = literal(value=32, id=778, pos=[(2,1643,8)])
  literal.773: bits[32] = literal(value=64, id=773, pos=[(2,1642,8)])
  literal.768: bits[32] = literal(value=128, id=768, pos=[(2,1641,8)])
  literal.763: bits[32] = literal(value=256, id=763, pos=[(2,1640,8)])
  literal.758: bits[32] = literal(value=512, id=758, pos=[(2,1639,8)])
  zero_ext.760: bits[512] = zero_ext(value, new_bit_count=512, id=760)
  zero_ext.765: bits[256] = zero_ext(value, new_bit_count=256, id=765)
  zero_ext.770: bits[128] = zero_ext(value, new_bit_count=128, id=770)
  zero_ext.775: bits[64] = zero_ext(value, new_bit_count=64, id=775)
  zero_ext.780: bits[32] = zero_ext(value, new_bit_count=32, id=780)
  bit_slice.785: bits[16] = bit_slice(value, start=0, width=16, id=785)
  bit_slice.790: bits[8] = bit_slice(value, start=0, width=8, id=790)
  bit_slice.795: bits[4] = bit_slice(value, start=0, width=4, id=795)
  bit_slice.800: bits[2] = bit_slice(value, start=0, width=2, id=800)
  bit_slice.805: bits[1] = bit_slice(value, start=0, width=1, id=805)
  encode.811: bits[6] = encode(one_hot.810, id=811, pos=[(2,1649,16)])
  eq.804: bits[1] = eq(literal.803, N, id=804)
  eq.799: bits[1] = eq(literal.798, N, id=799)
  eq.794: bits[1] = eq(literal.793, N, id=794)
  eq.789: bits[1] = eq(literal.788, N, id=789)
  eq.784: bits[1] = eq(literal.783, N, id=784)
  eq.779: bits[1] = eq(literal.778, N, id=779)
  eq.774: bits[1] = eq(literal.773, N, id=774)
  eq.769: bits[1] = eq(literal.768, N, id=769)
  eq.764: bits[1] = eq(literal.763, N, id=764)
  eq.759: bits[1] = eq(literal.758, N, id=759)
  invoke.761: bits[10] = invoke(zero_ext.760, to_apply=__std__clzt_pow2_512, id=761, pos=[(2,1639,32)])
  invoke.766: bits[9] = invoke(zero_ext.765, to_apply=__std__clzt_pow2_256, id=766, pos=[(2,1640,32)])
  invoke.771: bits[8] = invoke(zero_ext.770, to_apply=__std__clzt_pow2_128, id=771, pos=[(2,1641,32)])
  invoke.776: bits[7] = invoke(zero_ext.775, to_apply=__std__clzt_pow2_64, id=776, pos=[(2,1642,30)])
  invoke.781: bits[6] = invoke(zero_ext.780, to_apply=__std__clzt_pow2_32, id=781, pos=[(2,1643,30)])
  invoke.786: bits[5] = invoke(bit_slice.785, to_apply=__std__clzt_pow2_16, id=786, pos=[(2,1644,30)])
  invoke.791: bits[4] = invoke(bit_slice.790, to_apply=__std__clzt_pow2_8, id=791, pos=[(2,1645,28)])
  invoke.796: bits[3] = invoke(bit_slice.795, to_apply=__std__clzt_pow2_4, id=796, pos=[(2,1646,28)])
  invoke.801: bits[2] = invoke(bit_slice.800, to_apply=__std__clzt_pow2_2, id=801, pos=[(2,1647,28)])
  invoke.806: bits[1] = invoke(bit_slice.805, to_apply=__std__clzt_pow2_1, id=806, pos=[(2,1648,28)])
  zero_ext.812: bits[32] = zero_ext(encode.811, new_bit_count=32, id=812, pos=[(2,1649,16)])
  concat.814: bits[10] = concat(eq.804, eq.799, eq.794, eq.789, eq.784, eq.779, eq.774, eq.769, eq.764, eq.759, id=814)
  bit_slice.762: bits[6] = bit_slice(invoke.761, start=0, width=6, id=762)
  bit_slice.767: bits[6] = bit_slice(invoke.766, start=0, width=6, id=767)
  bit_slice.772: bits[6] = bit_slice(invoke.771, start=0, width=6, id=772)
  bit_slice.777: bits[6] = bit_slice(invoke.776, start=0, width=6, id=777)
  zero_ext.782: bits[6] = zero_ext(invoke.781, new_bit_count=6, id=782)
  zero_ext.787: bits[6] = zero_ext(invoke.786, new_bit_count=6, id=787)
  zero_ext.792: bits[6] = zero_ext(invoke.791, new_bit_count=6, id=792)
  zero_ext.797: bits[6] = zero_ext(invoke.796, new_bit_count=6, id=797)
  zero_ext.802: bits[6] = zero_ext(invoke.801, new_bit_count=6, id=802)
  zero_ext.807: bits[6] = zero_ext(invoke.806, new_bit_count=6, id=807)
  bit_slice.813: bits[6] = bit_slice(zero_ext.812, start=0, width=6, id=813)
  RESULT_BITS: bits[32] = literal(value=6, id=757, pos=[(2,1635,25)])
  literal.808: bits[1] = literal(value=1, id=808, pos=[(2,1649,8)])
  ret priority_sel.815: bits[6] = priority_sel(concat.814, cases=[bit_slice.762, bit_slice.767, bit_slice.772, bit_slice.777, zero_ext.782, zero_ext.787, zero_ext.792, zero_ext.797, zero_ext.802, zero_ext.807], default=bit_slice.813, id=815)
}

fn __std__clzt__28_5(value: bits[28] id=816) -> bits[5] {
  invoke.821: bits[4] = invoke(to_apply=__std__mask_bits__4, id=821, pos=[(2,1707,32)])
  N: bits[32] = literal(value=28, id=817, pos=[(2,1704,12)])
  concat.822: bits[32] = concat(value, invoke.821, id=822, pos=[(2,1707,14)])
  invoke.819: bits[32] = invoke(N, to_apply=__std__next_pow2, id=819, pos=[(2,1705,50)])
  invoke.823: bits[6] = invoke(concat.822, to_apply=__std__clzt_pow2__32_6, id=823, pos=[(2,1707,13)])
  RESULT_BITS: bits[32] = literal(value=5, id=818, pos=[(2,1704,20)])
  BITS_MISSING_UNTIL_POWER_TWO: bits[32] = sub(invoke.819, N, id=820, pos=[(2,1705,50)])
  ret bit_slice.824: bits[5] = bit_slice(invoke.823, start=0, width=5, id=824)
}

fn __apfloat__add__8_23(a: (bits[1], bits[8], bits[23]) id=825, b: (bits[1], bits[8], bits[23]) id=826) -> (bits[1], bits[8], bits[23]) {
  a_bexp: bits[8] = tuple_index(a, index=1, id=843, pos=[(0,3087,59)])
  b_bexp: bits[8] = tuple_index(b, index=1, id=844, pos=[(0,3087,67)])
  invoke.845: (bits[1], bits[8]) = invoke(a_bexp, b_bexp, to_apply=__apfloat__sign_magnitude_difference__8, id=845, pos=[(0,3087,57)])
  a_is_smaller: bits[1] = tuple_index(invoke.845, index=0, id=846, pos=[(0,3087,9)])
  tuple.849: ((bits[1], bits[8], bits[23]), (bits[1], bits[8], bits[23])) = tuple(a, b, id=849, pos=[(0,3088,51)])
  tuple.848: ((bits[1], bits[8], bits[23]), (bits[1], bits[8], bits[23])) = tuple(b, a, id=848, pos=[(0,3088,35)])
  sel.850: ((bits[1], bits[8], bits[23]), (bits[1], bits[8], bits[23])) = sel(a_is_smaller, cases=[tuple.849, tuple.848], id=850, pos=[(0,3088,17)])
  x: (bits[1], bits[8], bits[23]) = tuple_index(sel.850, index=0, id=851, pos=[(0,3088,9)])
  y: (bits[1], bits[8], bits[23]) = tuple_index(sel.850, index=1, id=852, pos=[(0,3088,12)])
  literal.853: bits[1] = literal(value=1, id=853, pos=[(0,3091,22)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=854, pos=[(0,3091,31)])
  literal.857: bits[1] = literal(value=1, id=857, pos=[(0,3092,22)])
  y_fraction: bits[23] = tuple_index(y, index=2, id=858, pos=[(0,3092,31)])
  x_bexp: bits[8] = tuple_index(x, index=1, id=861, pos=[(0,3095,25)])
  literal.862: bits[8] = literal(value=0, id=862, pos=[(0,3095,34)])
  concat.855: bits[24] = concat(literal.853, x_fraction, id=855, pos=[(0,3091,22)])
  y_bexp: bits[8] = tuple_index(y, index=1, id=866, pos=[(0,3096,25)])
  literal.867: bits[8] = literal(value=0, id=867, pos=[(0,3096,34)])
  concat.859: bits[24] = concat(literal.857, y_fraction, id=859, pos=[(0,3092,22)])
  eq.863: bits[1] = eq(x_bexp, literal.862, id=863, pos=[(0,3095,25)])
  fraction_x: bits[24] = zero_ext(concat.855, new_bit_count=24, id=856)
  literal.864: bits[24] = literal(value=0, id=864, pos=[(0,3095,49)])
  eq.868: bits[1] = eq(y_bexp, literal.867, id=868, pos=[(0,3096,25)])
  fraction_y: bits[24] = zero_ext(concat.859, new_bit_count=24, id=860)
  literal.869: bits[24] = literal(value=0, id=869, pos=[(0,3096,49)])
  fraction_x__1: bits[24] = sel(eq.863, cases=[fraction_x, literal.864], id=865, pos=[(0,3095,21)])
  fraction_y__1: bits[24] = sel(eq.868, cases=[fraction_y, literal.869], id=870, pos=[(0,3096,21)])
  zero_ext.871: bits[28] = zero_ext(fraction_x__1, new_bit_count=28, id=871)
  GUARD_ROUND_STICKY_BITS: bits[32] = literal(value=3, id=835, pos=[(0,3075,36)])
  zero_ext.873: bits[28] = zero_ext(fraction_y__1, new_bit_count=28, id=873)
  wide_x: bits[28] = shll(zero_ext.871, GUARD_ROUND_STICKY_BITS, id=872, pos=[(0,3099,17)])
  wide_y: bits[28] = shll(zero_ext.873, GUARD_ROUND_STICKY_BITS, id=874, pos=[(0,3100,17)])
  shift: bits[8] = tuple_index(invoke.845, index=1, id=847, pos=[(0,3087,23)])
  x_sign: bits[1] = tuple_index(x, index=0, id=876, pos=[(0,3106,23)])
  y_sign: bits[1] = tuple_index(y, index=0, id=877, pos=[(0,3106,33)])
  addend_x: bits[28] = zero_ext(wide_x, new_bit_count=28, id=875)
  shrl.882: bits[28] = shrl(wide_y, shift, id=882, pos=[(0,3112,31)])
  sticky: bits[1] = invoke(wide_y, shift, to_apply=__std__or_reduce_lsb__8_28, id=881, pos=[(0,3111,35)])
  ne.878: bits[1] = ne(x_sign, y_sign, id=878, pos=[(0,3106,23)])
  neg.879: bits[28] = neg(addend_x, id=879, pos=[(0,3106,41)])
  invoke.883: bits[28] = invoke(shrl.882, sticky, to_apply=__apfloat__or_last_bit__28, id=883, pos=[(0,3112,30)])
  addend_x__1: bits[28] = sel(ne.878, cases=[addend_x, neg.879], id=880, pos=[(0,3106,19)])
  addend_y: bits[28] = zero_ext(invoke.883, new_bit_count=28, id=884)
  sign_ext.885: bits[29] = sign_ext(addend_x__1, new_bit_count=29, id=885)
  sign_ext.886: bits[29] = sign_ext(addend_y, new_bit_count=29, id=886)
  fraction: bits[29] = add(sign_ext.885, sign_ext.886, id=887, pos=[(0,3116,20)])
  literal.919: bits[29] = literal(value=0, id=919, pos=[(0,3126,23)])
  slt.920: bits[1] = slt(fraction, literal.919, id=920, pos=[(0,3126,12)])
  neg.921: bits[29] = neg(fraction, id=921, pos=[(0,3126,46)])
  sel.922: bits[29] = sel(slt.920, cases=[fraction, neg.921], id=922, pos=[(0,3126,9)])
  abs_fraction: bits[28] = bit_slice(sel.922, start=0, width=28, id=923)
  zero_ext.931: bits[29] = zero_ext(abs_fraction, new_bit_count=29, id=931)
  leading_zeroes: bits[5] = invoke(abs_fraction, to_apply=__std__clzt__28_5, id=930, pos=[(0,3137,34)])
  literal.925: bits[32] = literal(value=1, id=925, pos=[(0,3132,42)])
  cancel_fraction: bits[29] = shll(zero_ext.931, leading_zeroes, id=932, pos=[(0,3140,26)])
  literal.933: bits[32] = literal(value=1, id=933, pos=[(0,3141,46)])
  shrl.926: bits[28] = shrl(abs_fraction, literal.925, id=926, pos=[(0,3132,26)])
  shrl.934: bits[29] = shrl(cancel_fraction, literal.933, id=934, pos=[(0,3141,27)])
  carry_fraction: bits[27] = bit_slice(shrl.926, start=0, width=27, id=927)
  bit_slice.928: bits[1] = bit_slice(abs_fraction, start=0, width=1, id=928, pos=[(0,3133,65)])
  carry_bit: bits[1] = bit_slice(abs_fraction, start=27, width=1, id=924, pos=[(0,3131,32)])
  cancel_fraction__1: bits[27] = bit_slice(shrl.934, start=0, width=27, id=935)
  carry_fraction__1: bits[27] = invoke(carry_fraction, bit_slice.928, to_apply=__apfloat__or_last_bit__27, id=929, pos=[(0,3133,36)])
  shifted_fraction: bits[27] = sel(carry_bit, cases=[cancel_fraction__1, carry_fraction__1], id=936, pos=[(0,3142,27)])
  normal_chunk: bits[3] = bit_slice(shifted_fraction, start=0, width=3, id=937, pos=[(0,3154,39)])
  literal.939: bits[3] = literal(value=4, id=939, pos=[(0,3156,38)])
  half_way_chunk: bits[2] = bit_slice(shifted_fraction, start=2, width=2, id=938, pos=[(0,3155,41)])
  literal.941: bits[2] = literal(value=3, id=941, pos=[(0,3156,68)])
  ugt.940: bits[1] = ugt(normal_chunk, literal.939, id=940, pos=[(0,3156,23)])
  eq.942: bits[1] = eq(half_way_chunk, literal.941, id=942, pos=[(0,3156,50)])
  zero_ext.944: bits[28] = zero_ext(shifted_fraction, new_bit_count=28, id=944)
  literal.945: bits[28] = literal(value=8, id=945, pos=[(0,3160,50)])
  do_round_up: bits[1] = or(ugt.940, eq.942, id=943, pos=[(0,3156,23)])
  zero_ext.947: bits[28] = zero_ext(shifted_fraction, new_bit_count=28, id=947)
  add.946: bits[28] = add(zero_ext.944, literal.945, id=946, pos=[(0,3160,9)])
  rounded_fraction: bits[28] = sel(do_round_up, cases=[zero_ext.947, add.946], id=948, pos=[(0,3159,27)])
  x_bexp__1: bits[8] = tuple_index(x, index=1, id=958, pos=[(0,3175,26)])
  rounding_carry: bits[1] = bit_slice(rounded_fraction, start=27, width=1, id=949, pos=[(0,3164,41)])
  zero_ext.959: bits[10] = zero_ext(x_bexp__1, new_bit_count=10, id=959)
  zero_ext.960: bits[10] = zero_ext(rounding_carry, new_bit_count=10, id=960)
  add.961: bits[10] = add(zero_ext.959, zero_ext.960, id=961, pos=[(0,3175,26)])
  literal.962: bits[10] = literal(value=1, id=962, pos=[(0,3176,24)])
  literal.888: bits[29] = literal(value=0, id=888, pos=[(0,3117,39)])
  literal.890: bits[29] = literal(value=0, id=890, pos=[(0,3118,58)])
  add.963: bits[10] = add(add.961, literal.962, id=963, pos=[(0,3175,26)])
  zero_ext.964: bits[10] = zero_ext(leading_zeroes, new_bit_count=10, id=964)
  fraction_is_zero: bits[1] = eq(fraction, literal.888, id=889, pos=[(0,3117,27)])
  slt.891: bits[1] = slt(fraction, literal.890, id=891, pos=[(0,3118,47)])
  wide_exponent: bits[10] = sub(add.963, zero_ext.964, id=965, pos=[(0,3175,26)])
  literal.966: bits[10] = literal(value=0, id=966, pos=[(0,3177,46)])
  bit_slice.951: bits[1] = bit_slice(rounded_fraction, start=27, width=1, id=951, pos=[(0,3170,60)])
  literal.953: bits[3] = literal(value=0, id=953, pos=[(0,3170,82)])
  literal.952: bits[3] = literal(value=1, id=952, pos=[(0,3170,68)])
  tuple.892: (bits[1], bits[1]) = tuple(fraction_is_zero, slt.891, id=892, pos=[(0,3118,28)])
  wide_exponent__1: bits[10] = sel(fraction_is_zero, cases=[wide_exponent, literal.966], id=967, pos=[(0,3177,24)])
  literal.968: bits[10] = literal(value=0, id=968, pos=[(0,3180,43)])
  bit_slice.950: bits[3] = bit_slice(GUARD_ROUND_STICKY_BITS, start=0, width=3, id=950)
  sel.954: bits[3] = sel(bit_slice.951, cases=[literal.953, literal.952], id=954, pos=[(0,3170,41)])
  literal.906: bits[1] = literal(value=0, id=906, pos=[(0,3120,9)])
  tuple_index.905: bits[1] = tuple_index(tuple.892, index=0, id=905)
  literal.895: bits[1] = literal(value=1, id=895, pos=[(0,3119,9)])
  tuple_index.894: bits[1] = tuple_index(tuple.892, index=0, id=894)
  x_sign__2: bits[1] = tuple_index(x, index=0, id=992, pos=[(0,3205,59)])
  literal.993: bits[1] = literal(value=0, id=993, pos=[(0,3205,68)])
  y_sign__4: bits[1] = tuple_index(y, index=0, id=997, pos=[(0,3206,59)])
  literal.998: bits[1] = literal(value=0, id=998, pos=[(0,3206,68)])
  x_sign__3: bits[1] = tuple_index(x, index=0, id=1005, pos=[(0,3211,59)])
  literal.1006: bits[1] = literal(value=1, id=1006, pos=[(0,3211,68)])
  y_sign__5: bits[1] = tuple_index(y, index=0, id=1010, pos=[(0,3212,59)])
  literal.1011: bits[1] = literal(value=1, id=1011, pos=[(0,3212,68)])
  slt.969: bits[1] = slt(wide_exponent__1, literal.968, id=969, pos=[(0,3180,27)])
  bit_slice.971: bits[9] = bit_slice(wide_exponent__1, start=0, width=9, id=971)
  literal.970: bits[9] = literal(value=0, id=970, pos=[(0,3181,8)])
  fraction_shift: bits[3] = add(bit_slice.950, sel.954, id=955, pos=[(0,3170,8)])
  literal.904: bits[1] = literal(value=1, id=904)
  eq.907: bits[1] = eq(literal.906, tuple_index.905, id=907)
  literal.910: bits[1] = literal(value=1, id=910, pos=[(0,3120,16)])
  tuple_index.909: bits[1] = tuple_index(tuple.892, index=1, id=909)
  literal.893: bits[1] = literal(value=1, id=893)
  eq.896: bits[1] = eq(literal.895, tuple_index.894, id=896)
  invoke.991: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=991, pos=[(0,3205,29)])
  eq.994: bits[1] = eq(x_sign__2, literal.993, id=994, pos=[(0,3205,59)])
  invoke.996: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=996, pos=[(0,3206,29)])
  eq.999: bits[1] = eq(y_sign__4, literal.998, id=999, pos=[(0,3206,59)])
  invoke.1004: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=1004, pos=[(0,3211,29)])
  eq.1007: bits[1] = eq(x_sign__3, literal.1006, id=1007, pos=[(0,3211,59)])
  invoke.1009: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=1009, pos=[(0,3212,29)])
  eq.1012: bits[1] = eq(y_sign__5, literal.1011, id=1012, pos=[(0,3212,59)])
  MAX_EXPONENT: bits[8] = invoke(to_apply=__std__mask_bits__8, id=977, pos=[(0,3193,39)])
  wide_exponent__2: bits[9] = sel(slt.969, cases=[bit_slice.971, literal.970], id=972, pos=[(0,3180,24)])
  literal.973: bits[9] = literal(value=1, id=973, pos=[(0,3190,27)])
  shrl.956: bits[28] = shrl(rounded_fraction, fraction_shift, id=956, pos=[(0,3171,27)])
  and.908: bits[1] = and(literal.904, eq.907, id=908)
  eq.911: bits[1] = eq(literal.910, tuple_index.909, id=911)
  and.897: bits[1] = and(literal.893, eq.896, id=897)
  literal.899: bits[1] = literal(value=1, id=899, pos=[(0,3119,15)])
  and.995: bits[1] = and(invoke.991, eq.994, id=995, pos=[(0,3205,29)])
  and.1000: bits[1] = and(invoke.996, eq.999, id=1000, pos=[(0,3206,29)])
  and.1008: bits[1] = and(invoke.1004, eq.1007, id=1008, pos=[(0,3211,29)])
  and.1013: bits[1] = and(invoke.1009, eq.1012, id=1013, pos=[(0,3212,29)])
  SATURATED_EXPONENT: bits[9] = zero_ext(MAX_EXPONENT, new_bit_count=9, id=978)
  ult.974: bits[1] = ult(wide_exponent__2, literal.973, id=974, pos=[(0,3190,11)])
  result_fraction: bits[23] = bit_slice(shrl.956, start=0, width=23, id=957)
  literal.975: bits[23] = literal(value=0, id=975, pos=[(0,3190,44)])
  and.912: bits[1] = and(and.908, eq.911, id=912)
  and.900: bits[1] = and(and.897, literal.899, id=900)
  x_sign__1: bits[1] = tuple_index(x, index=0, id=901, pos=[(0,3119,22)])
  y_sign__1: bits[1] = tuple_index(y, index=0, id=902, pos=[(0,3119,32)])
  y_sign__2: bits[1] = tuple_index(y, index=0, id=913, pos=[(0,3120,27)])
  invoke.1015: bits[1] = invoke(x, to_apply=__apfloat__is_nan__8_23, id=1015, pos=[(0,3213,30)])
  invoke.1016: bits[1] = invoke(y, to_apply=__apfloat__is_nan__8_23, id=1016, pos=[(0,3213,64)])
  has_pos_inf: bits[1] = or(and.995, and.1000, id=1001, pos=[(0,3205,29)])
  has_neg_inf: bits[1] = or(and.1008, and.1013, id=1014, pos=[(0,3211,29)])
  invoke.985: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=985, pos=[(0,3201,31)])
  invoke.986: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=986, pos=[(0,3201,65)])
  ult.979: bits[1] = ult(wide_exponent__2, SATURATED_EXPONENT, id=979, pos=[(0,3196,11)])
  literal.980: bits[23] = literal(value=0, id=980, pos=[(0,3196,73)])
  result_fraction__1: bits[23] = sel(ult.974, cases=[result_fraction, literal.975], id=976, pos=[(0,3190,8)])
  FRACTION_SZ: bits[32] = literal(value=23, id=828, pos=[(0,3063,24)])
  literal.1021: bits[32] = literal(value=1, id=1021, pos=[(0,3215,66)])
  HIDDEN_BIT: bits[32] = literal(value=1, id=834, pos=[(0,3074,23)])
  concat.917: bits[2] = concat(and.912, and.900, id=917)
  and.903: bits[1] = and(x_sign__1, y_sign__1, id=903, pos=[(0,3119,22)])
  not.914: bits[1] = not(y_sign__2, id=914, pos=[(0,3120,25)])
  y_sign__3: bits[1] = tuple_index(y, index=0, id=916, pos=[(0,3121,14)])
  ult.982: bits[1] = ult(wide_exponent__2, SATURATED_EXPONENT, id=982, pos=[(0,3198,11)])
  bit_slice.983: bits[8] = bit_slice(wide_exponent__2, start=0, width=8, id=983)
  or.1017: bits[1] = or(invoke.1015, invoke.1016, id=1017, pos=[(0,3213,30)])
  and.1018: bits[1] = and(has_pos_inf, has_neg_inf, id=1018, pos=[(0,3214,25)])
  is_operand_inf: bits[1] = or(invoke.985, invoke.986, id=987, pos=[(0,3201,31)])
  result_fraction__2: bits[23] = sel(ult.979, cases=[literal.980, result_fraction__1], id=981, pos=[(0,3196,8)])
  literal.989: bits[23] = literal(value=0, id=989, pos=[(0,3203,46)])
  literal.1020: bits[23] = literal(value=1, id=1020, pos=[(0,3215,30)])
  sub.1022: bits[32] = sub(FRACTION_SZ, literal.1021, id=1022, pos=[(0,3215,52)])
  SIGN_BIT: bits[32] = literal(value=1, id=833, pos=[(0,3073,21)])
  FRACTION: bits[32] = add(HIDDEN_BIT, FRACTION_SZ, id=836, pos=[(0,3076,21)])
  result_sign: bits[1] = priority_sel(concat.917, cases=[and.903, not.914], default=y_sign__3, id=918)
  not.1002: bits[1] = not(has_pos_inf, id=1002, pos=[(0,3207,42)])
  result_exponent: bits[8] = sel(ult.982, cases=[MAX_EXPONENT, bit_slice.983], id=984, pos=[(0,3198,8)])
  is_result_nan: bits[1] = or(or.1017, and.1018, id=1019, pos=[(0,3213,30)])
  result_fraction__3: bits[23] = sel(is_operand_inf, cases=[result_fraction__2, literal.989], id=990, pos=[(0,3203,26)])
  FRACTION_HIGH_BIT: bits[23] = shll(literal.1020, sub.1022, id=1023, pos=[(0,3215,30)])
  EXP_SZ: bits[32] = literal(value=8, id=827, pos=[(0,3063,11)])
  literal.829: bits[32] = literal(value=1, id=829, pos=[(0,3067,35)])
  SIGNED_FRACTION: bits[32] = add(SIGN_BIT, FRACTION, id=837, pos=[(0,3077,28)])
  result_sign__1: bits[1] = sel(is_operand_inf, cases=[result_sign, not.1002], id=1003, pos=[(0,3207,22)])
  literal.1026: bits[1] = literal(value=0, id=1026, pos=[(0,3218,41)])
  result_exponent__1: bits[8] = sel(is_operand_inf, cases=[result_exponent, MAX_EXPONENT], id=988, pos=[(0,3202,26)])
  result_fraction__4: bits[23] = sel(is_result_nan, cases=[result_fraction__3, FRACTION_HIGH_BIT], id=1025, pos=[(0,3217,26)])
  literal.831: bits[32] = literal(value=1, id=831, pos=[(0,3069,27)])
  WIDE_EXP: bits[32] = add(EXP_SZ, literal.829, id=830, pos=[(0,3067,26)])
  literal.839: bits[32] = literal(value=1, id=839, pos=[(0,3080,32)])
  WIDE_FRACTION: bits[32] = add(SIGNED_FRACTION, GUARD_ROUND_STICKY_BITS, id=838, pos=[(0,3078,31)])
  literal.841: bits[32] = literal(value=1, id=841, pos=[(0,3084,53)])
  result_sign__2: bits[1] = sel(is_result_nan, cases=[result_sign__1, literal.1026], id=1027, pos=[(0,3218,22)])
  result_exponent__2: bits[8] = sel(is_result_nan, cases=[result_exponent__1, MAX_EXPONENT], id=1024, pos=[(0,3216,26)])
  zero_ext.1028: bits[23] = zero_ext(result_fraction__4, new_bit_count=23, id=1028)
  CARRY_EXP: bits[32] = add(literal.831, WIDE_EXP, id=832, pos=[(0,3069,27)])
  CARRY_FRACTION: bits[32] = add(literal.839, WIDE_FRACTION, id=840, pos=[(0,3080,32)])
  NORMALIZED_FRACTION: bits[32] = sub(WIDE_FRACTION, literal.841, id=842, pos=[(0,3084,37)])
  tuple_index.898: bits[1] = tuple_index(tuple.892, index=1, id=898)
  literal.915: bits[1] = literal(value=1, id=915, pos=[(0,3121,8)])
  ret tuple.1029: (bits[1], bits[8], bits[23]) = tuple(result_sign__2, result_exponent__2, zero_ext.1028, id=1029, pos=[(0,3221,33)])
}

fn __float32__add(x: (bits[1], bits[8], bits[23]) id=1030, y: (bits[1], bits[8], bits[23]) id=1031) -> (bits[1], bits[8], bits[23]) {
  ret invoke.1032: (bits[1], bits[8], bits[23]) = invoke(x, y, to_apply=__apfloat__add__8_23, id=1032, pos=[(1,363,48)])
}

fn ____float32__fast_rsqrt_config_refinements__1_counted_for_0_body(idx: bits[32] id=1093, approx: (bits[1], bits[8], bits[23]) id=1096, ONE_POINT_FIVE: (bits[1], bits[8], bits[23]) id=1097, half_x: (bits[1], bits[8], bits[23]) id=1098) -> (bits[1], bits[8], bits[23]) {
  prod: (bits[1], bits[8], bits[23]) = invoke(half_x, approx, to_apply=__float32__mul, id=1099, pos=[(1,403,22)])
  prod__1: (bits[1], bits[8], bits[23]) = invoke(prod, approx, to_apply=__float32__mul, id=1100, pos=[(1,404,22)])
  prod__1_sign: bits[1] = tuple_index(prod__1, index=0, id=1101, pos=[(1,405,37)])
  not.1102: bits[1] = not(prod__1_sign, id=1102, pos=[(1,405,32)])
  prod__1_bexp: bits[8] = tuple_index(prod__1, index=1, id=1103, pos=[(1,405,54)])
  prod__1_fraction: bits[23] = tuple_index(prod__1, index=2, id=1104, pos=[(1,405,75)])
  nprod: (bits[1], bits[8], bits[23]) = tuple(not.1102, prod__1_bexp, prod__1_fraction, id=1105, pos=[(1,405,24)])
  literal.1094: bits[32] = literal(value=0, id=1094)
  diff: (bits[1], bits[8], bits[23]) = invoke(ONE_POINT_FIVE, nprod, to_apply=__float32__add, id=1106, pos=[(1,406,22)])
  add.1095: bits[32] = add(idx, literal.1094, id=1095)
  ret invoke.1107: (bits[1], bits[8], bits[23]) = invoke(approx, diff, to_apply=__float32__mul, id=1107, pos=[(1,407,11)])
}

fn __float32__is_inf(f: (bits[1], bits[8], bits[23]) id=1033) -> bits[1] {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1034, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1035, pos=[(1,19,28)])
  ret invoke.1036: bits[1] = invoke(f, to_apply=__apfloat__is_inf__8_23, id=1036, pos=[(1,33,47)])
}

fn __float32__zero(sign: bits[1] id=1037) -> (bits[1], bits[8], bits[23]) {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1038, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1039, pos=[(1,19,28)])
  ret invoke.1040: (bits[1], bits[8], bits[23]) = invoke(sign, to_apply=__apfloat__zero__8_23, id=1040, pos=[(1,39,44)])
}

fn __apfloat__qnan__8_23() -> (bits[1], bits[8], bits[23]) {
  FRACTION_SZ: bits[32] = literal(value=23, id=1042, pos=[(0,50,25)])
  literal.1047: bits[32] = literal(value=1, id=1047, pos=[(0,54,57)])
  sub.1048: bits[32] = sub(FRACTION_SZ, literal.1047, id=1048, pos=[(0,54,43)])
  invoke.1044: bits[8] = invoke(to_apply=__std__mask_bits__8, id=1044, pos=[(0,53,28)])
  literal.1046: bits[23] = literal(value=1, id=1046, pos=[(0,54,18)])
  bit_slice.1049: bits[23] = bit_slice(sub.1048, start=0, width=23, id=1049)
  literal.1043: bits[1] = literal(value=0, id=1043, pos=[(0,52,14)])
  zero_ext.1045: bits[8] = zero_ext(invoke.1044, new_bit_count=8, id=1045)
  shll.1050: bits[23] = shll(literal.1046, bit_slice.1049, id=1050, pos=[(0,54,18)])
  EXP_SZ: bits[32] = literal(value=8, id=1041, pos=[(0,50,12)])
  ret tuple.1051: (bits[1], bits[8], bits[23]) = tuple(literal.1043, zero_ext.1045, shll.1050, id=1051, pos=[(0,51,33)])
}

fn __float32__qnan() -> (bits[1], bits[8], bits[23]) {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1052, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1053, pos=[(1,19,28)])
  ret invoke.1054: (bits[1], bits[8], bits[23]) = invoke(to_apply=__apfloat__qnan__8_23, id=1054, pos=[(1,27,36)])
}

fn __float32__is_nan(f: (bits[1], bits[8], bits[23]) id=1055) -> bits[1] {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1056, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1057, pos=[(1,19,28)])
  ret invoke.1058: bits[1] = invoke(f, to_apply=__apfloat__is_nan__8_23, id=1058, pos=[(1,29,47)])
}

fn __float32__is_zero_or_subnormal(f: (bits[1], bits[8], bits[23]) id=1059) -> bits[1] {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1060, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1061, pos=[(1,19,28)])
  ret invoke.1062: bits[1] = invoke(f, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=1062, pos=[(1,82,33)])
}

fn __apfloat__inf__8_23(sign: bits[1] id=1063) -> (bits[1], bits[8], bits[23]) {
  invoke.1066: bits[8] = invoke(to_apply=__std__mask_bits__8, id=1066, pos=[(0,78,28)])
  literal.1067: bits[23] = literal(value=0, id=1067, pos=[(0,79,18)])
  EXP_SZ: bits[32] = literal(value=8, id=1064, pos=[(0,75,11)])
  FRACTION_SZ: bits[32] = literal(value=23, id=1065, pos=[(0,75,24)])
  ret tuple.1068: (bits[1], bits[8], bits[23]) = tuple(sign, invoke.1066, literal.1067, id=1068, pos=[(0,76,33)])
}

fn __float32__inf(sign: bits[1] id=1069) -> (bits[1], bits[8], bits[23]) {
  F32_EXP_SZ: bits[32] = literal(value=8, id=1070, pos=[(1,18,23)])
  F32_FRACTION_SZ: bits[32] = literal(value=23, id=1071, pos=[(1,19,28)])
  ret invoke.1072: (bits[1], bits[8], bits[23]) = invoke(sign, to_apply=__apfloat__inf__8_23, id=1072, pos=[(1,31,42)])
}

fn __float32__fast_rsqrt_config_refinements__1(x: (bits[1], bits[8], bits[23]) id=1073) -> (bits[1], bits[8], bits[23]) {
  x__1: (bits[1], bits[8], bits[23]) = invoke(x, to_apply=__float32__subnormals_to_zero, id=1086, pos=[(1,396,30)])
  invoke.1087: bits[32] = invoke(x__1, to_apply=__float32__flatten, id=1087, pos=[(1,398,50)])
  literal.1088: bits[32] = literal(value=1, id=1088, pos=[(1,398,57)])
  MAGIC_NUMBER: bits[32] = literal(value=1597463007, id=1085, pos=[(1,393,25)])
  shrl.1089: bits[32] = shrl(invoke.1087, literal.1088, id=1089, pos=[(1,398,50)])
  literal.1081: bits[1] = literal(value=1, id=1081, pos=[(1,392,70)])
  literal.1082: bits[22] = literal(value=0, id=1082, pos=[(1,392,78)])
  literal.1075: bits[1] = literal(value=0, id=1075, pos=[(1,391,40)])
  literal.1076: bits[8] = literal(value=126, id=1076, pos=[(1,391,52)])
  literal.1077: bits[23] = literal(value=0, id=1077, pos=[(1,391,71)])
  sub.1090: bits[32] = sub(MAGIC_NUMBER, shrl.1089, id=1090, pos=[(1,398,27)])
  literal.1079: bits[1] = literal(value=0, id=1079, pos=[(1,392,39)])
  literal.1080: bits[8] = literal(value=127, id=1080, pos=[(1,392,51)])
  concat.1083: bits[23] = concat(literal.1081, literal.1082, id=1083, pos=[(1,392,70)])
  ZERO_POINT_FIVE: (bits[1], bits[8], bits[23]) = tuple(literal.1075, literal.1076, literal.1077, id=1078, pos=[(1,391,32)])
  approx: (bits[1], bits[8], bits[23]) = invoke(sub.1090, to_apply=__float32__unflatten, id=1091, pos=[(1,398,26)])
  ONE_POINT_FIVE: (bits[1], bits[8], bits[23]) = tuple(literal.1079, literal.1080, concat.1083, id=1084, pos=[(1,392,31)])
  half_x: (bits[1], bits[8], bits[23]) = invoke(x__1, ZERO_POINT_FIVE, to_apply=__float32__mul, id=1092, pos=[(1,399,20)])
  x__1_sign: bits[1] = tuple_index(x__1, index=0, id=1110, pos=[(1,417,38)])
  x__1_sign__1: bits[1] = tuple_index(x__1, index=0, id=1113, pos=[(1,419,21)])
  literal.1114: bits[1] = literal(value=1, id=1114, pos=[(1,419,30)])
  invoke.1109: bits[1] = invoke(x__1, to_apply=__float32__is_inf, id=1109, pos=[(1,417,26)])
  result: (bits[1], bits[8], bits[23]) = counted_for(approx, trip_count=1, stride=1, body=____float32__fast_rsqrt_config_refinements__1_counted_for_0_body, invariant_args=[ONE_POINT_FIVE, half_x], id=1108)
  invoke.1111: (bits[1], bits[8], bits[23]) = invoke(x__1_sign, to_apply=__float32__zero, id=1111, pos=[(1,417,36)])
  eq.1115: bits[1] = eq(x__1_sign__1, literal.1114, id=1115, pos=[(1,419,21)])
  result__1: (bits[1], bits[8], bits[23]) = sel(invoke.1109, cases=[result, invoke.1111], id=1112, pos=[(1,417,17)])
  invoke.1116: (bits[1], bits[8], bits[23]) = invoke(to_apply=__float32__qnan, id=1116, pos=[(1,419,41)])
  invoke.1118: bits[1] = invoke(x__1, to_apply=__float32__is_nan, id=1118, pos=[(1,421,26)])
  result__2: (bits[1], bits[8], bits[23]) = sel(eq.1115, cases=[result__1, invoke.1116], id=1117, pos=[(1,419,17)])
  x__1_sign__2: bits[1] = tuple_index(x__1, index=0, id=1121, pos=[(1,423,51)])
  invoke.1120: bits[1] = invoke(x__1, to_apply=__float32__is_zero_or_subnormal, id=1120, pos=[(1,423,40)])
  result__3: (bits[1], bits[8], bits[23]) = sel(invoke.1118, cases=[result__2, x__1], id=1119, pos=[(1,421,17)])
  invoke.1122: (bits[1], bits[8], bits[23]) = invoke(x__1_sign__2, to_apply=__float32__inf, id=1122, pos=[(1,423,49)])
  NUM_REFINEMENTS: bits[32] = literal(value=1, id=1074, pos=[(1,390,37)])
  ret result__4: (bits[1], bits[8], bits[23]) = sel(invoke.1120, cases=[result__3, invoke.1122], id=1123, pos=[(1,423,17)])
}

top fn __float32__fast_rsqrt(x: (bits[1], bits[8], bits[23]) id=1124) -> (bits[1], bits[8], bits[23]) {
  ret invoke.1125: (bits[1], bits[8], bits[23]) = invoke(x, to_apply=__float32__fast_rsqrt_config_refinements__1, id=1125, pos=[(1,427,64)])
}