package bfloat16

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

fn __std__uadd_with_overflow__8_8_8_8_8(x: bits[8] id=1, y: bits[8] id=2) -> (bits[1], bits[8]) {
  x_extended: bits[9] = zero_ext(x, new_bit_count=9, id=8)
  y_extended: bits[9] = zero_ext(y, new_bit_count=9, id=9)
  full_result: bits[9] = add(x_extended, y_extended, id=10, pos=[(0,1120,45)])
  bit_slice.12: bits[1] = bit_slice(full_result, start=8, width=1, id=12, pos=[(0,1122,49)])
  overflow_detected: bits[1] = or_reduce(bit_slice.12, id=13, pos=[(0,1122,37)])
  narrowed_result: bits[8] = bit_slice(full_result, start=0, width=8, id=11)
  V: bits[32] = literal(value=8, id=3, pos=[(0,1114,5)])
  N: bits[32] = literal(value=8, id=4, pos=[(0,1114,13)])
  M: bits[32] = literal(value=8, id=5, pos=[(0,1114,21)])
  MAX_N_M: bits[32] = literal(value=8, id=6, pos=[(0,1114,29)])
  MAX_N_M_V: bits[32] = literal(value=8, id=7, pos=[(0,1114,57)])
  ret tuple.14: (bits[1], bits[8]) = tuple(overflow_detected, narrowed_result, id=14, pos=[(0,1124,4)])
}

fn __abs_diff__abs_diff__8(x: bits[8] id=15, y: bits[8] id=16) -> (bits[1], bits[8]) {
  ynot: bits[8] = not(y, id=18, pos=[(1,90,15)])
  invoke.19: (bits[1], bits[8]) = invoke(x, ynot, to_apply=__std__uadd_with_overflow__8_8_8_8_8, id=19, pos=[(1,91,63)])
  carry_out: bits[1] = tuple_index(invoke.19, index=0, id=20, pos=[(1,91,9)])
  nc: bits[1] = not(carry_out, id=22, pos=[(1,92,19)])
  z: bits[8] = tuple_index(invoke.19, index=1, id=21, pos=[(1,91,20)])
  xor_mask: bits[8] = sign_ext(nc, new_bit_count=8, id=24, pos=[(1,94,32)])
  result: bits[8] = xor(z, xor_mask, id=25, pos=[(1,95,18)])
  N: bits[32] = literal(value=8, id=17, pos=[(1,89,16)])
  literal.23: bits[8] = literal(value=0, id=23, pos=[(1,94,42)])
  ret tuple.26: (bits[1], bits[8]) = tuple(carry_out, result, id=26, pos=[(1,96,18)])
}

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

fn __abs_diff__to_corrected__8(adr: (bits[1], bits[8]) id=30) -> bits[8] {
  adr_correction: bits[1] = tuple_index(adr, index=0, id=33, pos=[(1,54,25)])
  adr_uncorrected: bits[8] = tuple_index(adr, index=1, id=32, pos=[(1,54,7)])
  zero_ext.34: bits[8] = zero_ext(adr_correction, new_bit_count=8, id=34)
  N: bits[32] = literal(value=8, id=31, pos=[(1,53,20)])
  ret add.35: bits[8] = add(adr_uncorrected, zero_ext.34, id=35, pos=[(1,54,7)])
}

fn __apfloat__sign_magnitude_difference__8(a: bits[8] id=36, b: bits[8] id=37) -> (bits[1], bits[8]) {
  abs_diff_result: (bits[1], bits[8]) = invoke(a, b, to_apply=__abs_diff__abs_diff__8, id=39, pos=[(2,3009,44)])
  invoke.40: bits[1] = invoke(abs_diff_result, to_apply=__abs_diff__is_x_larger__8, id=40, pos=[(2,3010,27)])
  not.41: bits[1] = not(invoke.40, id=41, pos=[(2,3010,5)])
  invoke.42: bits[8] = invoke(abs_diff_result, to_apply=__abs_diff__to_corrected__8, id=42, pos=[(2,3010,68)])
  WIDTH: bits[32] = literal(value=8, id=38, pos=[(2,3008,29)])
  ret tuple.43: (bits[1], bits[8]) = tuple(not.41, invoke.42, id=43, pos=[(2,3010,4)])
}

fn __std__keep_lsbs__8_12(x: bits[12] id=44, n: bits[8] id=45) -> bits[12] {
  literal.48: bits[12] = literal(value=4095, id=48, pos=[(0,1412,19)])
  shll.49: bits[12] = shll(literal.48, n, id=49, pos=[(0,1412,19)])
  not.50: bits[12] = not(shll.49, id=50, pos=[(0,1412,8)])
  WIDTH: bits[32] = literal(value=12, id=46, pos=[(0,1411,17)])
  N_WIDTH: bits[32] = literal(value=8, id=47, pos=[(0,1411,29)])
  ret and.51: bits[12] = and(x, not.50, id=51, pos=[(0,1412,4)])
}

