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,3268,24)])
  x_fraction: bits[23] = tuple_index(x, index=2, id=97, pos=[(0,3294,23)])
  literal.99: bits[48] = literal(value=1, id=99, pos=[(0,3295,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,3296,23)])
  literal.105: bits[48] = literal(value=1, id=105, pos=[(0,3297,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,3295,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,3297,22)])
  invoke.94: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=94, pos=[(0,3291,40)])
  invoke.95: bits[1] = invoke(y, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=95, pos=[(0,3291,67)])
  x_fraction__1: bits[48] = or(zero_ext.98, shll.101, id=102, pos=[(0,3294,23)])
  y_fraction__1: bits[48] = or(zero_ext.104, shll.107, id=108, pos=[(0,3296,23)])
  x_bexp: bits[8] = tuple_index(x, index=1, id=116, pos=[(0,3309,16)])
  y_bexp: bits[8] = tuple_index(y, index=1, id=118, pos=[(0,3309,45)])
  invoke.112: bits[8] = invoke(to_apply=__std__mask_bits__8, id=112, pos=[(0,3308,29)])
  has_0_arg: bits[1] = or(invoke.94, invoke.95, id=96, pos=[(0,3291,40)])
  umul.110: bits[48] = umul(x_fraction__1, y_fraction__1, id=110, pos=[(0,3300,63)])
  literal.109: bits[48] = literal(value=0, id=109, pos=[(0,3300,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,3308,61)])
  fraction: bits[48] = sel(has_0_arg, cases=[umul.110, literal.109], id=111, pos=[(0,3300,19)])
  add.120: bits[10] = add(zero_ext.117, zero_ext.119, id=120, pos=[(0,3309,16)])
  bias: bits[10] = shra(zero_ext.113, literal.114, id=115, pos=[(0,3308,29)])
  bit_slice.124: bits[1] = bit_slice(fraction, start=47, width=1, id=124, pos=[(0,3324,33)])
  exp: bits[10] = sub(add.120, bias, id=121, pos=[(0,3309,16)])
  literal.122: bits[10] = literal(value=0, id=122, pos=[(0,3318,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,3329,25)])
  exp__1: bits[10] = sel(has_0_arg, cases=[exp, literal.122], id=123, pos=[(0,3318,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,3330,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,3334,14)])
  literal.134: bits[10] = literal(value=0, id=134, pos=[(0,3346,29)])
  fraction__2: bits[48] = or(fraction__1, sticky, id=129, pos=[(0,3331,19)])
  literal.136: bits[48] = literal(value=1, id=136, pos=[(0,3346,60)])
  sle.135: bits[1] = sle(exp__2, literal.134, id=135, pos=[(0,3346,22)])
  shrl.137: bits[48] = shrl(fraction__2, literal.136, id=137, pos=[(0,3346,48)])
  bit_slice.132: bits[1] = bit_slice(fraction__2, start=0, width=1, id=132, pos=[(0,3345,25)])
  fraction__3: bits[48] = sel(sle.135, cases=[fraction__2, shrl.137], id=138, pos=[(0,3346,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,3347,19)])
  bit_slice.141: bits[22] = bit_slice(fraction__4, start=0, width=22, id=141, pos=[(0,3358,31)])
  literal.142: bits[22] = literal(value=0, id=142, pos=[(0,3358,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,3360,41)])
  literal.147: bits[22] = literal(value=0, id=147, pos=[(0,3361,32)])
  bit_slice.140: bits[1] = bit_slice(fraction__4, start=22, width=1, id=140, pos=[(0,3357,30)])
  eq.143: bits[1] = eq(bit_slice.141, literal.142, id=143, pos=[(0,3358,31)])
  shrl.154: bits[48] = shrl(fraction__4, zero_ext.153, id=154, pos=[(0,3368,20)])
  bit_slice.145: bits[1] = bit_slice(fraction__4, start=22, width=1, id=145, pos=[(0,3359,40)])
  ne.148: bits[1] = ne(bit_slice.146, literal.147, id=148, pos=[(0,3360,41)])
  is_half_way: bits[1] = and(bit_slice.140, eq.143, id=144, pos=[(0,3357,30)])
  bit_slice.150: bits[1] = bit_slice(fraction__4, start=23, width=1, id=150, pos=[(0,3363,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,3359,40)])
  and.151: bits[1] = and(is_half_way, bit_slice.150, id=151, pos=[(0,3363,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,3370,47)])
  do_round_up: bits[1] = or(greater_than_half_way, and.151, id=152, pos=[(0,3362,22)])
  add.158: bits[24] = add(fraction__6, literal.157, id=158, pos=[(0,3370,36)])
  fraction__7: bits[24] = sel(do_round_up, cases=[fraction__6, add.158], id=159, pos=[(0,3370,19)])
  literal.161: bits[10] = literal(value=1, id=161, pos=[(0,3374,39)])
  bit_slice.160: bits[1] = bit_slice(fraction__7, start=23, width=1, id=160, pos=[(0,3374,25)])
  add.162: bits[10] = add(exp__2, literal.161, id=162, pos=[(0,3374,33)])
  exp__3: bits[10] = sel(bit_slice.160, cases=[exp__2, add.162], id=163, pos=[(0,3374,14)])
  literal.164: bits[10] = literal(value=0, id=164, pos=[(0,3375,30)])
  is_subnormal: bits[1] = sle(exp__3, literal.164, id=165, pos=[(0,3375,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,3384,39)])
  high_exp: bits[8] = invoke(to_apply=__std__mask_bits__8, id=175, pos=[(0,3388,33)])
  invoke.193: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=193, pos=[(0,3402,28)])
  invoke.194: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=194, pos=[(0,3402,62)])
  result_exp__1: bits[9] = sel(is_subnormal, cases=[result_exp, literal.171], id=172, pos=[(0,3384,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,3385,44)])
  invoke.190: bits[1] = invoke(x, to_apply=__apfloat__is_nan__8_23, id=190, pos=[(0,3401,28)])
  invoke.191: bits[1] = invoke(y, to_apply=__apfloat__is_nan__8_23, id=191, pos=[(0,3401,62)])
  has_inf_arg: bits[1] = or(invoke.193, invoke.194, id=195, pos=[(0,3402,28)])
  invoke.184: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_23, id=184, pos=[(0,3395,31)])
  invoke.185: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_23, id=185, pos=[(0,3395,65)])
  ult.181: bits[1] = ult(result_exp__1, zero_ext.180, id=181, pos=[(0,3392,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,3390,11)])
  literal.178: bits[23] = literal(value=0, id=178, pos=[(0,3390,78)])
  result_fraction__1: bits[23] = sel(is_subnormal, cases=[result_fraction, literal.173], id=174, pos=[(0,3385,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,3405,78)])
  has_nan_arg: bits[1] = or(invoke.190, invoke.191, id=192, pos=[(0,3401,28)])
  and.196: bits[1] = and(has_0_arg, has_inf_arg, id=196, pos=[(0,3403,40)])
  x_sign: bits[1] = tuple_index(x, index=0, id=166, pos=[(0,3378,23)])
  y_sign: bits[1] = tuple_index(y, index=0, id=167, pos=[(0,3378,33)])
  is_operand_inf: bits[1] = or(invoke.184, invoke.185, id=186, pos=[(0,3395,31)])
  result_exp__2: bits[8] = sel(ult.181, cases=[high_exp, bit_slice.182], id=183, pos=[(0,3392,8)])
  result_fraction__2: bits[23] = sel(ult.177, cases=[literal.178, result_fraction__1], id=179, pos=[(0,3390,8)])
  literal.188: bits[23] = literal(value=0, id=188, pos=[(0,3397,46)])
  literal.199: bits[23] = literal(value=1, id=199, pos=[(0,3405,23)])
  sub.202: bits[23] = sub(bit_slice.200, literal.201, id=202, pos=[(0,3405,45)])
  EXP_SZ: bits[32] = literal(value=8, id=79, pos=[(0,3268,11)])
  literal.81: bits[32] = literal(value=1, id=81, pos=[(0,3272,35)])
  is_result_nan: bits[1] = or(has_nan_arg, and.196, id=197, pos=[(0,3403,24)])
  result_sign: bits[1] = ne(x_sign, y_sign, id=168, pos=[(0,3378,23)])
  literal.205: bits[1] = literal(value=0, id=205, pos=[(0,3407,41)])
  result_exp__3: bits[8] = sel(is_operand_inf, cases=[result_exp__2, high_exp], id=187, pos=[(0,3396,21)])
  result_fraction__3: bits[23] = sel(is_operand_inf, cases=[result_fraction__2, literal.188], id=189, pos=[(0,3397,26)])
  nan_fraction: bits[23] = shll(literal.199, sub.202, id=203, pos=[(0,3405,23)])
  WIDE_EXP: bits[32] = add(EXP_SZ, literal.81, id=82, pos=[(0,3272,26)])
  literal.83: bits[32] = literal(value=1, id=83, pos=[(0,3274,39)])
  literal.85: bits[32] = literal(value=1, id=85, pos=[(0,3278,49)])
  add.87: bits[32] = add(FRACTION_SZ, FRACTION_SZ, id=87, pos=[(0,3282,31)])
  literal.88: bits[32] = literal(value=2, id=88, pos=[(0,3282,59)])
  literal.90: bits[32] = literal(value=1, id=90, pos=[(0,3284,53)])
  literal.92: bits[32] = literal(value=1, id=92, pos=[(0,3288,47)])
  result_sign__1: bits[1] = sel(is_result_nan, cases=[result_sign, literal.205], id=206, pos=[(0,3407,22)])
  result_exp__4: bits[8] = sel(is_result_nan, cases=[result_exp__3, high_exp], id=198, pos=[(0,3404,21)])
  result_fraction__4: bits[23] = sel(is_result_nan, cases=[result_fraction__3, nan_fraction], id=204, pos=[(0,3406,26)])
  SIGNED_EXP: bits[32] = add(WIDE_EXP, literal.83, id=84, pos=[(0,3274,28)])
  ROUNDING_FRACTION: bits[32] = add(FRACTION_SZ, literal.85, id=86, pos=[(0,3278,35)])
  WIDE_FRACTION: bits[32] = add(add.87, literal.88, id=89, pos=[(0,3282,31)])
  FRACTION_ROUNDING_BIT: bits[32] = sub(FRACTION_SZ, literal.90, id=91, pos=[(0,3284,39)])
  STICKY_FRACTION: bits[32] = add(FRACTION_SZ, literal.92, id=93, pos=[(0,3288,33)])
  ret tuple.207: (bits[1], bits[8], bits[23]) = tuple(result_sign__1, result_exp__4, result_fraction__4, id=207, pos=[(0,3409,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,1114,45)])
  bit_slice.222: bits[1] = bit_slice(full_result, start=8, width=1, id=222, pos=[(2,1116,49)])
  overflow_detected: bits[1] = or_reduce(bit_slice.222, id=223, pos=[(2,1116,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,1108,5)])
  N: bits[32] = literal(value=8, id=214, pos=[(2,1108,13)])
  M: bits[32] = literal(value=8, id=215, pos=[(2,1108,21)])
  MAX_N_M: bits[32] = literal(value=8, id=216, pos=[(2,1108,29)])
  MAX_N_M_V: bits[32] = literal(value=8, id=217, pos=[(2,1108,57)])
  ret tuple.224: (bits[1], bits[8]) = tuple(overflow_detected, narrowed_result, id=224, pos=[(2,1118,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,3009,44)])
  invoke.250: bits[1] = invoke(abs_diff_result, to_apply=__abs_diff__is_x_larger__8, id=250, pos=[(0,3010,27)])
  not.251: bits[1] = not(invoke.250, id=251, pos=[(0,3010,5)])
  invoke.252: bits[8] = invoke(abs_diff_result, to_apply=__abs_diff__to_corrected__8, id=252, pos=[(0,3010,68)])
  WIDTH: bits[32] = literal(value=8, id=248, pos=[(0,3008,29)])
  ret tuple.253: (bits[1], bits[8]) = tuple(not.251, invoke.252, id=253, pos=[(0,3010,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,1406,19)])
  shll.259: bits[28] = shll(literal.258, n, id=259, pos=[(2,1406,19)])
  not.260: bits[28] = not(shll.259, id=260, pos=[(2,1406,8)])
  WIDTH: bits[32] = literal(value=28, id=256, pos=[(2,1405,17)])
  N_WIDTH: bits[32] = literal(value=8, id=257, pos=[(2,1405,29)])
  ret and.261: bits[28] = and(x, not.260, id=261, pos=[(2,1406,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,1492,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,1499,18)])
  shll.272: bits[28] = shll(value, sub.271, id=272, pos=[(2,1499,8)])
  literal.273: bits[28] = literal(value=0, id=273, pos=[(2,1499,47)])
  invoke.267: bits[28] = invoke(value, n, to_apply=__std__keep_lsbs__8_28, id=267, pos=[(2,1496,17)])
  literal.268: bits[28] = literal(value=0, id=268, pos=[(2,1496,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=264, pos=[(2,1492,22)])
  ne.274: bits[1] = ne(shll.272, literal.273, id=274, pos=[(2,1499,8)])
  ne.269: bits[1] = ne(invoke.267, literal.268, id=269, pos=[(2,1496,17)])
  N_WIDTH: bits[32] = literal(value=8, id=266, pos=[(2,1492,54)])
  ret sel.275: bits[1] = sel(DO_MASK_IMPL, cases=[ne.274, ne.269], id=275, pos=[(2,1494,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,1522,21)])
  N_WIDTH: bits[32] = literal(value=8, id=279, pos=[(2,1522,33)])
  ret invoke.280: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_8_28, id=280, pos=[(2,1523,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,3053,40)])
  literal.284: bits[1] = literal(value=0, id=284, pos=[(0,3053,28)])
  or.286: bits[1] = or(bit_slice.285, lsb, id=286, pos=[(0,3053,40)])
  WIDTH: bits[32] = literal(value=28, id=283, pos=[(0,3052,15)])
  ret bit_slice_update.287: bits[28] = bit_slice_update(value, literal.284, or.286, id=287, pos=[(0,3053,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,3053,40)])
  literal.291: bits[1] = literal(value=0, id=291, pos=[(0,3053,28)])
  or.293: bits[1] = or(bit_slice.292, lsb, id=293, pos=[(0,3053,40)])
  WIDTH: bits[32] = literal(value=27, id=290, pos=[(0,3052,15)])
  ret bit_slice_update.294: bits[27] = bit_slice_update(value, literal.291, or.293, id=294, pos=[(0,3053,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__upow__32_counted_for_0_body(i: bits[32] id=314, __loop_carry: (bits[32], bits[32], bits[32]) id=317) -> (bits[32], bits[32], bits[32]) {
  tuple_index.319: bits[32] = tuple_index(__loop_carry, index=0, id=319)
  literal.329: bits[32] = literal(value=1, id=329, pos=[(2,960,29)])
  literal.318: bits[1] = literal(value=1, id=318)
  literal.320: bits[1] = literal(value=1, id=320)
  and.330: bits[32] = and(tuple_index.319, literal.329, id=330, pos=[(2,960,25)])
  literal.331: bits[32] = literal(value=1, id=331, pos=[(2,960,41)])
  tuple_index.325: bits[32] = tuple_index(__loop_carry, index=2, id=325)
  tuple_index.322: bits[32] = tuple_index(__loop_carry, index=1, id=322)
  and.321: bits[1] = and(literal.318, literal.320, id=321)
  literal.323: bits[1] = literal(value=1, id=323)
  literal.335: bits[1] = literal(value=1, id=335, pos=[(2,962,14)])
  eq.332: bits[1] = eq(and.330, literal.331, id=332, pos=[(2,960,25)])
  umul.333: bits[32] = umul(tuple_index.325, tuple_index.322, id=333, pos=[(2,960,51)])
  literal.315: bits[32] = literal(value=0, id=315)
  and.324: bits[1] = and(and.321, literal.323, id=324)
  literal.326: bits[1] = literal(value=1, id=326)
  shrl.336: bits[32] = shrl(tuple_index.319, literal.335, id=336, pos=[(2,962,9)])
  umul.337: bits[32] = umul(tuple_index.322, tuple_index.322, id=337, pos=[(2,962,17)])
  result: bits[32] = sel(eq.332, cases=[tuple_index.325, umul.333], id=334, pos=[(2,960,21)])
  add.316: bits[32] = add(i, literal.315, id=316)
  and.327: bits[1] = and(and.324, literal.326, id=327)
  literal.328: bits[32] = literal(value=32, id=328, pos=[(2,955,12)])
  ret tuple.338: (bits[32], bits[32], bits[32]) = tuple(shrl.336, umul.337, result, id=338, pos=[(2,962,8)])
}

fn __std__upow__32(x: bits[32] id=309, n: bits[32] id=310) -> bits[32] {
  result: bits[32] = literal(value=1, id=312, pos=[(2,956,17)])
  tuple.313: (bits[32], bits[32], bits[32]) = tuple(n, x, result, id=313, pos=[(2,963,6)])
  work: (bits[32], bits[32], bits[32]) = counted_for(tuple.313, trip_count=32, stride=1, body=____std__upow__32_counted_for_0_body, id=339)
  N: bits[32] = literal(value=32, id=311, pos=[(2,955,12)])
  literal.340: bits[32] = literal(value=2, id=340, pos=[(2,964,9)])
  ret tuple_index.341: bits[32] = tuple_index(work, index=2, id=341, pos=[(2,964,8)])
}

fn __std__next_pow2(n: bits[32] id=342) -> bits[32] {
  literal.343: bits[32] = literal(value=2, id=343, pos=[(2,1680,39)])
  invoke.344: bits[32] = invoke(n, to_apply=__std__clog2__32, id=344, pos=[(2,1680,51)])
  ret invoke.345: bits[32] = invoke(literal.343, invoke.344, to_apply=__std__upow__32, id=345, pos=[(2,1680,38)])
}

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

fn __std__clzt_pow2_1(value: bits[1] id=349) -> bits[1] {
  ret not.350: bits[1] = not(value, id=350, pos=[(2,1578,4)])
}

fn __std__combine_clzt_halfs__1(left: bits[1] id=351, right: bits[1] id=352) -> bits[2] {
  bit_slice.354: bits[1] = bit_slice(left, start=0, width=1, id=354, pos=[(2,1533,15)])
  bit_slice.355: bits[1] = bit_slice(right, start=0, width=1, id=355, pos=[(2,1533,27)])
  tuple.356: (bits[1], bits[1]) = tuple(bit_slice.354, bit_slice.355, id=356, pos=[(2,1533,10)])
  literal.370: bits[1] = literal(value=1, id=370, pos=[(2,1535,9)])
  tuple_index.369: bits[1] = tuple_index(tuple.356, index=0, id=369)
  literal.359: bits[1] = literal(value=1, id=359, pos=[(2,1534,9)])
  tuple_index.358: bits[1] = tuple_index(tuple.356, index=0, id=358)
  literal.368: bits[1] = literal(value=1, id=368)
  eq.371: bits[1] = eq(literal.370, tuple_index.369, id=371)
  literal.374: bits[1] = literal(value=0, id=374, pos=[(2,1535,15)])
  tuple_index.373: bits[1] = tuple_index(tuple.356, index=1, id=373)
  literal.357: bits[1] = literal(value=1, id=357)
  eq.360: bits[1] = eq(literal.359, tuple_index.358, id=360)
  literal.363: bits[1] = literal(value=1, id=363, pos=[(2,1534,15)])
  tuple_index.362: bits[1] = tuple_index(tuple.356, index=1, id=362)
  and.372: bits[1] = and(literal.368, eq.371, id=372)
  eq.375: bits[1] = eq(literal.374, tuple_index.373, id=375)
  and.361: bits[1] = and(literal.357, eq.360, id=361)
  eq.364: bits[1] = eq(literal.363, tuple_index.362, id=364)
  and.376: bits[1] = and(and.372, eq.375, id=376)
  and.365: bits[1] = and(and.361, eq.364, id=365)
  literal.366: bits[1] = literal(value=0, id=366, pos=[(2,1534,32)])
  literal.377: bits[2] = literal(value=1, id=377, pos=[(2,1535,24)])
  bit_slice.378: bits[0] = bit_slice(right, start=0, width=0, id=378, pos=[(2,1535,40)])
  literal.381: bits[1] = literal(value=0, id=381, pos=[(2,1536,13)])
  concat.383: bits[2] = concat(and.376, and.365, id=383)
  concat.367: bits[2] = concat(left, literal.366, id=367, pos=[(2,1534,24)])
  concat.379: bits[2] = concat(literal.377, bit_slice.378, id=379, pos=[(2,1535,24)])
  concat.382: bits[2] = concat(literal.381, left, id=382, pos=[(2,1536,13)])
  N: bits[32] = literal(value=1, id=353, pos=[(2,1532,22)])
  literal.380: bits[1] = literal(value=1, id=380, pos=[(2,1536,8)])
  ret priority_sel.384: bits[2] = priority_sel(concat.383, cases=[concat.367, concat.379], default=concat.382, id=384)
}

fn __std__clzt_pow2_2(value: bits[2] id=385) -> bits[2] {
  literal.386: bits[32] = literal(value=2, id=386, pos=[(2,1584,20)])
  literal.387: bits[1] = literal(value=1, id=387, pos=[(2,1584,29)])
  bit_slice.390: bits[1] = bit_slice(value, start=1, width=1, id=390, pos=[(2,1585,40)])
  bit_slice.392: bits[1] = bit_slice(value, start=0, width=1, id=392, pos=[(2,1585,70)])
  shrl.388: bits[32] = shrl(literal.386, literal.387, id=388, pos=[(2,1584,20)])
  invoke.391: bits[1] = invoke(bit_slice.390, to_apply=__std__clzt_pow2_1, id=391, pos=[(2,1585,34)])
  invoke.393: bits[1] = invoke(bit_slice.392, to_apply=__std__clzt_pow2_1, id=393, pos=[(2,1585,64)])
  N_HALF: bits[32] = zero_ext(shrl.388, new_bit_count=32, id=389)
  ret invoke.394: bits[2] = invoke(invoke.391, invoke.393, to_apply=__std__combine_clzt_halfs__1, id=394, pos=[(2,1585,22)])
}

fn __std__combine_clzt_halfs__2(left: bits[2] id=395, right: bits[2] id=396) -> bits[3] {
  bit_slice.398: bits[1] = bit_slice(left, start=1, width=1, id=398, pos=[(2,1533,15)])
  bit_slice.399: bits[1] = bit_slice(right, start=1, width=1, id=399, pos=[(2,1533,27)])
  tuple.400: (bits[1], bits[1]) = tuple(bit_slice.398, bit_slice.399, id=400, pos=[(2,1533,10)])
  literal.414: bits[1] = literal(value=1, id=414, pos=[(2,1535,9)])
  tuple_index.413: bits[1] = tuple_index(tuple.400, index=0, id=413)
  literal.403: bits[1] = literal(value=1, id=403, pos=[(2,1534,9)])
  tuple_index.402: bits[1] = tuple_index(tuple.400, index=0, id=402)
  literal.412: bits[1] = literal(value=1, id=412)
  eq.415: bits[1] = eq(literal.414, tuple_index.413, id=415)
  literal.418: bits[1] = literal(value=0, id=418, pos=[(2,1535,15)])
  tuple_index.417: bits[1] = tuple_index(tuple.400, index=1, id=417)
  literal.401: bits[1] = literal(value=1, id=401)
  eq.404: bits[1] = eq(literal.403, tuple_index.402, id=404)
  literal.407: bits[1] = literal(value=1, id=407, pos=[(2,1534,15)])
  tuple_index.406: bits[1] = tuple_index(tuple.400, index=1, id=406)
  and.416: bits[1] = and(literal.412, eq.415, id=416)
  eq.419: bits[1] = eq(literal.418, tuple_index.417, id=419)
  and.405: bits[1] = and(literal.401, eq.404, id=405)
  eq.408: bits[1] = eq(literal.407, tuple_index.406, id=408)
  and.420: bits[1] = and(and.416, eq.419, id=420)
  and.409: bits[1] = and(and.405, eq.408, id=409)
  literal.410: bits[1] = literal(value=0, id=410, pos=[(2,1534,32)])
  literal.421: bits[2] = literal(value=1, id=421, pos=[(2,1535,24)])
  bit_slice.422: bits[1] = bit_slice(right, start=0, width=1, id=422, pos=[(2,1535,40)])
  literal.425: bits[1] = literal(value=0, id=425, pos=[(2,1536,13)])
  concat.427: bits[2] = concat(and.420, and.409, id=427)
  concat.411: bits[3] = concat(left, literal.410, id=411, pos=[(2,1534,24)])
  concat.423: bits[3] = concat(literal.421, bit_slice.422, id=423, pos=[(2,1535,24)])
  concat.426: bits[3] = concat(literal.425, left, id=426, pos=[(2,1536,13)])
  N: bits[32] = literal(value=2, id=397, pos=[(2,1532,22)])
  literal.424: bits[1] = literal(value=1, id=424, pos=[(2,1536,8)])
  ret priority_sel.428: bits[3] = priority_sel(concat.427, cases=[concat.411, concat.423], default=concat.426, id=428)
}

fn __std__clzt_pow2_4(value: bits[4] id=429) -> bits[3] {
  literal.430: bits[32] = literal(value=4, id=430, pos=[(2,1589,20)])
  literal.431: bits[1] = literal(value=1, id=431, pos=[(2,1589,29)])
  bit_slice.434: bits[2] = bit_slice(value, start=2, width=2, id=434, pos=[(2,1590,40)])
  bit_slice.436: bits[2] = bit_slice(value, start=0, width=2, id=436, pos=[(2,1590,70)])
  shrl.432: bits[32] = shrl(literal.430, literal.431, id=432, pos=[(2,1589,20)])
  invoke.435: bits[2] = invoke(bit_slice.434, to_apply=__std__clzt_pow2_2, id=435, pos=[(2,1590,34)])
  invoke.437: bits[2] = invoke(bit_slice.436, to_apply=__std__clzt_pow2_2, id=437, pos=[(2,1590,64)])
  N_HALF: bits[32] = zero_ext(shrl.432, new_bit_count=32, id=433)
  ret invoke.438: bits[3] = invoke(invoke.435, invoke.437, to_apply=__std__combine_clzt_halfs__2, id=438, pos=[(2,1590,22)])
}

fn __std__combine_clzt_halfs__3(left: bits[3] id=439, right: bits[3] id=440) -> bits[4] {
  bit_slice.442: bits[1] = bit_slice(left, start=2, width=1, id=442, pos=[(2,1533,15)])
  bit_slice.443: bits[1] = bit_slice(right, start=2, width=1, id=443, pos=[(2,1533,27)])
  tuple.444: (bits[1], bits[1]) = tuple(bit_slice.442, bit_slice.443, id=444, pos=[(2,1533,10)])
  literal.458: bits[1] = literal(value=1, id=458, pos=[(2,1535,9)])
  tuple_index.457: bits[1] = tuple_index(tuple.444, index=0, id=457)
  literal.447: bits[1] = literal(value=1, id=447, pos=[(2,1534,9)])
  tuple_index.446: bits[1] = tuple_index(tuple.444, index=0, id=446)
  literal.456: bits[1] = literal(value=1, id=456)
  eq.459: bits[1] = eq(literal.458, tuple_index.457, id=459)
  literal.462: bits[1] = literal(value=0, id=462, pos=[(2,1535,15)])
  tuple_index.461: bits[1] = tuple_index(tuple.444, index=1, id=461)
  literal.445: bits[1] = literal(value=1, id=445)
  eq.448: bits[1] = eq(literal.447, tuple_index.446, id=448)
  literal.451: bits[1] = literal(value=1, id=451, pos=[(2,1534,15)])
  tuple_index.450: bits[1] = tuple_index(tuple.444, index=1, id=450)
  and.460: bits[1] = and(literal.456, eq.459, id=460)
  eq.463: bits[1] = eq(literal.462, tuple_index.461, id=463)
  and.449: bits[1] = and(literal.445, eq.448, id=449)
  eq.452: bits[1] = eq(literal.451, tuple_index.450, id=452)
  and.464: bits[1] = and(and.460, eq.463, id=464)
  and.453: bits[1] = and(and.449, eq.452, id=453)
  literal.454: bits[1] = literal(value=0, id=454, pos=[(2,1534,32)])
  literal.465: bits[2] = literal(value=1, id=465, pos=[(2,1535,24)])
  bit_slice.466: bits[2] = bit_slice(right, start=0, width=2, id=466, pos=[(2,1535,40)])
  literal.469: bits[1] = literal(value=0, id=469, pos=[(2,1536,13)])
  concat.471: bits[2] = concat(and.464, and.453, id=471)
  concat.455: bits[4] = concat(left, literal.454, id=455, pos=[(2,1534,24)])
  concat.467: bits[4] = concat(literal.465, bit_slice.466, id=467, pos=[(2,1535,24)])
  concat.470: bits[4] = concat(literal.469, left, id=470, pos=[(2,1536,13)])
  N: bits[32] = literal(value=3, id=441, pos=[(2,1532,22)])
  literal.468: bits[1] = literal(value=1, id=468, pos=[(2,1536,8)])
  ret priority_sel.472: bits[4] = priority_sel(concat.471, cases=[concat.455, concat.467], default=concat.470, id=472)
}

fn __std__clzt_pow2_8(value: bits[8] id=473) -> bits[4] {
  literal.474: bits[32] = literal(value=8, id=474, pos=[(2,1594,20)])
  literal.475: bits[1] = literal(value=1, id=475, pos=[(2,1594,29)])
  bit_slice.478: bits[4] = bit_slice(value, start=4, width=4, id=478, pos=[(2,1595,40)])
  bit_slice.480: bits[4] = bit_slice(value, start=0, width=4, id=480, pos=[(2,1595,70)])
  shrl.476: bits[32] = shrl(literal.474, literal.475, id=476, pos=[(2,1594,20)])
  invoke.479: bits[3] = invoke(bit_slice.478, to_apply=__std__clzt_pow2_4, id=479, pos=[(2,1595,34)])
  invoke.481: bits[3] = invoke(bit_slice.480, to_apply=__std__clzt_pow2_4, id=481, pos=[(2,1595,64)])
  N_HALF: bits[32] = zero_ext(shrl.476, new_bit_count=32, id=477)
  ret invoke.482: bits[4] = invoke(invoke.479, invoke.481, to_apply=__std__combine_clzt_halfs__3, id=482, pos=[(2,1595,22)])
}

fn __std__combine_clzt_halfs__4(left: bits[4] id=483, right: bits[4] id=484) -> bits[5] {
  bit_slice.486: bits[1] = bit_slice(left, start=3, width=1, id=486, pos=[(2,1533,15)])
  bit_slice.487: bits[1] = bit_slice(right, start=3, width=1, id=487, pos=[(2,1533,27)])
  tuple.488: (bits[1], bits[1]) = tuple(bit_slice.486, bit_slice.487, id=488, pos=[(2,1533,10)])
  literal.502: bits[1] = literal(value=1, id=502, pos=[(2,1535,9)])
  tuple_index.501: bits[1] = tuple_index(tuple.488, index=0, id=501)
  literal.491: bits[1] = literal(value=1, id=491, pos=[(2,1534,9)])
  tuple_index.490: bits[1] = tuple_index(tuple.488, index=0, id=490)
  literal.500: bits[1] = literal(value=1, id=500)
  eq.503: bits[1] = eq(literal.502, tuple_index.501, id=503)
  literal.506: bits[1] = literal(value=0, id=506, pos=[(2,1535,15)])
  tuple_index.505: bits[1] = tuple_index(tuple.488, index=1, id=505)
  literal.489: bits[1] = literal(value=1, id=489)
  eq.492: bits[1] = eq(literal.491, tuple_index.490, id=492)
  literal.495: bits[1] = literal(value=1, id=495, pos=[(2,1534,15)])
  tuple_index.494: bits[1] = tuple_index(tuple.488, index=1, id=494)
  and.504: bits[1] = and(literal.500, eq.503, id=504)
  eq.507: bits[1] = eq(literal.506, tuple_index.505, id=507)
  and.493: bits[1] = and(literal.489, eq.492, id=493)
  eq.496: bits[1] = eq(literal.495, tuple_index.494, id=496)
  and.508: bits[1] = and(and.504, eq.507, id=508)
  and.497: bits[1] = and(and.493, eq.496, id=497)
  literal.498: bits[1] = literal(value=0, id=498, pos=[(2,1534,32)])
  literal.509: bits[2] = literal(value=1, id=509, pos=[(2,1535,24)])
  bit_slice.510: bits[3] = bit_slice(right, start=0, width=3, id=510, pos=[(2,1535,40)])
  literal.513: bits[1] = literal(value=0, id=513, pos=[(2,1536,13)])
  concat.515: bits[2] = concat(and.508, and.497, id=515)
  concat.499: bits[5] = concat(left, literal.498, id=499, pos=[(2,1534,24)])
  concat.511: bits[5] = concat(literal.509, bit_slice.510, id=511, pos=[(2,1535,24)])
  concat.514: bits[5] = concat(literal.513, left, id=514, pos=[(2,1536,13)])
  N: bits[32] = literal(value=4, id=485, pos=[(2,1532,22)])
  literal.512: bits[1] = literal(value=1, id=512, pos=[(2,1536,8)])
  ret priority_sel.516: bits[5] = priority_sel(concat.515, cases=[concat.499, concat.511], default=concat.514, id=516)
}

fn __std__clzt_pow2_16(value: bits[16] id=517) -> bits[5] {
  literal.518: bits[32] = literal(value=16, id=518, pos=[(2,1599,20)])
  literal.519: bits[1] = literal(value=1, id=519, pos=[(2,1599,30)])
  bit_slice.522: bits[8] = bit_slice(value, start=8, width=8, id=522, pos=[(2,1600,40)])
  bit_slice.524: bits[8] = bit_slice(value, start=0, width=8, id=524, pos=[(2,1600,70)])
  shrl.520: bits[32] = shrl(literal.518, literal.519, id=520, pos=[(2,1599,20)])
  invoke.523: bits[4] = invoke(bit_slice.522, to_apply=__std__clzt_pow2_8, id=523, pos=[(2,1600,34)])
  invoke.525: bits[4] = invoke(bit_slice.524, to_apply=__std__clzt_pow2_8, id=525, pos=[(2,1600,64)])
  N_HALF: bits[32] = zero_ext(shrl.520, new_bit_count=32, id=521)
  ret invoke.526: bits[5] = invoke(invoke.523, invoke.525, to_apply=__std__combine_clzt_halfs__4, id=526, pos=[(2,1600,22)])
}

fn __std__combine_clzt_halfs__5(left: bits[5] id=527, right: bits[5] id=528) -> bits[6] {
  bit_slice.530: bits[1] = bit_slice(left, start=4, width=1, id=530, pos=[(2,1533,15)])
  bit_slice.531: bits[1] = bit_slice(right, start=4, width=1, id=531, pos=[(2,1533,27)])
  tuple.532: (bits[1], bits[1]) = tuple(bit_slice.530, bit_slice.531, id=532, pos=[(2,1533,10)])
  literal.546: bits[1] = literal(value=1, id=546, pos=[(2,1535,9)])
  tuple_index.545: bits[1] = tuple_index(tuple.532, index=0, id=545)
  literal.535: bits[1] = literal(value=1, id=535, pos=[(2,1534,9)])
  tuple_index.534: bits[1] = tuple_index(tuple.532, index=0, id=534)
  literal.544: bits[1] = literal(value=1, id=544)
  eq.547: bits[1] = eq(literal.546, tuple_index.545, id=547)
  literal.550: bits[1] = literal(value=0, id=550, pos=[(2,1535,15)])
  tuple_index.549: bits[1] = tuple_index(tuple.532, index=1, id=549)
  literal.533: bits[1] = literal(value=1, id=533)
  eq.536: bits[1] = eq(literal.535, tuple_index.534, id=536)
  literal.539: bits[1] = literal(value=1, id=539, pos=[(2,1534,15)])
  tuple_index.538: bits[1] = tuple_index(tuple.532, index=1, id=538)
  and.548: bits[1] = and(literal.544, eq.547, id=548)
  eq.551: bits[1] = eq(literal.550, tuple_index.549, id=551)
  and.537: bits[1] = and(literal.533, eq.536, id=537)
  eq.540: bits[1] = eq(literal.539, tuple_index.538, id=540)
  and.552: bits[1] = and(and.548, eq.551, id=552)
  and.541: bits[1] = and(and.537, eq.540, id=541)
  literal.542: bits[1] = literal(value=0, id=542, pos=[(2,1534,32)])
  literal.553: bits[2] = literal(value=1, id=553, pos=[(2,1535,24)])
  bit_slice.554: bits[4] = bit_slice(right, start=0, width=4, id=554, pos=[(2,1535,40)])
  literal.557: bits[1] = literal(value=0, id=557, pos=[(2,1536,13)])
  concat.559: bits[2] = concat(and.552, and.541, id=559)
  concat.543: bits[6] = concat(left, literal.542, id=543, pos=[(2,1534,24)])
  concat.555: bits[6] = concat(literal.553, bit_slice.554, id=555, pos=[(2,1535,24)])
  concat.558: bits[6] = concat(literal.557, left, id=558, pos=[(2,1536,13)])
  N: bits[32] = literal(value=5, id=529, pos=[(2,1532,22)])
  literal.556: bits[1] = literal(value=1, id=556, pos=[(2,1536,8)])
  ret priority_sel.560: bits[6] = priority_sel(concat.559, cases=[concat.543, concat.555], default=concat.558, id=560)
}

fn __std__clzt_pow2_32(value: bits[32] id=561) -> bits[6] {
  literal.562: bits[32] = literal(value=32, id=562, pos=[(2,1604,20)])
  literal.563: bits[1] = literal(value=1, id=563, pos=[(2,1604,30)])
  bit_slice.566: bits[16] = bit_slice(value, start=16, width=16, id=566, pos=[(2,1605,41)])
  bit_slice.568: bits[16] = bit_slice(value, start=0, width=16, id=568, pos=[(2,1605,72)])
  shrl.564: bits[32] = shrl(literal.562, literal.563, id=564, pos=[(2,1604,20)])
  invoke.567: bits[5] = invoke(bit_slice.566, to_apply=__std__clzt_pow2_16, id=567, pos=[(2,1605,35)])
  invoke.569: bits[5] = invoke(bit_slice.568, to_apply=__std__clzt_pow2_16, id=569, pos=[(2,1605,66)])
  N_HALF: bits[32] = zero_ext(shrl.564, new_bit_count=32, id=565)
  ret invoke.570: bits[6] = invoke(invoke.567, invoke.569, to_apply=__std__combine_clzt_halfs__5, id=570, pos=[(2,1605,22)])
}

fn __std__combine_clzt_halfs__6(left: bits[6] id=571, right: bits[6] id=572) -> bits[7] {
  bit_slice.574: bits[1] = bit_slice(left, start=5, width=1, id=574, pos=[(2,1533,15)])
  bit_slice.575: bits[1] = bit_slice(right, start=5, width=1, id=575, pos=[(2,1533,27)])
  tuple.576: (bits[1], bits[1]) = tuple(bit_slice.574, bit_slice.575, id=576, pos=[(2,1533,10)])
  literal.590: bits[1] = literal(value=1, id=590, pos=[(2,1535,9)])
  tuple_index.589: bits[1] = tuple_index(tuple.576, index=0, id=589)
  literal.579: bits[1] = literal(value=1, id=579, pos=[(2,1534,9)])
  tuple_index.578: bits[1] = tuple_index(tuple.576, index=0, id=578)
  literal.588: bits[1] = literal(value=1, id=588)
  eq.591: bits[1] = eq(literal.590, tuple_index.589, id=591)
  literal.594: bits[1] = literal(value=0, id=594, pos=[(2,1535,15)])
  tuple_index.593: bits[1] = tuple_index(tuple.576, index=1, id=593)
  literal.577: bits[1] = literal(value=1, id=577)
  eq.580: bits[1] = eq(literal.579, tuple_index.578, id=580)
  literal.583: bits[1] = literal(value=1, id=583, pos=[(2,1534,15)])
  tuple_index.582: bits[1] = tuple_index(tuple.576, index=1, id=582)
  and.592: bits[1] = and(literal.588, eq.591, id=592)
  eq.595: bits[1] = eq(literal.594, tuple_index.593, id=595)
  and.581: bits[1] = and(literal.577, eq.580, id=581)
  eq.584: bits[1] = eq(literal.583, tuple_index.582, id=584)
  and.596: bits[1] = and(and.592, eq.595, id=596)
  and.585: bits[1] = and(and.581, eq.584, id=585)
  literal.586: bits[1] = literal(value=0, id=586, pos=[(2,1534,32)])
  literal.597: bits[2] = literal(value=1, id=597, pos=[(2,1535,24)])
  bit_slice.598: bits[5] = bit_slice(right, start=0, width=5, id=598, pos=[(2,1535,40)])
  literal.601: bits[1] = literal(value=0, id=601, pos=[(2,1536,13)])
  concat.603: bits[2] = concat(and.596, and.585, id=603)
  concat.587: bits[7] = concat(left, literal.586, id=587, pos=[(2,1534,24)])
  concat.599: bits[7] = concat(literal.597, bit_slice.598, id=599, pos=[(2,1535,24)])
  concat.602: bits[7] = concat(literal.601, left, id=602, pos=[(2,1536,13)])
  N: bits[32] = literal(value=6, id=573, pos=[(2,1532,22)])
  literal.600: bits[1] = literal(value=1, id=600, pos=[(2,1536,8)])
  ret priority_sel.604: bits[7] = priority_sel(concat.603, cases=[concat.587, concat.599], default=concat.602, id=604)
}

fn __std__clzt_pow2_64(value: bits[64] id=605) -> bits[7] {
  literal.606: bits[32] = literal(value=64, id=606, pos=[(2,1609,20)])
  literal.607: bits[1] = literal(value=1, id=607, pos=[(2,1609,30)])
  bit_slice.610: bits[32] = bit_slice(value, start=32, width=32, id=610, pos=[(2,1610,41)])
  bit_slice.612: bits[32] = bit_slice(value, start=0, width=32, id=612, pos=[(2,1610,72)])
  shrl.608: bits[32] = shrl(literal.606, literal.607, id=608, pos=[(2,1609,20)])
  invoke.611: bits[6] = invoke(bit_slice.610, to_apply=__std__clzt_pow2_32, id=611, pos=[(2,1610,35)])
  invoke.613: bits[6] = invoke(bit_slice.612, to_apply=__std__clzt_pow2_32, id=613, pos=[(2,1610,66)])
  N_HALF: bits[32] = zero_ext(shrl.608, new_bit_count=32, id=609)
  ret invoke.614: bits[7] = invoke(invoke.611, invoke.613, to_apply=__std__combine_clzt_halfs__6, id=614, pos=[(2,1610,22)])
}

fn __std__combine_clzt_halfs__7(left: bits[7] id=615, right: bits[7] id=616) -> bits[8] {
  bit_slice.618: bits[1] = bit_slice(left, start=6, width=1, id=618, pos=[(2,1533,15)])
  bit_slice.619: bits[1] = bit_slice(right, start=6, width=1, id=619, pos=[(2,1533,27)])
  tuple.620: (bits[1], bits[1]) = tuple(bit_slice.618, bit_slice.619, id=620, pos=[(2,1533,10)])
  literal.634: bits[1] = literal(value=1, id=634, pos=[(2,1535,9)])
  tuple_index.633: bits[1] = tuple_index(tuple.620, index=0, id=633)
  literal.623: bits[1] = literal(value=1, id=623, pos=[(2,1534,9)])
  tuple_index.622: bits[1] = tuple_index(tuple.620, index=0, id=622)
  literal.632: bits[1] = literal(value=1, id=632)
  eq.635: bits[1] = eq(literal.634, tuple_index.633, id=635)
  literal.638: bits[1] = literal(value=0, id=638, pos=[(2,1535,15)])
  tuple_index.637: bits[1] = tuple_index(tuple.620, index=1, id=637)
  literal.621: bits[1] = literal(value=1, id=621)
  eq.624: bits[1] = eq(literal.623, tuple_index.622, id=624)
  literal.627: bits[1] = literal(value=1, id=627, pos=[(2,1534,15)])
  tuple_index.626: bits[1] = tuple_index(tuple.620, index=1, id=626)
  and.636: bits[1] = and(literal.632, eq.635, id=636)
  eq.639: bits[1] = eq(literal.638, tuple_index.637, id=639)
  and.625: bits[1] = and(literal.621, eq.624, id=625)
  eq.628: bits[1] = eq(literal.627, tuple_index.626, id=628)
  and.640: bits[1] = and(and.636, eq.639, id=640)
  and.629: bits[1] = and(and.625, eq.628, id=629)
  literal.630: bits[1] = literal(value=0, id=630, pos=[(2,1534,32)])
  literal.641: bits[2] = literal(value=1, id=641, pos=[(2,1535,24)])
  bit_slice.642: bits[6] = bit_slice(right, start=0, width=6, id=642, pos=[(2,1535,40)])
  literal.645: bits[1] = literal(value=0, id=645, pos=[(2,1536,13)])
  concat.647: bits[2] = concat(and.640, and.629, id=647)
  concat.631: bits[8] = concat(left, literal.630, id=631, pos=[(2,1534,24)])
  concat.643: bits[8] = concat(literal.641, bit_slice.642, id=643, pos=[(2,1535,24)])
  concat.646: bits[8] = concat(literal.645, left, id=646, pos=[(2,1536,13)])
  N: bits[32] = literal(value=7, id=617, pos=[(2,1532,22)])
  literal.644: bits[1] = literal(value=1, id=644, pos=[(2,1536,8)])
  ret priority_sel.648: bits[8] = priority_sel(concat.647, cases=[concat.631, concat.643], default=concat.646, id=648)
}

fn __std__clzt_pow2_128(value: bits[128] id=649) -> bits[8] {
  literal.650: bits[32] = literal(value=128, id=650, pos=[(2,1614,20)])
  literal.651: bits[1] = literal(value=1, id=651, pos=[(2,1614,31)])
  bit_slice.654: bits[64] = bit_slice(value, start=64, width=64, id=654, pos=[(2,1615,41)])
  bit_slice.656: bits[64] = bit_slice(value, start=0, width=64, id=656, pos=[(2,1615,72)])
  shrl.652: bits[32] = shrl(literal.650, literal.651, id=652, pos=[(2,1614,20)])
  invoke.655: bits[7] = invoke(bit_slice.654, to_apply=__std__clzt_pow2_64, id=655, pos=[(2,1615,35)])
  invoke.657: bits[7] = invoke(bit_slice.656, to_apply=__std__clzt_pow2_64, id=657, pos=[(2,1615,66)])
  N_HALF: bits[32] = zero_ext(shrl.652, new_bit_count=32, id=653)
  ret invoke.658: bits[8] = invoke(invoke.655, invoke.657, to_apply=__std__combine_clzt_halfs__7, id=658, pos=[(2,1615,22)])
}

fn __std__combine_clzt_halfs__8(left: bits[8] id=659, right: bits[8] id=660) -> bits[9] {
  bit_slice.662: bits[1] = bit_slice(left, start=7, width=1, id=662, pos=[(2,1533,15)])
  bit_slice.663: bits[1] = bit_slice(right, start=7, width=1, id=663, pos=[(2,1533,27)])
  tuple.664: (bits[1], bits[1]) = tuple(bit_slice.662, bit_slice.663, id=664, pos=[(2,1533,10)])
  literal.678: bits[1] = literal(value=1, id=678, pos=[(2,1535,9)])
  tuple_index.677: bits[1] = tuple_index(tuple.664, index=0, id=677)
  literal.667: bits[1] = literal(value=1, id=667, pos=[(2,1534,9)])
  tuple_index.666: bits[1] = tuple_index(tuple.664, index=0, id=666)
  literal.676: bits[1] = literal(value=1, id=676)
  eq.679: bits[1] = eq(literal.678, tuple_index.677, id=679)
  literal.682: bits[1] = literal(value=0, id=682, pos=[(2,1535,15)])
  tuple_index.681: bits[1] = tuple_index(tuple.664, index=1, id=681)
  literal.665: bits[1] = literal(value=1, id=665)
  eq.668: bits[1] = eq(literal.667, tuple_index.666, id=668)
  literal.671: bits[1] = literal(value=1, id=671, pos=[(2,1534,15)])
  tuple_index.670: bits[1] = tuple_index(tuple.664, index=1, id=670)
  and.680: bits[1] = and(literal.676, eq.679, id=680)
  eq.683: bits[1] = eq(literal.682, tuple_index.681, id=683)
  and.669: bits[1] = and(literal.665, eq.668, id=669)
  eq.672: bits[1] = eq(literal.671, tuple_index.670, id=672)
  and.684: bits[1] = and(and.680, eq.683, id=684)
  and.673: bits[1] = and(and.669, eq.672, id=673)
  literal.674: bits[1] = literal(value=0, id=674, pos=[(2,1534,32)])
  literal.685: bits[2] = literal(value=1, id=685, pos=[(2,1535,24)])
  bit_slice.686: bits[7] = bit_slice(right, start=0, width=7, id=686, pos=[(2,1535,40)])
  literal.689: bits[1] = literal(value=0, id=689, pos=[(2,1536,13)])
  concat.691: bits[2] = concat(and.684, and.673, id=691)
  concat.675: bits[9] = concat(left, literal.674, id=675, pos=[(2,1534,24)])
  concat.687: bits[9] = concat(literal.685, bit_slice.686, id=687, pos=[(2,1535,24)])
  concat.690: bits[9] = concat(literal.689, left, id=690, pos=[(2,1536,13)])
  N: bits[32] = literal(value=8, id=661, pos=[(2,1532,22)])
  literal.688: bits[1] = literal(value=1, id=688, pos=[(2,1536,8)])
  ret priority_sel.692: bits[9] = priority_sel(concat.691, cases=[concat.675, concat.687], default=concat.690, id=692)
}

fn __std__clzt_pow2_256(value: bits[256] id=693) -> bits[9] {
  literal.694: bits[32] = literal(value=256, id=694, pos=[(2,1619,20)])
  literal.695: bits[1] = literal(value=1, id=695, pos=[(2,1619,31)])
  bit_slice.698: bits[128] = bit_slice(value, start=128, width=128, id=698, pos=[(2,1620,42)])
  bit_slice.700: bits[128] = bit_slice(value, start=0, width=128, id=700, pos=[(2,1620,74)])
  shrl.696: bits[32] = shrl(literal.694, literal.695, id=696, pos=[(2,1619,20)])
  invoke.699: bits[8] = invoke(bit_slice.698, to_apply=__std__clzt_pow2_128, id=699, pos=[(2,1620,36)])
  invoke.701: bits[8] = invoke(bit_slice.700, to_apply=__std__clzt_pow2_128, id=701, pos=[(2,1620,68)])
  N_HALF: bits[32] = zero_ext(shrl.696, new_bit_count=32, id=697)
  ret invoke.702: bits[9] = invoke(invoke.699, invoke.701, to_apply=__std__combine_clzt_halfs__8, id=702, pos=[(2,1620,22)])
}

fn __std__combine_clzt_halfs__9(left: bits[9] id=703, right: bits[9] id=704) -> bits[10] {
  bit_slice.706: bits[1] = bit_slice(left, start=8, width=1, id=706, pos=[(2,1533,15)])
  bit_slice.707: bits[1] = bit_slice(right, start=8, width=1, id=707, pos=[(2,1533,27)])
  tuple.708: (bits[1], bits[1]) = tuple(bit_slice.706, bit_slice.707, id=708, pos=[(2,1533,10)])
  literal.722: bits[1] = literal(value=1, id=722, pos=[(2,1535,9)])
  tuple_index.721: bits[1] = tuple_index(tuple.708, index=0, id=721)
  literal.711: bits[1] = literal(value=1, id=711, pos=[(2,1534,9)])
  tuple_index.710: bits[1] = tuple_index(tuple.708, index=0, id=710)
  literal.720: bits[1] = literal(value=1, id=720)
  eq.723: bits[1] = eq(literal.722, tuple_index.721, id=723)
  literal.726: bits[1] = literal(value=0, id=726, pos=[(2,1535,15)])
  tuple_index.725: bits[1] = tuple_index(tuple.708, index=1, id=725)
  literal.709: bits[1] = literal(value=1, id=709)
  eq.712: bits[1] = eq(literal.711, tuple_index.710, id=712)
  literal.715: bits[1] = literal(value=1, id=715, pos=[(2,1534,15)])
  tuple_index.714: bits[1] = tuple_index(tuple.708, index=1, id=714)
  and.724: bits[1] = and(literal.720, eq.723, id=724)
  eq.727: bits[1] = eq(literal.726, tuple_index.725, id=727)
  and.713: bits[1] = and(literal.709, eq.712, id=713)
  eq.716: bits[1] = eq(literal.715, tuple_index.714, id=716)
  and.728: bits[1] = and(and.724, eq.727, id=728)
  and.717: bits[1] = and(and.713, eq.716, id=717)
  literal.718: bits[1] = literal(value=0, id=718, pos=[(2,1534,32)])
  literal.729: bits[2] = literal(value=1, id=729, pos=[(2,1535,24)])
  bit_slice.730: bits[8] = bit_slice(right, start=0, width=8, id=730, pos=[(2,1535,40)])
  literal.733: bits[1] = literal(value=0, id=733, pos=[(2,1536,13)])
  concat.735: bits[2] = concat(and.728, and.717, id=735)
  concat.719: bits[10] = concat(left, literal.718, id=719, pos=[(2,1534,24)])
  concat.731: bits[10] = concat(literal.729, bit_slice.730, id=731, pos=[(2,1535,24)])
  concat.734: bits[10] = concat(literal.733, left, id=734, pos=[(2,1536,13)])
  N: bits[32] = literal(value=9, id=705, pos=[(2,1532,22)])
  literal.732: bits[1] = literal(value=1, id=732, pos=[(2,1536,8)])
  ret priority_sel.736: bits[10] = priority_sel(concat.735, cases=[concat.719, concat.731], default=concat.734, id=736)
}

fn __std__clzt_pow2_512(value: bits[512] id=737) -> bits[10] {
  literal.738: bits[32] = literal(value=512, id=738, pos=[(2,1624,20)])
  literal.739: bits[1] = literal(value=1, id=739, pos=[(2,1624,31)])
  bit_slice.742: bits[256] = bit_slice(value, start=256, width=256, id=742, pos=[(2,1625,42)])
  bit_slice.744: bits[256] = bit_slice(value, start=0, width=256, id=744, pos=[(2,1625,74)])
  shrl.740: bits[32] = shrl(literal.738, literal.739, id=740, pos=[(2,1624,20)])
  invoke.743: bits[9] = invoke(bit_slice.742, to_apply=__std__clzt_pow2_256, id=743, pos=[(2,1625,36)])
  invoke.745: bits[9] = invoke(bit_slice.744, to_apply=__std__clzt_pow2_256, id=745, pos=[(2,1625,68)])
  N_HALF: bits[32] = zero_ext(shrl.740, new_bit_count=32, id=741)
  ret invoke.746: bits[10] = invoke(invoke.743, invoke.745, to_apply=__std__combine_clzt_halfs__9, id=746, pos=[(2,1625,22)])
}

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

fn __std__clzt__28_5(value: bits[28] id=808) -> bits[5] {
  invoke.813: bits[4] = invoke(to_apply=__std__mask_bits__4, id=813, pos=[(2,1702,32)])
  N: bits[32] = literal(value=28, id=809, pos=[(2,1699,12)])
  concat.814: bits[32] = concat(value, invoke.813, id=814, pos=[(2,1702,14)])
  invoke.811: bits[32] = invoke(N, to_apply=__std__next_pow2, id=811, pos=[(2,1700,50)])
  invoke.815: bits[6] = invoke(concat.814, to_apply=__std__clzt_pow2__32_6, id=815, pos=[(2,1702,13)])
  RESULT_BITS: bits[32] = literal(value=5, id=810, pos=[(2,1699,20)])
  BITS_MISSING_UNTIL_POWER_TWO: bits[32] = sub(invoke.811, N, id=812, pos=[(2,1700,50)])
  ret bit_slice.816: bits[5] = bit_slice(invoke.815, start=0, width=5, id=816)
}

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

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

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

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

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

fn __apfloat__qnan__8_23() -> (bits[1], bits[8], bits[23]) {
  FRACTION_SZ: bits[32] = literal(value=23, id=1034, pos=[(0,50,25)])
  literal.1039: bits[32] = literal(value=1, id=1039, pos=[(0,54,57)])
  sub.1040: bits[32] = sub(FRACTION_SZ, literal.1039, id=1040, pos=[(0,54,43)])
  invoke.1036: bits[8] = invoke(to_apply=__std__mask_bits__8, id=1036, pos=[(0,53,28)])
  literal.1038: bits[23] = literal(value=1, id=1038, pos=[(0,54,18)])
  bit_slice.1041: bits[23] = bit_slice(sub.1040, start=0, width=23, id=1041)
  literal.1035: bits[1] = literal(value=0, id=1035, pos=[(0,52,14)])
  zero_ext.1037: bits[8] = zero_ext(invoke.1036, new_bit_count=8, id=1037)
  shll.1042: bits[23] = shll(literal.1038, bit_slice.1041, id=1042, pos=[(0,54,18)])
  EXP_SZ: bits[32] = literal(value=8, id=1033, pos=[(0,50,12)])
  ret tuple.1043: (bits[1], bits[8], bits[23]) = tuple(literal.1035, zero_ext.1037, shll.1042, id=1043, pos=[(0,51,33)])
}

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

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

fn __float32__is_zero_or_subnormal(f: (bits[1], bits[8], bits[23]) id=1051) -> bits[1] {
  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] = invoke(f, to_apply=__apfloat__is_zero_or_subnormal__8_23, id=1054, pos=[(1,82,33)])
}

fn __apfloat__inf__8_23(sign: bits[1] id=1055) -> (bits[1], bits[8], bits[23]) {
  invoke.1058: bits[8] = invoke(to_apply=__std__mask_bits__8, id=1058, pos=[(0,78,28)])
  literal.1059: bits[23] = literal(value=0, id=1059, pos=[(0,79,18)])
  EXP_SZ: bits[32] = literal(value=8, id=1056, pos=[(0,75,11)])
  FRACTION_SZ: bits[32] = literal(value=23, id=1057, pos=[(0,75,24)])
  ret tuple.1060: (bits[1], bits[8], bits[23]) = tuple(sign, invoke.1058, literal.1059, id=1060, pos=[(0,76,33)])
}

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

fn __float32__fast_rsqrt_config_refinements__1(x: (bits[1], bits[8], bits[23]) id=1065) -> (bits[1], bits[8], bits[23]) {
  x__1: (bits[1], bits[8], bits[23]) = invoke(x, to_apply=__float32__subnormals_to_zero, id=1078, pos=[(1,396,30)])
  invoke.1079: bits[32] = invoke(x__1, to_apply=__float32__flatten, id=1079, pos=[(1,398,50)])
  literal.1080: bits[32] = literal(value=1, id=1080, pos=[(1,398,57)])
  MAGIC_NUMBER: bits[32] = literal(value=1597463007, id=1077, pos=[(1,393,25)])
  shrl.1081: bits[32] = shrl(invoke.1079, literal.1080, id=1081, pos=[(1,398,50)])
  literal.1073: bits[1] = literal(value=1, id=1073, pos=[(1,392,70)])
  literal.1074: bits[22] = literal(value=0, id=1074, pos=[(1,392,78)])
  literal.1067: bits[1] = literal(value=0, id=1067, pos=[(1,391,40)])
  literal.1068: bits[8] = literal(value=126, id=1068, pos=[(1,391,52)])
  literal.1069: bits[23] = literal(value=0, id=1069, pos=[(1,391,71)])
  sub.1082: bits[32] = sub(MAGIC_NUMBER, shrl.1081, id=1082, pos=[(1,398,27)])
  literal.1071: bits[1] = literal(value=0, id=1071, pos=[(1,392,39)])
  literal.1072: bits[8] = literal(value=127, id=1072, pos=[(1,392,51)])
  concat.1075: bits[23] = concat(literal.1073, literal.1074, id=1075, pos=[(1,392,70)])
  ZERO_POINT_FIVE: (bits[1], bits[8], bits[23]) = tuple(literal.1067, literal.1068, literal.1069, id=1070, pos=[(1,391,32)])
  approx: (bits[1], bits[8], bits[23]) = invoke(sub.1082, to_apply=__float32__unflatten, id=1083, pos=[(1,398,26)])
  ONE_POINT_FIVE: (bits[1], bits[8], bits[23]) = tuple(literal.1071, literal.1072, concat.1075, id=1076, pos=[(1,392,31)])
  half_x: (bits[1], bits[8], bits[23]) = invoke(x__1, ZERO_POINT_FIVE, to_apply=__float32__mul, id=1084, pos=[(1,399,20)])
  x__1_sign: bits[1] = tuple_index(x__1, index=0, id=1102, pos=[(1,417,38)])
  x__1_sign__1: bits[1] = tuple_index(x__1, index=0, id=1105, pos=[(1,419,21)])
  literal.1106: bits[1] = literal(value=1, id=1106, pos=[(1,419,30)])
  invoke.1101: bits[1] = invoke(x__1, to_apply=__float32__is_inf, id=1101, 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=1100)
  invoke.1103: (bits[1], bits[8], bits[23]) = invoke(x__1_sign, to_apply=__float32__zero, id=1103, pos=[(1,417,36)])
  eq.1107: bits[1] = eq(x__1_sign__1, literal.1106, id=1107, pos=[(1,419,21)])
  result__1: (bits[1], bits[8], bits[23]) = sel(invoke.1101, cases=[result, invoke.1103], id=1104, pos=[(1,417,17)])
  invoke.1108: (bits[1], bits[8], bits[23]) = invoke(to_apply=__float32__qnan, id=1108, pos=[(1,419,41)])
  invoke.1110: bits[1] = invoke(x__1, to_apply=__float32__is_nan, id=1110, pos=[(1,421,26)])
  result__2: (bits[1], bits[8], bits[23]) = sel(eq.1107, cases=[result__1, invoke.1108], id=1109, pos=[(1,419,17)])
  x__1_sign__2: bits[1] = tuple_index(x__1, index=0, id=1113, pos=[(1,423,51)])
  invoke.1112: bits[1] = invoke(x__1, to_apply=__float32__is_zero_or_subnormal, id=1112, pos=[(1,423,40)])
  result__3: (bits[1], bits[8], bits[23]) = sel(invoke.1110, cases=[result__2, x__1], id=1111, pos=[(1,421,17)])
  invoke.1114: (bits[1], bits[8], bits[23]) = invoke(x__1_sign__2, to_apply=__float32__inf, id=1114, pos=[(1,423,49)])
  NUM_REFINEMENTS: bits[32] = literal(value=1, id=1066, pos=[(1,390,37)])
  ret result__4: (bits[1], bits[8], bits[23]) = sel(invoke.1112, cases=[result__3, invoke.1114], id=1115, pos=[(1,423,17)])
}

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