package float64

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

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

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

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

fn __apfloat__sign_magnitude_difference__11(a: bits[11] id=36, b: bits[11] id=37) -> (bits[1], bits[11]) {
  abs_diff_result: (bits[1], bits[11]) = invoke(a, b, to_apply=__abs_diff__abs_diff__11, id=39, pos=[(2,3005,44)])
  invoke.40: bits[1] = invoke(abs_diff_result, to_apply=__abs_diff__is_x_larger__11, id=40, pos=[(2,3006,27)])
  not.41: bits[1] = not(invoke.40, id=41, pos=[(2,3006,5)])
  invoke.42: bits[11] = invoke(abs_diff_result, to_apply=__abs_diff__to_corrected__11, id=42, pos=[(2,3006,68)])
  WIDTH: bits[32] = literal(value=11, id=38, pos=[(2,3004,29)])
  ret tuple.43: (bits[1], bits[11]) = tuple(not.41, invoke.42, id=43, pos=[(2,3006,4)])
}

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

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

fn __std__or_reduce_lsb__11_57(value: bits[57] id=66, n: bits[11] id=67) -> bits[1] {
  WIDTH: bits[32] = literal(value=57, id=68, pos=[(0,1527,21)])
  N_WIDTH: bits[32] = literal(value=11, id=69, pos=[(0,1527,33)])
  ret invoke.70: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_11_57, id=70, pos=[(0,1528,22)])
}

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