fn __std__or_reduce_lsb_impl__1_8_12(value: bits[12] id=52, n: bits[8] id=53) -> bits[1] {
  WIDTH: bits[32] = literal(value=12, id=55, pos=[(0,1498,42)])
  bit_slice.60: bits[8] = bit_slice(WIDTH, start=0, width=8, id=60)
  sub.61: bits[8] = sub(bit_slice.60, n, id=61, pos=[(0,1505,18)])
  shll.62: bits[12] = shll(value, sub.61, id=62, pos=[(0,1505,8)])
  literal.63: bits[12] = literal(value=0, id=63, pos=[(0,1505,47)])
  invoke.57: bits[12] = invoke(value, n, to_apply=__std__keep_lsbs__8_12, id=57, pos=[(0,1502,17)])
  literal.58: bits[12] = literal(value=0, id=58, pos=[(0,1502,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=54, pos=[(0,1498,22)])
  ne.64: bits[1] = ne(shll.62, literal.63, id=64, pos=[(0,1505,8)])
  ne.59: bits[1] = ne(invoke.57, literal.58, id=59, pos=[(0,1502,17)])
  N_WIDTH: bits[32] = literal(value=8, id=56, pos=[(0,1498,54)])
  ret sel.65: bits[1] = sel(DO_MASK_IMPL, cases=[ne.64, ne.59], id=65, pos=[(0,1500,4)])
}

fn __std__or_reduce_lsb__8_12(value: bits[12] id=66, n: bits[8] id=67) -> bits[1] {
  WIDTH: bits[32] = literal(value=12, id=68, pos=[(0,1528,21)])
  N_WIDTH: bits[32] = literal(value=8, id=69, pos=[(0,1528,33)])
  ret invoke.70: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_8_12, id=70, pos=[(0,1529,22)])
}

fn __apfloat__or_last_bit__12(value: bits[12] id=71, lsb: bits[1] id=72) -> bits[12] {
  bit_slice.75: bits[1] = bit_slice(value, start=0, width=1, id=75, pos=[(2,3053,40)])
  literal.74: bits[1] = literal(value=0, id=74, pos=[(2,3053,28)])
  or.76: bits[1] = or(bit_slice.75, lsb, id=76, pos=[(2,3053,40)])
  WIDTH: bits[32] = literal(value=12, id=73, pos=[(2,3052,15)])
  ret bit_slice_update.77: bits[12] = bit_slice_update(value, literal.74, or.76, id=77, pos=[(2,3053,20)])
}

fn __apfloat__or_last_bit__11(value: bits[11] id=78, lsb: bits[1] id=79) -> bits[11] {
  bit_slice.82: bits[1] = bit_slice(value, start=0, width=1, id=82, pos=[(2,3053,40)])
  literal.81: bits[1] = literal(value=0, id=81, pos=[(2,3053,28)])
  or.83: bits[1] = or(bit_slice.82, lsb, id=83, pos=[(2,3053,40)])
  WIDTH: bits[32] = literal(value=11, id=80, pos=[(2,3052,15)])
  ret bit_slice_update.84: bits[11] = bit_slice_update(value, literal.81, or.83, id=84, pos=[(2,3053,20)])
}

fn __std__clog2__32(x: bits[32] id=85) -> bits[32] {
  literal.90: bits[32] = literal(value=1, id=90, pos=[(0,716,49)])
  sub.91: bits[32] = sub(x, literal.90, id=91, pos=[(0,716,45)])
  reverse.92: bits[32] = reverse(sub.91, id=92, pos=[(0,716,44)])
  one_hot.93: bits[33] = one_hot(reverse.92, lsb_prio=true, id=93, pos=[(0,716,44)])
  N: bits[32] = literal(value=32, id=86, pos=[(0,715,13)])
  encode.94: bits[6] = encode(one_hot.93, id=94, pos=[(0,716,44)])
  literal.87: bits[32] = literal(value=1, id=87, pos=[(0,716,12)])
  zero_ext.89: bits[32] = zero_ext(N, new_bit_count=32, id=89)
  zero_ext.95: bits[32] = zero_ext(encode.94, new_bit_count=32, id=95, pos=[(0,716,44)])
  uge.88: bits[1] = uge(x, literal.87, id=88, pos=[(0,716,7)])
  literal.97: bits[32] = literal(value=0, id=97, pos=[(0,716,69)])
  sub.96: bits[32] = sub(zero_ext.89, zero_ext.95, id=96, pos=[(0,716,25)])
  ret sel.98: bits[32] = sel(uge.88, cases=[literal.97, sub.96], id=98, pos=[(0,716,4)])
}

fn ____std__pow__32_0_counted_for_0_body(i: bits[32] id=105, __loop_carry: (bits[32], bits[32], bits[32]) id=108) -> (bits[32], bits[32], bits[32]) {
  tuple_index.110: bits[32] = tuple_index(__loop_carry, index=0, id=110)
  literal.120: bits[32] = literal(value=1, id=120, pos=[(0,960,29)])
  literal.109: bits[1] = literal(value=1, id=109)
  literal.111: bits[1] = literal(value=1, id=111)
  and.121: bits[32] = and(tuple_index.110, literal.120, id=121, pos=[(0,960,25)])
  literal.122: bits[32] = literal(value=1, id=122, pos=[(0,960,41)])
  tuple_index.116: bits[32] = tuple_index(__loop_carry, index=2, id=116)
  tuple_index.113: bits[32] = tuple_index(__loop_carry, index=1, id=113)
  and.112: bits[1] = and(literal.109, literal.111, id=112)
  literal.114: bits[1] = literal(value=1, id=114)
  literal.126: bits[1] = literal(value=1, id=126, pos=[(0,962,14)])
  eq.123: bits[1] = eq(and.121, literal.122, id=123, pos=[(0,960,25)])
  umul.124: bits[32] = umul(tuple_index.116, tuple_index.113, id=124, pos=[(0,960,51)])
  literal.106: bits[32] = literal(value=0, id=106)
  and.115: bits[1] = and(and.112, literal.114, id=115)
  literal.117: bits[1] = literal(value=1, id=117)
  shrl.127: bits[32] = shrl(tuple_index.110, literal.126, id=127, pos=[(0,962,9)])
  umul.128: bits[32] = umul(tuple_index.113, tuple_index.113, id=128, pos=[(0,962,17)])
  result: bits[32] = sel(eq.123, cases=[tuple_index.116, umul.124], id=125, pos=[(0,960,21)])
  add.107: bits[32] = add(i, literal.106, id=107)
  and.118: bits[1] = and(and.115, literal.117, id=118)
  literal.119: bits[32] = literal(value=32, id=119, pos=[(0,955,20)])
  ret tuple.129: (bits[32], bits[32], bits[32]) = tuple(shrl.127, umul.128, result, id=129, pos=[(0,962,8)])
}

fn __std__pow__32_0(x: bits[32] id=99, n: bits[32] id=100) -> bits[32] {
  result: bits[32] = literal(value=1, id=103, pos=[(0,956,17)])
  tuple.104: (bits[32], bits[32], bits[32]) = tuple(n, x, result, id=104, pos=[(0,963,6)])
  work: (bits[32], bits[32], bits[32]) = counted_for(tuple.104, trip_count=32, stride=1, body=____std__pow__32_0_counted_for_0_body, id=130)
  S: bits[1] = literal(value=0, id=101, pos=[(0,955,11)])
  N: bits[32] = literal(value=32, id=102, pos=[(0,955,20)])
  literal.131: bits[32] = literal(value=2, id=131, pos=[(0,964,9)])
  ret tuple_index.132: bits[32] = tuple_index(work, index=2, id=132, pos=[(0,964,8)])
}

fn __std__upow__32(x: bits[32] id=133, n: bits[32] id=134) -> bits[32] {
  N: bits[32] = literal(value=32, id=135, pos=[(0,967,12)])
  ret invoke.136: bits[32] = invoke(x, n, to_apply=__std__pow__32_0, id=136, pos=[(0,967,54)])
}

fn __std__next_pow2(n: bits[32] id=137) -> bits[32] {
  literal.138: bits[32] = literal(value=2, id=138, pos=[(0,1686,39)])
  invoke.139: bits[32] = invoke(n, to_apply=__std__clog2__32, id=139, pos=[(0,1686,51)])
  ret invoke.140: bits[32] = invoke(literal.138, invoke.139, to_apply=__std__upow__32, id=140, pos=[(0,1686,38)])
}

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

fn __std__clzt_pow2_1(value: bits[1] id=144) -> bits[1] {
  ret not.145: bits[1] = not(value, id=145, pos=[(0,1584,4)])
}

fn __std__combine_clzt_halfs__1(left: bits[1] id=146, right: bits[1] id=147) -> bits[2] {
  bit_slice.149: bits[1] = bit_slice(left, start=0, width=1, id=149, pos=[(0,1539,15)])
  bit_slice.150: bits[1] = bit_slice(right, start=0, width=1, id=150, pos=[(0,1539,27)])
  tuple.151: (bits[1], bits[1]) = tuple(bit_slice.149, bit_slice.150, id=151, pos=[(0,1539,10)])
  literal.165: bits[1] = literal(value=1, id=165, pos=[(0,1541,9)])
  tuple_index.164: bits[1] = tuple_index(tuple.151, index=0, id=164)
  literal.154: bits[1] = literal(value=1, id=154, pos=[(0,1540,9)])
  tuple_index.153: bits[1] = tuple_index(tuple.151, index=0, id=153)
  literal.163: bits[1] = literal(value=1, id=163)
  eq.166: bits[1] = eq(literal.165, tuple_index.164, id=166)
  literal.169: bits[1] = literal(value=0, id=169, pos=[(0,1541,15)])
  tuple_index.168: bits[1] = tuple_index(tuple.151, index=1, id=168)
  literal.152: bits[1] = literal(value=1, id=152)
  eq.155: bits[1] = eq(literal.154, tuple_index.153, id=155)
  literal.158: bits[1] = literal(value=1, id=158, pos=[(0,1540,15)])
  tuple_index.157: bits[1] = tuple_index(tuple.151, index=1, id=157)
  and.167: bits[1] = and(literal.163, eq.166, id=167)
  eq.170: bits[1] = eq(literal.169, tuple_index.168, id=170)
  and.156: bits[1] = and(literal.152, eq.155, id=156)
  eq.159: bits[1] = eq(literal.158, tuple_index.157, id=159)
  and.171: bits[1] = and(and.167, eq.170, id=171)
  and.160: bits[1] = and(and.156, eq.159, id=160)
  literal.161: bits[1] = literal(value=0, id=161, pos=[(0,1540,32)])
  literal.172: bits[2] = literal(value=1, id=172, pos=[(0,1541,24)])
  bit_slice.173: bits[0] = bit_slice(right, start=0, width=0, id=173, pos=[(0,1541,40)])
  literal.176: bits[1] = literal(value=0, id=176, pos=[(0,1542,13)])
  concat.178: bits[2] = concat(and.171, and.160, id=178)
  concat.162: bits[2] = concat(left, literal.161, id=162, pos=[(0,1540,24)])
  concat.174: bits[2] = concat(literal.172, bit_slice.173, id=174, pos=[(0,1541,24)])
  concat.177: bits[2] = concat(literal.176, left, id=177, pos=[(0,1542,13)])
  N: bits[32] = literal(value=1, id=148, pos=[(0,1538,22)])
  literal.175: bits[1] = literal(value=1, id=175, pos=[(0,1542,8)])
  ret priority_sel.179: bits[2] = priority_sel(concat.178, cases=[concat.162, concat.174], default=concat.177, id=179)
}

fn __std__clzt_pow2_2(value: bits[2] id=180) -> bits[2] {
  literal.181: bits[32] = literal(value=2, id=181, pos=[(0,1590,20)])
  literal.182: bits[1] = literal(value=1, id=182, pos=[(0,1590,29)])
  bit_slice.185: bits[1] = bit_slice(value, start=1, width=1, id=185, pos=[(0,1591,40)])
  bit_slice.187: bits[1] = bit_slice(value, start=0, width=1, id=187, pos=[(0,1591,70)])
  shrl.183: bits[32] = shrl(literal.181, literal.182, id=183, pos=[(0,1590,20)])
  invoke.186: bits[1] = invoke(bit_slice.185, to_apply=__std__clzt_pow2_1, id=186, pos=[(0,1591,34)])
  invoke.188: bits[1] = invoke(bit_slice.187, to_apply=__std__clzt_pow2_1, id=188, pos=[(0,1591,64)])
  N_HALF: bits[32] = zero_ext(shrl.183, new_bit_count=32, id=184)
  ret invoke.189: bits[2] = invoke(invoke.186, invoke.188, to_apply=__std__combine_clzt_halfs__1, id=189, pos=[(0,1591,22)])
}

fn __std__combine_clzt_halfs__2(left: bits[2] id=190, right: bits[2] id=191) -> bits[3] {
  bit_slice.193: bits[1] = bit_slice(left, start=1, width=1, id=193, pos=[(0,1539,15)])
  bit_slice.194: bits[1] = bit_slice(right, start=1, width=1, id=194, pos=[(0,1539,27)])
  tuple.195: (bits[1], bits[1]) = tuple(bit_slice.193, bit_slice.194, id=195, pos=[(0,1539,10)])
  literal.209: bits[1] = literal(value=1, id=209, pos=[(0,1541,9)])
  tuple_index.208: bits[1] = tuple_index(tuple.195, index=0, id=208)
  literal.198: bits[1] = literal(value=1, id=198, pos=[(0,1540,9)])
  tuple_index.197: bits[1] = tuple_index(tuple.195, index=0, id=197)
  literal.207: bits[1] = literal(value=1, id=207)
  eq.210: bits[1] = eq(literal.209, tuple_index.208, id=210)
  literal.213: bits[1] = literal(value=0, id=213, pos=[(0,1541,15)])
  tuple_index.212: bits[1] = tuple_index(tuple.195, index=1, id=212)
  literal.196: bits[1] = literal(value=1, id=196)
  eq.199: bits[1] = eq(literal.198, tuple_index.197, id=199)
  literal.202: bits[1] = literal(value=1, id=202, pos=[(0,1540,15)])
  tuple_index.201: bits[1] = tuple_index(tuple.195, index=1, id=201)
  and.211: bits[1] = and(literal.207, eq.210, id=211)
  eq.214: bits[1] = eq(literal.213, tuple_index.212, id=214)
  and.200: bits[1] = and(literal.196, eq.199, id=200)
  eq.203: bits[1] = eq(literal.202, tuple_index.201, id=203)
  and.215: bits[1] = and(and.211, eq.214, id=215)
  and.204: bits[1] = and(and.200, eq.203, id=204)
  literal.205: bits[1] = literal(value=0, id=205, pos=[(0,1540,32)])
  literal.216: bits[2] = literal(value=1, id=216, pos=[(0,1541,24)])
  bit_slice.217: bits[1] = bit_slice(right, start=0, width=1, id=217, pos=[(0,1541,40)])
  literal.220: bits[1] = literal(value=0, id=220, pos=[(0,1542,13)])
  concat.222: bits[2] = concat(and.215, and.204, id=222)
  concat.206: bits[3] = concat(left, literal.205, id=206, pos=[(0,1540,24)])
  concat.218: bits[3] = concat(literal.216, bit_slice.217, id=218, pos=[(0,1541,24)])
  concat.221: bits[3] = concat(literal.220, left, id=221, pos=[(0,1542,13)])
  N: bits[32] = literal(value=2, id=192, pos=[(0,1538,22)])
  literal.219: bits[1] = literal(value=1, id=219, pos=[(0,1542,8)])
  ret priority_sel.223: bits[3] = priority_sel(concat.222, cases=[concat.206, concat.218], default=concat.221, id=223)
}

fn __std__clzt_pow2_4(value: bits[4] id=224) -> bits[3] {
  literal.225: bits[32] = literal(value=4, id=225, pos=[(0,1595,20)])
  literal.226: bits[1] = literal(value=1, id=226, pos=[(0,1595,29)])
  bit_slice.229: bits[2] = bit_slice(value, start=2, width=2, id=229, pos=[(0,1596,40)])
  bit_slice.231: bits[2] = bit_slice(value, start=0, width=2, id=231, pos=[(0,1596,70)])
  shrl.227: bits[32] = shrl(literal.225, literal.226, id=227, pos=[(0,1595,20)])
  invoke.230: bits[2] = invoke(bit_slice.229, to_apply=__std__clzt_pow2_2, id=230, pos=[(0,1596,34)])
  invoke.232: bits[2] = invoke(bit_slice.231, to_apply=__std__clzt_pow2_2, id=232, pos=[(0,1596,64)])
  N_HALF: bits[32] = zero_ext(shrl.227, new_bit_count=32, id=228)
  ret invoke.233: bits[3] = invoke(invoke.230, invoke.232, to_apply=__std__combine_clzt_halfs__2, id=233, pos=[(0,1596,22)])
}

fn __std__combine_clzt_halfs__3(left: bits[3] id=234, right: bits[3] id=235) -> bits[4] {
  bit_slice.237: bits[1] = bit_slice(left, start=2, width=1, id=237, pos=[(0,1539,15)])
  bit_slice.238: bits[1] = bit_slice(right, start=2, width=1, id=238, pos=[(0,1539,27)])
  tuple.239: (bits[1], bits[1]) = tuple(bit_slice.237, bit_slice.238, id=239, pos=[(0,1539,10)])
  literal.253: bits[1] = literal(value=1, id=253, pos=[(0,1541,9)])
  tuple_index.252: bits[1] = tuple_index(tuple.239, index=0, id=252)
  literal.242: bits[1] = literal(value=1, id=242, pos=[(0,1540,9)])
  tuple_index.241: bits[1] = tuple_index(tuple.239, index=0, id=241)
  literal.251: bits[1] = literal(value=1, id=251)
  eq.254: bits[1] = eq(literal.253, tuple_index.252, id=254)
  literal.257: bits[1] = literal(value=0, id=257, pos=[(0,1541,15)])
  tuple_index.256: bits[1] = tuple_index(tuple.239, index=1, id=256)
  literal.240: bits[1] = literal(value=1, id=240)
  eq.243: bits[1] = eq(literal.242, tuple_index.241, id=243)
  literal.246: bits[1] = literal(value=1, id=246, pos=[(0,1540,15)])
  tuple_index.245: bits[1] = tuple_index(tuple.239, index=1, id=245)
  and.255: bits[1] = and(literal.251, eq.254, id=255)
  eq.258: bits[1] = eq(literal.257, tuple_index.256, id=258)
  and.244: bits[1] = and(literal.240, eq.243, id=244)
  eq.247: bits[1] = eq(literal.246, tuple_index.245, id=247)
  and.259: bits[1] = and(and.255, eq.258, id=259)
  and.248: bits[1] = and(and.244, eq.247, id=248)
  literal.249: bits[1] = literal(value=0, id=249, pos=[(0,1540,32)])
  literal.260: bits[2] = literal(value=1, id=260, pos=[(0,1541,24)])
  bit_slice.261: bits[2] = bit_slice(right, start=0, width=2, id=261, pos=[(0,1541,40)])
  literal.264: bits[1] = literal(value=0, id=264, pos=[(0,1542,13)])
  concat.266: bits[2] = concat(and.259, and.248, id=266)
  concat.250: bits[4] = concat(left, literal.249, id=250, pos=[(0,1540,24)])
  concat.262: bits[4] = concat(literal.260, bit_slice.261, id=262, pos=[(0,1541,24)])
  concat.265: bits[4] = concat(literal.264, left, id=265, pos=[(0,1542,13)])
  N: bits[32] = literal(value=3, id=236, pos=[(0,1538,22)])
  literal.263: bits[1] = literal(value=1, id=263, pos=[(0,1542,8)])
  ret priority_sel.267: bits[4] = priority_sel(concat.266, cases=[concat.250, concat.262], default=concat.265, id=267)
}

fn __std__clzt_pow2_8(value: bits[8] id=268) -> bits[4] {
  literal.269: bits[32] = literal(value=8, id=269, pos=[(0,1600,20)])
  literal.270: bits[1] = literal(value=1, id=270, pos=[(0,1600,29)])
  bit_slice.273: bits[4] = bit_slice(value, start=4, width=4, id=273, pos=[(0,1601,40)])
  bit_slice.275: bits[4] = bit_slice(value, start=0, width=4, id=275, pos=[(0,1601,70)])
  shrl.271: bits[32] = shrl(literal.269, literal.270, id=271, pos=[(0,1600,20)])
  invoke.274: bits[3] = invoke(bit_slice.273, to_apply=__std__clzt_pow2_4, id=274, pos=[(0,1601,34)])
  invoke.276: bits[3] = invoke(bit_slice.275, to_apply=__std__clzt_pow2_4, id=276, pos=[(0,1601,64)])
  N_HALF: bits[32] = zero_ext(shrl.271, new_bit_count=32, id=272)
  ret invoke.277: bits[4] = invoke(invoke.274, invoke.276, to_apply=__std__combine_clzt_halfs__3, id=277, pos=[(0,1601,22)])
}

fn __std__combine_clzt_halfs__4(left: bits[4] id=278, right: bits[4] id=279) -> bits[5] {
  bit_slice.281: bits[1] = bit_slice(left, start=3, width=1, id=281, pos=[(0,1539,15)])
  bit_slice.282: bits[1] = bit_slice(right, start=3, width=1, id=282, pos=[(0,1539,27)])
  tuple.283: (bits[1], bits[1]) = tuple(bit_slice.281, bit_slice.282, id=283, pos=[(0,1539,10)])
  literal.297: bits[1] = literal(value=1, id=297, pos=[(0,1541,9)])
  tuple_index.296: bits[1] = tuple_index(tuple.283, index=0, id=296)
  literal.286: bits[1] = literal(value=1, id=286, pos=[(0,1540,9)])
  tuple_index.285: bits[1] = tuple_index(tuple.283, index=0, id=285)
  literal.295: bits[1] = literal(value=1, id=295)
  eq.298: bits[1] = eq(literal.297, tuple_index.296, id=298)
  literal.301: bits[1] = literal(value=0, id=301, pos=[(0,1541,15)])
  tuple_index.300: bits[1] = tuple_index(tuple.283, index=1, id=300)
  literal.284: bits[1] = literal(value=1, id=284)
  eq.287: bits[1] = eq(literal.286, tuple_index.285, id=287)
  literal.290: bits[1] = literal(value=1, id=290, pos=[(0,1540,15)])
  tuple_index.289: bits[1] = tuple_index(tuple.283, index=1, id=289)
  and.299: bits[1] = and(literal.295, eq.298, id=299)
  eq.302: bits[1] = eq(literal.301, tuple_index.300, id=302)
  and.288: bits[1] = and(literal.284, eq.287, id=288)
  eq.291: bits[1] = eq(literal.290, tuple_index.289, id=291)
  and.303: bits[1] = and(and.299, eq.302, id=303)
  and.292: bits[1] = and(and.288, eq.291, id=292)
  literal.293: bits[1] = literal(value=0, id=293, pos=[(0,1540,32)])
  literal.304: bits[2] = literal(value=1, id=304, pos=[(0,1541,24)])
  bit_slice.305: bits[3] = bit_slice(right, start=0, width=3, id=305, pos=[(0,1541,40)])
  literal.308: bits[1] = literal(value=0, id=308, pos=[(0,1542,13)])
  concat.310: bits[2] = concat(and.303, and.292, id=310)
  concat.294: bits[5] = concat(left, literal.293, id=294, pos=[(0,1540,24)])
  concat.306: bits[5] = concat(literal.304, bit_slice.305, id=306, pos=[(0,1541,24)])
  concat.309: bits[5] = concat(literal.308, left, id=309, pos=[(0,1542,13)])
  N: bits[32] = literal(value=4, id=280, pos=[(0,1538,22)])
  literal.307: bits[1] = literal(value=1, id=307, pos=[(0,1542,8)])
  ret priority_sel.311: bits[5] = priority_sel(concat.310, cases=[concat.294, concat.306], default=concat.309, id=311)
}

fn __std__clzt_pow2_16(value: bits[16] id=312) -> bits[5] {
  literal.313: bits[32] = literal(value=16, id=313, pos=[(0,1605,20)])
  literal.314: bits[1] = literal(value=1, id=314, pos=[(0,1605,30)])
  bit_slice.317: bits[8] = bit_slice(value, start=8, width=8, id=317, pos=[(0,1606,40)])
  bit_slice.319: bits[8] = bit_slice(value, start=0, width=8, id=319, pos=[(0,1606,70)])
  shrl.315: bits[32] = shrl(literal.313, literal.314, id=315, pos=[(0,1605,20)])
  invoke.318: bits[4] = invoke(bit_slice.317, to_apply=__std__clzt_pow2_8, id=318, pos=[(0,1606,34)])
  invoke.320: bits[4] = invoke(bit_slice.319, to_apply=__std__clzt_pow2_8, id=320, pos=[(0,1606,64)])
  N_HALF: bits[32] = zero_ext(shrl.315, new_bit_count=32, id=316)
  ret invoke.321: bits[5] = invoke(invoke.318, invoke.320, to_apply=__std__combine_clzt_halfs__4, id=321, pos=[(0,1606,22)])
}

fn __std__combine_clzt_halfs__5(left: bits[5] id=322, right: bits[5] id=323) -> bits[6] {
  bit_slice.325: bits[1] = bit_slice(left, start=4, width=1, id=325, pos=[(0,1539,15)])
  bit_slice.326: bits[1] = bit_slice(right, start=4, width=1, id=326, pos=[(0,1539,27)])
  tuple.327: (bits[1], bits[1]) = tuple(bit_slice.325, bit_slice.326, id=327, pos=[(0,1539,10)])
  literal.341: bits[1] = literal(value=1, id=341, pos=[(0,1541,9)])
  tuple_index.340: bits[1] = tuple_index(tuple.327, index=0, id=340)
  literal.330: bits[1] = literal(value=1, id=330, pos=[(0,1540,9)])
  tuple_index.329: bits[1] = tuple_index(tuple.327, index=0, id=329)
  literal.339: bits[1] = literal(value=1, id=339)
  eq.342: bits[1] = eq(literal.341, tuple_index.340, id=342)
  literal.345: bits[1] = literal(value=0, id=345, pos=[(0,1541,15)])
  tuple_index.344: bits[1] = tuple_index(tuple.327, index=1, id=344)
  literal.328: bits[1] = literal(value=1, id=328)
  eq.331: bits[1] = eq(literal.330, tuple_index.329, id=331)
  literal.334: bits[1] = literal(value=1, id=334, pos=[(0,1540,15)])
  tuple_index.333: bits[1] = tuple_index(tuple.327, index=1, id=333)
  and.343: bits[1] = and(literal.339, eq.342, id=343)
  eq.346: bits[1] = eq(literal.345, tuple_index.344, id=346)
  and.332: bits[1] = and(literal.328, eq.331, id=332)
  eq.335: bits[1] = eq(literal.334, tuple_index.333, id=335)
  and.347: bits[1] = and(and.343, eq.346, id=347)
  and.336: bits[1] = and(and.332, eq.335, id=336)
  literal.337: bits[1] = literal(value=0, id=337, pos=[(0,1540,32)])
  literal.348: bits[2] = literal(value=1, id=348, pos=[(0,1541,24)])
  bit_slice.349: bits[4] = bit_slice(right, start=0, width=4, id=349, pos=[(0,1541,40)])
  literal.352: bits[1] = literal(value=0, id=352, pos=[(0,1542,13)])
  concat.354: bits[2] = concat(and.347, and.336, id=354)
  concat.338: bits[6] = concat(left, literal.337, id=338, pos=[(0,1540,24)])
  concat.350: bits[6] = concat(literal.348, bit_slice.349, id=350, pos=[(0,1541,24)])
  concat.353: bits[6] = concat(literal.352, left, id=353, pos=[(0,1542,13)])
  N: bits[32] = literal(value=5, id=324, pos=[(0,1538,22)])
  literal.351: bits[1] = literal(value=1, id=351, pos=[(0,1542,8)])
  ret priority_sel.355: bits[6] = priority_sel(concat.354, cases=[concat.338, concat.350], default=concat.353, id=355)
}

fn __std__clzt_pow2_32(value: bits[32] id=356) -> bits[6] {
  literal.357: bits[32] = literal(value=32, id=357, pos=[(0,1610,20)])
  literal.358: bits[1] = literal(value=1, id=358, pos=[(0,1610,30)])
  bit_slice.361: bits[16] = bit_slice(value, start=16, width=16, id=361, pos=[(0,1611,41)])
  bit_slice.363: bits[16] = bit_slice(value, start=0, width=16, id=363, pos=[(0,1611,72)])
  shrl.359: bits[32] = shrl(literal.357, literal.358, id=359, pos=[(0,1610,20)])
  invoke.362: bits[5] = invoke(bit_slice.361, to_apply=__std__clzt_pow2_16, id=362, pos=[(0,1611,35)])
  invoke.364: bits[5] = invoke(bit_slice.363, to_apply=__std__clzt_pow2_16, id=364, pos=[(0,1611,66)])
  N_HALF: bits[32] = zero_ext(shrl.359, new_bit_count=32, id=360)
  ret invoke.365: bits[6] = invoke(invoke.362, invoke.364, to_apply=__std__combine_clzt_halfs__5, id=365, pos=[(0,1611,22)])
}

fn __std__combine_clzt_halfs__6(left: bits[6] id=366, right: bits[6] id=367) -> bits[7] {
  bit_slice.369: bits[1] = bit_slice(left, start=5, width=1, id=369, pos=[(0,1539,15)])
  bit_slice.370: bits[1] = bit_slice(right, start=5, width=1, id=370, pos=[(0,1539,27)])
  tuple.371: (bits[1], bits[1]) = tuple(bit_slice.369, bit_slice.370, id=371, pos=[(0,1539,10)])
  literal.385: bits[1] = literal(value=1, id=385, pos=[(0,1541,9)])
  tuple_index.384: bits[1] = tuple_index(tuple.371, index=0, id=384)
  literal.374: bits[1] = literal(value=1, id=374, pos=[(0,1540,9)])
  tuple_index.373: bits[1] = tuple_index(tuple.371, index=0, id=373)
  literal.383: bits[1] = literal(value=1, id=383)
  eq.386: bits[1] = eq(literal.385, tuple_index.384, id=386)
  literal.389: bits[1] = literal(value=0, id=389, pos=[(0,1541,15)])
  tuple_index.388: bits[1] = tuple_index(tuple.371, index=1, id=388)
  literal.372: bits[1] = literal(value=1, id=372)
  eq.375: bits[1] = eq(literal.374, tuple_index.373, id=375)
  literal.378: bits[1] = literal(value=1, id=378, pos=[(0,1540,15)])
  tuple_index.377: bits[1] = tuple_index(tuple.371, index=1, id=377)
  and.387: bits[1] = and(literal.383, eq.386, id=387)
  eq.390: bits[1] = eq(literal.389, tuple_index.388, id=390)
  and.376: bits[1] = and(literal.372, eq.375, id=376)
  eq.379: bits[1] = eq(literal.378, tuple_index.377, id=379)
  and.391: bits[1] = and(and.387, eq.390, id=391)
  and.380: bits[1] = and(and.376, eq.379, id=380)
  literal.381: bits[1] = literal(value=0, id=381, pos=[(0,1540,32)])
  literal.392: bits[2] = literal(value=1, id=392, pos=[(0,1541,24)])
  bit_slice.393: bits[5] = bit_slice(right, start=0, width=5, id=393, pos=[(0,1541,40)])
  literal.396: bits[1] = literal(value=0, id=396, pos=[(0,1542,13)])
  concat.398: bits[2] = concat(and.391, and.380, id=398)
  concat.382: bits[7] = concat(left, literal.381, id=382, pos=[(0,1540,24)])
  concat.394: bits[7] = concat(literal.392, bit_slice.393, id=394, pos=[(0,1541,24)])
  concat.397: bits[7] = concat(literal.396, left, id=397, pos=[(0,1542,13)])
  N: bits[32] = literal(value=6, id=368, pos=[(0,1538,22)])
  literal.395: bits[1] = literal(value=1, id=395, pos=[(0,1542,8)])
  ret priority_sel.399: bits[7] = priority_sel(concat.398, cases=[concat.382, concat.394], default=concat.397, id=399)
}

fn __std__clzt_pow2_64(value: bits[64] id=400) -> bits[7] {
  literal.401: bits[32] = literal(value=64, id=401, pos=[(0,1615,20)])
  literal.402: bits[1] = literal(value=1, id=402, pos=[(0,1615,30)])
  bit_slice.405: bits[32] = bit_slice(value, start=32, width=32, id=405, pos=[(0,1616,41)])
  bit_slice.407: bits[32] = bit_slice(value, start=0, width=32, id=407, pos=[(0,1616,72)])
  shrl.403: bits[32] = shrl(literal.401, literal.402, id=403, pos=[(0,1615,20)])
  invoke.406: bits[6] = invoke(bit_slice.405, to_apply=__std__clzt_pow2_32, id=406, pos=[(0,1616,35)])
  invoke.408: bits[6] = invoke(bit_slice.407, to_apply=__std__clzt_pow2_32, id=408, pos=[(0,1616,66)])
  N_HALF: bits[32] = zero_ext(shrl.403, new_bit_count=32, id=404)
  ret invoke.409: bits[7] = invoke(invoke.406, invoke.408, to_apply=__std__combine_clzt_halfs__6, id=409, pos=[(0,1616,22)])
}

fn __std__combine_clzt_halfs__7(left: bits[7] id=410, right: bits[7] id=411) -> bits[8] {
  bit_slice.413: bits[1] = bit_slice(left, start=6, width=1, id=413, pos=[(0,1539,15)])
  bit_slice.414: bits[1] = bit_slice(right, start=6, width=1, id=414, pos=[(0,1539,27)])
  tuple.415: (bits[1], bits[1]) = tuple(bit_slice.413, bit_slice.414, id=415, pos=[(0,1539,10)])
  literal.429: bits[1] = literal(value=1, id=429, pos=[(0,1541,9)])
  tuple_index.428: bits[1] = tuple_index(tuple.415, index=0, id=428)
  literal.418: bits[1] = literal(value=1, id=418, pos=[(0,1540,9)])
  tuple_index.417: bits[1] = tuple_index(tuple.415, index=0, id=417)
  literal.427: bits[1] = literal(value=1, id=427)
  eq.430: bits[1] = eq(literal.429, tuple_index.428, id=430)
  literal.433: bits[1] = literal(value=0, id=433, pos=[(0,1541,15)])
  tuple_index.432: bits[1] = tuple_index(tuple.415, index=1, id=432)
  literal.416: bits[1] = literal(value=1, id=416)
  eq.419: bits[1] = eq(literal.418, tuple_index.417, id=419)
  literal.422: bits[1] = literal(value=1, id=422, pos=[(0,1540,15)])
  tuple_index.421: bits[1] = tuple_index(tuple.415, index=1, id=421)
  and.431: bits[1] = and(literal.427, eq.430, id=431)
  eq.434: bits[1] = eq(literal.433, tuple_index.432, id=434)
  and.420: bits[1] = and(literal.416, eq.419, id=420)
  eq.423: bits[1] = eq(literal.422, tuple_index.421, id=423)
  and.435: bits[1] = and(and.431, eq.434, id=435)
  and.424: bits[1] = and(and.420, eq.423, id=424)
  literal.425: bits[1] = literal(value=0, id=425, pos=[(0,1540,32)])
  literal.436: bits[2] = literal(value=1, id=436, pos=[(0,1541,24)])
  bit_slice.437: bits[6] = bit_slice(right, start=0, width=6, id=437, pos=[(0,1541,40)])
  literal.440: bits[1] = literal(value=0, id=440, pos=[(0,1542,13)])
  concat.442: bits[2] = concat(and.435, and.424, id=442)
  concat.426: bits[8] = concat(left, literal.425, id=426, pos=[(0,1540,24)])
  concat.438: bits[8] = concat(literal.436, bit_slice.437, id=438, pos=[(0,1541,24)])
  concat.441: bits[8] = concat(literal.440, left, id=441, pos=[(0,1542,13)])
  N: bits[32] = literal(value=7, id=412, pos=[(0,1538,22)])
  literal.439: bits[1] = literal(value=1, id=439, pos=[(0,1542,8)])
  ret priority_sel.443: bits[8] = priority_sel(concat.442, cases=[concat.426, concat.438], default=concat.441, id=443)
}

fn __std__clzt_pow2_128(value: bits[128] id=444) -> bits[8] {
  literal.445: bits[32] = literal(value=128, id=445, pos=[(0,1620,20)])
  literal.446: bits[1] = literal(value=1, id=446, pos=[(0,1620,31)])
  bit_slice.449: bits[64] = bit_slice(value, start=64, width=64, id=449, pos=[(0,1621,41)])
  bit_slice.451: bits[64] = bit_slice(value, start=0, width=64, id=451, pos=[(0,1621,72)])
  shrl.447: bits[32] = shrl(literal.445, literal.446, id=447, pos=[(0,1620,20)])
  invoke.450: bits[7] = invoke(bit_slice.449, to_apply=__std__clzt_pow2_64, id=450, pos=[(0,1621,35)])
  invoke.452: bits[7] = invoke(bit_slice.451, to_apply=__std__clzt_pow2_64, id=452, pos=[(0,1621,66)])
  N_HALF: bits[32] = zero_ext(shrl.447, new_bit_count=32, id=448)
  ret invoke.453: bits[8] = invoke(invoke.450, invoke.452, to_apply=__std__combine_clzt_halfs__7, id=453, pos=[(0,1621,22)])
}

fn __std__combine_clzt_halfs__8(left: bits[8] id=454, right: bits[8] id=455) -> bits[9] {
  bit_slice.457: bits[1] = bit_slice(left, start=7, width=1, id=457, pos=[(0,1539,15)])
  bit_slice.458: bits[1] = bit_slice(right, start=7, width=1, id=458, pos=[(0,1539,27)])
  tuple.459: (bits[1], bits[1]) = tuple(bit_slice.457, bit_slice.458, id=459, pos=[(0,1539,10)])
  literal.473: bits[1] = literal(value=1, id=473, pos=[(0,1541,9)])
  tuple_index.472: bits[1] = tuple_index(tuple.459, index=0, id=472)
  literal.462: bits[1] = literal(value=1, id=462, pos=[(0,1540,9)])
  tuple_index.461: bits[1] = tuple_index(tuple.459, index=0, id=461)
  literal.471: bits[1] = literal(value=1, id=471)
  eq.474: bits[1] = eq(literal.473, tuple_index.472, id=474)
  literal.477: bits[1] = literal(value=0, id=477, pos=[(0,1541,15)])
  tuple_index.476: bits[1] = tuple_index(tuple.459, index=1, id=476)
  literal.460: bits[1] = literal(value=1, id=460)
  eq.463: bits[1] = eq(literal.462, tuple_index.461, id=463)
  literal.466: bits[1] = literal(value=1, id=466, pos=[(0,1540,15)])
  tuple_index.465: bits[1] = tuple_index(tuple.459, index=1, id=465)
  and.475: bits[1] = and(literal.471, eq.474, id=475)
  eq.478: bits[1] = eq(literal.477, tuple_index.476, id=478)
  and.464: bits[1] = and(literal.460, eq.463, id=464)
  eq.467: bits[1] = eq(literal.466, tuple_index.465, id=467)
  and.479: bits[1] = and(and.475, eq.478, id=479)
  and.468: bits[1] = and(and.464, eq.467, id=468)
  literal.469: bits[1] = literal(value=0, id=469, pos=[(0,1540,32)])
  literal.480: bits[2] = literal(value=1, id=480, pos=[(0,1541,24)])
  bit_slice.481: bits[7] = bit_slice(right, start=0, width=7, id=481, pos=[(0,1541,40)])
  literal.484: bits[1] = literal(value=0, id=484, pos=[(0,1542,13)])
  concat.486: bits[2] = concat(and.479, and.468, id=486)
  concat.470: bits[9] = concat(left, literal.469, id=470, pos=[(0,1540,24)])
  concat.482: bits[9] = concat(literal.480, bit_slice.481, id=482, pos=[(0,1541,24)])
  concat.485: bits[9] = concat(literal.484, left, id=485, pos=[(0,1542,13)])
  N: bits[32] = literal(value=8, id=456, pos=[(0,1538,22)])
  literal.483: bits[1] = literal(value=1, id=483, pos=[(0,1542,8)])
  ret priority_sel.487: bits[9] = priority_sel(concat.486, cases=[concat.470, concat.482], default=concat.485, id=487)
}

fn __std__clzt_pow2_256(value: bits[256] id=488) -> bits[9] {
  literal.489: bits[32] = literal(value=256, id=489, pos=[(0,1625,20)])
  literal.490: bits[1] = literal(value=1, id=490, pos=[(0,1625,31)])
  bit_slice.493: bits[128] = bit_slice(value, start=128, width=128, id=493, pos=[(0,1626,42)])
  bit_slice.495: bits[128] = bit_slice(value, start=0, width=128, id=495, pos=[(0,1626,74)])
  shrl.491: bits[32] = shrl(literal.489, literal.490, id=491, pos=[(0,1625,20)])
  invoke.494: bits[8] = invoke(bit_slice.493, to_apply=__std__clzt_pow2_128, id=494, pos=[(0,1626,36)])
  invoke.496: bits[8] = invoke(bit_slice.495, to_apply=__std__clzt_pow2_128, id=496, pos=[(0,1626,68)])
  N_HALF: bits[32] = zero_ext(shrl.491, new_bit_count=32, id=492)
  ret invoke.497: bits[9] = invoke(invoke.494, invoke.496, to_apply=__std__combine_clzt_halfs__8, id=497, pos=[(0,1626,22)])
}

fn __std__combine_clzt_halfs__9(left: bits[9] id=498, right: bits[9] id=499) -> bits[10] {
  bit_slice.501: bits[1] = bit_slice(left, start=8, width=1, id=501, pos=[(0,1539,15)])
  bit_slice.502: bits[1] = bit_slice(right, start=8, width=1, id=502, pos=[(0,1539,27)])
  tuple.503: (bits[1], bits[1]) = tuple(bit_slice.501, bit_slice.502, id=503, pos=[(0,1539,10)])
  literal.517: bits[1] = literal(value=1, id=517, pos=[(0,1541,9)])
  tuple_index.516: bits[1] = tuple_index(tuple.503, index=0, id=516)
  literal.506: bits[1] = literal(value=1, id=506, pos=[(0,1540,9)])
  tuple_index.505: bits[1] = tuple_index(tuple.503, index=0, id=505)
  literal.515: bits[1] = literal(value=1, id=515)
  eq.518: bits[1] = eq(literal.517, tuple_index.516, id=518)
  literal.521: bits[1] = literal(value=0, id=521, pos=[(0,1541,15)])
  tuple_index.520: bits[1] = tuple_index(tuple.503, index=1, id=520)
  literal.504: bits[1] = literal(value=1, id=504)
  eq.507: bits[1] = eq(literal.506, tuple_index.505, id=507)
  literal.510: bits[1] = literal(value=1, id=510, pos=[(0,1540,15)])
  tuple_index.509: bits[1] = tuple_index(tuple.503, index=1, id=509)
  and.519: bits[1] = and(literal.515, eq.518, id=519)
  eq.522: bits[1] = eq(literal.521, tuple_index.520, id=522)
  and.508: bits[1] = and(literal.504, eq.507, id=508)
  eq.511: bits[1] = eq(literal.510, tuple_index.509, id=511)
  and.523: bits[1] = and(and.519, eq.522, id=523)
  and.512: bits[1] = and(and.508, eq.511, id=512)
  literal.513: bits[1] = literal(value=0, id=513, pos=[(0,1540,32)])
  literal.524: bits[2] = literal(value=1, id=524, pos=[(0,1541,24)])
  bit_slice.525: bits[8] = bit_slice(right, start=0, width=8, id=525, pos=[(0,1541,40)])
  literal.528: bits[1] = literal(value=0, id=528, pos=[(0,1542,13)])
  concat.530: bits[2] = concat(and.523, and.512, id=530)
  concat.514: bits[10] = concat(left, literal.513, id=514, pos=[(0,1540,24)])
  concat.526: bits[10] = concat(literal.524, bit_slice.525, id=526, pos=[(0,1541,24)])
  concat.529: bits[10] = concat(literal.528, left, id=529, pos=[(0,1542,13)])
  N: bits[32] = literal(value=9, id=500, pos=[(0,1538,22)])
  literal.527: bits[1] = literal(value=1, id=527, pos=[(0,1542,8)])
  ret priority_sel.531: bits[10] = priority_sel(concat.530, cases=[concat.514, concat.526], default=concat.529, id=531)
}

fn __std__clzt_pow2_512(value: bits[512] id=532) -> bits[10] {
  literal.533: bits[32] = literal(value=512, id=533, pos=[(0,1630,20)])
  literal.534: bits[1] = literal(value=1, id=534, pos=[(0,1630,31)])
  bit_slice.537: bits[256] = bit_slice(value, start=256, width=256, id=537, pos=[(0,1631,42)])
  bit_slice.539: bits[256] = bit_slice(value, start=0, width=256, id=539, pos=[(0,1631,74)])
  shrl.535: bits[32] = shrl(literal.533, literal.534, id=535, pos=[(0,1630,20)])
  invoke.538: bits[9] = invoke(bit_slice.537, to_apply=__std__clzt_pow2_256, id=538, pos=[(0,1631,36)])
  invoke.540: bits[9] = invoke(bit_slice.539, to_apply=__std__clzt_pow2_256, id=540, pos=[(0,1631,68)])
  N_HALF: bits[32] = zero_ext(shrl.535, new_bit_count=32, id=536)
  ret invoke.541: bits[10] = invoke(invoke.538, invoke.540, to_apply=__std__combine_clzt_halfs__9, id=541, pos=[(0,1631,22)])
}

fn __std__clzt_pow2__16_5(value: bits[16] id=542) -> bits[5] {
  reverse.596: bits[16] = reverse(value, id=596, pos=[(0,1650,16)])
  one_hot.597: bits[17] = one_hot(reverse.596, lsb_prio=true, id=597, pos=[(0,1650,16)])
  literal.590: bits[32] = literal(value=1, id=590, pos=[(0,1649,8)])
  N: bits[32] = literal(value=16, id=543, pos=[(0,1636,17)])
  literal.585: bits[32] = literal(value=2, id=585, pos=[(0,1648,8)])
  literal.580: bits[32] = literal(value=4, id=580, pos=[(0,1647,8)])
  literal.575: bits[32] = literal(value=8, id=575, pos=[(0,1646,8)])
  literal.570: bits[32] = literal(value=16, id=570, pos=[(0,1645,8)])
  literal.565: bits[32] = literal(value=32, id=565, pos=[(0,1644,8)])
  literal.560: bits[32] = literal(value=64, id=560, pos=[(0,1643,8)])
  literal.555: bits[32] = literal(value=128, id=555, pos=[(0,1642,8)])
  literal.550: bits[32] = literal(value=256, id=550, pos=[(0,1641,8)])
  literal.545: bits[32] = literal(value=512, id=545, pos=[(0,1640,8)])
  zero_ext.547: bits[512] = zero_ext(value, new_bit_count=512, id=547)
  zero_ext.552: bits[256] = zero_ext(value, new_bit_count=256, id=552)
  zero_ext.557: bits[128] = zero_ext(value, new_bit_count=128, id=557)
  zero_ext.562: bits[64] = zero_ext(value, new_bit_count=64, id=562)
  zero_ext.567: bits[32] = zero_ext(value, new_bit_count=32, id=567)
  zero_ext.572: bits[16] = zero_ext(value, new_bit_count=16, id=572)
  bit_slice.577: bits[8] = bit_slice(value, start=0, width=8, id=577)
  bit_slice.582: bits[4] = bit_slice(value, start=0, width=4, id=582)
  bit_slice.587: bits[2] = bit_slice(value, start=0, width=2, id=587)
  bit_slice.592: bits[1] = bit_slice(value, start=0, width=1, id=592)
  encode.598: bits[5] = encode(one_hot.597, id=598, pos=[(0,1650,16)])
  eq.591: bits[1] = eq(literal.590, N, id=591)
  eq.586: bits[1] = eq(literal.585, N, id=586)
  eq.581: bits[1] = eq(literal.580, N, id=581)
  eq.576: bits[1] = eq(literal.575, N, id=576)
  eq.571: bits[1] = eq(literal.570, N, id=571)
  eq.566: bits[1] = eq(literal.565, N, id=566)
  eq.561: bits[1] = eq(literal.560, N, id=561)
  eq.556: bits[1] = eq(literal.555, N, id=556)
  eq.551: bits[1] = eq(literal.550, N, id=551)
  eq.546: bits[1] = eq(literal.545, N, id=546)
  invoke.548: bits[10] = invoke(zero_ext.547, to_apply=__std__clzt_pow2_512, id=548, pos=[(0,1640,32)])
  invoke.553: bits[9] = invoke(zero_ext.552, to_apply=__std__clzt_pow2_256, id=553, pos=[(0,1641,32)])
  invoke.558: bits[8] = invoke(zero_ext.557, to_apply=__std__clzt_pow2_128, id=558, pos=[(0,1642,32)])
  invoke.563: bits[7] = invoke(zero_ext.562, to_apply=__std__clzt_pow2_64, id=563, pos=[(0,1643,30)])
  invoke.568: bits[6] = invoke(zero_ext.567, to_apply=__std__clzt_pow2_32, id=568, pos=[(0,1644,30)])
  invoke.573: bits[5] = invoke(zero_ext.572, to_apply=__std__clzt_pow2_16, id=573, pos=[(0,1645,30)])
  invoke.578: bits[4] = invoke(bit_slice.577, to_apply=__std__clzt_pow2_8, id=578, pos=[(0,1646,28)])
  invoke.583: bits[3] = invoke(bit_slice.582, to_apply=__std__clzt_pow2_4, id=583, pos=[(0,1647,28)])
  invoke.588: bits[2] = invoke(bit_slice.587, to_apply=__std__clzt_pow2_2, id=588, pos=[(0,1648,28)])
  invoke.593: bits[1] = invoke(bit_slice.592, to_apply=__std__clzt_pow2_1, id=593, pos=[(0,1649,28)])
  zero_ext.599: bits[16] = zero_ext(encode.598, new_bit_count=16, id=599, pos=[(0,1650,16)])
  concat.601: bits[10] = concat(eq.591, eq.586, eq.581, eq.576, eq.571, eq.566, eq.561, eq.556, eq.551, eq.546, id=601)
  bit_slice.549: bits[5] = bit_slice(invoke.548, start=0, width=5, id=549)
  bit_slice.554: bits[5] = bit_slice(invoke.553, start=0, width=5, id=554)
  bit_slice.559: bits[5] = bit_slice(invoke.558, start=0, width=5, id=559)
  bit_slice.564: bits[5] = bit_slice(invoke.563, start=0, width=5, id=564)
  bit_slice.569: bits[5] = bit_slice(invoke.568, start=0, width=5, id=569)
  zero_ext.574: bits[5] = zero_ext(invoke.573, new_bit_count=5, id=574)
  zero_ext.579: bits[5] = zero_ext(invoke.578, new_bit_count=5, id=579)
  zero_ext.584: bits[5] = zero_ext(invoke.583, new_bit_count=5, id=584)
  zero_ext.589: bits[5] = zero_ext(invoke.588, new_bit_count=5, id=589)
  zero_ext.594: bits[5] = zero_ext(invoke.593, new_bit_count=5, id=594)
  bit_slice.600: bits[5] = bit_slice(zero_ext.599, start=0, width=5, id=600)
  RESULT_BITS: bits[32] = literal(value=5, id=544, pos=[(0,1636,25)])
  literal.595: bits[1] = literal(value=1, id=595, pos=[(0,1650,8)])
  ret priority_sel.602: bits[5] = priority_sel(concat.601, cases=[bit_slice.549, bit_slice.554, bit_slice.559, bit_slice.564, bit_slice.569, zero_ext.574, zero_ext.579, zero_ext.584, zero_ext.589, zero_ext.594], default=bit_slice.600, id=602)
}

fn __std__clzt__12_4(value: bits[12] id=603) -> bits[4] {
  invoke.608: bits[4] = invoke(to_apply=__std__mask_bits__4, id=608, pos=[(0,1708,32)])
  N: bits[32] = literal(value=12, id=604, pos=[(0,1705,12)])
  concat.609: bits[16] = concat(value, invoke.608, id=609, pos=[(0,1708,14)])
  invoke.606: bits[32] = invoke(N, to_apply=__std__next_pow2, id=606, pos=[(0,1706,50)])
  invoke.610: bits[5] = invoke(concat.609, to_apply=__std__clzt_pow2__16_5, id=610, pos=[(0,1708,13)])
  RESULT_BITS: bits[32] = literal(value=4, id=605, pos=[(0,1705,20)])
  BITS_MISSING_UNTIL_POWER_TWO: bits[32] = sub(invoke.606, N, id=607, pos=[(0,1706,50)])
  ret bit_slice.611: bits[4] = bit_slice(invoke.610, start=0, width=4, id=611)
}

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

fn __apfloat__is_inf__8_7(x: (bits[1], bits[8], bits[7]) id=615) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=618, pos=[(2,96,6)])
  invoke.619: bits[8] = invoke(to_apply=__std__mask_bits__8, id=619, pos=[(2,96,29)])
  x_fraction: bits[7] = tuple_index(x, index=2, id=621, pos=[(2,96,44)])
  literal.622: bits[7] = literal(value=0, id=622, pos=[(2,96,57)])
  eq.620: bits[1] = eq(x_bexp, invoke.619, id=620, pos=[(2,96,6)])
  eq.623: bits[1] = eq(x_fraction, literal.622, id=623, pos=[(2,96,44)])
  EXP_SZ: bits[32] = literal(value=8, id=616, pos=[(2,95,14)])
  FRACTION_SZ: bits[32] = literal(value=7, id=617, pos=[(2,95,27)])
  ret and.624: bits[1] = and(eq.620, eq.623, id=624, pos=[(2,96,6)])
}

