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,1120,45)])
  bit_slice.222: bits[1] = bit_slice(full_result, start=8, width=1, id=222, pos=[(2,1122,49)])
  overflow_detected: bits[1] = or_reduce(bit_slice.222, id=223, pos=[(2,1122,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,1114,5)])
  N: bits[32] = literal(value=8, id=214, pos=[(2,1114,13)])
  M: bits[32] = literal(value=8, id=215, pos=[(2,1114,21)])
  MAX_N_M: bits[32] = literal(value=8, id=216, pos=[(2,1114,29)])
  MAX_N_M_V: bits[32] = literal(value=8, id=217, pos=[(2,1114,57)])
  ret tuple.224: (bits[1], bits[8]) = tuple(overflow_detected, narrowed_result, id=224, pos=[(2,1124,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,1412,19)])
  shll.259: bits[28] = shll(literal.258, n, id=259, pos=[(2,1412,19)])
  not.260: bits[28] = not(shll.259, id=260, pos=[(2,1412,8)])
  WIDTH: bits[32] = literal(value=28, id=256, pos=[(2,1411,17)])
  N_WIDTH: bits[32] = literal(value=8, id=257, pos=[(2,1411,29)])
  ret and.261: bits[28] = and(x, not.260, id=261, pos=[(2,1412,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,1498,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,1505,18)])
  shll.272: bits[28] = shll(value, sub.271, id=272, pos=[(2,1505,8)])
  literal.273: bits[28] = literal(value=0, id=273, pos=[(2,1505,47)])
  invoke.267: bits[28] = invoke(value, n, to_apply=__std__keep_lsbs__8_28, id=267, pos=[(2,1502,17)])
  literal.268: bits[28] = literal(value=0, id=268, pos=[(2,1502,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=264, pos=[(2,1498,22)])
  ne.274: bits[1] = ne(shll.272, literal.273, id=274, pos=[(2,1505,8)])
  ne.269: bits[1] = ne(invoke.267, literal.268, id=269, pos=[(2,1502,17)])
  N_WIDTH: bits[32] = literal(value=8, id=266, pos=[(2,1498,54)])
  ret sel.275: bits[1] = sel(DO_MASK_IMPL, cases=[ne.274, ne.269], id=275, pos=[(2,1500,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,1528,21)])
  N_WIDTH: bits[32] = literal(value=8, id=279, pos=[(2,1528,33)])
  ret invoke.280: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_8_28, id=280, pos=[(2,1529,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__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)
  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)
  tuple_index.323: bits[32] = tuple_index(__loop_carry, index=1, id=323)
  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,962,14)])
  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,962,9)])
  umul.338: bits[32] = umul(tuple_index.323, tuple_index.323, id=338, pos=[(2,962,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.339: (bits[32], bits[32], bits[32]) = tuple(shrl.337, umul.338, result, id=339, pos=[(2,962,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,963,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=340)
  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.341: bits[32] = literal(value=2, id=341, pos=[(2,964,9)])
  ret tuple_index.342: bits[32] = tuple_index(work, index=2, id=342, pos=[(2,964,8)])
}

fn __std__upow__32(x: bits[32] id=343, n: bits[32] id=344) -> bits[32] {
  N: bits[32] = literal(value=32, id=345, pos=[(2,967,12)])
  ret invoke.346: bits[32] = invoke(x, n, to_apply=__std__pow__32_0, id=346, pos=[(2,967,54)])
}

fn __std__next_pow2(n: bits[32] id=347) -> bits[32] {
  literal.348: bits[32] = literal(value=2, id=348, pos=[(2,1686,39)])
  invoke.349: bits[32] = invoke(n, to_apply=__std__clog2__32, id=349, pos=[(2,1686,51)])
  ret invoke.350: bits[32] = invoke(literal.348, invoke.349, to_apply=__std__upow__32, id=350, pos=[(2,1686,38)])
}

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

fn __std__clzt_pow2_1(value: bits[1] id=354) -> bits[1] {
  ret not.355: bits[1] = not(value, id=355, pos=[(2,1584,4)])
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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