package std

file_number 0 "/inputs/subtree/xls/dslx/stdlib/std.x"

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

fn __std__combine_clzt_halfs__1(left: bits[1] id=3, right: bits[1] id=4) -> bits[2] {
  bit_slice.6: bits[1] = bit_slice(left, start=0, width=1, id=6, pos=[(0,1533,15)])
  bit_slice.7: bits[1] = bit_slice(right, start=0, width=1, id=7, pos=[(0,1533,27)])
  tuple.8: (bits[1], bits[1]) = tuple(bit_slice.6, bit_slice.7, id=8, pos=[(0,1533,10)])
  literal.22: bits[1] = literal(value=1, id=22, pos=[(0,1535,9)])
  tuple_index.21: bits[1] = tuple_index(tuple.8, index=0, id=21)
  literal.11: bits[1] = literal(value=1, id=11, pos=[(0,1534,9)])
  tuple_index.10: bits[1] = tuple_index(tuple.8, index=0, id=10)
  literal.20: bits[1] = literal(value=1, id=20)
  eq.23: bits[1] = eq(literal.22, tuple_index.21, id=23)
  literal.26: bits[1] = literal(value=0, id=26, pos=[(0,1535,15)])
  tuple_index.25: bits[1] = tuple_index(tuple.8, index=1, id=25)
  literal.9: bits[1] = literal(value=1, id=9)
  eq.12: bits[1] = eq(literal.11, tuple_index.10, id=12)
  literal.15: bits[1] = literal(value=1, id=15, pos=[(0,1534,15)])
  tuple_index.14: bits[1] = tuple_index(tuple.8, index=1, id=14)
  and.24: bits[1] = and(literal.20, eq.23, id=24)
  eq.27: bits[1] = eq(literal.26, tuple_index.25, id=27)
  and.13: bits[1] = and(literal.9, eq.12, id=13)
  eq.16: bits[1] = eq(literal.15, tuple_index.14, id=16)
  and.28: bits[1] = and(and.24, eq.27, id=28)
  and.17: bits[1] = and(and.13, eq.16, id=17)
  literal.18: bits[1] = literal(value=0, id=18, pos=[(0,1534,32)])
  literal.29: bits[2] = literal(value=1, id=29, pos=[(0,1535,24)])
  bit_slice.30: bits[0] = bit_slice(right, start=0, width=0, id=30, pos=[(0,1535,40)])
  literal.33: bits[1] = literal(value=0, id=33, pos=[(0,1536,13)])
  concat.35: bits[2] = concat(and.28, and.17, id=35)
  concat.19: bits[2] = concat(left, literal.18, id=19, pos=[(0,1534,24)])
  concat.31: bits[2] = concat(literal.29, bit_slice.30, id=31, pos=[(0,1535,24)])
  concat.34: bits[2] = concat(literal.33, left, id=34, pos=[(0,1536,13)])
  N: bits[32] = literal(value=1, id=5, pos=[(0,1532,22)])
  literal.32: bits[1] = literal(value=1, id=32, pos=[(0,1536,8)])
  ret priority_sel.36: bits[2] = priority_sel(concat.35, cases=[concat.19, concat.31], default=concat.34, id=36)
}

fn __std__clzt_pow2_2(value: bits[2] id=37) -> bits[2] {
  literal.38: bits[32] = literal(value=2, id=38, pos=[(0,1584,20)])
  literal.39: bits[1] = literal(value=1, id=39, pos=[(0,1584,29)])
  bit_slice.42: bits[1] = bit_slice(value, start=1, width=1, id=42, pos=[(0,1585,40)])
  bit_slice.44: bits[1] = bit_slice(value, start=0, width=1, id=44, pos=[(0,1585,70)])
  shrl.40: bits[32] = shrl(literal.38, literal.39, id=40, pos=[(0,1584,20)])
  invoke.43: bits[1] = invoke(bit_slice.42, to_apply=__std__clzt_pow2_1, id=43, pos=[(0,1585,34)])
  invoke.45: bits[1] = invoke(bit_slice.44, to_apply=__std__clzt_pow2_1, id=45, pos=[(0,1585,64)])
  N_HALF: bits[32] = zero_ext(shrl.40, new_bit_count=32, id=41)
  ret invoke.46: bits[2] = invoke(invoke.43, invoke.45, to_apply=__std__combine_clzt_halfs__1, id=46, pos=[(0,1585,22)])
}