fn __apfloat__is_nan__8_7(x: (bits[1], bits[8], bits[7]) id=625) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=628, pos=[(2,71,6)])
  invoke.629: bits[8] = invoke(to_apply=__std__mask_bits__8, id=629, pos=[(2,71,29)])
  x_fraction: bits[7] = tuple_index(x, index=2, id=631, pos=[(2,71,44)])
  literal.632: bits[7] = literal(value=0, id=632, pos=[(2,71,57)])
  eq.630: bits[1] = eq(x_bexp, invoke.629, id=630, pos=[(2,71,6)])
  ne.633: bits[1] = ne(x_fraction, literal.632, id=633, pos=[(2,71,44)])
  EXP_SZ: bits[32] = literal(value=8, id=626, pos=[(2,70,14)])
  FRACTION_SZ: bits[32] = literal(value=7, id=627, pos=[(2,70,27)])
  ret and.634: bits[1] = and(eq.630, ne.633, id=634, pos=[(2,71,6)])
}

fn __apfloat__add__8_7(a: (bits[1], bits[8], bits[7]) id=635, b: (bits[1], bits[8], bits[7]) id=636) -> (bits[1], bits[8], bits[7]) {
  a_bexp: bits[8] = tuple_index(a, index=1, id=653, pos=[(2,3091,59)])
  b_bexp: bits[8] = tuple_index(b, index=1, id=654, pos=[(2,3091,67)])
  invoke.655: (bits[1], bits[8]) = invoke(a_bexp, b_bexp, to_apply=__apfloat__sign_magnitude_difference__8, id=655, pos=[(2,3091,57)])
  a_is_smaller: bits[1] = tuple_index(invoke.655, index=0, id=656, pos=[(2,3091,9)])
  tuple.659: ((bits[1], bits[8], bits[7]), (bits[1], bits[8], bits[7])) = tuple(a, b, id=659, pos=[(2,3092,51)])
  tuple.658: ((bits[1], bits[8], bits[7]), (bits[1], bits[8], bits[7])) = tuple(b, a, id=658, pos=[(2,3092,35)])
  sel.660: ((bits[1], bits[8], bits[7]), (bits[1], bits[8], bits[7])) = sel(a_is_smaller, cases=[tuple.659, tuple.658], id=660, pos=[(2,3092,17)])
  x: (bits[1], bits[8], bits[7]) = tuple_index(sel.660, index=0, id=661, pos=[(2,3092,9)])
  y: (bits[1], bits[8], bits[7]) = tuple_index(sel.660, index=1, id=662, pos=[(2,3092,12)])
  literal.663: bits[1] = literal(value=1, id=663, pos=[(2,3095,22)])
  x_fraction: bits[7] = tuple_index(x, index=2, id=664, pos=[(2,3095,31)])
  literal.667: bits[1] = literal(value=1, id=667, pos=[(2,3096,22)])
  y_fraction: bits[7] = tuple_index(y, index=2, id=668, pos=[(2,3096,31)])
  x_bexp: bits[8] = tuple_index(x, index=1, id=671, pos=[(2,3099,25)])
  literal.672: bits[8] = literal(value=0, id=672, pos=[(2,3099,34)])
  concat.665: bits[8] = concat(literal.663, x_fraction, id=665, pos=[(2,3095,22)])
  y_bexp: bits[8] = tuple_index(y, index=1, id=676, pos=[(2,3100,25)])
  literal.677: bits[8] = literal(value=0, id=677, pos=[(2,3100,34)])
  concat.669: bits[8] = concat(literal.667, y_fraction, id=669, pos=[(2,3096,22)])
  eq.673: bits[1] = eq(x_bexp, literal.672, id=673, pos=[(2,3099,25)])
  fraction_x: bits[8] = zero_ext(concat.665, new_bit_count=8, id=666)
  literal.674: bits[8] = literal(value=0, id=674, pos=[(2,3099,49)])
  eq.678: bits[1] = eq(y_bexp, literal.677, id=678, pos=[(2,3100,25)])
  fraction_y: bits[8] = zero_ext(concat.669, new_bit_count=8, id=670)
  literal.679: bits[8] = literal(value=0, id=679, pos=[(2,3100,49)])
  fraction_x__1: bits[8] = sel(eq.673, cases=[fraction_x, literal.674], id=675, pos=[(2,3099,21)])
  fraction_y__1: bits[8] = sel(eq.678, cases=[fraction_y, literal.679], id=680, pos=[(2,3100,21)])
  zero_ext.681: bits[12] = zero_ext(fraction_x__1, new_bit_count=12, id=681)
  GUARD_ROUND_STICKY_BITS: bits[32] = literal(value=3, id=645, pos=[(2,3079,36)])
  zero_ext.683: bits[12] = zero_ext(fraction_y__1, new_bit_count=12, id=683)
  wide_x: bits[12] = shll(zero_ext.681, GUARD_ROUND_STICKY_BITS, id=682, pos=[(2,3103,17)])
  wide_y: bits[12] = shll(zero_ext.683, GUARD_ROUND_STICKY_BITS, id=684, pos=[(2,3104,17)])
  shift: bits[8] = tuple_index(invoke.655, index=1, id=657, pos=[(2,3091,23)])
  x_sign: bits[1] = tuple_index(x, index=0, id=686, pos=[(2,3110,23)])
  y_sign: bits[1] = tuple_index(y, index=0, id=687, pos=[(2,3110,33)])
  addend_x: bits[12] = zero_ext(wide_x, new_bit_count=12, id=685)
  shrl.692: bits[12] = shrl(wide_y, shift, id=692, pos=[(2,3116,31)])
  sticky: bits[1] = invoke(wide_y, shift, to_apply=__std__or_reduce_lsb__8_12, id=691, pos=[(2,3115,35)])
  ne.688: bits[1] = ne(x_sign, y_sign, id=688, pos=[(2,3110,23)])
  neg.689: bits[12] = neg(addend_x, id=689, pos=[(2,3110,41)])
  invoke.693: bits[12] = invoke(shrl.692, sticky, to_apply=__apfloat__or_last_bit__12, id=693, pos=[(2,3116,30)])
  addend_x__1: bits[12] = sel(ne.688, cases=[addend_x, neg.689], id=690, pos=[(2,3110,19)])
  addend_y: bits[12] = zero_ext(invoke.693, new_bit_count=12, id=694)
  sign_ext.695: bits[13] = sign_ext(addend_x__1, new_bit_count=13, id=695)
  sign_ext.696: bits[13] = sign_ext(addend_y, new_bit_count=13, id=696)
  fraction: bits[13] = add(sign_ext.695, sign_ext.696, id=697, pos=[(2,3120,20)])
  literal.729: bits[13] = literal(value=0, id=729, pos=[(2,3130,23)])
  slt.730: bits[1] = slt(fraction, literal.729, id=730, pos=[(2,3130,12)])
  neg.731: bits[13] = neg(fraction, id=731, pos=[(2,3130,46)])
  sel.732: bits[13] = sel(slt.730, cases=[fraction, neg.731], id=732, pos=[(2,3130,9)])
  abs_fraction: bits[12] = bit_slice(sel.732, start=0, width=12, id=733)
  zero_ext.741: bits[13] = zero_ext(abs_fraction, new_bit_count=13, id=741)
  leading_zeroes: bits[4] = invoke(abs_fraction, to_apply=__std__clzt__12_4, id=740, pos=[(2,3141,34)])
  literal.735: bits[32] = literal(value=1, id=735, pos=[(2,3136,42)])
  cancel_fraction: bits[13] = shll(zero_ext.741, leading_zeroes, id=742, pos=[(2,3144,26)])
  literal.743: bits[32] = literal(value=1, id=743, pos=[(2,3145,46)])
  shrl.736: bits[12] = shrl(abs_fraction, literal.735, id=736, pos=[(2,3136,26)])
  shrl.744: bits[13] = shrl(cancel_fraction, literal.743, id=744, pos=[(2,3145,27)])
  carry_fraction: bits[11] = bit_slice(shrl.736, start=0, width=11, id=737)
  bit_slice.738: bits[1] = bit_slice(abs_fraction, start=0, width=1, id=738, pos=[(2,3137,65)])
  carry_bit: bits[1] = bit_slice(abs_fraction, start=11, width=1, id=734, pos=[(2,3135,32)])
  cancel_fraction__1: bits[11] = bit_slice(shrl.744, start=0, width=11, id=745)
  carry_fraction__1: bits[11] = invoke(carry_fraction, bit_slice.738, to_apply=__apfloat__or_last_bit__11, id=739, pos=[(2,3137,36)])
  shifted_fraction: bits[11] = sel(carry_bit, cases=[cancel_fraction__1, carry_fraction__1], id=746, pos=[(2,3146,27)])
  normal_chunk: bits[3] = bit_slice(shifted_fraction, start=0, width=3, id=747, pos=[(2,3158,39)])
  literal.749: bits[3] = literal(value=4, id=749, pos=[(2,3160,38)])
  half_way_chunk: bits[2] = bit_slice(shifted_fraction, start=2, width=2, id=748, pos=[(2,3159,41)])
  literal.751: bits[2] = literal(value=3, id=751, pos=[(2,3160,68)])
  ugt.750: bits[1] = ugt(normal_chunk, literal.749, id=750, pos=[(2,3160,23)])
  eq.752: bits[1] = eq(half_way_chunk, literal.751, id=752, pos=[(2,3160,50)])
  zero_ext.754: bits[12] = zero_ext(shifted_fraction, new_bit_count=12, id=754)
  literal.755: bits[12] = literal(value=8, id=755, pos=[(2,3164,50)])
  do_round_up: bits[1] = or(ugt.750, eq.752, id=753, pos=[(2,3160,23)])
  zero_ext.757: bits[12] = zero_ext(shifted_fraction, new_bit_count=12, id=757)
  add.756: bits[12] = add(zero_ext.754, literal.755, id=756, pos=[(2,3164,9)])
  rounded_fraction: bits[12] = sel(do_round_up, cases=[zero_ext.757, add.756], id=758, pos=[(2,3163,27)])
  x_bexp__1: bits[8] = tuple_index(x, index=1, id=768, pos=[(2,3179,26)])
  rounding_carry: bits[1] = bit_slice(rounded_fraction, start=11, width=1, id=759, pos=[(2,3168,41)])
  zero_ext.769: bits[10] = zero_ext(x_bexp__1, new_bit_count=10, id=769)
  zero_ext.770: bits[10] = zero_ext(rounding_carry, new_bit_count=10, id=770)
  add.771: bits[10] = add(zero_ext.769, zero_ext.770, id=771, pos=[(2,3179,26)])
  literal.772: bits[10] = literal(value=1, id=772, pos=[(2,3180,24)])
  literal.698: bits[13] = literal(value=0, id=698, pos=[(2,3121,39)])
  literal.700: bits[13] = literal(value=0, id=700, pos=[(2,3122,58)])
  add.773: bits[10] = add(add.771, literal.772, id=773, pos=[(2,3179,26)])
  zero_ext.774: bits[10] = zero_ext(leading_zeroes, new_bit_count=10, id=774)
  fraction_is_zero: bits[1] = eq(fraction, literal.698, id=699, pos=[(2,3121,27)])
  slt.701: bits[1] = slt(fraction, literal.700, id=701, pos=[(2,3122,47)])
  wide_exponent: bits[10] = sub(add.773, zero_ext.774, id=775, pos=[(2,3179,26)])
  literal.776: bits[10] = literal(value=0, id=776, pos=[(2,3181,46)])
  bit_slice.761: bits[1] = bit_slice(rounded_fraction, start=11, width=1, id=761, pos=[(2,3174,60)])
  literal.763: bits[3] = literal(value=0, id=763, pos=[(2,3174,82)])
  literal.762: bits[3] = literal(value=1, id=762, pos=[(2,3174,68)])
  tuple.702: (bits[1], bits[1]) = tuple(fraction_is_zero, slt.701, id=702, pos=[(2,3122,28)])
  wide_exponent__1: bits[10] = sel(fraction_is_zero, cases=[wide_exponent, literal.776], id=777, pos=[(2,3181,24)])
  literal.778: bits[10] = literal(value=0, id=778, pos=[(2,3184,43)])
  bit_slice.760: bits[3] = bit_slice(GUARD_ROUND_STICKY_BITS, start=0, width=3, id=760)
  sel.764: bits[3] = sel(bit_slice.761, cases=[literal.763, literal.762], id=764, pos=[(2,3174,41)])
  literal.716: bits[1] = literal(value=0, id=716, pos=[(2,3124,9)])
  tuple_index.715: bits[1] = tuple_index(tuple.702, index=0, id=715)
  literal.705: bits[1] = literal(value=1, id=705, pos=[(2,3123,9)])
  tuple_index.704: bits[1] = tuple_index(tuple.702, index=0, id=704)
  x_sign__2: bits[1] = tuple_index(x, index=0, id=802, pos=[(2,3209,59)])
  literal.803: bits[1] = literal(value=0, id=803, pos=[(2,3209,68)])
  y_sign__4: bits[1] = tuple_index(y, index=0, id=807, pos=[(2,3210,59)])
  literal.808: bits[1] = literal(value=0, id=808, pos=[(2,3210,68)])
  x_sign__3: bits[1] = tuple_index(x, index=0, id=815, pos=[(2,3215,59)])
  literal.816: bits[1] = literal(value=1, id=816, pos=[(2,3215,68)])
  y_sign__5: bits[1] = tuple_index(y, index=0, id=820, pos=[(2,3216,59)])
  literal.821: bits[1] = literal(value=1, id=821, pos=[(2,3216,68)])
  slt.779: bits[1] = slt(wide_exponent__1, literal.778, id=779, pos=[(2,3184,27)])
  bit_slice.781: bits[9] = bit_slice(wide_exponent__1, start=0, width=9, id=781)
  literal.780: bits[9] = literal(value=0, id=780, pos=[(2,3185,8)])
  fraction_shift: bits[3] = add(bit_slice.760, sel.764, id=765, pos=[(2,3174,8)])
  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,3124,16)])
  tuple_index.719: bits[1] = tuple_index(tuple.702, index=1, id=719)
  literal.703: bits[1] = literal(value=1, id=703)
  eq.706: bits[1] = eq(literal.705, tuple_index.704, id=706)
  invoke.801: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_7, id=801, pos=[(2,3209,29)])
  eq.804: bits[1] = eq(x_sign__2, literal.803, id=804, pos=[(2,3209,59)])
  invoke.806: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_7, id=806, pos=[(2,3210,29)])
  eq.809: bits[1] = eq(y_sign__4, literal.808, id=809, pos=[(2,3210,59)])
  invoke.814: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_7, id=814, pos=[(2,3215,29)])
  eq.817: bits[1] = eq(x_sign__3, literal.816, id=817, pos=[(2,3215,59)])
  invoke.819: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_7, id=819, pos=[(2,3216,29)])
  eq.822: bits[1] = eq(y_sign__5, literal.821, id=822, pos=[(2,3216,59)])
  MAX_EXPONENT: bits[8] = invoke(to_apply=__std__mask_bits__8, id=787, pos=[(2,3197,39)])
  wide_exponent__2: bits[9] = sel(slt.779, cases=[bit_slice.781, literal.780], id=782, pos=[(2,3184,24)])
  literal.783: bits[9] = literal(value=1, id=783, pos=[(2,3194,27)])
  shrl.766: bits[12] = shrl(rounded_fraction, fraction_shift, id=766, pos=[(2,3175,27)])
  and.718: bits[1] = and(literal.714, eq.717, id=718)
  eq.721: bits[1] = eq(literal.720, tuple_index.719, id=721)
  and.707: bits[1] = and(literal.703, eq.706, id=707)
  literal.709: bits[1] = literal(value=1, id=709, pos=[(2,3123,15)])
  and.805: bits[1] = and(invoke.801, eq.804, id=805, pos=[(2,3209,29)])
  and.810: bits[1] = and(invoke.806, eq.809, id=810, pos=[(2,3210,29)])
  and.818: bits[1] = and(invoke.814, eq.817, id=818, pos=[(2,3215,29)])
  and.823: bits[1] = and(invoke.819, eq.822, id=823, pos=[(2,3216,29)])
  SATURATED_EXPONENT: bits[9] = zero_ext(MAX_EXPONENT, new_bit_count=9, id=788)
  ult.784: bits[1] = ult(wide_exponent__2, literal.783, id=784, pos=[(2,3194,11)])
  result_fraction: bits[7] = bit_slice(shrl.766, start=0, width=7, id=767)
  literal.785: bits[7] = literal(value=0, id=785, pos=[(2,3194,44)])
  and.722: bits[1] = and(and.718, eq.721, id=722)
  and.710: bits[1] = and(and.707, literal.709, id=710)
  x_sign__1: bits[1] = tuple_index(x, index=0, id=711, pos=[(2,3123,22)])
  y_sign__1: bits[1] = tuple_index(y, index=0, id=712, pos=[(2,3123,32)])
  y_sign__2: bits[1] = tuple_index(y, index=0, id=723, pos=[(2,3124,27)])
  invoke.825: bits[1] = invoke(x, to_apply=__apfloat__is_nan__8_7, id=825, pos=[(2,3217,30)])
  invoke.826: bits[1] = invoke(y, to_apply=__apfloat__is_nan__8_7, id=826, pos=[(2,3217,64)])
  has_pos_inf: bits[1] = or(and.805, and.810, id=811, pos=[(2,3209,29)])
  has_neg_inf: bits[1] = or(and.818, and.823, id=824, pos=[(2,3215,29)])
  invoke.795: bits[1] = invoke(x, to_apply=__apfloat__is_inf__8_7, id=795, pos=[(2,3205,31)])
  invoke.796: bits[1] = invoke(y, to_apply=__apfloat__is_inf__8_7, id=796, pos=[(2,3205,65)])
  ult.789: bits[1] = ult(wide_exponent__2, SATURATED_EXPONENT, id=789, pos=[(2,3200,11)])
  literal.790: bits[7] = literal(value=0, id=790, pos=[(2,3200,73)])
  result_fraction__1: bits[7] = sel(ult.784, cases=[result_fraction, literal.785], id=786, pos=[(2,3194,8)])
  FRACTION_SZ: bits[32] = literal(value=7, id=638, pos=[(2,3067,24)])
  literal.831: bits[32] = literal(value=1, id=831, pos=[(2,3219,66)])
  HIDDEN_BIT: bits[32] = literal(value=1, id=644, pos=[(2,3078,23)])
  concat.727: bits[2] = concat(and.722, and.710, id=727)
  and.713: bits[1] = and(x_sign__1, y_sign__1, id=713, pos=[(2,3123,22)])
  not.724: bits[1] = not(y_sign__2, id=724, pos=[(2,3124,25)])
  y_sign__3: bits[1] = tuple_index(y, index=0, id=726, pos=[(2,3125,14)])
  ult.792: bits[1] = ult(wide_exponent__2, SATURATED_EXPONENT, id=792, pos=[(2,3202,11)])
  bit_slice.793: bits[8] = bit_slice(wide_exponent__2, start=0, width=8, id=793)
  or.827: bits[1] = or(invoke.825, invoke.826, id=827, pos=[(2,3217,30)])
  and.828: bits[1] = and(has_pos_inf, has_neg_inf, id=828, pos=[(2,3218,25)])
  is_operand_inf: bits[1] = or(invoke.795, invoke.796, id=797, pos=[(2,3205,31)])
  result_fraction__2: bits[7] = sel(ult.789, cases=[literal.790, result_fraction__1], id=791, pos=[(2,3200,8)])
  literal.799: bits[7] = literal(value=0, id=799, pos=[(2,3207,46)])
  literal.830: bits[7] = literal(value=1, id=830, pos=[(2,3219,30)])
  sub.832: bits[32] = sub(FRACTION_SZ, literal.831, id=832, pos=[(2,3219,52)])
  SIGN_BIT: bits[32] = literal(value=1, id=643, pos=[(2,3077,21)])
  FRACTION: bits[32] = add(HIDDEN_BIT, FRACTION_SZ, id=646, pos=[(2,3080,21)])
  result_sign: bits[1] = priority_sel(concat.727, cases=[and.713, not.724], default=y_sign__3, id=728)
  not.812: bits[1] = not(has_pos_inf, id=812, pos=[(2,3211,42)])
  result_exponent: bits[8] = sel(ult.792, cases=[MAX_EXPONENT, bit_slice.793], id=794, pos=[(2,3202,8)])
  is_result_nan: bits[1] = or(or.827, and.828, id=829, pos=[(2,3217,30)])
  result_fraction__3: bits[7] = sel(is_operand_inf, cases=[result_fraction__2, literal.799], id=800, pos=[(2,3207,26)])
  FRACTION_HIGH_BIT: bits[7] = shll(literal.830, sub.832, id=833, pos=[(2,3219,30)])
  EXP_SZ: bits[32] = literal(value=8, id=637, pos=[(2,3067,11)])
  literal.639: bits[32] = literal(value=1, id=639, pos=[(2,3071,35)])
  SIGNED_FRACTION: bits[32] = add(SIGN_BIT, FRACTION, id=647, pos=[(2,3081,28)])
  result_sign__1: bits[1] = sel(is_operand_inf, cases=[result_sign, not.812], id=813, pos=[(2,3211,22)])
  literal.836: bits[1] = literal(value=0, id=836, pos=[(2,3222,41)])
  result_exponent__1: bits[8] = sel(is_operand_inf, cases=[result_exponent, MAX_EXPONENT], id=798, pos=[(2,3206,26)])
  result_fraction__4: bits[7] = sel(is_result_nan, cases=[result_fraction__3, FRACTION_HIGH_BIT], id=835, pos=[(2,3221,26)])
  literal.641: bits[32] = literal(value=1, id=641, pos=[(2,3073,27)])
  WIDE_EXP: bits[32] = add(EXP_SZ, literal.639, id=640, pos=[(2,3071,26)])
  literal.649: bits[32] = literal(value=1, id=649, pos=[(2,3084,32)])
  WIDE_FRACTION: bits[32] = add(SIGNED_FRACTION, GUARD_ROUND_STICKY_BITS, id=648, pos=[(2,3082,31)])
  literal.651: bits[32] = literal(value=1, id=651, pos=[(2,3088,53)])
  result_sign__2: bits[1] = sel(is_result_nan, cases=[result_sign__1, literal.836], id=837, pos=[(2,3222,22)])
  result_exponent__2: bits[8] = sel(is_result_nan, cases=[result_exponent__1, MAX_EXPONENT], id=834, pos=[(2,3220,26)])
  zero_ext.838: bits[7] = zero_ext(result_fraction__4, new_bit_count=7, id=838)
  CARRY_EXP: bits[32] = add(literal.641, WIDE_EXP, id=642, pos=[(2,3073,27)])
  CARRY_FRACTION: bits[32] = add(literal.649, WIDE_FRACTION, id=650, pos=[(2,3084,32)])
  NORMALIZED_FRACTION: bits[32] = sub(WIDE_FRACTION, literal.651, id=652, pos=[(2,3088,37)])
  tuple_index.708: bits[1] = tuple_index(tuple.702, index=1, id=708)
  literal.725: bits[1] = literal(value=1, id=725, pos=[(2,3125,8)])
  ret tuple.839: (bits[1], bits[8], bits[7]) = tuple(result_sign__2, result_exponent__2, zero_ext.838, id=839, pos=[(2,3225,33)])
}