fn __apfloat__or_last_bit__56(value: bits[56] id=78, lsb: bits[1] id=79) -> bits[56] {
  bit_slice.82: bits[1] = bit_slice(value, start=0, width=1, id=82, pos=[(2,3049,40)])
  literal.81: bits[1] = literal(value=0, id=81, pos=[(2,3049,28)])
  or.83: bits[1] = or(bit_slice.82, lsb, id=83, pos=[(2,3049,40)])
  WIDTH: bits[32] = literal(value=56, id=80, pos=[(2,3048,15)])
  ret bit_slice_update.84: bits[56] = bit_slice_update(value, literal.81, or.83, id=84, pos=[(2,3049,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)
  literal.128: bits[32] = literal(value=0, id=128, pos=[(0,961,25)])
  tuple_index.113: bits[32] = tuple_index(__loop_carry, index=1, id=113)
  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)
  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,961,14)])
  eq.129: bits[1] = eq(tuple_index.110, literal.128, id=129, pos=[(0,961,20)])
  umul.130: bits[32] = umul(tuple_index.113, tuple_index.113, id=130, pos=[(0,961,46)])
  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,961,9)])
  sel.131: bits[32] = sel(eq.129, cases=[umul.130, tuple_index.113], id=131, pos=[(0,961,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.132: (bits[32], bits[32], bits[32]) = tuple(shrl.127, sel.131, result, id=132, pos=[(0,961,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,962,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=133)
  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.134: bits[32] = literal(value=2, id=134, pos=[(0,963,9)])
  ret tuple_index.135: bits[32] = tuple_index(work, index=2, id=135, pos=[(0,963,8)])
}

fn __std__upow__32(x: bits[32] id=136, n: bits[32] id=137) -> bits[32] {
  N: bits[32] = literal(value=32, id=138, pos=[(0,966,12)])
  ret invoke.139: bits[32] = invoke(x, n, to_apply=__std__pow__32_0, id=139, pos=[(0,966,54)])
}

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

fn __std__mask_bits__7() -> bits[7] {
  literal.145: bits[7] = literal(value=0, id=145, pos=[(0,835,41)])
  X: bits[32] = literal(value=7, id=144, pos=[(0,835,17)])
  ret not.146: bits[7] = not(literal.145, id=146, pos=[(0,835,40)])
}

fn __std__clzt_pow2_1(value: bits[1] id=147) -> bits[1] {
  ret not.148: bits[1] = not(value, id=148, pos=[(0,1583,4)])
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn __std__clzt__57_6(value: bits[57] id=606) -> bits[6] {
  invoke.611: bits[7] = invoke(to_apply=__std__mask_bits__7, id=611, pos=[(0,1707,32)])
  N: bits[32] = literal(value=57, id=607, pos=[(0,1704,12)])
  concat.612: bits[64] = concat(value, invoke.611, id=612, pos=[(0,1707,14)])
  invoke.609: bits[32] = invoke(N, to_apply=__std__next_pow2, id=609, pos=[(0,1705,50)])
  invoke.613: bits[7] = invoke(concat.612, to_apply=__std__clzt_pow2__64_7, id=613, pos=[(0,1707,13)])
  RESULT_BITS: bits[32] = literal(value=6, id=608, pos=[(0,1704,20)])
  BITS_MISSING_UNTIL_POWER_TWO: bits[32] = sub(invoke.609, N, id=610, pos=[(0,1705,50)])
  ret bit_slice.614: bits[6] = bit_slice(invoke.613, start=0, width=6, id=614)
}

fn __std__mask_bits__11() -> bits[11] {
  literal.616: bits[11] = literal(value=0, id=616, pos=[(0,835,41)])
  X: bits[32] = literal(value=11, id=615, pos=[(0,835,17)])
  ret not.617: bits[11] = not(literal.616, id=617, pos=[(0,835,40)])
}

fn __apfloat__is_inf__11_52(x: (bits[1], bits[11], bits[52]) id=618) -> bits[1] {
  x_bexp: bits[11] = tuple_index(x, index=1, id=621, pos=[(2,96,6)])
  invoke.622: bits[11] = invoke(to_apply=__std__mask_bits__11, id=622, pos=[(2,96,29)])
  x_fraction: bits[52] = tuple_index(x, index=2, id=624, pos=[(2,96,44)])
  literal.625: bits[52] = literal(value=0, id=625, pos=[(2,96,57)])
  eq.623: bits[1] = eq(x_bexp, invoke.622, id=623, pos=[(2,96,6)])
  eq.626: bits[1] = eq(x_fraction, literal.625, id=626, pos=[(2,96,44)])
  EXP_SZ: bits[32] = literal(value=11, id=619, pos=[(2,95,14)])
  FRACTION_SZ: bits[32] = literal(value=52, id=620, pos=[(2,95,27)])
  ret and.627: bits[1] = and(eq.623, eq.626, id=627, pos=[(2,96,6)])
}

fn __apfloat__is_nan__11_52(x: (bits[1], bits[11], bits[52]) id=628) -> bits[1] {
  x_bexp: bits[11] = tuple_index(x, index=1, id=631, pos=[(2,71,6)])
  invoke.632: bits[11] = invoke(to_apply=__std__mask_bits__11, id=632, pos=[(2,71,29)])
  x_fraction: bits[52] = tuple_index(x, index=2, id=634, pos=[(2,71,44)])
  literal.635: bits[52] = literal(value=0, id=635, pos=[(2,71,57)])
  eq.633: bits[1] = eq(x_bexp, invoke.632, id=633, pos=[(2,71,6)])
  ne.636: bits[1] = ne(x_fraction, literal.635, id=636, pos=[(2,71,44)])
  EXP_SZ: bits[32] = literal(value=11, id=629, pos=[(2,70,14)])
  FRACTION_SZ: bits[32] = literal(value=52, id=630, pos=[(2,70,27)])
  ret and.637: bits[1] = and(eq.633, ne.636, id=637, pos=[(2,71,6)])
}

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

fn __apfloat__sub__11_52(x: (bits[1], bits[11], bits[52]) id=843, y: (bits[1], bits[11], bits[52]) id=844) -> (bits[1], bits[11], bits[52]) {
  y_sign: bits[1] = tuple_index(y, index=0, id=847, pos=[(2,3238,51)])
  not.848: bits[1] = not(y_sign, id=848, pos=[(2,3238,49)])
  y_bexp: bits[11] = tuple_index(y, index=1, id=849, pos=[(2,3238,65)])
  y_fraction: bits[52] = tuple_index(y, index=2, id=850, pos=[(2,3238,83)])
  y__1: (bits[1], bits[11], bits[52]) = tuple(not.848, y_bexp, y_fraction, id=851, pos=[(2,3238,41)])
  EXP_SZ: bits[32] = literal(value=11, id=845, pos=[(2,3235,11)])
  FRACTION_SZ: bits[32] = literal(value=52, id=846, pos=[(2,3235,24)])
  ret invoke.852: (bits[1], bits[11], bits[52]) = invoke(x, y__1, to_apply=__apfloat__add__11_52, id=852, pos=[(2,3239,7)])
}

top fn __float64__sub(x: (bits[1], bits[11], bits[52]) id=853, y: (bits[1], bits[11], bits[52]) id=854) -> (bits[1], bits[11], bits[52]) {
  ret invoke.855: (bits[1], bits[11], bits[52]) = invoke(x, y, to_apply=__apfloat__sub__11_52, id=855, pos=[(3,168,48)])
}