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__max_normal_exp__8() -> bits[8] {
  EXP_SZ: bits[32] = literal(value=8, id=1, pos=[(0,196,22)])
  literal.3: bits[32] = literal(value=1, id=3, pos=[(0,197,32)])
  literal.2: bits[8] = literal(value=1, id=2, pos=[(0,197,6)])
  sub.4: bits[32] = sub(EXP_SZ, literal.3, id=4, pos=[(0,197,23)])
  shll.5: bits[8] = shll(literal.2, sub.4, id=5, pos=[(0,197,6)])
  literal.6: bits[8] = literal(value=1, id=6, pos=[(0,197,42)])
  sub.7: bits[8] = sub(shll.5, literal.6, id=7, pos=[(0,197,6)])
  ret zero_ext.8: bits[8] = zero_ext(sub.7, new_bit_count=8, id=8)
}

fn __apfloat__min_normal_exp__8() -> bits[8] {
  EXP_SZ: bits[32] = literal(value=8, id=9, pos=[(0,207,22)])
  literal.11: bits[32] = literal(value=1, id=11, pos=[(0,208,59)])
  literal.10: bits[8] = literal(value=1, id=10, pos=[(0,208,33)])
  sub.12: bits[32] = sub(EXP_SZ, literal.11, id=12, pos=[(0,208,50)])
  shll.13: bits[8] = shll(literal.10, sub.12, id=13, pos=[(0,208,33)])
  literal.14: bits[8] = literal(value=2, id=14, pos=[(0,208,69)])
  sub.15: bits[8] = sub(shll.13, literal.14, id=15, pos=[(0,208,33)])
  minus_min_normal_exp: bits[8] = zero_ext(sub.15, new_bit_count=8, id=16)
  ret neg.17: bits[8] = neg(minus_min_normal_exp, id=17, pos=[(0,209,4)])
}

fn __apfloat__is_zero_or_subnormal__8_7(x: (bits[1], bits[8], bits[7]) id=18) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=21, pos=[(0,804,5)])
  literal.22: bits[8] = literal(value=0, id=22, pos=[(0,804,14)])
  EXP_SZ: bits[32] = literal(value=8, id=19, pos=[(0,802,28)])
  FRACTION_SZ: bits[32] = literal(value=7, id=20, pos=[(0,802,41)])
  ret eq.23: bits[1] = eq(x_bexp, literal.22, id=23, pos=[(0,804,5)])
}

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

fn __apfloat__subnormals_to_zero__8_7(x: (bits[1], bits[8], bits[7]) id=30) -> (bits[1], bits[8], bits[7]) {
  x_sign: bits[1] = tuple_index(x, index=0, id=34, pos=[(0,809,60)])
  invoke.33: bits[1] = invoke(x, to_apply=__apfloat__is_zero_or_subnormal__8_7, id=33, pos=[(0,809,27)])
  invoke.35: (bits[1], bits[8], bits[7]) = invoke(x_sign, to_apply=__apfloat__zero__8_7, id=35, pos=[(0,809,37)])
  EXP_SZ: bits[32] = literal(value=8, id=31, pos=[(0,807,26)])
  FRACTION_SZ: bits[32] = literal(value=7, id=32, pos=[(0,807,39)])
  ret sel.36: (bits[1], bits[8], bits[7]) = sel(invoke.33, cases=[x, invoke.35], id=36, pos=[(0,809,4)])
}

fn __std__signed_max_value__8_7() -> bits[8] {
  literal.39: bits[8] = literal(value=1, id=39, pos=[(1,47,6)])
  N_MINUS_ONE: bits[32] = literal(value=7, id=38, pos=[(1,46,32)])
  shll.40: bits[8] = shll(literal.39, N_MINUS_ONE, id=40, pos=[(1,47,6)])
  literal.41: bits[8] = literal(value=1, id=41, pos=[(1,47,32)])
  sub.42: bits[8] = sub(shll.40, literal.41, id=42, pos=[(1,47,6)])
  N: bits[32] = literal(value=8, id=37, pos=[(1,46,24)])
  ret sign_ext.43: bits[8] = sign_ext(sub.42, new_bit_count=8, id=43)
}

