package bfloat16

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

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

fn __apfloat__zero__8_7(sign: bits[1] id=7) -> (bits[1], bits[8], bits[7]) {
  literal.10: bits[8] = literal(value=0, id=10, pos=[(0,131,47)])
  literal.11: bits[7] = literal(value=0, id=11, pos=[(0,131,73)])
  EXP_SZ: bits[32] = literal(value=8, id=8, pos=[(0,130,12)])
  FRACTION_SZ: bits[32] = literal(value=7, id=9, pos=[(0,130,25)])
  ret tuple.12: (bits[1], bits[8], bits[7]) = tuple(sign, literal.10, literal.11, id=12, pos=[(0,131,33)])
}

fn __apfloat__subnormals_to_zero__8_7(x: (bits[1], bits[8], bits[7]) id=13) -> (bits[1], bits[8], bits[7]) {
  x_sign: bits[1] = tuple_index(x, index=0, id=17, pos=[(0,809,60)])
  invoke.16: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__8_7, id=16, pos=[(0,809,27)])
  invoke.18: (bits[1], bits[8], bits[7]) = invoke(x_sign, to_apply=__apfloat__zero__8_7, id=18, pos=[(0,809,37)])
  EXP_SZ: bits[32] = literal(value=8, id=14, pos=[(0,807,26)])
  FRACTION_SZ: bits[32] = literal(value=7, id=15, pos=[(0,807,39)])
  ret sel.19: (bits[1], bits[8], bits[7]) = sel(invoke.16, cases=[x, invoke.18], id=19, pos=[(0,809,4)])
}

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

fn __apfloat__tag__8_7(input_float: (bits[1], bits[8], bits[7]) id=23) -> bits[3] {
  input_float_bexp: bits[8] = tuple_index(input_float, index=1, id=27, pos=[(0,40,22)])
  input_float_fraction: bits[7] = tuple_index(input_float, index=2, id=28, pos=[(0,40,40)])
  tuple.29: (bits[8], bits[7]) = tuple(input_float_bexp, input_float_fraction, id=29, pos=[(0,40,10)])
  EXPR_MASK: bits[8] = invoke(to_apply=__std__mask_bits__8, id=26, pos=[(0,39,36)])
  tuple_index.59: bits[8] = tuple_index(tuple.29, index=0, id=59)
  tuple_index.50: bits[8] = tuple_index(tuple.29, index=0, id=50)
  literal.42: bits[8] = literal(value=0, id=42, pos=[(0,42,9)])
  tuple_index.41: bits[8] = tuple_index(tuple.29, index=0, id=41)
  literal.32: bits[8] = literal(value=0, id=32, pos=[(0,41,9)])
  tuple_index.31: bits[8] = tuple_index(tuple.29, index=0, id=31)
  literal.58: bits[1] = literal(value=1, id=58)
  eq.60: bits[1] = eq(EXPR_MASK, tuple_index.59, id=60)
  literal.49: bits[1] = literal(value=1, id=49)
  eq.51: bits[1] = eq(EXPR_MASK, tuple_index.50, id=51)
  literal.54: bits[7] = literal(value=0, id=54, pos=[(0,43,20)])
  tuple_index.53: bits[7] = tuple_index(tuple.29, index=1, id=53)
  literal.40: bits[1] = literal(value=1, id=40)
  eq.43: bits[1] = eq(literal.42, tuple_index.41, id=43)
  literal.30: bits[1] = literal(value=1, id=30)
  eq.33: bits[1] = eq(literal.32, tuple_index.31, id=33)
  literal.36: bits[7] = literal(value=0, id=36, pos=[(0,41,23)])
  tuple_index.35: bits[7] = tuple_index(tuple.29, index=1, id=35)
  and.61: bits[1] = and(literal.58, eq.60, id=61)
  literal.63: bits[1] = literal(value=1, id=63, pos=[(0,44,20)])
  and.52: bits[1] = and(literal.49, eq.51, id=52)
  eq.55: bits[1] = eq(literal.54, tuple_index.53, id=55)
  and.44: bits[1] = and(literal.40, eq.43, id=44)
  literal.46: bits[1] = literal(value=1, id=46, pos=[(0,42,23)])
  and.34: bits[1] = and(literal.30, eq.33, id=34)
  eq.37: bits[1] = eq(literal.36, tuple_index.35, id=37)
  literal.66: bits[1] = literal(value=1, id=66)
  literal.68: bits[1] = literal(value=1, id=68, pos=[(0,45,9)])
  and.64: bits[1] = and(and.61, literal.63, id=64)
  and.56: bits[1] = and(and.52, eq.55, id=56)
  and.47: bits[1] = and(and.44, literal.46, id=47)
  and.38: bits[1] = and(and.34, eq.37, id=38)
  and.69: bits[1] = and(literal.66, literal.68, id=69)
  literal.71: bits[1] = literal(value=1, id=71, pos=[(0,45,12)])
  concat.74: bits[4] = concat(and.64, and.56, and.47, and.38, id=74)
  literal.39: bits[3] = literal(value=3, id=39, pos=[(0,41,45)])
  literal.48: bits[3] = literal(value=2, id=48, pos=[(0,42,29)])
  literal.57: bits[3] = literal(value=1, id=57, pos=[(0,43,42)])
  literal.65: bits[3] = literal(value=0, id=65, pos=[(0,44,26)])
  literal.73: bits[3] = literal(value=4, id=73, pos=[(0,45,18)])
  EXP_SZ: bits[32] = literal(value=8, id=24, pos=[(0,38,11)])
  FRACTION_SZ: bits[32] = literal(value=7, id=25, pos=[(0,38,24)])
  tuple_index.45: bits[7] = tuple_index(tuple.29, index=1, id=45)
  tuple_index.62: bits[7] = tuple_index(tuple.29, index=1, id=62)
  tuple_index.67: bits[8] = tuple_index(tuple.29, index=0, id=67)
  tuple_index.70: bits[7] = tuple_index(tuple.29, index=1, id=70)
  and.72: bits[1] = and(and.69, literal.71, id=72)
  ret priority_sel.75: bits[3] = priority_sel(concat.74, cases=[literal.39, literal.48, literal.57, literal.65], default=literal.73, id=75)
}