fn __std__combine_clzt_halfs__2(left: bits[2] id=47, right: bits[2] id=48) -> bits[3] {
  bit_slice.50: bits[1] = bit_slice(left, start=1, width=1, id=50, pos=[(0,1533,15)])
  bit_slice.51: bits[1] = bit_slice(right, start=1, width=1, id=51, pos=[(0,1533,27)])
  tuple.52: (bits[1], bits[1]) = tuple(bit_slice.50, bit_slice.51, id=52, pos=[(0,1533,10)])
  literal.66: bits[1] = literal(value=1, id=66, pos=[(0,1535,9)])
  tuple_index.65: bits[1] = tuple_index(tuple.52, index=0, id=65)
  literal.55: bits[1] = literal(value=1, id=55, pos=[(0,1534,9)])
  tuple_index.54: bits[1] = tuple_index(tuple.52, index=0, id=54)
  literal.64: bits[1] = literal(value=1, id=64)
  eq.67: bits[1] = eq(literal.66, tuple_index.65, id=67)
  literal.70: bits[1] = literal(value=0, id=70, pos=[(0,1535,15)])
  tuple_index.69: bits[1] = tuple_index(tuple.52, index=1, id=69)
  literal.53: bits[1] = literal(value=1, id=53)
  eq.56: bits[1] = eq(literal.55, tuple_index.54, id=56)
  literal.59: bits[1] = literal(value=1, id=59, pos=[(0,1534,15)])
  tuple_index.58: bits[1] = tuple_index(tuple.52, index=1, id=58)
  and.68: bits[1] = and(literal.64, eq.67, id=68)
  eq.71: bits[1] = eq(literal.70, tuple_index.69, id=71)
  and.57: bits[1] = and(literal.53, eq.56, id=57)
  eq.60: bits[1] = eq(literal.59, tuple_index.58, id=60)
  and.72: bits[1] = and(and.68, eq.71, id=72)
  and.61: bits[1] = and(and.57, eq.60, id=61)
  literal.62: bits[1] = literal(value=0, id=62, pos=[(0,1534,32)])
  literal.73: bits[2] = literal(value=1, id=73, pos=[(0,1535,24)])
  bit_slice.74: bits[1] = bit_slice(right, start=0, width=1, id=74, pos=[(0,1535,40)])
  literal.77: bits[1] = literal(value=0, id=77, pos=[(0,1536,13)])
  concat.79: bits[2] = concat(and.72, and.61, id=79)
  concat.63: bits[3] = concat(left, literal.62, id=63, pos=[(0,1534,24)])
  concat.75: bits[3] = concat(literal.73, bit_slice.74, id=75, pos=[(0,1535,24)])
  concat.78: bits[3] = concat(literal.77, left, id=78, pos=[(0,1536,13)])
  N: bits[32] = literal(value=2, id=49, pos=[(0,1532,22)])
  literal.76: bits[1] = literal(value=1, id=76, pos=[(0,1536,8)])
  ret priority_sel.80: bits[3] = priority_sel(concat.79, cases=[concat.63, concat.75], default=concat.78, id=80)
}

fn __std__clzt_pow2_4(value: bits[4] id=81) -> bits[3] {
  literal.82: bits[32] = literal(value=4, id=82, pos=[(0,1589,20)])
  literal.83: bits[1] = literal(value=1, id=83, pos=[(0,1589,29)])
  bit_slice.86: bits[2] = bit_slice(value, start=2, width=2, id=86, pos=[(0,1590,40)])
  bit_slice.88: bits[2] = bit_slice(value, start=0, width=2, id=88, pos=[(0,1590,70)])
  shrl.84: bits[32] = shrl(literal.82, literal.83, id=84, pos=[(0,1589,20)])
  invoke.87: bits[2] = invoke(bit_slice.86, to_apply=__std__clzt_pow2_2, id=87, pos=[(0,1590,34)])
  invoke.89: bits[2] = invoke(bit_slice.88, to_apply=__std__clzt_pow2_2, id=89, pos=[(0,1590,64)])
  N_HALF: bits[32] = zero_ext(shrl.84, new_bit_count=32, id=85)
  ret invoke.90: bits[3] = invoke(invoke.87, invoke.89, to_apply=__std__combine_clzt_halfs__2, id=90, pos=[(0,1590,22)])
}