fn __apfloat__exponent_bias__8_7(f: (bits[1], bits[8], bits[7]) id=44) -> bits[8] {
  invoke.47: bits[8] = invoke(to_apply=__std__signed_max_value__8_7, id=47, pos=[(0,221,25)])
  EXP_SZ: bits[32] = literal(value=8, id=45, pos=[(0,220,21)])
  FRACTION_SZ: bits[32] = literal(value=7, id=46, pos=[(0,220,34)])
  ret sign_ext.48: bits[8] = sign_ext(invoke.47, new_bit_count=8, id=48)
}

fn __apfloat__unbiased_exponent__8_7(f: (bits[1], bits[8], bits[7]) id=49) -> bits[8] {
  f_bexp: bits[8] = tuple_index(f, index=1, id=53, pos=[(0,266,6)])
  zero_ext.54: bits[8] = zero_ext(f_bexp, new_bit_count=8, id=54)
  bias: bits[8] = invoke(f, to_apply=__apfloat__exponent_bias__8_7, id=52, pos=[(0,265,28)])
  EXP_SZ: bits[32] = literal(value=8, id=50, pos=[(0,263,25)])
  FRACTION_SZ: bits[32] = literal(value=7, id=51, pos=[(0,263,38)])
  ret sub.55: bits[8] = sub(zero_ext.54, bias, id=55, pos=[(0,266,6)])
}

fn __apfloat__bias__8(unbiased_exponent: bits[8] id=56) -> bits[8] {
  BIAS: bits[8] = invoke(to_apply=__std__signed_max_value__8_7, id=58, pos=[(0,343,38)])
  add.59: bits[8] = add(unbiased_exponent, BIAS, id=59, pos=[(0,344,5)])
  EXP_SZ: bits[32] = literal(value=8, id=57, pos=[(0,342,12)])
  ret sign_ext.60: bits[8] = sign_ext(add.59, new_bit_count=8, id=60)
}

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

fn __apfloat__inf__8_7(sign: bits[1] id=64) -> (bits[1], bits[8], bits[7]) {
  invoke.67: bits[8] = invoke(to_apply=__std__mask_bits__8, id=67, pos=[(0,78,28)])
  literal.68: bits[7] = literal(value=0, id=68, pos=[(0,79,18)])
  EXP_SZ: bits[32] = literal(value=8, id=65, pos=[(0,75,11)])
  FRACTION_SZ: bits[32] = literal(value=7, id=66, pos=[(0,75,24)])
  ret tuple.69: (bits[1], bits[8], bits[7]) = tuple(sign, invoke.67, literal.68, id=69, pos=[(0,76,33)])
}

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

fn __apfloat__is_inf__8_7(x: (bits[1], bits[8], bits[7]) id=73) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=76, pos=[(0,96,6)])
  invoke.77: bits[8] = invoke(to_apply=__std__mask_bits__8, id=77, pos=[(0,96,29)])
  x_fraction: bits[7] = tuple_index(x, index=2, id=79, pos=[(0,96,44)])
  literal.80: bits[7] = literal(value=0, id=80, pos=[(0,96,57)])
  eq.78: bits[1] = eq(x_bexp, invoke.77, id=78, pos=[(0,96,6)])
  eq.81: bits[1] = eq(x_fraction, literal.80, id=81, pos=[(0,96,44)])
  EXP_SZ: bits[32] = literal(value=8, id=74, pos=[(0,95,14)])
  FRACTION_SZ: bits[32] = literal(value=7, id=75, pos=[(0,95,27)])
  ret and.82: bits[1] = and(eq.78, eq.81, id=82, pos=[(0,96,6)])
}

fn __apfloat__is_nan__8_7(x: (bits[1], bits[8], bits[7]) id=83) -> bits[1] {
  x_bexp: bits[8] = tuple_index(x, index=1, id=86, pos=[(0,71,6)])
  invoke.87: bits[8] = invoke(to_apply=__std__mask_bits__8, id=87, pos=[(0,71,29)])
  x_fraction: bits[7] = tuple_index(x, index=2, id=89, pos=[(0,71,44)])
  literal.90: bits[7] = literal(value=0, id=90, pos=[(0,71,57)])
  eq.88: bits[1] = eq(x_bexp, invoke.87, id=88, pos=[(0,71,6)])
  ne.91: bits[1] = ne(x_fraction, literal.90, id=91, pos=[(0,71,44)])
  EXP_SZ: bits[32] = literal(value=8, id=84, pos=[(0,70,14)])
  FRACTION_SZ: bits[32] = literal(value=7, id=85, pos=[(0,70,27)])
  ret and.92: bits[1] = and(eq.88, ne.91, id=92, pos=[(0,71,6)])
}

