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)
}

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)])
}

fn __std__combine_clzt_halfs__5(left: bits[5] id=179, right: bits[5] id=180) -> bits[6] {
  bit_slice.182: bits[1] = bit_slice(left, start=4, width=1, id=182, pos=[(0,1533,15)])
  bit_slice.183: bits[1] = bit_slice(right, start=4, width=1, id=183, pos=[(0,1533,27)])
  tuple.184: (bits[1], bits[1]) = tuple(bit_slice.182, bit_slice.183, id=184, pos=[(0,1533,10)])
  literal.198: bits[1] = literal(value=1, id=198, pos=[(0,1535,9)])
  tuple_index.197: bits[1] = tuple_index(tuple.184, index=0, id=197)
  literal.187: bits[1] = literal(value=1, id=187, pos=[(0,1534,9)])
  tuple_index.186: bits[1] = tuple_index(tuple.184, index=0, id=186)
  literal.196: bits[1] = literal(value=1, id=196)
  eq.199: bits[1] = eq(literal.198, tuple_index.197, id=199)
  literal.202: bits[1] = literal(value=0, id=202, pos=[(0,1535,15)])
  tuple_index.201: bits[1] = tuple_index(tuple.184, index=1, id=201)
  literal.185: bits[1] = literal(value=1, id=185)
  eq.188: bits[1] = eq(literal.187, tuple_index.186, id=188)
  literal.191: bits[1] = literal(value=1, id=191, pos=[(0,1534,15)])
  tuple_index.190: bits[1] = tuple_index(tuple.184, index=1, id=190)
  and.200: bits[1] = and(literal.196, eq.199, id=200)
  eq.203: bits[1] = eq(literal.202, tuple_index.201, id=203)
  and.189: bits[1] = and(literal.185, eq.188, id=189)
  eq.192: bits[1] = eq(literal.191, tuple_index.190, id=192)
  and.204: bits[1] = and(and.200, eq.203, id=204)
  and.193: bits[1] = and(and.189, eq.192, id=193)
  literal.194: bits[1] = literal(value=0, id=194, pos=[(0,1534,32)])
  literal.205: bits[2] = literal(value=1, id=205, pos=[(0,1535,24)])
  bit_slice.206: bits[4] = bit_slice(right, start=0, width=4, id=206, pos=[(0,1535,40)])
  literal.209: bits[1] = literal(value=0, id=209, pos=[(0,1536,13)])
  concat.211: bits[2] = concat(and.204, and.193, id=211)
  concat.195: bits[6] = concat(left, literal.194, id=195, pos=[(0,1534,24)])
  concat.207: bits[6] = concat(literal.205, bit_slice.206, id=207, pos=[(0,1535,24)])
  concat.210: bits[6] = concat(literal.209, left, id=210, pos=[(0,1536,13)])
  N: bits[32] = literal(value=5, id=181, pos=[(0,1532,22)])
  literal.208: bits[1] = literal(value=1, id=208, pos=[(0,1536,8)])
  ret priority_sel.212: bits[6] = priority_sel(concat.211, cases=[concat.195, concat.207], default=concat.210, id=212)
}

fn __std__clzt_pow2_32(value: bits[32] id=213) -> bits[6] {
  literal.214: bits[32] = literal(value=32, id=214, pos=[(0,1604,20)])
  literal.215: bits[1] = literal(value=1, id=215, pos=[(0,1604,30)])
  bit_slice.218: bits[16] = bit_slice(value, start=16, width=16, id=218, pos=[(0,1605,41)])
  bit_slice.220: bits[16] = bit_slice(value, start=0, width=16, id=220, pos=[(0,1605,72)])
  shrl.216: bits[32] = shrl(literal.214, literal.215, id=216, pos=[(0,1604,20)])
  invoke.219: bits[5] = invoke(bit_slice.218, to_apply=__std__clzt_pow2_16, id=219, pos=[(0,1605,35)])
  invoke.221: bits[5] = invoke(bit_slice.220, to_apply=__std__clzt_pow2_16, id=221, pos=[(0,1605,66)])
  N_HALF: bits[32] = zero_ext(shrl.216, new_bit_count=32, id=217)
  ret invoke.222: bits[6] = invoke(invoke.219, invoke.221, to_apply=__std__combine_clzt_halfs__5, id=222, pos=[(0,1605,22)])
}

