package hfloat16

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

fn __apfloat__is_zero_or_subnormal__5_10(x: (bits[1], bits[5], bits[10]) id=1) -> bits[1] {
  x_bexp: bits[5] = tuple_index(x, index=1, id=4, pos=[(0,804,5)])
  literal.5: bits[5] = literal(value=0, id=5, pos=[(0,804,14)])
  EXP_SZ: bits[32] = literal(value=5, id=2, pos=[(0,802,28)])
  FRACTION_SZ: bits[32] = literal(value=10, id=3, pos=[(0,802,41)])
  ret eq.6: bits[1] = eq(x_bexp, literal.5, id=6, pos=[(0,804,5)])
}

fn __std__umul__11_11_22(x: bits[11] id=7, y: bits[11] id=8) -> bits[22] {
  zero_ext.12: bits[22] = zero_ext(x, new_bit_count=22, id=12)
  zero_ext.13: bits[22] = zero_ext(y, new_bit_count=22, id=13)
  N: bits[32] = literal(value=11, id=9, pos=[(1,223,12)])
  M: bits[32] = literal(value=11, id=10, pos=[(1,223,20)])
  R: bits[32] = literal(value=22, id=11, pos=[(1,223,28)])
  ret umul.14: bits[22] = umul(zero_ext.12, zero_ext.13, id=14, pos=[(1,224,5)])
}

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

fn __std__msb__22_0(x: bits[22] id=18) -> bits[1] {
  zero_ext.21: bits[22] = zero_ext(x, new_bit_count=22, id=21)
  S: bits[1] = literal(value=0, id=19, pos=[(1,357,11)])
  N: bits[32] = literal(value=22, id=20, pos=[(1,357,20)])
  ret bit_slice.22: bits[1] = bit_slice(zero_ext.21, start=21, width=1, id=22, pos=[(1,357,61)])
}

fn __apfloat__is_inf__5_10(x: (bits[1], bits[5], bits[10]) id=23) -> bits[1] {
  x_bexp: bits[5] = tuple_index(x, index=1, id=26, pos=[(0,96,6)])
  invoke.27: bits[5] = invoke(to_apply=__std__mask_bits__5, id=27, pos=[(0,96,29)])
  x_fraction: bits[10] = tuple_index(x, index=2, id=29, pos=[(0,96,44)])
  literal.30: bits[10] = literal(value=0, id=30, pos=[(0,96,57)])
  eq.28: bits[1] = eq(x_bexp, invoke.27, id=28, pos=[(0,96,6)])
  eq.31: bits[1] = eq(x_fraction, literal.30, id=31, pos=[(0,96,44)])
  EXP_SZ: bits[32] = literal(value=5, id=24, pos=[(0,95,14)])
  FRACTION_SZ: bits[32] = literal(value=10, id=25, pos=[(0,95,27)])
  ret and.32: bits[1] = and(eq.28, eq.31, id=32, pos=[(0,96,6)])
}

fn __std__signed_max_value__7_6() -> bits[7] {
  literal.35: bits[7] = literal(value=1, id=35, pos=[(1,47,6)])
  N_MINUS_ONE: bits[32] = literal(value=6, id=34, pos=[(1,46,32)])
  shll.36: bits[7] = shll(literal.35, N_MINUS_ONE, id=36, pos=[(1,47,6)])
  literal.37: bits[7] = literal(value=1, id=37, pos=[(1,47,32)])
  sub.38: bits[7] = sub(shll.36, literal.37, id=38, pos=[(1,47,6)])
  N: bits[32] = literal(value=7, id=33, pos=[(1,46,24)])
  ret sign_ext.39: bits[7] = sign_ext(sub.38, new_bit_count=7, id=39)
}

fn __apfloat__is_nan__5_10(x: (bits[1], bits[5], bits[10]) id=40) -> bits[1] {
  x_bexp: bits[5] = tuple_index(x, index=1, id=43, pos=[(0,71,6)])
  invoke.44: bits[5] = invoke(to_apply=__std__mask_bits__5, id=44, pos=[(0,71,29)])
  x_fraction: bits[10] = tuple_index(x, index=2, id=46, pos=[(0,71,44)])
  literal.47: bits[10] = literal(value=0, id=47, pos=[(0,71,57)])
  eq.45: bits[1] = eq(x_bexp, invoke.44, id=45, pos=[(0,71,6)])
  ne.48: bits[1] = ne(x_fraction, literal.47, id=48, pos=[(0,71,44)])
  EXP_SZ: bits[32] = literal(value=5, id=41, pos=[(0,70,14)])
  FRACTION_SZ: bits[32] = literal(value=10, id=42, pos=[(0,70,27)])
  ret and.49: bits[1] = and(eq.45, ne.48, id=49, pos=[(0,71,6)])
}