fn __apfloat__qnan__8_7() -> (bits[1], bits[8], bits[7]) {
  FRACTION_SZ: bits[32] = literal(value=7, id=77, pos=[(0,50,25)])
  literal.82: bits[32] = literal(value=1, id=82, pos=[(0,54,57)])
  sub.83: bits[32] = sub(FRACTION_SZ, literal.82, id=83, pos=[(0,54,43)])
  invoke.79: bits[8] = invoke(to_apply=__std__mask_bits__8, id=79, pos=[(0,53,28)])
  literal.81: bits[7] = literal(value=1, id=81, pos=[(0,54,18)])
  bit_slice.84: bits[7] = bit_slice(sub.83, start=0, width=7, id=84)
  literal.78: bits[1] = literal(value=0, id=78, pos=[(0,52,14)])
  zero_ext.80: bits[8] = zero_ext(invoke.79, new_bit_count=8, id=80)
  shll.85: bits[7] = shll(literal.81, bit_slice.84, id=85, pos=[(0,54,18)])
  EXP_SZ: bits[32] = literal(value=8, id=76, pos=[(0,50,12)])
  ret tuple.86: (bits[1], bits[8], bits[7]) = tuple(literal.78, zero_ext.80, shll.85, id=86, pos=[(0,51,33)])
}