fn __std__combine_clzt_halfs__6(left: bits[6] id=223, right: bits[6] id=224) -> bits[7] {
  bit_slice.226: bits[1] = bit_slice(left, start=5, width=1, id=226, pos=[(0,1533,15)])
  bit_slice.227: bits[1] = bit_slice(right, start=5, width=1, id=227, pos=[(0,1533,27)])
  tuple.228: (bits[1], bits[1]) = tuple(bit_slice.226, bit_slice.227, id=228, pos=[(0,1533,10)])
  literal.242: bits[1] = literal(value=1, id=242, pos=[(0,1535,9)])
  tuple_index.241: bits[1] = tuple_index(tuple.228, index=0, id=241)
  literal.231: bits[1] = literal(value=1, id=231, pos=[(0,1534,9)])
  tuple_index.230: bits[1] = tuple_index(tuple.228, index=0, id=230)
  literal.240: bits[1] = literal(value=1, id=240)
  eq.243: bits[1] = eq(literal.242, tuple_index.241, id=243)
  literal.246: bits[1] = literal(value=0, id=246, pos=[(0,1535,15)])
  tuple_index.245: bits[1] = tuple_index(tuple.228, index=1, id=245)
  literal.229: bits[1] = literal(value=1, id=229)
  eq.232: bits[1] = eq(literal.231, tuple_index.230, id=232)
  literal.235: bits[1] = literal(value=1, id=235, pos=[(0,1534,15)])
  tuple_index.234: bits[1] = tuple_index(tuple.228, index=1, id=234)
  and.244: bits[1] = and(literal.240, eq.243, id=244)
  eq.247: bits[1] = eq(literal.246, tuple_index.245, id=247)
  and.233: bits[1] = and(literal.229, eq.232, id=233)
  eq.236: bits[1] = eq(literal.235, tuple_index.234, id=236)
  and.248: bits[1] = and(and.244, eq.247, id=248)
  and.237: bits[1] = and(and.233, eq.236, id=237)
  literal.238: bits[1] = literal(value=0, id=238, pos=[(0,1534,32)])
  literal.249: bits[2] = literal(value=1, id=249, pos=[(0,1535,24)])
  bit_slice.250: bits[5] = bit_slice(right, start=0, width=5, id=250, pos=[(0,1535,40)])
  literal.253: bits[1] = literal(value=0, id=253, pos=[(0,1536,13)])
  concat.255: bits[2] = concat(and.248, and.237, id=255)
  concat.239: bits[7] = concat(left, literal.238, id=239, pos=[(0,1534,24)])
  concat.251: bits[7] = concat(literal.249, bit_slice.250, id=251, pos=[(0,1535,24)])
  concat.254: bits[7] = concat(literal.253, left, id=254, pos=[(0,1536,13)])
  N: bits[32] = literal(value=6, id=225, pos=[(0,1532,22)])
  literal.252: bits[1] = literal(value=1, id=252, pos=[(0,1536,8)])
  ret priority_sel.256: bits[7] = priority_sel(concat.255, cases=[concat.239, concat.251], default=concat.254, id=256)
}

fn __std__clzt_pow2_64(value: bits[64] id=257) -> bits[7] {
  literal.258: bits[32] = literal(value=64, id=258, pos=[(0,1609,20)])
  literal.259: bits[1] = literal(value=1, id=259, pos=[(0,1609,30)])
  bit_slice.262: bits[32] = bit_slice(value, start=32, width=32, id=262, pos=[(0,1610,41)])
  bit_slice.264: bits[32] = bit_slice(value, start=0, width=32, id=264, pos=[(0,1610,72)])
  shrl.260: bits[32] = shrl(literal.258, literal.259, id=260, pos=[(0,1609,20)])
  invoke.263: bits[6] = invoke(bit_slice.262, to_apply=__std__clzt_pow2_32, id=263, pos=[(0,1610,35)])
  invoke.265: bits[6] = invoke(bit_slice.264, to_apply=__std__clzt_pow2_32, id=265, pos=[(0,1610,66)])
  N_HALF: bits[32] = zero_ext(shrl.260, new_bit_count=32, id=261)
  ret invoke.266: bits[7] = invoke(invoke.263, invoke.265, to_apply=__std__combine_clzt_halfs__6, id=266, pos=[(0,1610,22)])
}

