package hfloat16

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/hfloat16.x"

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

fn __abs_diff__abs_diff__5(x: bits[5] id=15, y: bits[5] id=16) -> (bits[1], bits[5]) {
  ynot: bits[5] = not(y, id=18, pos=[(1,90,15)])
  invoke.19: (bits[1], bits[5]) = invoke(x, ynot, to_apply=__std__uadd_with_overflow__5_5_5_5_5, 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[5] = tuple_index(invoke.19, index=1, id=21, pos=[(1,91,20)])
  xor_mask: bits[5] = sign_ext(nc, new_bit_count=5, id=24, pos=[(1,94,32)])
  result: bits[5] = xor(z, xor_mask, id=25, pos=[(1,95,18)])
  N: bits[32] = literal(value=5, id=17, pos=[(1,89,16)])
  literal.23: bits[5] = literal(value=0, id=23, pos=[(1,94,42)])
  ret tuple.26: (bits[1], bits[5]) = tuple(carry_out, result, id=26, pos=[(1,96,18)])
}

fn __abs_diff__is_x_larger__5(adr: (bits[1], bits[5]) id=27) -> bits[1] {
  N: bits[32] = literal(value=5, 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__5(adr: (bits[1], bits[5]) id=30) -> bits[5] {
  adr_correction: bits[1] = tuple_index(adr, index=0, id=33, pos=[(1,54,25)])
  adr_uncorrected: bits[5] = tuple_index(adr, index=1, id=32, pos=[(1,54,7)])
  zero_ext.34: bits[5] = zero_ext(adr_correction, new_bit_count=5, id=34)
  N: bits[32] = literal(value=5, id=31, pos=[(1,53,20)])
  ret add.35: bits[5] = add(adr_uncorrected, zero_ext.34, id=35, pos=[(1,54,7)])
}

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

fn __std__keep_lsbs__5_15(x: bits[15] id=44, n: bits[5] id=45) -> bits[15] {
  literal.48: bits[15] = literal(value=32767, id=48, pos=[(0,1406,19)])
  shll.49: bits[15] = shll(literal.48, n, id=49, pos=[(0,1406,19)])
  not.50: bits[15] = not(shll.49, id=50, pos=[(0,1406,8)])
  WIDTH: bits[32] = literal(value=15, id=46, pos=[(0,1405,17)])
  N_WIDTH: bits[32] = literal(value=5, id=47, pos=[(0,1405,29)])
  ret and.51: bits[15] = and(x, not.50, id=51, pos=[(0,1406,4)])
}

fn __std__or_reduce_lsb_impl__1_5_15(value: bits[15] id=52, n: bits[5] id=53) -> bits[1] {
  WIDTH: bits[32] = literal(value=15, id=55, pos=[(0,1492,42)])
  bit_slice.60: bits[5] = bit_slice(WIDTH, start=0, width=5, id=60)
  sub.61: bits[5] = sub(bit_slice.60, n, id=61, pos=[(0,1499,18)])
  shll.62: bits[15] = shll(value, sub.61, id=62, pos=[(0,1499,8)])
  literal.63: bits[15] = literal(value=0, id=63, pos=[(0,1499,47)])
  invoke.57: bits[15] = invoke(value, n, to_apply=__std__keep_lsbs__5_15, id=57, pos=[(0,1496,17)])
  literal.58: bits[15] = literal(value=0, id=58, pos=[(0,1496,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=54, pos=[(0,1492,22)])
  ne.64: bits[1] = ne(shll.62, literal.63, id=64, pos=[(0,1499,8)])
  ne.59: bits[1] = ne(invoke.57, literal.58, id=59, pos=[(0,1496,17)])
  N_WIDTH: bits[32] = literal(value=5, id=56, pos=[(0,1492,54)])
  ret sel.65: bits[1] = sel(DO_MASK_IMPL, cases=[ne.64, ne.59], id=65, pos=[(0,1494,4)])
}

fn __std__or_reduce_lsb__5_15(value: bits[15] id=66, n: bits[5] id=67) -> bits[1] {
  WIDTH: bits[32] = literal(value=15, id=68, pos=[(0,1522,21)])
  N_WIDTH: bits[32] = literal(value=5, id=69, pos=[(0,1522,33)])
  ret invoke.70: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_5_15, id=70, pos=[(0,1523,22)])
}

fn __apfloat__or_last_bit__15(value: bits[15] id=71, lsb: bits[1] id=72) -> bits[15] {
  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=15, id=73, pos=[(2,3052,15)])
  ret bit_slice_update.77: bits[15] = bit_slice_update(value, literal.74, or.76, id=77, pos=[(2,3053,20)])
}

fn __apfloat__or_last_bit__14(value: bits[14] id=78, lsb: bits[1] id=79) -> bits[14] {
  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=14, id=80, pos=[(2,3052,15)])
  ret bit_slice_update.84: bits[14] = 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__upow__32_counted_for_0_body(i: bits[32] id=104, __loop_carry: (bits[32], bits[32], bits[32]) id=107) -> (bits[32], bits[32], bits[32]) {
  tuple_index.109: bits[32] = tuple_index(__loop_carry, index=0, id=109)
  literal.119: bits[32] = literal(value=1, id=119, pos=[(0,960,29)])
  literal.108: bits[1] = literal(value=1, id=108)
  literal.110: bits[1] = literal(value=1, id=110)
  and.120: bits[32] = and(tuple_index.109, literal.119, id=120, pos=[(0,960,25)])
  literal.121: bits[32] = literal(value=1, id=121, pos=[(0,960,41)])
  tuple_index.115: bits[32] = tuple_index(__loop_carry, index=2, id=115)
  tuple_index.112: bits[32] = tuple_index(__loop_carry, index=1, id=112)
  and.111: bits[1] = and(literal.108, literal.110, id=111)
  literal.113: bits[1] = literal(value=1, id=113)
  literal.125: bits[1] = literal(value=1, id=125, pos=[(0,962,14)])
  eq.122: bits[1] = eq(and.120, literal.121, id=122, pos=[(0,960,25)])
  umul.123: bits[32] = umul(tuple_index.115, tuple_index.112, id=123, pos=[(0,960,51)])
  literal.105: bits[32] = literal(value=0, id=105)
  and.114: bits[1] = and(and.111, literal.113, id=114)
  literal.116: bits[1] = literal(value=1, id=116)
  shrl.126: bits[32] = shrl(tuple_index.109, literal.125, id=126, pos=[(0,962,9)])
  umul.127: bits[32] = umul(tuple_index.112, tuple_index.112, id=127, pos=[(0,962,17)])
  result: bits[32] = sel(eq.122, cases=[tuple_index.115, umul.123], id=124, pos=[(0,960,21)])
  add.106: bits[32] = add(i, literal.105, id=106)
  and.117: bits[1] = and(and.114, literal.116, id=117)
  literal.118: bits[32] = literal(value=32, id=118, pos=[(0,955,12)])
  ret tuple.128: (bits[32], bits[32], bits[32]) = tuple(shrl.126, umul.127, result, id=128, pos=[(0,962,8)])
}

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

fn __std__next_pow2(n: bits[32] id=132) -> bits[32] {
  literal.133: bits[32] = literal(value=2, id=133, pos=[(0,1680,39)])
  invoke.134: bits[32] = invoke(n, to_apply=__std__clog2__32, id=134, pos=[(0,1680,51)])
  ret invoke.135: bits[32] = invoke(literal.133, invoke.134, to_apply=__std__upow__32, id=135, pos=[(0,1680,38)])
}

fn __std__mask_bits__1() -> bits[1] {
  literal.137: bits[1] = literal(value=0, id=137, pos=[(0,835,41)])
  X: bits[32] = literal(value=1, id=136, pos=[(0,835,17)])
  ret not.138: bits[1] = not(literal.137, id=138, pos=[(0,835,40)])
}

fn __std__clzt_pow2_1(value: bits[1] id=139) -> bits[1] {
  ret not.140: bits[1] = not(value, id=140, pos=[(0,1578,4)])
}

fn __std__combine_clzt_halfs__1(left: bits[1] id=141, right: bits[1] id=142) -> bits[2] {
  bit_slice.144: bits[1] = bit_slice(left, start=0, width=1, id=144, pos=[(0,1533,15)])
  bit_slice.145: bits[1] = bit_slice(right, start=0, width=1, id=145, pos=[(0,1533,27)])
  tuple.146: (bits[1], bits[1]) = tuple(bit_slice.144, bit_slice.145, id=146, pos=[(0,1533,10)])
  literal.160: bits[1] = literal(value=1, id=160, pos=[(0,1535,9)])
  tuple_index.159: bits[1] = tuple_index(tuple.146, index=0, id=159)
  literal.149: bits[1] = literal(value=1, id=149, pos=[(0,1534,9)])
  tuple_index.148: bits[1] = tuple_index(tuple.146, index=0, id=148)
  literal.158: bits[1] = literal(value=1, id=158)
  eq.161: bits[1] = eq(literal.160, tuple_index.159, id=161)
  literal.164: bits[1] = literal(value=0, id=164, pos=[(0,1535,15)])
  tuple_index.163: bits[1] = tuple_index(tuple.146, index=1, id=163)
  literal.147: bits[1] = literal(value=1, id=147)
  eq.150: bits[1] = eq(literal.149, tuple_index.148, id=150)
  literal.153: bits[1] = literal(value=1, id=153, pos=[(0,1534,15)])
  tuple_index.152: bits[1] = tuple_index(tuple.146, index=1, id=152)
  and.162: bits[1] = and(literal.158, eq.161, id=162)
  eq.165: bits[1] = eq(literal.164, tuple_index.163, id=165)
  and.151: bits[1] = and(literal.147, eq.150, id=151)
  eq.154: bits[1] = eq(literal.153, tuple_index.152, id=154)
  and.166: bits[1] = and(and.162, eq.165, id=166)
  and.155: bits[1] = and(and.151, eq.154, id=155)
  literal.156: bits[1] = literal(value=0, id=156, pos=[(0,1534,32)])
  literal.167: bits[2] = literal(value=1, id=167, pos=[(0,1535,24)])
  bit_slice.168: bits[0] = bit_slice(right, start=0, width=0, id=168, pos=[(0,1535,40)])
  literal.171: bits[1] = literal(value=0, id=171, pos=[(0,1536,13)])
  concat.173: bits[2] = concat(and.166, and.155, id=173)
  concat.157: bits[2] = concat(left, literal.156, id=157, pos=[(0,1534,24)])
  concat.169: bits[2] = concat(literal.167, bit_slice.168, id=169, pos=[(0,1535,24)])
  concat.172: bits[2] = concat(literal.171, left, id=172, pos=[(0,1536,13)])
  N: bits[32] = literal(value=1, id=143, pos=[(0,1532,22)])
  literal.170: bits[1] = literal(value=1, id=170, pos=[(0,1536,8)])
  ret priority_sel.174: bits[2] = priority_sel(concat.173, cases=[concat.157, concat.169], default=concat.172, id=174)
}

fn __std__clzt_pow2_2(value: bits[2] id=175) -> bits[2] {
  literal.176: bits[32] = literal(value=2, id=176, pos=[(0,1584,20)])
  literal.177: bits[1] = literal(value=1, id=177, pos=[(0,1584,29)])
  bit_slice.180: bits[1] = bit_slice(value, start=1, width=1, id=180, pos=[(0,1585,40)])
  bit_slice.182: bits[1] = bit_slice(value, start=0, width=1, id=182, pos=[(0,1585,70)])
  shrl.178: bits[32] = shrl(literal.176, literal.177, id=178, pos=[(0,1584,20)])
  invoke.181: bits[1] = invoke(bit_slice.180, to_apply=__std__clzt_pow2_1, id=181, pos=[(0,1585,34)])
  invoke.183: bits[1] = invoke(bit_slice.182, to_apply=__std__clzt_pow2_1, id=183, pos=[(0,1585,64)])
  N_HALF: bits[32] = zero_ext(shrl.178, new_bit_count=32, id=179)
  ret invoke.184: bits[2] = invoke(invoke.181, invoke.183, to_apply=__std__combine_clzt_halfs__1, id=184, pos=[(0,1585,22)])
}

fn __std__combine_clzt_halfs__2(left: bits[2] id=185, right: bits[2] id=186) -> bits[3] {
  bit_slice.188: bits[1] = bit_slice(left, start=1, width=1, id=188, pos=[(0,1533,15)])
  bit_slice.189: bits[1] = bit_slice(right, start=1, width=1, id=189, pos=[(0,1533,27)])
  tuple.190: (bits[1], bits[1]) = tuple(bit_slice.188, bit_slice.189, id=190, pos=[(0,1533,10)])
  literal.204: bits[1] = literal(value=1, id=204, pos=[(0,1535,9)])
  tuple_index.203: bits[1] = tuple_index(tuple.190, index=0, id=203)
  literal.193: bits[1] = literal(value=1, id=193, pos=[(0,1534,9)])
  tuple_index.192: bits[1] = tuple_index(tuple.190, index=0, id=192)
  literal.202: bits[1] = literal(value=1, id=202)
  eq.205: bits[1] = eq(literal.204, tuple_index.203, id=205)
  literal.208: bits[1] = literal(value=0, id=208, pos=[(0,1535,15)])
  tuple_index.207: bits[1] = tuple_index(tuple.190, index=1, id=207)
  literal.191: bits[1] = literal(value=1, id=191)
  eq.194: bits[1] = eq(literal.193, tuple_index.192, id=194)
  literal.197: bits[1] = literal(value=1, id=197, pos=[(0,1534,15)])
  tuple_index.196: bits[1] = tuple_index(tuple.190, index=1, id=196)
  and.206: bits[1] = and(literal.202, eq.205, id=206)
  eq.209: bits[1] = eq(literal.208, tuple_index.207, id=209)
  and.195: bits[1] = and(literal.191, eq.194, id=195)
  eq.198: bits[1] = eq(literal.197, tuple_index.196, id=198)
  and.210: bits[1] = and(and.206, eq.209, id=210)
  and.199: bits[1] = and(and.195, eq.198, id=199)
  literal.200: bits[1] = literal(value=0, id=200, pos=[(0,1534,32)])
  literal.211: bits[2] = literal(value=1, id=211, pos=[(0,1535,24)])
  bit_slice.212: bits[1] = bit_slice(right, start=0, width=1, id=212, pos=[(0,1535,40)])
  literal.215: bits[1] = literal(value=0, id=215, pos=[(0,1536,13)])
  concat.217: bits[2] = concat(and.210, and.199, id=217)
  concat.201: bits[3] = concat(left, literal.200, id=201, pos=[(0,1534,24)])
  concat.213: bits[3] = concat(literal.211, bit_slice.212, id=213, pos=[(0,1535,24)])
  concat.216: bits[3] = concat(literal.215, left, id=216, pos=[(0,1536,13)])
  N: bits[32] = literal(value=2, id=187, pos=[(0,1532,22)])
  literal.214: bits[1] = literal(value=1, id=214, pos=[(0,1536,8)])
  ret priority_sel.218: bits[3] = priority_sel(concat.217, cases=[concat.201, concat.213], default=concat.216, id=218)
}

fn __std__clzt_pow2_4(value: bits[4] id=219) -> bits[3] {
  literal.220: bits[32] = literal(value=4, id=220, pos=[(0,1589,20)])
  literal.221: bits[1] = literal(value=1, id=221, pos=[(0,1589,29)])
  bit_slice.224: bits[2] = bit_slice(value, start=2, width=2, id=224, pos=[(0,1590,40)])
  bit_slice.226: bits[2] = bit_slice(value, start=0, width=2, id=226, pos=[(0,1590,70)])
  shrl.222: bits[32] = shrl(literal.220, literal.221, id=222, pos=[(0,1589,20)])
  invoke.225: bits[2] = invoke(bit_slice.224, to_apply=__std__clzt_pow2_2, id=225, pos=[(0,1590,34)])
  invoke.227: bits[2] = invoke(bit_slice.226, to_apply=__std__clzt_pow2_2, id=227, pos=[(0,1590,64)])
  N_HALF: bits[32] = zero_ext(shrl.222, new_bit_count=32, id=223)
  ret invoke.228: bits[3] = invoke(invoke.225, invoke.227, to_apply=__std__combine_clzt_halfs__2, id=228, pos=[(0,1590,22)])
}

fn __std__combine_clzt_halfs__3(left: bits[3] id=229, right: bits[3] id=230) -> bits[4] {
  bit_slice.232: bits[1] = bit_slice(left, start=2, width=1, id=232, pos=[(0,1533,15)])
  bit_slice.233: bits[1] = bit_slice(right, start=2, width=1, id=233, pos=[(0,1533,27)])
  tuple.234: (bits[1], bits[1]) = tuple(bit_slice.232, bit_slice.233, id=234, pos=[(0,1533,10)])
  literal.248: bits[1] = literal(value=1, id=248, pos=[(0,1535,9)])
  tuple_index.247: bits[1] = tuple_index(tuple.234, index=0, id=247)
  literal.237: bits[1] = literal(value=1, id=237, pos=[(0,1534,9)])
  tuple_index.236: bits[1] = tuple_index(tuple.234, index=0, id=236)
  literal.246: bits[1] = literal(value=1, id=246)
  eq.249: bits[1] = eq(literal.248, tuple_index.247, id=249)
  literal.252: bits[1] = literal(value=0, id=252, pos=[(0,1535,15)])
  tuple_index.251: bits[1] = tuple_index(tuple.234, index=1, id=251)
  literal.235: bits[1] = literal(value=1, id=235)
  eq.238: bits[1] = eq(literal.237, tuple_index.236, id=238)
  literal.241: bits[1] = literal(value=1, id=241, pos=[(0,1534,15)])
  tuple_index.240: bits[1] = tuple_index(tuple.234, index=1, id=240)
  and.250: bits[1] = and(literal.246, eq.249, id=250)
  eq.253: bits[1] = eq(literal.252, tuple_index.251, id=253)
  and.239: bits[1] = and(literal.235, eq.238, id=239)
  eq.242: bits[1] = eq(literal.241, tuple_index.240, id=242)
  and.254: bits[1] = and(and.250, eq.253, id=254)
  and.243: bits[1] = and(and.239, eq.242, id=243)
  literal.244: bits[1] = literal(value=0, id=244, pos=[(0,1534,32)])
  literal.255: bits[2] = literal(value=1, id=255, pos=[(0,1535,24)])
  bit_slice.256: bits[2] = bit_slice(right, start=0, width=2, id=256, pos=[(0,1535,40)])
  literal.259: bits[1] = literal(value=0, id=259, pos=[(0,1536,13)])
  concat.261: bits[2] = concat(and.254, and.243, id=261)
  concat.245: bits[4] = concat(left, literal.244, id=245, pos=[(0,1534,24)])
  concat.257: bits[4] = concat(literal.255, bit_slice.256, id=257, pos=[(0,1535,24)])
  concat.260: bits[4] = concat(literal.259, left, id=260, pos=[(0,1536,13)])
  N: bits[32] = literal(value=3, id=231, pos=[(0,1532,22)])
  literal.258: bits[1] = literal(value=1, id=258, pos=[(0,1536,8)])
  ret priority_sel.262: bits[4] = priority_sel(concat.261, cases=[concat.245, concat.257], default=concat.260, id=262)
}

fn __std__clzt_pow2_8(value: bits[8] id=263) -> bits[4] {
  literal.264: bits[32] = literal(value=8, id=264, pos=[(0,1594,20)])
  literal.265: bits[1] = literal(value=1, id=265, pos=[(0,1594,29)])
  bit_slice.268: bits[4] = bit_slice(value, start=4, width=4, id=268, pos=[(0,1595,40)])
  bit_slice.270: bits[4] = bit_slice(value, start=0, width=4, id=270, pos=[(0,1595,70)])
  shrl.266: bits[32] = shrl(literal.264, literal.265, id=266, pos=[(0,1594,20)])
  invoke.269: bits[3] = invoke(bit_slice.268, to_apply=__std__clzt_pow2_4, id=269, pos=[(0,1595,34)])
  invoke.271: bits[3] = invoke(bit_slice.270, to_apply=__std__clzt_pow2_4, id=271, pos=[(0,1595,64)])
  N_HALF: bits[32] = zero_ext(shrl.266, new_bit_count=32, id=267)
  ret invoke.272: bits[4] = invoke(invoke.269, invoke.271, to_apply=__std__combine_clzt_halfs__3, id=272, pos=[(0,1595,22)])
}

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

fn __std__clzt_pow2_16(value: bits[16] id=307) -> bits[5] {
  literal.308: bits[32] = literal(value=16, id=308, pos=[(0,1599,20)])
  literal.309: bits[1] = literal(value=1, id=309, pos=[(0,1599,30)])
  bit_slice.312: bits[8] = bit_slice(value, start=8, width=8, id=312, pos=[(0,1600,40)])
  bit_slice.314: bits[8] = bit_slice(value, start=0, width=8, id=314, pos=[(0,1600,70)])
  shrl.310: bits[32] = shrl(literal.308, literal.309, id=310, pos=[(0,1599,20)])
  invoke.313: bits[4] = invoke(bit_slice.312, to_apply=__std__clzt_pow2_8, id=313, pos=[(0,1600,34)])
  invoke.315: bits[4] = invoke(bit_slice.314, to_apply=__std__clzt_pow2_8, id=315, pos=[(0,1600,64)])
  N_HALF: bits[32] = zero_ext(shrl.310, new_bit_count=32, id=311)
  ret invoke.316: bits[5] = invoke(invoke.313, invoke.315, to_apply=__std__combine_clzt_halfs__4, id=316, pos=[(0,1600,22)])
}

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

fn __std__clzt_pow2_32(value: bits[32] id=351) -> bits[6] {
  literal.352: bits[32] = literal(value=32, id=352, pos=[(0,1604,20)])
  literal.353: bits[1] = literal(value=1, id=353, pos=[(0,1604,30)])
  bit_slice.356: bits[16] = bit_slice(value, start=16, width=16, id=356, pos=[(0,1605,41)])
  bit_slice.358: bits[16] = bit_slice(value, start=0, width=16, id=358, pos=[(0,1605,72)])
  shrl.354: bits[32] = shrl(literal.352, literal.353, id=354, pos=[(0,1604,20)])
  invoke.357: bits[5] = invoke(bit_slice.356, to_apply=__std__clzt_pow2_16, id=357, pos=[(0,1605,35)])
  invoke.359: bits[5] = invoke(bit_slice.358, to_apply=__std__clzt_pow2_16, id=359, pos=[(0,1605,66)])
  N_HALF: bits[32] = zero_ext(shrl.354, new_bit_count=32, id=355)
  ret invoke.360: bits[6] = invoke(invoke.357, invoke.359, to_apply=__std__combine_clzt_halfs__5, id=360, pos=[(0,1605,22)])
}

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

fn __std__clzt_pow2_64(value: bits[64] id=395) -> bits[7] {
  literal.396: bits[32] = literal(value=64, id=396, pos=[(0,1609,20)])
  literal.397: bits[1] = literal(value=1, id=397, pos=[(0,1609,30)])
  bit_slice.400: bits[32] = bit_slice(value, start=32, width=32, id=400, pos=[(0,1610,41)])
  bit_slice.402: bits[32] = bit_slice(value, start=0, width=32, id=402, pos=[(0,1610,72)])
  shrl.398: bits[32] = shrl(literal.396, literal.397, id=398, pos=[(0,1609,20)])
  invoke.401: bits[6] = invoke(bit_slice.400, to_apply=__std__clzt_pow2_32, id=401, pos=[(0,1610,35)])
  invoke.403: bits[6] = invoke(bit_slice.402, to_apply=__std__clzt_pow2_32, id=403, pos=[(0,1610,66)])
  N_HALF: bits[32] = zero_ext(shrl.398, new_bit_count=32, id=399)
  ret invoke.404: bits[7] = invoke(invoke.401, invoke.403, to_apply=__std__combine_clzt_halfs__6, id=404, pos=[(0,1610,22)])
}

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

fn __std__clzt_pow2_128(value: bits[128] id=439) -> bits[8] {
  literal.440: bits[32] = literal(value=128, id=440, pos=[(0,1614,20)])
  literal.441: bits[1] = literal(value=1, id=441, pos=[(0,1614,31)])
  bit_slice.444: bits[64] = bit_slice(value, start=64, width=64, id=444, pos=[(0,1615,41)])
  bit_slice.446: bits[64] = bit_slice(value, start=0, width=64, id=446, pos=[(0,1615,72)])
  shrl.442: bits[32] = shrl(literal.440, literal.441, id=442, pos=[(0,1614,20)])
  invoke.445: bits[7] = invoke(bit_slice.444, to_apply=__std__clzt_pow2_64, id=445, pos=[(0,1615,35)])
  invoke.447: bits[7] = invoke(bit_slice.446, to_apply=__std__clzt_pow2_64, id=447, pos=[(0,1615,66)])
  N_HALF: bits[32] = zero_ext(shrl.442, new_bit_count=32, id=443)
  ret invoke.448: bits[8] = invoke(invoke.445, invoke.447, to_apply=__std__combine_clzt_halfs__7, id=448, pos=[(0,1615,22)])
}

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

fn __std__clzt_pow2_256(value: bits[256] id=483) -> bits[9] {
  literal.484: bits[32] = literal(value=256, id=484, pos=[(0,1619,20)])
  literal.485: bits[1] = literal(value=1, id=485, pos=[(0,1619,31)])
  bit_slice.488: bits[128] = bit_slice(value, start=128, width=128, id=488, pos=[(0,1620,42)])
  bit_slice.490: bits[128] = bit_slice(value, start=0, width=128, id=490, pos=[(0,1620,74)])
  shrl.486: bits[32] = shrl(literal.484, literal.485, id=486, pos=[(0,1619,20)])
  invoke.489: bits[8] = invoke(bit_slice.488, to_apply=__std__clzt_pow2_128, id=489, pos=[(0,1620,36)])
  invoke.491: bits[8] = invoke(bit_slice.490, to_apply=__std__clzt_pow2_128, id=491, pos=[(0,1620,68)])
  N_HALF: bits[32] = zero_ext(shrl.486, new_bit_count=32, id=487)
  ret invoke.492: bits[9] = invoke(invoke.489, invoke.491, to_apply=__std__combine_clzt_halfs__8, id=492, pos=[(0,1620,22)])
}

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

fn __std__clzt_pow2_512(value: bits[512] id=527) -> bits[10] {
  literal.528: bits[32] = literal(value=512, id=528, pos=[(0,1624,20)])
  literal.529: bits[1] = literal(value=1, id=529, pos=[(0,1624,31)])
  bit_slice.532: bits[256] = bit_slice(value, start=256, width=256, id=532, pos=[(0,1625,42)])
  bit_slice.534: bits[256] = bit_slice(value, start=0, width=256, id=534, pos=[(0,1625,74)])
  shrl.530: bits[32] = shrl(literal.528, literal.529, id=530, pos=[(0,1624,20)])
  invoke.533: bits[9] = invoke(bit_slice.532, to_apply=__std__clzt_pow2_256, id=533, pos=[(0,1625,36)])
  invoke.535: bits[9] = invoke(bit_slice.534, to_apply=__std__clzt_pow2_256, id=535, pos=[(0,1625,68)])
  N_HALF: bits[32] = zero_ext(shrl.530, new_bit_count=32, id=531)
  ret invoke.536: bits[10] = invoke(invoke.533, invoke.535, to_apply=__std__combine_clzt_halfs__9, id=536, pos=[(0,1625,22)])
}

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

fn __std__clzt__15_4(value: bits[15] id=598) -> bits[4] {
  invoke.603: bits[1] = invoke(to_apply=__std__mask_bits__1, id=603, pos=[(0,1702,32)])
  N: bits[32] = literal(value=15, id=599, pos=[(0,1699,12)])
  concat.604: bits[16] = concat(value, invoke.603, id=604, pos=[(0,1702,14)])
  invoke.601: bits[32] = invoke(N, to_apply=__std__next_pow2, id=601, pos=[(0,1700,50)])
  invoke.605: bits[5] = invoke(concat.604, to_apply=__std__clzt_pow2__16_5, id=605, pos=[(0,1702,13)])
  RESULT_BITS: bits[32] = literal(value=4, id=600, pos=[(0,1699,20)])
  BITS_MISSING_UNTIL_POWER_TWO: bits[32] = sub(invoke.601, N, id=602, pos=[(0,1700,50)])
  ret bit_slice.606: bits[4] = bit_slice(invoke.605, start=0, width=4, id=606)
}

fn __std__mask_bits__5() -> bits[5] {
  literal.608: bits[5] = literal(value=0, id=608, pos=[(0,835,41)])
  X: bits[32] = literal(value=5, id=607, pos=[(0,835,17)])
  ret not.609: bits[5] = not(literal.608, id=609, pos=[(0,835,40)])
}

fn __apfloat__is_inf__5_10(x: (bits[1], bits[5], bits[10]) id=610) -> bits[1] {
  x_bexp: bits[5] = tuple_index(x, index=1, id=613, pos=[(2,96,6)])
  invoke.614: bits[5] = invoke(to_apply=__std__mask_bits__5, id=614, pos=[(2,96,29)])
  x_fraction: bits[10] = tuple_index(x, index=2, id=616, pos=[(2,96,44)])
  literal.617: bits[10] = literal(value=0, id=617, pos=[(2,96,57)])
  eq.615: bits[1] = eq(x_bexp, invoke.614, id=615, pos=[(2,96,6)])
  eq.618: bits[1] = eq(x_fraction, literal.617, id=618, pos=[(2,96,44)])
  EXP_SZ: bits[32] = literal(value=5, id=611, pos=[(2,95,14)])
  FRACTION_SZ: bits[32] = literal(value=10, id=612, pos=[(2,95,27)])
  ret and.619: bits[1] = and(eq.615, eq.618, id=619, pos=[(2,96,6)])
}

fn __apfloat__is_nan__5_10(x: (bits[1], bits[5], bits[10]) id=620) -> bits[1] {
  x_bexp: bits[5] = tuple_index(x, index=1, id=623, pos=[(2,71,6)])
  invoke.624: bits[5] = invoke(to_apply=__std__mask_bits__5, id=624, pos=[(2,71,29)])
  x_fraction: bits[10] = tuple_index(x, index=2, id=626, pos=[(2,71,44)])
  literal.627: bits[10] = literal(value=0, id=627, pos=[(2,71,57)])
  eq.625: bits[1] = eq(x_bexp, invoke.624, id=625, pos=[(2,71,6)])
  ne.628: bits[1] = ne(x_fraction, literal.627, id=628, pos=[(2,71,44)])
  EXP_SZ: bits[32] = literal(value=5, id=621, pos=[(2,70,14)])
  FRACTION_SZ: bits[32] = literal(value=10, id=622, pos=[(2,70,27)])
  ret and.629: bits[1] = and(eq.625, ne.628, id=629, pos=[(2,71,6)])
}

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

fn __apfloat__sub__5_10(x: (bits[1], bits[5], bits[10]) id=835, y: (bits[1], bits[5], bits[10]) id=836) -> (bits[1], bits[5], bits[10]) {
  y_sign: bits[1] = tuple_index(y, index=0, id=839, pos=[(2,3242,51)])
  not.840: bits[1] = not(y_sign, id=840, pos=[(2,3242,49)])
  y_bexp: bits[5] = tuple_index(y, index=1, id=841, pos=[(2,3242,65)])
  y_fraction: bits[10] = tuple_index(y, index=2, id=842, pos=[(2,3242,83)])
  y__1: (bits[1], bits[5], bits[10]) = tuple(not.840, y_bexp, y_fraction, id=843, pos=[(2,3242,41)])
  EXP_SZ: bits[32] = literal(value=5, id=837, pos=[(2,3239,11)])
  FRACTION_SZ: bits[32] = literal(value=10, id=838, pos=[(2,3239,24)])
  ret invoke.844: (bits[1], bits[5], bits[10]) = invoke(x, y__1, to_apply=__apfloat__add__5_10, id=844, pos=[(2,3243,7)])
}

top fn __hfloat16__sub(x: (bits[1], bits[5], bits[10]) id=845, y: (bits[1], bits[5], bits[10]) id=846) -> (bits[1], bits[5], bits[10]) {
  ret invoke.847: (bits[1], bits[5], bits[10]) = invoke(x, y, to_apply=__apfloat__sub__5_10, id=847, pos=[(3,118,51)])
}