fn __apfloat__qnan__8_7() -> (bits[1], bits[8], bits[7]) {
  FRACTION_SZ: bits[32] = literal(value=7, id=94, pos=[(0,50,25)])
  literal.99: bits[32] = literal(value=1, id=99, pos=[(0,54,57)])
  sub.100: bits[32] = sub(FRACTION_SZ, literal.99, id=100, pos=[(0,54,43)])
  invoke.96: bits[8] = invoke(to_apply=__std__mask_bits__8, id=96, pos=[(0,53,28)])
  literal.98: bits[7] = literal(value=1, id=98, pos=[(0,54,18)])
  bit_slice.101: bits[7] = bit_slice(sub.100, start=0, width=7, id=101)
  literal.95: bits[1] = literal(value=0, id=95, pos=[(0,52,14)])
  zero_ext.97: bits[8] = zero_ext(invoke.96, new_bit_count=8, id=97)
  shll.102: bits[7] = shll(literal.98, bit_slice.101, id=102, pos=[(0,54,18)])
  EXP_SZ: bits[32] = literal(value=8, id=93, pos=[(0,50,12)])
  ret tuple.103: (bits[1], bits[8], bits[7]) = tuple(literal.95, zero_ext.97, shll.102, id=103, pos=[(0,51,33)])
}