fn __apfloat__sub__8_7(x: (bits[1], bits[8], bits[7]) id=840, y: (bits[1], bits[8], bits[7]) id=841) -> (bits[1], bits[8], bits[7]) {
  y_sign: bits[1] = tuple_index(y, index=0, id=844, pos=[(2,3242,51)])
  not.845: bits[1] = not(y_sign, id=845, pos=[(2,3242,49)])
  y_bexp: bits[8] = tuple_index(y, index=1, id=846, pos=[(2,3242,65)])
  y_fraction: bits[7] = tuple_index(y, index=2, id=847, pos=[(2,3242,83)])
  y__1: (bits[1], bits[8], bits[7]) = tuple(not.845, y_bexp, y_fraction, id=848, pos=[(2,3242,41)])
  EXP_SZ: bits[32] = literal(value=8, id=842, pos=[(2,3239,11)])
  FRACTION_SZ: bits[32] = literal(value=7, id=843, pos=[(2,3239,24)])
  ret invoke.849: (bits[1], bits[8], bits[7]) = invoke(x, y__1, to_apply=__apfloat__add__8_7, id=849, pos=[(2,3243,7)])
}

top fn __bfloat16__sub(x: (bits[1], bits[8], bits[7]) id=850, y: (bits[1], bits[8], bits[7]) id=851) -> (bits[1], bits[8], bits[7]) {
  ret invoke.852: (bits[1], bits[8], bits[7]) = invoke(x, y, to_apply=__apfloat__sub__8_7, id=852, pos=[(3,164,51)])
}