fn __apfloat__raw_mul__5_10_10_7_22(x: (bits[1], bits[5], bits[10]) id=50, y: (bits[1], bits[5], bits[10]) id=51) -> (bits[1], bits[1], bits[7], bits[22]) {
  literal.60: bits[1] = literal(value=1, id=60, pos=[(0,3434,24)])
  x_fraction: bits[10] = tuple_index(x, index=2, id=61, pos=[(0,3434,33)])
  literal.63: bits[1] = literal(value=1, id=63, pos=[(0,3435,24)])
  y_fraction: bits[10] = tuple_index(y, index=2, id=64, pos=[(0,3435,33)])
  x_bexp: bits[5] = tuple_index(x, index=1, id=73, pos=[(0,3448,16)])
  y_bexp: bits[5] = tuple_index(y, index=1, id=75, pos=[(0,3448,45)])
  invoke.69: bits[5] = invoke(to_apply=__std__mask_bits__5, id=69, pos=[(0,3447,29)])
  invoke.57: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__5_10, id=57, pos=[(0,3431,40)])
  invoke.58: bits[1] = invoke(y, to_apply=__apfloat__is_zero_or_subnormal__5_10, id=58, pos=[(0,3431,67)])
  x_significand: bits[11] = concat(literal.60, x_fraction, id=62, pos=[(0,3434,24)])
  y_significand: bits[11] = concat(literal.63, y_fraction, id=65, pos=[(0,3435,24)])
  zero_ext.74: bits[7] = zero_ext(x_bexp, new_bit_count=7, id=74)
  zero_ext.76: bits[7] = zero_ext(y_bexp, new_bit_count=7, id=76)
  zero_ext.70: bits[7] = zero_ext(invoke.69, new_bit_count=7, id=70)
  literal.71: bits[7] = literal(value=1, id=71, pos=[(0,3447,61)])
  has_0_arg: bits[1] = or(invoke.57, invoke.58, id=59, pos=[(0,3431,40)])
  invoke.67: bits[22] = invoke(x_significand, y_significand, to_apply=__std__umul__11_11_22, id=67, pos=[(0,3439,61)])
  literal.66: bits[22] = literal(value=0, id=66, pos=[(0,3439,23)])
  add.77: bits[7] = add(zero_ext.74, zero_ext.76, id=77, pos=[(0,3448,16)])
  bias: bits[7] = shra(zero_ext.70, literal.71, id=72, pos=[(0,3447,29)])
  full_product: bits[22] = sel(has_0_arg, cases=[invoke.67, literal.66], id=68, pos=[(0,3439,8)])
  invoke.100: bits[1] = invoke(x, to_apply=__apfloat__is_inf__5_10, id=100, pos=[(0,3488,28)])
  invoke.101: bits[1] = invoke(y, to_apply=__apfloat__is_inf__5_10, id=101, pos=[(0,3488,41)])
  exp: bits[7] = sub(add.77, bias, id=78, pos=[(0,3448,16)])
  literal.79: bits[7] = literal(value=0, id=79, pos=[(0,3457,29)])
  in_upper_binade: bits[1] = invoke(full_product, to_apply=__std__msb__22_0, id=81, pos=[(0,3463,34)])
  literal.82: bits[1] = literal(value=1, id=82, pos=[(0,3464,90)])
  invoke.97: bits[1] = invoke(x, to_apply=__apfloat__is_nan__5_10, id=97, pos=[(0,3487,28)])
  invoke.98: bits[1] = invoke(y, to_apply=__apfloat__is_nan__5_10, id=98, pos=[(0,3487,41)])
  has_inf_arg: bits[1] = or(invoke.100, invoke.101, id=102, pos=[(0,3488,28)])
  invoke.90: bits[1] = invoke(x, to_apply=__apfloat__is_inf__5_10, id=90, pos=[(0,3481,31)])
  invoke.91: bits[1] = invoke(y, to_apply=__apfloat__is_inf__5_10, id=91, pos=[(0,3481,44)])
  exp__1: bits[7] = sel(has_0_arg, cases=[exp, literal.79], id=80, pos=[(0,3457,14)])
  zero_ext.85: bits[7] = zero_ext(in_upper_binade, new_bit_count=7, id=85)
  shll.83: bits[22] = shll(full_product, literal.82, id=83, pos=[(0,3464,74)])
  has_nan_arg: bits[1] = or(invoke.97, invoke.98, id=99, pos=[(0,3487,28)])
  and.103: bits[1] = and(has_0_arg, has_inf_arg, id=103, pos=[(0,3489,40)])
  x_sign: bits[1] = tuple_index(x, index=0, id=87, pos=[(0,3471,23)])
  y_sign: bits[1] = tuple_index(y, index=0, id=88, pos=[(0,3471,33)])
  is_operand_inf: bits[1] = or(invoke.90, invoke.91, id=92, pos=[(0,3481,31)])
  result_exp: bits[7] = add(exp__1, zero_ext.85, id=86, pos=[(0,3468,14)])
  invoke.93: bits[7] = invoke(to_apply=__std__signed_max_value__7_6, id=93, pos=[(0,3482,62)])
  result_fraction: bits[22] = sel(in_upper_binade, cases=[shll.83, full_product], id=84, pos=[(0,3464,30)])
  literal.95: bits[22] = literal(value=0, id=95, pos=[(0,3483,46)])
  is_result_nan: bits[1] = or(has_nan_arg, and.103, id=104, pos=[(0,3489,24)])
  result_sign: bits[1] = ne(x_sign, y_sign, id=89, pos=[(0,3471,23)])
  result_exp__1: bits[7] = sel(is_operand_inf, cases=[result_exp, invoke.93], id=94, pos=[(0,3482,21)])
  result_fraction__1: bits[22] = sel(is_operand_inf, cases=[result_fraction, literal.95], id=96, pos=[(0,3483,26)])
  EXP_SZ: bits[32] = literal(value=5, id=52, pos=[(0,3426,5)])
  FRACTION_SZ_X: bits[32] = literal(value=10, id=53, pos=[(0,3426,18)])
  FRACTION_SZ_Y: bits[32] = literal(value=10, id=54, pos=[(0,3426,38)])
  SIGNED_EXP: bits[32] = literal(value=7, id=55, pos=[(0,3426,58)])
  WIDE_FRACTION: bits[32] = literal(value=22, id=56, pos=[(0,3427,5)])
  ret tuple.105: (bits[1], bits[1], bits[7], bits[22]) = tuple(is_result_nan, result_sign, result_exp__1, result_fraction__1, id=105, pos=[(0,3491,42)])
}

fn __std__mask_bits__6() -> bits[6] {
  literal.107: bits[6] = literal(value=0, id=107, pos=[(1,835,41)])
  X: bits[32] = literal(value=6, id=106, pos=[(1,835,17)])
  ret not.108: bits[6] = not(literal.107, id=108, pos=[(1,835,40)])
}

fn __apfloat__mul_no_round__6_7_5_10_22(a: (bits[1], bits[5], bits[10]) id=109, b: (bits[1], bits[5], bits[10]) id=110) -> (bits[1], bits[6], bits[22]) {
  raw_product: (bits[1], bits[1], bits[7], bits[22]) = invoke(a, b, to_apply=__apfloat__raw_mul__5_10_10_7_22, id=116, pos=[(0,3574,29)])
  raw_product_bexp__2: bits[7] = tuple_index(raw_product, index=2, id=125, pos=[(0,3583,45)])
  neg.126: bits[7] = neg(raw_product_bexp__2, id=126, pos=[(0,3583,33)])
  raw_product_bexp: bits[7] = tuple_index(raw_product, index=2, id=117, pos=[(0,3580,34)])
  literal.118: bits[7] = literal(value=0, id=118, pos=[(0,3580,43)])
  raw_product_bexp__1: bits[7] = tuple_index(raw_product, index=2, id=121, pos=[(0,3581,75)])
  raw_product_fraction: bits[22] = tuple_index(raw_product, index=3, id=124, pos=[(0,3583,19)])
  bit_slice.127: bits[6] = bit_slice(neg.126, start=0, width=6, id=127)
  is_subnormal: bits[1] = sle(raw_product_bexp, literal.118, id=119, pos=[(0,3580,34)])
  bit_slice.122: bits[6] = bit_slice(raw_product_bexp__1, start=0, width=6, id=122)
  literal.120: bits[6] = literal(value=0, id=120, pos=[(0,3581,39)])
  raw_product_fraction__1: bits[22] = tuple_index(raw_product, index=3, id=129, pos=[(0,3585,19)])
  shrl.128: bits[22] = shrl(raw_product_fraction, bit_slice.127, id=128, pos=[(0,3583,19)])
  literal.134: bits[2] = literal(value=3, id=134, pos=[(0,3593,22)])
  literal.135: bits[20] = literal(value=0, id=135, pos=[(0,3593,30)])
  raw_product_sign: bits[1] = tuple_index(raw_product, index=1, id=138, pos=[(0,3596,35)])
  result_exp: bits[6] = sel(is_subnormal, cases=[bit_slice.122, literal.120], id=123, pos=[(0,3581,21)])
  result_fraction: bits[22] = sel(is_subnormal, cases=[raw_product_fraction__1, shrl.128], id=130, pos=[(0,3582,26)])
  literal.132: bits[1] = literal(value=0, id=132, pos=[(0,3591,18)])
  invoke.133: bits[6] = invoke(to_apply=__std__mask_bits__6, id=133, pos=[(0,3592,32)])
  concat.136: bits[22] = concat(literal.134, literal.135, id=136, pos=[(0,3593,22)])
  raw_product_is_nan: bits[1] = tuple_index(raw_product, index=0, id=131, pos=[(0,3588,18)])
  tuple.139: (bits[1], bits[6], bits[22]) = tuple(raw_product_sign, result_exp, result_fraction, id=139, pos=[(0,3596,16)])
  tuple.137: (bits[1], bits[6], bits[22]) = tuple(literal.132, invoke.133, concat.136, id=137, pos=[(0,3590,16)])
  EXP_SZ: bits[32] = literal(value=5, id=111, pos=[(0,3570,5)])
  FRACTION_SZ: bits[32] = literal(value=10, id=112, pos=[(0,3570,18)])
  WIDE_FRACTION: bits[32] = literal(value=22, id=113, pos=[(0,3570,36)])
  EXP_CARRY: bits[32] = literal(value=6, id=114, pos=[(0,3571,5)])
  EXP_SIGN_CARRY: bits[32] = literal(value=7, id=115, pos=[(0,3571,40)])
  ret sel.140: (bits[1], bits[6], bits[22]) = sel(raw_product_is_nan, cases=[tuple.139, tuple.137], id=140, pos=[(0,3588,4)])
}