fn __apfloat__inf__8_7(sign: bits[1] id=87) -> (bits[1], bits[8], bits[7]) {
  invoke.90: bits[8] = invoke(to_apply=__std__mask_bits__8, id=90, pos=[(0,78,28)])
  literal.91: bits[7] = literal(value=0, id=91, pos=[(0,79,18)])
  EXP_SZ: bits[32] = literal(value=8, id=88, pos=[(0,75,11)])
  FRACTION_SZ: bits[32] = literal(value=7, id=89, pos=[(0,75,24)])
  ret tuple.92: (bits[1], bits[8], bits[7]) = tuple(sign, invoke.90, literal.91, id=92, pos=[(0,76,33)])
}

fn __std__signed_max_value__8_7() -> bits[8] {
  literal.95: bits[8] = literal(value=1, id=95, pos=[(1,47,6)])
  N_MINUS_ONE: bits[32] = literal(value=7, id=94, pos=[(1,46,32)])
  shll.96: bits[8] = shll(literal.95, N_MINUS_ONE, id=96, pos=[(1,47,6)])
  literal.97: bits[8] = literal(value=1, id=97, pos=[(1,47,32)])
  sub.98: bits[8] = sub(shll.96, literal.97, id=98, pos=[(1,47,6)])
  N: bits[32] = literal(value=8, id=93, pos=[(1,46,24)])
  ret sign_ext.99: bits[8] = sign_ext(sub.98, new_bit_count=8, id=99)
}

fn __apfloat__bias__8(unbiased_exponent: bits[8] id=100) -> bits[8] {
  BIAS: bits[8] = invoke(to_apply=__std__signed_max_value__8_7, id=102, pos=[(0,343,38)])
  add.103: bits[8] = add(unbiased_exponent, BIAS, id=103, pos=[(0,344,5)])
  EXP_SZ: bits[32] = literal(value=8, id=101, pos=[(0,342,12)])
  ret sign_ext.104: bits[8] = sign_ext(add.103, new_bit_count=8, id=104)
}

fn __apfloat__has_fractional_part__8_7(f: (bits[1], bits[8], bits[7]) id=105) -> bits[1] {
  FRACTION_SZ: bits[32] = literal(value=7, id=107, pos=[(0,4187,40)])
  bit_slice.109: bits[8] = bit_slice(FRACTION_SZ, start=0, width=8, id=109)
  f_bexp: bits[8] = tuple_index(f, index=1, id=108, pos=[(0,4188,5)])
  invoke.110: bits[8] = invoke(bit_slice.109, to_apply=__apfloat__bias__8, id=110, pos=[(0,4188,17)])
  EXP_SZ: bits[32] = literal(value=8, id=106, pos=[(0,4187,27)])
  ret ult.111: bits[1] = ult(f_bexp, invoke.110, id=111, pos=[(0,4188,5)])
}

fn __apfloat__has_negative_exponent__8_7(f: (bits[1], bits[8], bits[7]) id=112) -> bits[1] {
  literal.116: bits[8] = literal(value=0, id=116, pos=[(0,4215,18)])
  f_bexp: bits[8] = tuple_index(f, index=1, id=115, pos=[(0,4215,5)])
  invoke.117: bits[8] = invoke(literal.116, to_apply=__apfloat__bias__8, id=117, pos=[(0,4215,17)])
  EXP_SZ: bits[32] = literal(value=8, id=113, pos=[(0,4213,29)])
  FRACTION_SZ: bits[32] = literal(value=7, id=114, pos=[(0,4213,42)])
  ret ult.118: bits[1] = ult(f_bexp, invoke.117, id=118, pos=[(0,4215,5)])
}

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

fn __apfloat__one__8_7(sign: bits[1] id=122) -> (bits[1], bits[8], bits[7]) {
  invoke.127: bits[7] = invoke(to_apply=__std__mask_bits__7, id=127, pos=[(0,150,28)])
  EXP_SZ: bits[32] = literal(value=8, id=123, pos=[(0,146,11)])
  literal.125: bits[32] = literal(value=1, id=125, pos=[(0,147,34)])
  zero_ext.128: bits[8] = zero_ext(invoke.127, new_bit_count=8, id=128)
  literal.129: bits[7] = literal(value=0, id=129, pos=[(0,151,18)])
  FRACTION_SZ: bits[32] = literal(value=7, id=124, pos=[(0,146,24)])
  MASK_SZ: bits[32] = sub(EXP_SZ, literal.125, id=126, pos=[(0,147,25)])
  ret tuple.130: (bits[1], bits[8], bits[7]) = tuple(sign, zero_ext.128, literal.129, id=130, pos=[(0,148,33)])
}