fn __apfloat__ldexp__8_7(fraction: (bits[1], bits[8], bits[7]) id=104, exp: bits[32] id=105) -> (bits[1], bits[8], bits[7]) {
  fraction__1: (bits[1], bits[8], bits[7]) = invoke(fraction, to_apply=__apfloat__subnormals_to_zero__8_7, id=112, pos=[(0,2103,37)])
  invoke.115: bits[8] = invoke(fraction__1, to_apply=__apfloat__unbiased_exponent__8_7, id=115, pos=[(0,2107,59)])
  sign_ext.114: bits[33] = sign_ext(exp, new_bit_count=33, id=114, pos=[(0,2107,20)])
  sign_ext.117: bits[33] = sign_ext(invoke.115, new_bit_count=33, id=117, pos=[(0,2107,41)])
  invoke.110: bits[8] = invoke(to_apply=__apfloat__min_normal_exp__8, id=110, pos=[(0,2100,39)])
  exp__1: bits[33] = add(sign_ext.114, sign_ext.117, id=118, pos=[(0,2107,20)])
  MIN_EXPONENT: bits[33] = sign_ext(invoke.110, new_bit_count=33, id=111)
  literal.128: bits[33] = literal(value=1, id=128, pos=[(0,2118,34)])
  invoke.108: bits[8] = invoke(to_apply=__apfloat__max_normal_exp__8, id=108, pos=[(0,2099,39)])
  bit_slice.120: bits[8] = bit_slice(exp__1, start=0, width=8, id=120)
  sub.129: bits[33] = sub(MIN_EXPONENT, literal.128, id=129, pos=[(0,2118,19)])
  fraction__1_fraction__1: bits[7] = tuple_index(fraction__1, index=2, id=131, pos=[(0,2118,52)])
  invoke.132: bits[7] = invoke(to_apply=__std__mask_bits__7, id=132, pos=[(0,2118,79)])
  MAX_EXPONENT: bits[33] = sign_ext(invoke.108, new_bit_count=33, id=109)
  fraction__1_sign: bits[1] = tuple_index(fraction__1, index=0, id=119, pos=[(0,2109,30)])
  invoke.121: bits[8] = invoke(bit_slice.120, to_apply=__apfloat__bias__8, id=121, pos=[(0,2109,47)])
  fraction__1_fraction: bits[7] = tuple_index(fraction__1, index=2, id=122, pos=[(0,2109,86)])
  fraction__1_sign__1: bits[1] = tuple_index(fraction__1, index=0, id=125, pos=[(0,2112,74)])
  eq.130: bits[1] = eq(exp__1, sub.129, id=130, pos=[(0,2118,11)])
  eq.133: bits[1] = eq(fraction__1_fraction__1, invoke.132, id=133, pos=[(0,2118,52)])
  fraction__1_sign__3: bits[1] = tuple_index(fraction__1, index=0, id=139, pos=[(0,2121,46)])
  fraction__1_sign__2: bits[1] = tuple_index(fraction__1, index=0, id=135, pos=[(0,2119,34)])
  literal.136: bits[8] = literal(value=1, id=136, pos=[(0,2119,47)])
  literal.137: bits[7] = literal(value=0, id=137, pos=[(0,2119,71)])
  sgt.124: bits[1] = sgt(exp__1, MAX_EXPONENT, id=124, pos=[(0,2112,20)])
  result: (bits[1], bits[8], bits[7]) = tuple(fraction__1_sign, invoke.121, fraction__1_fraction, id=123, pos=[(0,2109,14)])
  invoke.126: (bits[1], bits[8], bits[7]) = invoke(fraction__1_sign__1, to_apply=__apfloat__inf__8_7, id=126, pos=[(0,2112,44)])
  and.134: bits[1] = and(eq.130, eq.133, id=134, pos=[(0,2118,11)])
  invoke.140: (bits[1], bits[8], bits[7]) = invoke(fraction__1_sign__3, to_apply=__apfloat__zero__8_7, id=140, pos=[(0,2121,16)])
  tuple.138: (bits[1], bits[8], bits[7]) = tuple(fraction__1_sign__2, literal.136, literal.137, id=138, pos=[(0,2119,18)])
  slt.142: bits[1] = slt(exp__1, MIN_EXPONENT, id=142, pos=[(0,2124,20)])
  result__1: (bits[1], bits[8], bits[7]) = sel(sgt.124, cases=[result, invoke.126], id=127, pos=[(0,2112,17)])
  underflow_result: (bits[1], bits[8], bits[7]) = sel(and.134, cases=[invoke.140, tuple.138], id=141, pos=[(0,2118,8)])
  invoke.145: bits[1] = invoke(fraction__1, to_apply=__apfloat__is_zero_or_subnormal__8_7, id=145, pos=[(0,2129,40)])
  invoke.146: bits[1] = invoke(fraction__1, to_apply=__apfloat__is_inf__8_7, id=146, pos=[(0,2129,60)])
  result__2: (bits[1], bits[8], bits[7]) = sel(slt.142, cases=[result__1, underflow_result], id=143, pos=[(0,2124,17)])
  or.147: bits[1] = or(invoke.145, invoke.146, id=147, pos=[(0,2129,40)])
  result__3: (bits[1], bits[8], bits[7]) = invoke(result__2, to_apply=__apfloat__subnormals_to_zero__8_7, id=144, pos=[(0,2126,35)])
  invoke.149: bits[1] = invoke(fraction__1, to_apply=__apfloat__is_nan__8_7, id=149, pos=[(0,2130,26)])
  result__4: (bits[1], bits[8], bits[7]) = sel(or.147, cases=[result__3, fraction__1], id=148, pos=[(0,2129,17)])
  invoke.150: (bits[1], bits[8], bits[7]) = invoke(to_apply=__apfloat__qnan__8_7, id=150, pos=[(0,2130,43)])
  EXP_SZ: bits[32] = literal(value=8, id=106, pos=[(0,2095,13)])
  FRACTION_SZ: bits[32] = literal(value=7, id=107, pos=[(0,2095,26)])
  literal.113: bits[33] = literal(value=0, id=113, pos=[(0,2107,26)])
  literal.116: bits[33] = literal(value=0, id=116, pos=[(0,2107,92)])
  ret result__5: (bits[1], bits[8], bits[7]) = sel(invoke.149, cases=[result__4, invoke.150], id=151, pos=[(0,2130,17)])
}

top fn __bfloat16__ldexp(f: (bits[1], bits[8], bits[7]) id=152, e: bits[32] id=153) -> (bits[1], bits[8], bits[7]) {
  ret invoke.154: (bits[1], bits[8], bits[7]) = invoke(f, e, to_apply=__apfloat__ldexp__8_7, id=154, pos=[(2,64,54)])
}