fn __std__uadd_with_overflow__6_6_6_6_6(x: bits[6] id=141, y: bits[6] id=142) -> (bits[1], bits[6]) {
  x_extended: bits[7] = zero_ext(x, new_bit_count=7, id=148)
  y_extended: bits[7] = zero_ext(y, new_bit_count=7, id=149)
  full_result: bits[7] = add(x_extended, y_extended, id=150, pos=[(1,1120,45)])
  bit_slice.152: bits[1] = bit_slice(full_result, start=6, width=1, id=152, pos=[(1,1122,49)])
  overflow_detected: bits[1] = or_reduce(bit_slice.152, id=153, pos=[(1,1122,37)])
  narrowed_result: bits[6] = bit_slice(full_result, start=0, width=6, id=151)
  V: bits[32] = literal(value=6, id=143, pos=[(1,1114,5)])
  N: bits[32] = literal(value=6, id=144, pos=[(1,1114,13)])
  M: bits[32] = literal(value=6, id=145, pos=[(1,1114,21)])
  MAX_N_M: bits[32] = literal(value=6, id=146, pos=[(1,1114,29)])
  MAX_N_M_V: bits[32] = literal(value=6, id=147, pos=[(1,1114,57)])
  ret tuple.154: (bits[1], bits[6]) = tuple(overflow_detected, narrowed_result, id=154, pos=[(1,1124,4)])
}

fn __abs_diff__abs_diff__6(x: bits[6] id=155, y: bits[6] id=156) -> (bits[1], bits[6]) {
  ynot: bits[6] = not(y, id=158, pos=[(2,90,15)])
  invoke.159: (bits[1], bits[6]) = invoke(x, ynot, to_apply=__std__uadd_with_overflow__6_6_6_6_6, id=159, pos=[(2,91,63)])
  carry_out: bits[1] = tuple_index(invoke.159, index=0, id=160, pos=[(2,91,9)])
  nc: bits[1] = not(carry_out, id=162, pos=[(2,92,19)])
  z: bits[6] = tuple_index(invoke.159, index=1, id=161, pos=[(2,91,20)])
  xor_mask: bits[6] = sign_ext(nc, new_bit_count=6, id=164, pos=[(2,94,32)])
  result: bits[6] = xor(z, xor_mask, id=165, pos=[(2,95,18)])
  N: bits[32] = literal(value=6, id=157, pos=[(2,89,16)])
  literal.163: bits[6] = literal(value=0, id=163, pos=[(2,94,42)])
  ret tuple.166: (bits[1], bits[6]) = tuple(carry_out, result, id=166, pos=[(2,96,18)])
}

fn __abs_diff__is_x_larger__6(adr: (bits[1], bits[6]) id=167) -> bits[1] {
  N: bits[32] = literal(value=6, id=168, pos=[(2,47,19)])
  ret adr_correction: bits[1] = tuple_index(adr, index=0, id=169, pos=[(2,47,63)])
}

fn __abs_diff__to_corrected__6(adr: (bits[1], bits[6]) id=170) -> bits[6] {
  adr_correction: bits[1] = tuple_index(adr, index=0, id=173, pos=[(2,54,25)])
  adr_uncorrected: bits[6] = tuple_index(adr, index=1, id=172, pos=[(2,54,7)])
  zero_ext.174: bits[6] = zero_ext(adr_correction, new_bit_count=6, id=174)
  N: bits[32] = literal(value=6, id=171, pos=[(2,53,20)])
  ret add.175: bits[6] = add(adr_uncorrected, zero_ext.174, id=175, pos=[(2,54,7)])
}

fn __apfloat__sign_magnitude_difference__6(a: bits[6] id=176, b: bits[6] id=177) -> (bits[1], bits[6]) {
  abs_diff_result: (bits[1], bits[6]) = invoke(a, b, to_apply=__abs_diff__abs_diff__6, id=179, pos=[(0,3009,44)])
  invoke.180: bits[1] = invoke(abs_diff_result, to_apply=__abs_diff__is_x_larger__6, id=180, pos=[(0,3010,27)])
  not.181: bits[1] = not(invoke.180, id=181, pos=[(0,3010,5)])
  invoke.182: bits[6] = invoke(abs_diff_result, to_apply=__abs_diff__to_corrected__6, id=182, pos=[(0,3010,68)])
  WIDTH: bits[32] = literal(value=6, id=178, pos=[(0,3008,29)])
  ret tuple.183: (bits[1], bits[6]) = tuple(not.181, invoke.182, id=183, pos=[(0,3010,4)])
}

fn __std__keep_lsbs__6_34(x: bits[34] id=184, n: bits[6] id=185) -> bits[34] {
  literal.188: bits[34] = literal(value=17179869183, id=188, pos=[(1,1412,19)])
  shll.189: bits[34] = shll(literal.188, n, id=189, pos=[(1,1412,19)])
  not.190: bits[34] = not(shll.189, id=190, pos=[(1,1412,8)])
  WIDTH: bits[32] = literal(value=34, id=186, pos=[(1,1411,17)])
  N_WIDTH: bits[32] = literal(value=6, id=187, pos=[(1,1411,29)])
  ret and.191: bits[34] = and(x, not.190, id=191, pos=[(1,1412,4)])
}