fn __apfloat__exponent_bias__8_7(f: (bits[1], bits[8], bits[7]) id=131) -> bits[8] {
  invoke.134: bits[8] = invoke(to_apply=__std__signed_max_value__8_7, id=134, pos=[(0,221,25)])
  EXP_SZ: bits[32] = literal(value=8, id=132, pos=[(0,220,21)])
  FRACTION_SZ: bits[32] = literal(value=7, id=133, pos=[(0,220,34)])
  ret sign_ext.135: bits[8] = sign_ext(invoke.134, new_bit_count=8, id=135)
}

fn __apfloat__unbiased_exponent__8_7(f: (bits[1], bits[8], bits[7]) id=136) -> bits[8] {
  f_bexp: bits[8] = tuple_index(f, index=1, id=140, pos=[(0,266,6)])
  zero_ext.141: bits[8] = zero_ext(f_bexp, new_bit_count=8, id=141)
  bias: bits[8] = invoke(f, to_apply=__apfloat__exponent_bias__8_7, id=139, pos=[(0,265,28)])
  EXP_SZ: bits[32] = literal(value=8, id=137, pos=[(0,263,25)])
  FRACTION_SZ: bits[32] = literal(value=7, id=138, pos=[(0,263,38)])
  ret sub.142: bits[8] = sub(zero_ext.141, bias, id=142, pos=[(0,266,6)])
}

fn __apfloat__round_up_no_sign_positive_exp__8_7(f: (bits[1], bits[8], bits[7]) id=143) -> (bits[1], bits[8], bits[7]) {
  exp: bits[8] = invoke(f, to_apply=__apfloat__unbiased_exponent__8_7, id=146, pos=[(0,4234,31)])
  invoke.147: bits[7] = invoke(to_apply=__std__mask_bits__7, id=147, pos=[(0,4236,40)])
  sign_ext.148: bits[32] = sign_ext(exp, new_bit_count=32, id=148)
  f_fraction: bits[7] = tuple_index(f, index=2, id=150, pos=[(0,4255,9)])
  fractional_mask: bits[7] = shrl(invoke.147, sign_ext.148, id=149, pos=[(0,4236,40)])
  zero_ext.151: bits[8] = zero_ext(f_fraction, new_bit_count=8, id=151)
  zero_ext.152: bits[8] = zero_ext(fractional_mask, new_bit_count=8, id=152)
  fraction_up: bits[8] = add(zero_ext.151, zero_ext.152, id=153, pos=[(0,4255,9)])
  FRACTION_SZ: bits[32] = literal(value=7, id=145, pos=[(0,4231,46)])
  dynamic_bit_slice.155: bits[1] = dynamic_bit_slice(fraction_up, FRACTION_SZ, width=1, id=155, pos=[(0,4258,46)])
  literal.158: bits[8] = literal(value=0, id=158, pos=[(0,4260,40)])
  f_bexp: bits[8] = tuple_index(f, index=1, id=154, pos=[(0,4258,27)])
  zero_ext.156: bits[8] = zero_ext(dynamic_bit_slice.155, new_bit_count=8, id=156)
  dynamic_bit_slice.159: bits[7] = dynamic_bit_slice(fraction_up, literal.158, width=7, id=159, pos=[(0,4260,39)])
  not.160: bits[7] = not(fractional_mask, id=160, pos=[(0,4260,62)])
  f_sign: bits[1] = tuple_index(f, index=0, id=162, pos=[(0,4261,21)])
  bexp_with_carry: bits[8] = add(f_bexp, zero_ext.156, id=157, pos=[(0,4258,27)])
  fraction_integral: bits[7] = and(dynamic_bit_slice.159, not.160, id=161, pos=[(0,4260,39)])
  EXP_SZ: bits[32] = literal(value=8, id=144, pos=[(0,4231,33)])
  ret tuple.163: (bits[1], bits[8], bits[7]) = tuple(f_sign, bexp_with_carry, fraction_integral, id=163, pos=[(0,4261,12)])
}