fn __std__combine_clzt_halfs__7(left: bits[7] id=267, right: bits[7] id=268) -> bits[8] {
  bit_slice.270: bits[1] = bit_slice(left, start=6, width=1, id=270, pos=[(0,1533,15)])
  bit_slice.271: bits[1] = bit_slice(right, start=6, width=1, id=271, pos=[(0,1533,27)])
  tuple.272: (bits[1], bits[1]) = tuple(bit_slice.270, bit_slice.271, id=272, pos=[(0,1533,10)])
  literal.286: bits[1] = literal(value=1, id=286, pos=[(0,1535,9)])
  tuple_index.285: bits[1] = tuple_index(tuple.272, index=0, id=285)
  literal.275: bits[1] = literal(value=1, id=275, pos=[(0,1534,9)])
  tuple_index.274: bits[1] = tuple_index(tuple.272, index=0, id=274)
  literal.284: bits[1] = literal(value=1, id=284)
  eq.287: bits[1] = eq(literal.286, tuple_index.285, id=287)
  literal.290: bits[1] = literal(value=0, id=290, pos=[(0,1535,15)])
  tuple_index.289: bits[1] = tuple_index(tuple.272, index=1, id=289)
  literal.273: bits[1] = literal(value=1, id=273)
  eq.276: bits[1] = eq(literal.275, tuple_index.274, id=276)
  literal.279: bits[1] = literal(value=1, id=279, pos=[(0,1534,15)])
  tuple_index.278: bits[1] = tuple_index(tuple.272, index=1, id=278)
  and.288: bits[1] = and(literal.284, eq.287, id=288)
  eq.291: bits[1] = eq(literal.290, tuple_index.289, id=291)
  and.277: bits[1] = and(literal.273, eq.276, id=277)
  eq.280: bits[1] = eq(literal.279, tuple_index.278, id=280)
  and.292: bits[1] = and(and.288, eq.291, id=292)
  and.281: bits[1] = and(and.277, eq.280, id=281)
  literal.282: bits[1] = literal(value=0, id=282, pos=[(0,1534,32)])
  literal.293: bits[2] = literal(value=1, id=293, pos=[(0,1535,24)])
  bit_slice.294: bits[6] = bit_slice(right, start=0, width=6, id=294, pos=[(0,1535,40)])
  literal.297: bits[1] = literal(value=0, id=297, pos=[(0,1536,13)])
  concat.299: bits[2] = concat(and.292, and.281, id=299)
  concat.283: bits[8] = concat(left, literal.282, id=283, pos=[(0,1534,24)])
  concat.295: bits[8] = concat(literal.293, bit_slice.294, id=295, pos=[(0,1535,24)])
  concat.298: bits[8] = concat(literal.297, left, id=298, pos=[(0,1536,13)])
  N: bits[32] = literal(value=7, id=269, pos=[(0,1532,22)])
  literal.296: bits[1] = literal(value=1, id=296, pos=[(0,1536,8)])
  ret priority_sel.300: bits[8] = priority_sel(concat.299, cases=[concat.283, concat.295], default=concat.298, id=300)
}

fn __std__clzt_pow2_128(value: bits[128] id=301) -> bits[8] {
  literal.302: bits[32] = literal(value=128, id=302, pos=[(0,1614,20)])
  literal.303: bits[1] = literal(value=1, id=303, pos=[(0,1614,31)])
  bit_slice.306: bits[64] = bit_slice(value, start=64, width=64, id=306, pos=[(0,1615,41)])
  bit_slice.308: bits[64] = bit_slice(value, start=0, width=64, id=308, pos=[(0,1615,72)])
  shrl.304: bits[32] = shrl(literal.302, literal.303, id=304, pos=[(0,1614,20)])
  invoke.307: bits[7] = invoke(bit_slice.306, to_apply=__std__clzt_pow2_64, id=307, pos=[(0,1615,35)])
  invoke.309: bits[7] = invoke(bit_slice.308, to_apply=__std__clzt_pow2_64, id=309, pos=[(0,1615,66)])
  N_HALF: bits[32] = zero_ext(shrl.304, new_bit_count=32, id=305)
  ret invoke.310: bits[8] = invoke(invoke.307, invoke.309, to_apply=__std__combine_clzt_halfs__7, id=310, pos=[(0,1615,22)])
}