fn __std__or_reduce_lsb_impl__1_6_34(value: bits[34] id=192, n: bits[6] id=193) -> bits[1] {
  WIDTH: bits[32] = literal(value=34, id=195, pos=[(1,1498,42)])
  bit_slice.200: bits[6] = bit_slice(WIDTH, start=0, width=6, id=200)
  sub.201: bits[6] = sub(bit_slice.200, n, id=201, pos=[(1,1505,18)])
  shll.202: bits[34] = shll(value, sub.201, id=202, pos=[(1,1505,8)])
  literal.203: bits[34] = literal(value=0, id=203, pos=[(1,1505,47)])
  invoke.197: bits[34] = invoke(value, n, to_apply=__std__keep_lsbs__6_34, id=197, pos=[(1,1502,17)])
  literal.198: bits[34] = literal(value=0, id=198, pos=[(1,1502,31)])
  DO_MASK_IMPL: bits[1] = literal(value=1, id=194, pos=[(1,1498,22)])
  ne.204: bits[1] = ne(shll.202, literal.203, id=204, pos=[(1,1505,8)])
  ne.199: bits[1] = ne(invoke.197, literal.198, id=199, pos=[(1,1502,17)])
  N_WIDTH: bits[32] = literal(value=6, id=196, pos=[(1,1498,54)])
  ret sel.205: bits[1] = sel(DO_MASK_IMPL, cases=[ne.204, ne.199], id=205, pos=[(1,1500,4)])
}

fn __std__or_reduce_lsb__6_34(value: bits[34] id=206, n: bits[6] id=207) -> bits[1] {
  WIDTH: bits[32] = literal(value=34, id=208, pos=[(1,1528,21)])
  N_WIDTH: bits[32] = literal(value=6, id=209, pos=[(1,1528,33)])
  ret invoke.210: bits[1] = invoke(value, n, to_apply=__std__or_reduce_lsb_impl__1_6_34, id=210, pos=[(1,1529,22)])
}

fn __apfloat__is_product_inf__6_22(p: (bits[1], bits[6], bits[22]) id=211) -> bits[1] {
  p_bexp: bits[6] = tuple_index(p, index=1, id=214, pos=[(0,3550,5)])
  invoke.215: bits[6] = invoke(to_apply=__std__mask_bits__6, id=215, pos=[(0,3550,28)])
  p_fraction: bits[22] = tuple_index(p, index=2, id=217, pos=[(0,3550,46)])
  literal.218: bits[22] = literal(value=0, id=218, pos=[(0,3550,59)])
  eq.216: bits[1] = eq(p_bexp, invoke.215, id=216, pos=[(0,3550,5)])
  eq.219: bits[1] = eq(p_fraction, literal.218, id=219, pos=[(0,3550,46)])
  EXP_CARRY: bits[32] = literal(value=6, id=212, pos=[(0,3548,18)])
  WIDE_FRACTION: bits[32] = literal(value=22, id=213, pos=[(0,3548,34)])
  ret and.220: bits[1] = and(eq.216, eq.219, id=220, pos=[(0,3550,5)])
}

fn __apfloat__is_product_nan__6_22(p: (bits[1], bits[6], bits[22]) id=221) -> bits[1] {
  p_bexp: bits[6] = tuple_index(p, index=1, id=224, pos=[(0,3556,5)])
  invoke.225: bits[6] = invoke(to_apply=__std__mask_bits__6, id=225, pos=[(0,3556,28)])
  p_fraction: bits[22] = tuple_index(p, index=2, id=227, pos=[(0,3556,46)])
  literal.228: bits[22] = literal(value=0, id=228, pos=[(0,3556,59)])
  eq.226: bits[1] = eq(p_bexp, invoke.225, id=226, pos=[(0,3556,5)])
  ne.229: bits[1] = ne(p_fraction, literal.228, id=229, pos=[(0,3556,46)])
  EXP_CARRY: bits[32] = literal(value=6, id=222, pos=[(0,3554,18)])
  WIDE_FRACTION: bits[32] = literal(value=22, id=223, pos=[(0,3554,34)])
  ret and.230: bits[1] = and(eq.226, ne.229, id=230, pos=[(0,3556,5)])
}