fn __apfloat__round_down_no_sign_positive_exp__8_7(f: (bits[1], bits[8], bits[7]) id=164) -> (bits[1], bits[8], bits[7]) {
  exp: bits[8] = invoke(f, to_apply=__apfloat__unbiased_exponent__8_7, id=167, pos=[(0,4268,31)])
  invoke.168: bits[7] = invoke(to_apply=__std__mask_bits__7, id=168, pos=[(0,4270,40)])
  sign_ext.169: bits[32] = sign_ext(exp, new_bit_count=32, id=169)
  fractional_mask: bits[7] = shrl(invoke.168, sign_ext.169, id=170, pos=[(0,4270,40)])
  f_fraction: bits[7] = tuple_index(f, index=2, id=171, pos=[(0,4272,29)])
  not.172: bits[7] = not(fractional_mask, id=172, pos=[(0,4272,41)])
  f_sign: bits[1] = tuple_index(f, index=0, id=174, pos=[(0,4273,21)])
  f_bexp: bits[8] = tuple_index(f, index=1, id=175, pos=[(0,4273,35)])
  fraction_integral: bits[7] = and(f_fraction, not.172, id=173, pos=[(0,4272,29)])
  EXP_SZ: bits[32] = literal(value=8, id=165, pos=[(0,4265,35)])
  FRACTION_SZ: bits[32] = literal(value=7, id=166, pos=[(0,4265,48)])
  ret tuple.176: (bits[1], bits[8], bits[7]) = tuple(f_sign, f_bexp, fraction_integral, id=176, pos=[(0,4273,12)])
}