fn __std__combine_clzt_halfs__8(left: bits[8] id=311, right: bits[8] id=312) -> bits[9] {
  bit_slice.314: bits[1] = bit_slice(left, start=7, width=1, id=314, pos=[(0,1533,15)])
  bit_slice.315: bits[1] = bit_slice(right, start=7, width=1, id=315, pos=[(0,1533,27)])
  tuple.316: (bits[1], bits[1]) = tuple(bit_slice.314, bit_slice.315, id=316, pos=[(0,1533,10)])
  literal.330: bits[1] = literal(value=1, id=330, pos=[(0,1535,9)])
  tuple_index.329: bits[1] = tuple_index(tuple.316, index=0, id=329)
  literal.319: bits[1] = literal(value=1, id=319, pos=[(0,1534,9)])
  tuple_index.318: bits[1] = tuple_index(tuple.316, index=0, id=318)
  literal.328: bits[1] = literal(value=1, id=328)
  eq.331: bits[1] = eq(literal.330, tuple_index.329, id=331)
  literal.334: bits[1] = literal(value=0, id=334, pos=[(0,1535,15)])
  tuple_index.333: bits[1] = tuple_index(tuple.316, index=1, id=333)
  literal.317: bits[1] = literal(value=1, id=317)
  eq.320: bits[1] = eq(literal.319, tuple_index.318, id=320)
  literal.323: bits[1] = literal(value=1, id=323, pos=[(0,1534,15)])
  tuple_index.322: bits[1] = tuple_index(tuple.316, index=1, id=322)
  and.332: bits[1] = and(literal.328, eq.331, id=332)
  eq.335: bits[1] = eq(literal.334, tuple_index.333, id=335)
  and.321: bits[1] = and(literal.317, eq.320, id=321)
  eq.324: bits[1] = eq(literal.323, tuple_index.322, id=324)
  and.336: bits[1] = and(and.332, eq.335, id=336)
  and.325: bits[1] = and(and.321, eq.324, id=325)
  literal.326: bits[1] = literal(value=0, id=326, pos=[(0,1534,32)])
  literal.337: bits[2] = literal(value=1, id=337, pos=[(0,1535,24)])
  bit_slice.338: bits[7] = bit_slice(right, start=0, width=7, id=338, pos=[(0,1535,40)])
  literal.341: bits[1] = literal(value=0, id=341, pos=[(0,1536,13)])
  concat.343: bits[2] = concat(and.336, and.325, id=343)
  concat.327: bits[9] = concat(left, literal.326, id=327, pos=[(0,1534,24)])
  concat.339: bits[9] = concat(literal.337, bit_slice.338, id=339, pos=[(0,1535,24)])
  concat.342: bits[9] = concat(literal.341, left, id=342, pos=[(0,1536,13)])
  N: bits[32] = literal(value=8, id=313, pos=[(0,1532,22)])
  literal.340: bits[1] = literal(value=1, id=340, pos=[(0,1536,8)])
  ret priority_sel.344: bits[9] = priority_sel(concat.343, cases=[concat.327, concat.339], default=concat.342, id=344)
}

top fn __std__clzt_pow2_256(value: bits[256] id=345) -> bits[9] {
  literal.346: bits[32] = literal(value=256, id=346, pos=[(0,1619,20)])
  literal.347: bits[1] = literal(value=1, id=347, pos=[(0,1619,31)])
  bit_slice.350: bits[128] = bit_slice(value, start=128, width=128, id=350, pos=[(0,1620,42)])
  bit_slice.352: bits[128] = bit_slice(value, start=0, width=128, id=352, pos=[(0,1620,74)])
  shrl.348: bits[32] = shrl(literal.346, literal.347, id=348, pos=[(0,1619,20)])
  invoke.351: bits[8] = invoke(bit_slice.350, to_apply=__std__clzt_pow2_128, id=351, pos=[(0,1620,36)])
  invoke.353: bits[8] = invoke(bit_slice.352, to_apply=__std__clzt_pow2_128, id=353, pos=[(0,1620,68)])
  N_HALF: bits[32] = zero_ext(shrl.348, new_bit_count=32, id=349)
  ret invoke.354: bits[9] = invoke(invoke.351, invoke.353, to_apply=__std__combine_clzt_halfs__8, id=354, pos=[(0,1620,22)])
}