fn __itok__apfloat__fma__5_10(__token: token id=231, __activated: bits[1] id=232, a: (bits[1], bits[5], bits[10]) id=233, b: (bits[1], bits[5], bits[10]) id=234, c: (bits[1], bits[5], bits[10]) id=235) -> (token, (bits[1], bits[5], bits[10])) {
  FRACTION_SZ: bits[32] = literal(value=10, id=237, pos=[(0,3614,24)])
  literal.242: bits[32] = literal(value=1, id=242, pos=[(0,3622,46)])
  add.243: bits[32] = add(FRACTION_SZ, literal.242, id=243, pos=[(0,3622,32)])
  literal.244: bits[32] = literal(value=3, id=244, pos=[(0,3622,55)])
  literal.284: bits[32] = literal(value=1, id=284, pos=[(0,3651,79)])
  ab: (bits[1], bits[6], bits[22]) = invoke(a, b, to_apply=__apfloat__mul_no_round__6_7_5_10_22, id=255, pos=[(0,3636,25)])
  c_bexp: bits[5] = tuple_index(c, index=1, id=257, pos=[(0,3639,44)])
  c_fraction: bits[10] = tuple_index(c, index=2, id=272, pos=[(0,3645,18)])
  literal.274: bits[34] = literal(value=1, id=274, pos=[(0,3645,52)])
  umul.245: bits[32] = umul(add.243, literal.244, id=245, pos=[(0,3622,32)])
  literal.246: bits[32] = literal(value=1, id=246, pos=[(0,3622,63)])
  add.285: bits[32] = add(FRACTION_SZ, literal.284, id=285, pos=[(0,3651,65)])
  literal.286: bits[32] = literal(value=2, id=286, pos=[(0,3651,88)])
  ab_bexp: bits[6] = tuple_index(ab, index=1, id=256, pos=[(0,3639,36)])
  zero_ext.258: bits[6] = zero_ext(c_bexp, new_bit_count=6, id=258)
  c_bexp__2: bits[5] = tuple_index(c, index=1, id=277, pos=[(0,3646,21)])
  literal.278: bits[5] = literal(value=0, id=278, pos=[(0,3646,30)])
  zero_ext.273: bits[34] = zero_ext(c_fraction, new_bit_count=34, id=273)
  shll.275: bits[34] = shll(literal.274, FRACTION_SZ, id=275, pos=[(0,3645,52)])
  literal.290: bits[32] = literal(value=1, id=290, pos=[(0,3652,59)])
  ab_fraction: bits[22] = tuple_index(ab, index=2, id=282, pos=[(0,3651,11)])
  WIDE_FRACTION: bits[32] = add(umul.245, literal.246, id=247, pos=[(0,3622,32)])
  umul.287: bits[32] = umul(add.285, literal.286, id=287, pos=[(0,3651,65)])
  invoke.259: (bits[1], bits[6]) = invoke(ab_bexp, zero_ext.258, to_apply=__apfloat__sign_magnitude_difference__6, id=259, pos=[(0,3639,33)])
  eq.279: bits[1] = eq(c_bexp__2, literal.278, id=279, pos=[(0,3646,21)])
  wide_c: bits[34] = or(zero_ext.273, shll.275, id=276, pos=[(0,3645,18)])
  literal.280: bits[34] = literal(value=0, id=280, pos=[(0,3646,45)])
  add.291: bits[32] = add(FRACTION_SZ, literal.290, id=291, pos=[(0,3652,45)])
  zero_ext.283: bits[34] = zero_ext(ab_fraction, new_bit_count=34, id=283)
  sub.288: bits[32] = sub(WIDE_FRACTION, umul.287, id=288, pos=[(0,3651,47)])
  ab_exp_smaller: bits[1] = tuple_index(invoke.259, index=0, id=260, pos=[(0,3638,9)])
  literal.294: bits[6] = literal(value=0, id=294, pos=[(0,3656,64)])
  exp_difference: bits[6] = tuple_index(invoke.259, index=1, id=261, pos=[(0,3638,25)])
  wide_c__1: bits[34] = sel(eq.279, cases=[wide_c, literal.280], id=281, pos=[(0,3646,17)])
  sub.292: bits[32] = sub(WIDE_FRACTION, add.291, id=292, pos=[(0,3652,28)])
  literal.296: bits[6] = literal(value=0, id=296, pos=[(0,3657,39)])
  c_bexp__1: bits[5] = tuple_index(c, index=1, id=262, pos=[(0,3641,30)])
  wide_ab: bits[34] = shll(zero_ext.283, sub.288, id=289, pos=[(0,3651,11)])
  rshift_ab: bits[6] = sel(ab_exp_smaller, cases=[literal.294, exp_difference], id=295, pos=[(0,3656,20)])
  wide_c__2: bits[34] = shll(wide_c__1, sub.292, id=293, pos=[(0,3652,17)])
  rshift_c: bits[6] = sel(ab_exp_smaller, cases=[exp_difference, literal.296], id=297, pos=[(0,3657,19)])
  ab_bexp__1: bits[6] = tuple_index(ab, index=1, id=266, pos=[(0,3641,74)])
  ab_sign: bits[1] = tuple_index(ab, index=0, id=267, pos=[(0,3641,83)])
  zero_ext.263: bits[6] = zero_ext(c_bexp__1, new_bit_count=6, id=263)
  c_sign: bits[1] = tuple_index(c, index=0, id=264, pos=[(0,3641,55)])
  invoke.300: bits[1] = invoke(wide_ab, rshift_ab, to_apply=__std__or_reduce_lsb__6_34, id=300, pos=[(0,3660,38)])
  invoke.302: bits[1] = invoke(wide_c__2, rshift_c, to_apply=__std__or_reduce_lsb__6_34, id=302, pos=[(0,3661,37)])
  tuple.268: (bits[6], bits[1]) = tuple(ab_bexp__1, ab_sign, id=268, pos=[(0,3641,71)])
  tuple.265: (bits[6], bits[1]) = tuple(zero_ext.263, c_sign, id=265, pos=[(0,3641,28)])
  shifted_ab: bits[34] = shrl(wide_ab, rshift_ab, id=298, pos=[(0,3658,21)])
  sticky_ab: bits[34] = zero_ext(invoke.300, new_bit_count=34, id=301)
  shifted_c: bits[34] = shrl(wide_c__2, rshift_c, id=299, pos=[(0,3659,20)])
  sticky_c: bits[34] = zero_ext(invoke.302, new_bit_count=34, id=303)
  sel.269: (bits[6], bits[1]) = sel(ab_exp_smaller, cases=[tuple.268, tuple.265], id=269, pos=[(0,3641,8)])
  or.304: bits[34] = or(shifted_ab, sticky_ab, id=304, pos=[(0,3664,22)])
  or.306: bits[34] = or(shifted_c, sticky_c, id=306, pos=[(0,3665,21)])
  ab_sign__1: bits[1] = tuple_index(ab, index=0, id=308, pos=[(0,3668,26)])
  greater_sign: bits[1] = tuple_index(sel.269, index=1, id=271, pos=[(0,3640,22)])
  shifted_ab__1: bits[36] = zero_ext(or.304, new_bit_count=36, id=305)
  c_sign__1: bits[1] = tuple_index(c, index=0, id=312, pos=[(0,3669,24)])
  shifted_c__1: bits[36] = zero_ext(or.306, new_bit_count=36, id=307)
  ne.309: bits[1] = ne(ab_sign__1, greater_sign, id=309, pos=[(0,3668,26)])
  neg.310: bits[36] = neg(shifted_ab__1, id=310, pos=[(0,3668,50)])
  ne.313: bits[1] = ne(c_sign__1, greater_sign, id=313, pos=[(0,3669,24)])
  neg.314: bits[36] = neg(shifted_c__1, id=314, pos=[(0,3669,48)])
  shifted_ab__2: bits[36] = sel(ne.309, cases=[shifted_ab__1, neg.310], id=311, pos=[(0,3668,21)])
  shifted_c__2: bits[36] = sel(ne.313, cases=[shifted_c__1, neg.314], id=315, pos=[(0,3669,20)])
  sum_fraction: bits[36] = add(shifted_ab__2, shifted_c__2, id=316, pos=[(0,3672,23)])
  literal.344: bits[36] = literal(value=0, id=344, pos=[(0,3681,42)])
  slt.345: bits[1] = slt(sum_fraction, literal.344, id=345, pos=[(0,3681,27)])
  neg.346: bits[36] = neg(sum_fraction, id=346, pos=[(0,3682,27)])
  sel.347: bits[36] = sel(slt.345, cases=[sum_fraction, neg.346], id=347, pos=[(0,3681,24)])
  abs_fraction: bits[35] = bit_slice(sel.347, start=0, width=35, id=348)
  reverse.356: bits[35] = reverse(abs_fraction, id=356, pos=[(0,3695,28)])
  one_hot.357: bits[36] = one_hot(reverse.356, lsb_prio=true, id=357, pos=[(0,3695,28)])
  encode.358: bits[6] = encode(one_hot.357, id=358, pos=[(0,3695,28)])
  leading_zeroes: bits[35] = zero_ext(encode.358, new_bit_count=35, id=359, pos=[(0,3695,28)])
  literal.360: bits[35] = literal(value=1, id=360, pos=[(0,3696,34)])
  carry_bit: bits[1] = bit_slice(abs_fraction, start=34, width=1, id=349, pos=[(0,3689,32)])
  cancel: bits[1] = ugt(leading_zeroes, literal.360, id=361, pos=[(0,3696,17)])
  tuple.366: (bits[1], bits[1]) = tuple(carry_bit, cancel, id=366, pos=[(0,3699,33)])
  literal.387: bits[1] = literal(value=0, id=387, pos=[(0,3702,9)])
  tuple_index.386: bits[1] = tuple_index(tuple.366, index=0, id=386)
  literal.378: bits[1] = literal(value=0, id=378, pos=[(0,3701,9)])
  tuple_index.377: bits[1] = tuple_index(tuple.366, index=0, id=377)
  literal.369: bits[1] = literal(value=1, id=369, pos=[(0,3700,9)])
  tuple_index.368: bits[1] = tuple_index(tuple.366, index=0, id=368)
  literal.385: bits[1] = literal(value=1, id=385)
  eq.388: bits[1] = eq(literal.387, tuple_index.386, id=388)
  literal.391: bits[1] = literal(value=0, id=391, pos=[(0,3702,16)])
  tuple_index.390: bits[1] = tuple_index(tuple.366, index=1, id=390)
  literal.376: bits[1] = literal(value=1, id=376)
  eq.379: bits[1] = eq(literal.378, tuple_index.377, id=379)
  literal.382: bits[1] = literal(value=1, id=382, pos=[(0,3701,16)])
  tuple_index.381: bits[1] = tuple_index(tuple.366, index=1, id=381)
  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=0, id=373, pos=[(0,3700,15)])
  tuple_index.372: bits[1] = tuple_index(tuple.366, index=1, id=372)
  literal.350: bits[35] = literal(value=1, id=350, pos=[(0,3690,42)])
  literal.362: bits[35] = literal(value=1, id=362, pos=[(0,3698,43)])
  and.389: bits[1] = and(literal.385, eq.388, id=389)
  eq.392: bits[1] = eq(literal.391, tuple_index.390, id=392)
  and.380: bits[1] = and(literal.376, eq.379, id=380)
  eq.383: bits[1] = eq(literal.382, tuple_index.381, id=383)
  and.371: bits[1] = and(literal.367, eq.370, id=371)
  eq.374: bits[1] = eq(literal.373, tuple_index.372, id=374)
  shrl.351: bits[35] = shrl(abs_fraction, literal.350, id=351, pos=[(0,3690,26)])
  bit_slice.353: bits[1] = bit_slice(abs_fraction, start=0, width=1, id=353, pos=[(0,3691,55)])
  sub.363: bits[35] = sub(leading_zeroes, literal.362, id=363, pos=[(0,3698,26)])
  and.393: bits[1] = and(and.389, eq.392, id=393)
  and.384: bits[1] = and(and.380, eq.383, id=384)
  and.375: bits[1] = and(and.371, eq.374, id=375)
  carry_fraction: bits[34] = bit_slice(shrl.351, start=0, width=34, id=352)
  zero_ext.354: bits[34] = zero_ext(bit_slice.353, new_bit_count=34, id=354)
  shll.364: bits[35] = shll(abs_fraction, sub.363, id=364, pos=[(0,3698,9)])
  literal.397: bits[34] = literal(value=0, id=397, pos=[(0,3703,39)])
  concat.403: bits[3] = concat(and.393, and.384, and.375, id=403)
  carry_fraction__1: bits[34] = or(carry_fraction, zero_ext.354, id=355, pos=[(0,3691,25)])
  cancel_fraction: bits[34] = bit_slice(shll.364, start=0, width=34, id=365)
  bit_slice.394: bits[34] = bit_slice(abs_fraction, start=0, width=34, id=394)
  identity.402: bits[34] = identity(literal.397, id=402)
  WIDE_FRACTION_LOW_BIT: bits[32] = sub(WIDE_FRACTION, FRACTION_SZ, id=252, pos=[(0,3630,39)])
  literal.408: bits[32] = literal(value=2, id=408, pos=[(0,3713,85)])
  shifted_fraction: bits[34] = priority_sel(concat.403, cases=[carry_fraction__1, cancel_fraction, bit_slice.394], default=identity.402, id=404)
  literal.407: bits[23] = literal(value=1, id=407, pos=[(0,3713,24)])
  sub.409: bits[32] = sub(WIDE_FRACTION_LOW_BIT, literal.408, id=409, pos=[(0,3713,61)])
  normal_chunk: bits[23] = bit_slice(shifted_fraction, start=0, width=23, id=405, pos=[(0,3710,39)])
  half_of_extra: bits[23] = shll(literal.407, sub.409, id=410, pos=[(0,3713,24)])
  half_way_chunk: bits[2] = bit_slice(shifted_fraction, start=22, width=2, id=406, pos=[(0,3712,24)])
  literal.412: bits[2] = literal(value=3, id=412, pos=[(0,3715,63)])
  literal.420: bits[32] = literal(value=1, id=420, pos=[(0,3718,63)])
  ugt.411: bits[1] = ugt(normal_chunk, half_of_extra, id=411, pos=[(0,3715,12)])
  eq.413: bits[1] = eq(half_way_chunk, literal.412, id=413, pos=[(0,3715,45)])
  literal.419: bits[35] = literal(value=1, id=419, pos=[(0,3718,9)])
  sub.421: bits[32] = sub(WIDE_FRACTION_LOW_BIT, literal.420, id=421, pos=[(0,3718,39)])
  or.414: bits[1] = or(ugt.411, eq.413, id=414, pos=[(0,3715,12)])
  literal.416: bits[1] = literal(value=0, id=416, pos=[(0,3715,87)])
  literal.415: bits[1] = literal(value=1, id=415, pos=[(0,3715,73)])
  zero_ext.418: bits[35] = zero_ext(shifted_fraction, new_bit_count=35, id=418)
  shll.422: bits[35] = shll(literal.419, sub.421, id=422, pos=[(0,3718,9)])
  do_round_up: bits[1] = sel(or.414, cases=[literal.416, literal.415], id=417, pos=[(0,3715,8)])
  zero_ext.424: bits[35] = zero_ext(shifted_fraction, new_bit_count=35, id=424)
  add.423: bits[35] = add(zero_ext.418, shll.422, id=423, pos=[(0,3717,8)])
  rounded_fraction: bits[35] = sel(do_round_up, cases=[zero_ext.424, add.423], id=425, pos=[(0,3716,27)])
  greater_exp: bits[6] = tuple_index(sel.269, index=0, id=270, pos=[(0,3640,9)])
  rounding_carry: bits[1] = bit_slice(rounded_fraction, start=34, width=1, id=426, pos=[(0,3723,41)])
  zero_ext.432: bits[7] = zero_ext(greater_exp, new_bit_count=7, id=432)
  zero_ext.433: bits[7] = zero_ext(rounding_carry, new_bit_count=7, id=433)
  add.434: bits[7] = add(zero_ext.432, zero_ext.433, id=434, pos=[(0,3728,15)])
  literal.435: bits[7] = literal(value=1, id=435, pos=[(0,3729,15)])
  literal.317: bits[36] = literal(value=0, id=317, pos=[(0,3673,43)])
  literal.319: bits[36] = literal(value=0, id=319, pos=[(0,3674,62)])
  add.436: bits[7] = add(add.434, literal.435, id=436, pos=[(0,3728,15)])
  bit_slice.437: bits[7] = bit_slice(leading_zeroes, start=0, width=7, id=437)
  fraction_is_zero: bits[1] = eq(sum_fraction, literal.317, id=318, pos=[(0,3673,27)])
  slt.320: bits[1] = slt(sum_fraction, literal.319, id=320, pos=[(0,3674,47)])
  bexp: bits[7] = sub(add.436, bit_slice.437, id=438, pos=[(0,3728,15)])
  literal.439: bits[7] = literal(value=0, id=439, pos=[(0,3730,37)])
  literal.427: bits[32] = literal(value=1, id=427, pos=[(0,3725,52)])
  tuple.321: (bits[1], bits[1]) = tuple(fraction_is_zero, slt.320, id=321, pos=[(0,3674,28)])
  bexp__1: bits[7] = sel(fraction_is_zero, cases=[bexp, literal.439], id=440, pos=[(0,3730,15)])
  literal.441: bits[7] = literal(value=0, id=441, pos=[(0,3731,25)])
  sub.428: bits[32] = sub(WIDE_FRACTION_LOW_BIT, literal.427, id=428, pos=[(0,3725,28)])
  literal.333: bits[1] = literal(value=0, id=333, pos=[(0,3676,9)])
  tuple_index.332: bits[1] = tuple_index(tuple.321, index=0, id=332)
  literal.324: bits[1] = literal(value=1, id=324, pos=[(0,3675,9)])
  tuple_index.323: bits[1] = tuple_index(tuple.321, index=0, id=323)
  ab_sign__2: bits[1] = tuple_index(ab, index=0, id=466, pos=[(0,3749,47)])
  literal.467: bits[1] = literal(value=0, id=467, pos=[(0,3749,56)])
  c_sign__2: bits[1] = tuple_index(c, index=0, id=471, pos=[(0,3749,80)])
  literal.472: bits[1] = literal(value=0, id=472, pos=[(0,3749,89)])
  ab_sign__3: bits[1] = tuple_index(ab, index=0, id=479, pos=[(0,3754,47)])
  literal.480: bits[1] = literal(value=1, id=480, pos=[(0,3754,56)])
  c_sign__3: bits[1] = tuple_index(c, index=0, id=484, pos=[(0,3754,80)])
  literal.485: bits[1] = literal(value=1, id=485, pos=[(0,3754,89)])
  slt.442: bits[1] = slt(bexp__1, literal.441, id=442, pos=[(0,3731,18)])
  bit_slice.444: bits[6] = bit_slice(bexp__1, start=0, width=6, id=444)
  literal.443: bits[6] = literal(value=0, id=443, pos=[(0,3731,48)])
  zero_ext.429: bits[35] = zero_ext(sub.428, new_bit_count=35, id=429)
  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,3676,16)])
  tuple_index.336: bits[1] = tuple_index(tuple.321, index=1, id=336)
  literal.322: bits[1] = literal(value=1, id=322)
  eq.325: bits[1] = eq(literal.324, tuple_index.323, id=325)
  invoke.465: bits[1] = invoke(ab, to_apply=__apfloat__is_product_inf__6_22, id=465, pos=[(0,3749,37)])
  eq.468: bits[1] = eq(ab_sign__2, literal.467, id=468, pos=[(0,3749,47)])
  invoke.470: bits[1] = invoke(c, to_apply=__apfloat__is_inf__5_10, id=470, pos=[(0,3749,72)])
  eq.473: bits[1] = eq(c_sign__2, literal.472, id=473, pos=[(0,3749,80)])
  invoke.478: bits[1] = invoke(ab, to_apply=__apfloat__is_product_inf__6_22, id=478, pos=[(0,3754,37)])
  eq.481: bits[1] = eq(ab_sign__3, literal.480, id=481, pos=[(0,3754,47)])
  invoke.483: bits[1] = invoke(c, to_apply=__apfloat__is_inf__5_10, id=483, pos=[(0,3754,72)])
  eq.486: bits[1] = eq(c_sign__3, literal.485, id=486, pos=[(0,3754,80)])
  invoke.450: bits[5] = invoke(to_apply=__std__mask_bits__5, id=450, pos=[(0,3739,38)])
  bexp__2: bits[6] = sel(slt.442, cases=[bit_slice.444, literal.443], id=445, pos=[(0,3731,15)])
  literal.446: bits[6] = literal(value=0, id=446, pos=[(0,3736,37)])
  shrl.430: bits[35] = shrl(rounded_fraction, zero_ext.429, id=430, pos=[(0,3724,27)])
  and.335: bits[1] = and(literal.331, eq.334, id=335)
  eq.338: bits[1] = eq(literal.337, tuple_index.336, id=338)
  and.326: bits[1] = and(literal.322, eq.325, id=326)
  literal.328: bits[1] = literal(value=1, id=328, pos=[(0,3675,15)])
  and.469: bits[1] = and(invoke.465, eq.468, id=469, pos=[(0,3749,37)])
  and.474: bits[1] = and(invoke.470, eq.473, id=474, pos=[(0,3749,72)])
  and.482: bits[1] = and(invoke.478, eq.481, id=482, pos=[(0,3754,37)])
  and.487: bits[1] = and(invoke.483, eq.486, id=487, pos=[(0,3754,72)])
  saturated_exp: bits[6] = zero_ext(invoke.450, new_bit_count=6, id=451)
  eq.447: bits[1] = eq(bexp__2, literal.446, id=447, pos=[(0,3736,29)])
  result_fraction: bits[10] = bit_slice(shrl.430, start=0, width=10, id=431)
  literal.448: bits[10] = literal(value=0, id=448, pos=[(0,3736,55)])
  and.339: bits[1] = and(and.335, eq.338, id=339)
  and.329: bits[1] = and(and.326, literal.328, id=329)
  invoke.489: bits[1] = invoke(ab, to_apply=__apfloat__is_product_nan__6_22, id=489, pos=[(0,3755,38)])
  invoke.490: bits[1] = invoke(c, to_apply=__apfloat__is_nan__5_10, id=490, pos=[(0,3755,51)])
  has_pos_inf: bits[1] = or(and.469, and.474, id=475, pos=[(0,3749,37)])
  has_neg_inf: bits[1] = or(and.482, and.487, id=488, pos=[(0,3754,37)])
  invoke.459: bits[1] = invoke(ab, to_apply=__apfloat__is_product_inf__6_22, id=459, pos=[(0,3745,39)])
  invoke.460: bits[1] = invoke(c, to_apply=__apfloat__is_inf__5_10, id=460, pos=[(0,3745,52)])
  ult.456: bits[1] = ult(bexp__2, saturated_exp, id=456, pos=[(0,3742,24)])
  max_exp: bits[5] = invoke(to_apply=__std__mask_bits__5, id=452, pos=[(0,3740,32)])
  bit_slice.457: bits[5] = bit_slice(bexp__2, start=0, width=5, id=457)
  ult.453: bits[1] = ult(bexp__2, saturated_exp, id=453, pos=[(0,3741,29)])
  literal.454: bits[10] = literal(value=0, id=454, pos=[(0,3741,77)])
  result_fraction__1: bits[10] = sel(eq.447, cases=[result_fraction, literal.448], id=449, pos=[(0,3736,26)])
  literal.496: bits[32] = literal(value=4, id=496, pos=[(0,3758,63)])
  nor.398: bits[1] = nor(and.375, and.384, and.393, id=398)
  concat.342: bits[2] = concat(and.339, and.329, id=342)
  literal.330: bits[1] = literal(value=0, id=330, pos=[(0,3675,21)])
  not.340: bits[1] = not(greater_sign, id=340, pos=[(0,3676,25)])
  or.491: bits[1] = or(invoke.489, invoke.490, id=491, pos=[(0,3755,38)])
  and.492: bits[1] = and(has_pos_inf, has_neg_inf, id=492, pos=[(0,3755,58)])
  is_operand_inf: bits[1] = or(invoke.459, invoke.460, id=461, pos=[(0,3745,39)])
  result_exp: bits[5] = sel(ult.456, cases=[max_exp, bit_slice.457], id=458, pos=[(0,3742,21)])
  result_fraction__2: bits[10] = sel(ult.453, cases=[literal.454, result_fraction__1], id=455, pos=[(0,3741,26)])
  literal.463: bits[10] = literal(value=0, id=463, pos=[(0,3747,46)])
  literal.495: bits[10] = literal(value=1, id=495, pos=[(0,3758,27)])
  sub.497: bits[32] = sub(FRACTION_SZ, literal.496, id=497, pos=[(0,3758,49)])
  and.399: bits[1] = and(__activated, nor.398, id=399)
  result_sign: bits[1] = priority_sel(concat.342, cases=[literal.330, not.340], default=greater_sign, id=343)
  not.476: bits[1] = not(has_pos_inf, id=476, pos=[(0,3750,42)])
  is_result_nan: bits[1] = or(or.491, and.492, id=493, pos=[(0,3755,38)])
  result_exp__1: bits[5] = sel(is_operand_inf, cases=[result_exp, max_exp], id=462, pos=[(0,3746,21)])
  result_fraction__3: bits[10] = sel(is_operand_inf, cases=[result_fraction__2, literal.463], id=464, pos=[(0,3747,26)])
  shll.498: bits[10] = shll(literal.495, sub.497, id=498, pos=[(0,3758,27)])
  not.400: bits[1] = not(and.399, id=400)
  result_sign__1: bits[1] = sel(is_operand_inf, cases=[result_sign, not.476], id=477, pos=[(0,3750,22)])
  literal.500: bits[1] = literal(value=0, id=500, pos=[(0,3759,41)])
  result_exp__2: bits[5] = sel(is_result_nan, cases=[result_exp__1, max_exp], id=494, pos=[(0,3756,21)])
  result_fraction__4: bits[10] = sel(is_result_nan, cases=[result_fraction__3, shll.498], id=499, pos=[(0,3758,8)])
  EXP_SZ: bits[32] = literal(value=5, id=236, pos=[(0,3614,11)])
  literal.238: bits[32] = literal(value=1, id=238, pos=[(0,3618,36)])
  literal.248: bits[32] = literal(value=1, id=248, pos=[(0,3624,53)])
  assert.401: token = assert(__token, not.400, message="Assertion failure via fail! @ /inputs/subtree/xls/dslx/stdlib/apfloat.x:3704:19-3704:60", label="carry_and_cancel", id=401)
  result_sign__2: bits[1] = sel(is_result_nan, cases=[result_sign__1, literal.500], id=501, pos=[(0,3759,22)])
  zero_ext.502: bits[5] = zero_ext(result_exp__2, new_bit_count=5, id=502)
  zero_ext.503: bits[10] = zero_ext(result_fraction__4, new_bit_count=10, id=503)
  EXP_CARRY: bits[32] = add(EXP_SZ, literal.238, id=239, pos=[(0,3618,27)])
  literal.240: bits[32] = literal(value=1, id=240, pos=[(0,3620,44)])
  WIDE_FRACTION_CARRY: bits[32] = add(WIDE_FRACTION, literal.248, id=249, pos=[(0,3624,37)])
  literal.250: bits[32] = literal(value=1, id=250, pos=[(0,3626,64)])
  literal.253: bits[32] = literal(value=1, id=253, pos=[(0,3634,68)])
  after_all.505: token = after_all(assert.401, id=505)
  tuple.504: (bits[1], bits[5], bits[10]) = tuple(result_sign__2, zero_ext.502, zero_ext.503, id=504, pos=[(0,3761,33)])
  EXP_SIGN_CARRY: bits[32] = add(EXP_CARRY, literal.240, id=241, pos=[(0,3620,32)])
  WIDE_FRACTION_SIGN_CARRY: bits[32] = add(WIDE_FRACTION_CARRY, literal.250, id=251, pos=[(0,3626,42)])
  WIDE_FRACTION_TOP_ROUNDING: bits[32] = sub(WIDE_FRACTION_LOW_BIT, literal.253, id=254, pos=[(0,3634,44)])
  tuple_index.327: bits[1] = tuple_index(tuple.321, index=1, id=327)
  literal.341: bits[1] = literal(value=1, id=341, pos=[(0,3677,8)])
  literal.395: bits[1] = literal(value=1, id=395, pos=[(0,3703,8)])
  literal.396: bits[8][16] = literal(value=[99, 97, 114, 114, 121, 95, 97, 110, 100, 95, 99, 97, 110, 99, 101, 108], id=396, pos=[(0,3703,19)])
  ret tuple.506: (token, (bits[1], bits[5], bits[10])) = tuple(after_all.505, tuple.504, id=506)
}