fn __apfloat__ceil_with_denorms__8_7(f: (bits[1], bits[8], bits[7]) id=177) -> (bits[1], bits[8], bits[7]) {
  f_sign__3: bits[1] = tuple_index(f, index=0, id=204, pos=[(0,4297,23)])
  literal.205: bits[1] = literal(value=0, id=205, pos=[(0,4297,32)])
  f_sign__2: bits[1] = tuple_index(f, index=0, id=196, pos=[(0,4290,20)])
  literal.197: bits[1] = literal(value=0, id=197, pos=[(0,4290,29)])
  literal.201: bits[1] = literal(value=0, id=201, pos=[(0,4295,45)])
  literal.199: bits[1] = literal(value=1, id=199, pos=[(0,4292,46)])
  eq.206: bits[1] = eq(f_sign__3, literal.205, id=206, pos=[(0,4297,23)])
  invoke.208: (bits[1], bits[8], bits[7]) = invoke(f, to_apply=__apfloat__round_down_no_sign_positive_exp__8_7, id=208, pos=[(0,4302,47)])
  invoke.207: (bits[1], bits[8], bits[7]) = invoke(f, to_apply=__apfloat__round_up_no_sign_positive_exp__8_7, id=207, pos=[(0,4299,45)])
  ne.198: bits[1] = ne(f_sign__2, literal.197, id=198, pos=[(0,4290,20)])
  invoke.202: (bits[1], bits[8], bits[7]) = invoke(literal.201, to_apply=__apfloat__one__8_7, id=202, pos=[(0,4295,23)])
  invoke.200: (bits[1], bits[8], bits[7]) = invoke(literal.199, to_apply=__apfloat__zero__8_7, id=200, pos=[(0,4292,24)])
  literal.188: bits[3] = literal(value=3, id=188, pos=[(0,4285,8)])
  invoke.180: bits[3] = invoke(f, to_apply=__apfloat__tag__8_7, id=180, pos=[(0,4282,13)])
  literal.184: bits[3] = literal(value=1, id=184, pos=[(0,4284,8)])
  literal.181: bits[3] = literal(value=0, id=181, pos=[(0,4283,8)])
  invoke.193: bits[1] = invoke(f, to_apply=__apfloat__has_fractional_part__8_7, id=193, pos=[(0,4287,35)])
  invoke.195: bits[1] = invoke(f, to_apply=__apfloat__has_negative_exponent__8_7, id=195, pos=[(0,4289,43)])
  sel.209: (bits[1], bits[8], bits[7]) = sel(eq.206, cases=[invoke.208, invoke.207], id=209, pos=[(0,4297,19)])
  sel.203: (bits[1], bits[8], bits[7]) = sel(ne.198, cases=[invoke.202, invoke.200], id=203, pos=[(0,4290,16)])
  eq.189: bits[1] = eq(literal.188, invoke.180, id=189)
  eq.185: bits[1] = eq(literal.184, invoke.180, id=185)
  eq.182: bits[1] = eq(literal.181, invoke.180, id=182)
  f_sign: bits[1] = tuple_index(f, index=0, id=186, pos=[(0,4284,58)])
  f_sign__1: bits[1] = tuple_index(f, index=0, id=190, pos=[(0,4285,55)])
  not.194: bits[1] = not(invoke.193, id=194, pos=[(0,4287,15)])
  sel.210: (bits[1], bits[8], bits[7]) = sel(invoke.195, cases=[sel.209, sel.203], id=210, pos=[(0,4289,19)])
  concat.212: bits[3] = concat(eq.189, eq.185, eq.182, id=212)
  invoke.183: (bits[1], bits[8], bits[7]) = invoke(to_apply=__apfloat__qnan__8_7, id=183, pos=[(0,4283,31)])
  invoke.187: (bits[1], bits[8], bits[7]) = invoke(f_sign, to_apply=__apfloat__inf__8_7, id=187, pos=[(0,4284,35)])
  invoke.191: (bits[1], bits[8], bits[7]) = invoke(f_sign__1, to_apply=__apfloat__zero__8_7, id=191, pos=[(0,4285,32)])
  sel.211: (bits[1], bits[8], bits[7]) = sel(not.194, cases=[sel.210, f], id=211, pos=[(0,4287,12)])
  EXP_SZ: bits[32] = literal(value=8, id=178, pos=[(0,4279,25)])
  FRACTION_SZ: bits[32] = literal(value=7, id=179, pos=[(0,4279,38)])
  literal.192: bits[1] = literal(value=1, id=192, pos=[(0,4286,8)])
  ret priority_sel.213: (bits[1], bits[8], bits[7]) = priority_sel(concat.212, cases=[invoke.183, invoke.187, invoke.191], default=sel.211, id=213)
}

fn __apfloat__ceil_daz__8_7(f: (bits[1], bits[8], bits[7]) id=214) -> (bits[1], bits[8], bits[7]) {
  invoke.217: (bits[1], bits[8], bits[7]) = invoke(f, to_apply=__apfloat__subnormals_to_zero__8_7, id=217, pos=[(0,4393,40)])
  EXP_SZ: bits[32] = literal(value=8, id=215, pos=[(0,4391,16)])
  FRACTION_SZ: bits[32] = literal(value=7, id=216, pos=[(0,4391,29)])
  ret invoke.218: (bits[1], bits[8], bits[7]) = invoke(invoke.217, to_apply=__apfloat__ceil_with_denorms__8_7, id=218, pos=[(0,4393,21)])
}

top fn __bfloat16__ceil_daz(f: (bits[1], bits[8], bits[7]) id=219) -> (bits[1], bits[8], bits[7]) {
  ret invoke.220: (bits[1], bits[8], bits[7]) = invoke(f, to_apply=__apfloat__ceil_daz__8_7, id=220, pos=[(2,180,52)])
}