fn __std__combine_clzt_halfs__3(left: bits[3] id=91, right: bits[3] id=92) -> bits[4] {
  bit_slice.94: bits[1] = bit_slice(left, start=2, width=1, id=94, pos=[(0,1533,15)])
  bit_slice.95: bits[1] = bit_slice(right, start=2, width=1, id=95, pos=[(0,1533,27)])
  tuple.96: (bits[1], bits[1]) = tuple(bit_slice.94, bit_slice.95, id=96, pos=[(0,1533,10)])
  literal.110: bits[1] = literal(value=1, id=110, pos=[(0,1535,9)])
  tuple_index.109: bits[1] = tuple_index(tuple.96, index=0, id=109)
  literal.99: bits[1] = literal(value=1, id=99, pos=[(0,1534,9)])
  tuple_index.98: bits[1] = tuple_index(tuple.96, index=0, id=98)
  literal.108: bits[1] = literal(value=1, id=108)
  eq.111: bits[1] = eq(literal.110, tuple_index.109, id=111)
  literal.114: bits[1] = literal(value=0, id=114, pos=[(0,1535,15)])
  tuple_index.113: bits[1] = tuple_index(tuple.96, index=1, id=113)
  literal.97: bits[1] = literal(value=1, id=97)
  eq.100: bits[1] = eq(literal.99, tuple_index.98, id=100)
  literal.103: bits[1] = literal(value=1, id=103, pos=[(0,1534,15)])
  tuple_index.102: bits[1] = tuple_index(tuple.96, index=1, id=102)
  and.112: bits[1] = and(literal.108, eq.111, id=112)
  eq.115: bits[1] = eq(literal.114, tuple_index.113, id=115)
  and.101: bits[1] = and(literal.97, eq.100, id=101)
  eq.104: bits[1] = eq(literal.103, tuple_index.102, id=104)
  and.116: bits[1] = and(and.112, eq.115, id=116)
  and.105: bits[1] = and(and.101, eq.104, id=105)
  literal.106: bits[1] = literal(value=0, id=106, pos=[(0,1534,32)])
  literal.117: bits[2] = literal(value=1, id=117, pos=[(0,1535,24)])
  bit_slice.118: bits[2] = bit_slice(right, start=0, width=2, id=118, pos=[(0,1535,40)])
  literal.121: bits[1] = literal(value=0, id=121, pos=[(0,1536,13)])
  concat.123: bits[2] = concat(and.116, and.105, id=123)
  concat.107: bits[4] = concat(left, literal.106, id=107, pos=[(0,1534,24)])
  concat.119: bits[4] = concat(literal.117, bit_slice.118, id=119, pos=[(0,1535,24)])
  concat.122: bits[4] = concat(literal.121, left, id=122, pos=[(0,1536,13)])
  N: bits[32] = literal(value=3, id=93, pos=[(0,1532,22)])
  literal.120: bits[1] = literal(value=1, id=120, pos=[(0,1536,8)])
  ret priority_sel.124: bits[4] = priority_sel(concat.123, cases=[concat.107, concat.119], default=concat.122, id=124)
}

fn __std__clzt_pow2_8(value: bits[8] id=125) -> bits[4] {
  literal.126: bits[32] = literal(value=8, id=126, pos=[(0,1594,20)])
  literal.127: bits[1] = literal(value=1, id=127, pos=[(0,1594,29)])
  bit_slice.130: bits[4] = bit_slice(value, start=4, width=4, id=130, pos=[(0,1595,40)])
  bit_slice.132: bits[4] = bit_slice(value, start=0, width=4, id=132, pos=[(0,1595,70)])
  shrl.128: bits[32] = shrl(literal.126, literal.127, id=128, pos=[(0,1594,20)])
  invoke.131: bits[3] = invoke(bit_slice.130, to_apply=__std__clzt_pow2_4, id=131, pos=[(0,1595,34)])
  invoke.133: bits[3] = invoke(bit_slice.132, to_apply=__std__clzt_pow2_4, id=133, pos=[(0,1595,64)])
  N_HALF: bits[32] = zero_ext(shrl.128, new_bit_count=32, id=129)
  ret invoke.134: bits[4] = invoke(invoke.131, invoke.133, to_apply=__std__combine_clzt_halfs__3, id=134, pos=[(0,1595,22)])
}

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

top fn __std__clzt_pow2_16(value: bits[16] id=169) -> bits[5] {
  literal.170: bits[32] = literal(value=16, id=170, pos=[(0,1599,20)])
  literal.171: bits[1] = literal(value=1, id=171, pos=[(0,1599,30)])
  bit_slice.174: bits[8] = bit_slice(value, start=8, width=8, id=174, pos=[(0,1600,40)])
  bit_slice.176: bits[8] = bit_slice(value, start=0, width=8, id=176, pos=[(0,1600,70)])
  shrl.172: bits[32] = shrl(literal.170, literal.171, id=172, pos=[(0,1599,20)])
  invoke.175: bits[4] = invoke(bit_slice.174, to_apply=__std__clzt_pow2_8, id=175, pos=[(0,1600,34)])
  invoke.177: bits[4] = invoke(bit_slice.176, to_apply=__std__clzt_pow2_8, id=177, pos=[(0,1600,64)])
  N_HALF: bits[32] = zero_ext(shrl.172, new_bit_count=32, id=173)
  ret invoke.178: bits[5] = invoke(invoke.175, invoke.177, to_apply=__std__combine_clzt_halfs__4, id=178, pos=[(0,1600,22)])
}