fn __itok__hfloat16__fma(__token: token id=507, __activated: bits[1] id=508, a: (bits[1], bits[5], bits[10]) id=509, b: (bits[1], bits[5], bits[10]) id=510, c: (bits[1], bits[5], bits[10]) id=511) -> (token, (bits[1], bits[5], bits[10])) {
  invoke.512: (token, (bits[1], bits[5], bits[10])) = invoke(__token, __activated, a, b, c, to_apply=__itok__apfloat__fma__5_10, id=512, pos=[(3,122,60)])
  tuple_index.513: token = tuple_index(invoke.512, index=0, id=513)
  after_all.515: token = after_all(tuple_index.513, id=515)
  tuple_index.514: (bits[1], bits[5], bits[10]) = tuple_index(invoke.512, index=1, id=514)
  ret tuple.516: (token, (bits[1], bits[5], bits[10])) = tuple(after_all.515, tuple_index.514, id=516)
}

top fn __hfloat16__fma(a: (bits[1], bits[5], bits[10]) id=517, b: (bits[1], bits[5], bits[10]) id=518, c: (bits[1], bits[5], bits[10]) id=519) -> (bits[1], bits[5], bits[10]) {
  after_all.520: token = after_all(id=520)
  literal.521: bits[1] = literal(value=1, id=521)
  invoke.522: (token, (bits[1], bits[5], bits[10])) = invoke(after_all.520, literal.521, a, b, c, to_apply=__itok__hfloat16__fma, id=522)
  ret tuple_index.523: (bits[1], bits[5], bits[10]) = tuple_index(invoke.522, index=1, id=523)
}