Upload 105 files

README.md

@@ -1,3 +1,32 @@
----
-license: other
----
+Model Card for vicuna-Wizard-7B-Uncensored-q3f16_0
+Model Description
+
+Note: Unlike the PC version, the Android MLC-LLM distribution does not have an option to edit the prompt configuration. This may result in unexpected responses.
+
+This Language Model (vicuna-Wizard-7B-Uncensored-q3f16_0) is based on Facebook's "Llama" 7B parameter model, trained on the Wizard-Vicuna uncensored dataset under a non-commercial license. It was specifically developed and formatted for use within the MLC-LLM project, which you can find more details about at MLC-LLM project URL.
+
+The model is designed for research and general text generation purposes. Thanks to MLC-LLM's Vulkan compatibility, the model is capable of working on both Nvidia and AMD graphics cards.
+
+Model Usage
+The vicuna-Wizard-7B-Uncensored-q3f16_0 model can generate human-like text that's useful for a variety of purposes, including but not limited to research, chatbots, writing aids, and more. You can use the model through MLC-LLM chat by copying it to the mlc-chat/dist folder of a compile MLC-Chat client.
+
+Limitations and Bias
+Although the model is capable of generating high-quality text, it is important to note that it is not perfect. Here are some potential limitations and biases:
+
+Output quality: Although trained on a large dataset, the model may occasionally produce text that is nonsensical or does not align with the input prompt.
+
+Biases in the data: The model has been trained on the Wizard-Vicuna uncensored dataset, and as such, it may have inherited biases present in this data. Despite our best efforts to minimize this, it may reflect biases in terms of gender, race, age, or other aspects.
+
+Safety and content: The uncensored nature of the training dataset means that the model could potentially produce text that some people find offensive, inappropriate, or politically biased. We recommend using this model with care, especially in environments with young users or those who might be affected by such content.
+
+Incorrect information: The model generates text based on patterns it learned during training and does not have access to real-world knowledge or updates beyond its training cut-off. As a result, the information it provides should always be verified for accuracy.
+
+Ethical Considerations and Safety
+While using this model, consider the following:
+
+Always verify the information provided by the model with reliable external sources before using it to make decisions or for factual reference.
+Monitor the output of the model for any potentially inappropriate or harmful content, especially if it is being used in a public or sensitive setting.
+Keep in mind the potential biases inherited from the training data and account for these when interpreting the output.
+Disclaimer
+This model is provided as-is, and the developers make no warranties regarding its performance, appropriateness, or accuracy. Use it at your own risk.
+license: othertions](https://mlc.ai/mlc-llm/docs/tutorials/runtime/cpp.html) for details.

debug/mod_tir_dynamic.py

@@ -0,0 +1,640 @@
+
+from tvm.script import ir as I
+from tvm.script import tir as T
+
+# fmt: off
+# from tvm.script import ir as I
+# from tvm.script import tir as T
+
+@I.ir_module
+class Module:
+    @T.prim_func
+    def extend_te(var_A: T.handle, var_concat_te: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), T.int64(1), n, n), "float16")
+        m = T.int64()
+        concat_te = T.match_buffer(var_concat_te, (T.int64(1), T.int64(1), n, m), "float16")
+        # with T.block("root"):
+        for b, _, i, j in T.grid(T.int64(1), T.int64(1), n, m):
+            with T.block("concat_te"):
+                v_b, v__, v_i, v_j = T.axis.remap("SSSS", [b, _, i, j])
+                T.reads(A[v_b, v__, v_i, v_j + n - m])
+                T.writes(concat_te[v_b, v__, v_i, v_j])
+                concat_te[v_b, v__, v_i, v_j] = T.if_then_else(v_j < m - n, T.float16(65504), A[v_b, v__, v_i, v_j + n - m])
+
+    @T.prim_func
+    def full(var_T_full: T.handle):
+        T.func_attr({"op_pattern": 0, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        T_full = T.match_buffer(var_T_full, (T.int64(1), T.int64(1), T.int64(1), n), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(1), T.int64(1), n):
+            with T.block("T_full"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads()
+                T.writes(T_full[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_full[v_ax0, v_ax1, v_ax2, v_ax3] = T.float16(65504)
+
+    @T.prim_func
+    def fused_NT_matmul1_divide1_maximum_minimum_cast(p_lv28: T.handle, p_lv29: T.handle, p_lv5: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv28 = T.match_buffer(p_lv28, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        m = T.int64()
+        lv29 = T.match_buffer(p_lv29, (T.int64(1), T.int64(32), m, T.int64(128)), "float16")
+        lv5 = T.match_buffer(p_lv5, (T.int64(1), T.int64(1), n, m), "float16")
+        var_compute_intermediate = T.match_buffer(p_output0, (T.int64(1), T.int64(32), n, m))
+        # with T.block("root"):
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), n, m), "float16")
+        var_T_divide_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), n, m), "float16")
+        var_T_maximum_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), n, m), "float16")
+        var_T_minimum_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), n, m), "float16")
+        for i0, i1, i2, i3, k in T.grid(T.int64(1), T.int64(32), n, m, T.int64(128)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_i3, v_k = T.axis.remap("SSSSR", [i0, i1, i2, i3, k])
+                T.reads(lv28[v_i0, v_i1, v_i2, v_k], lv29[v_i0, v_i1, v_i3, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] + lv28[v_i0, v_i1, v_i2, v_k] * lv29[v_i0, v_i1, v_i3, v_k]
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_divide"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                T.writes(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] * T.float16(0.088397790055248615)
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_maximum"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                T.writes(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = T.max(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], T.float16(-65504))
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_minimum"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], lv5[v_ax0, T.int64(0), v_ax2, v_ax3])
+                T.writes(var_T_minimum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_minimum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = T.min(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], lv5[v_ax0, T.int64(0), v_ax2, v_ax3])
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(var_T_minimum_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.writes(var_compute_intermediate[v_i0, v_i1, v_i2, v_i3])
+                var_compute_intermediate[v_i0, v_i1, v_i2, v_i3] = T.Cast("float32", var_T_minimum_intermediate[v_i0, v_i1, v_i2, v_i3])
+
+    @T.prim_func
+    def fused_NT_matmul4_divide2_maximum1_minimum1_cast3(lv1605: T.Buffer((T.int64(1), T.int64(32), T.int64(1), T.int64(128)), "float16"), p_lv1606: T.handle, p_lv1582: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv1606 = T.match_buffer(p_lv1606, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        lv1582 = T.match_buffer(p_lv1582, (T.int64(1), T.int64(1), T.int64(1), n), "float16")
+        var_compute_intermediate = T.match_buffer(p_output0, (T.int64(1), T.int64(32), T.int64(1), n))
+        # with T.block("root"):
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        var_T_divide_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        var_T_maximum_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        var_T_minimum_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        for i0, i1, i2, i3, k in T.grid(T.int64(1), T.int64(32), T.int64(1), n, T.int64(128)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_i3, v_k = T.axis.remap("SSSSR", [i0, i1, i2, i3, k])
+                T.reads(lv1605[v_i0, v_i1, v_i2, v_k], lv1606[v_i0, v_i1, v_i3, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2, v_i3] + lv1605[v_i0, v_i1, v_i2, v_k] * lv1606[v_i0, v_i1, v_i3, v_k]
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_divide"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                T.writes(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] * T.float16(0.088397790055248615)
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_maximum"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                T.writes(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = T.max(var_T_divide_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], T.float16(-65504))
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_minimum"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], lv1582[v_ax0, T.int64(0), v_ax2, v_ax3])
+                T.writes(var_T_minimum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_minimum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = T.min(var_T_maximum_intermediate[v_ax0, v_ax1, v_ax2, v_ax3], lv1582[v_ax0, T.int64(0), v_ax2, v_ax3])
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(var_T_minimum_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.writes(var_compute_intermediate[v_i0, v_i1, v_i2, v_i3])
+                var_compute_intermediate[v_i0, v_i1, v_i2, v_i3] = T.Cast("float32", var_T_minimum_intermediate[v_i0, v_i1, v_i2, v_i3])
+
+    @T.prim_func
+    def fused_decode1_NT_matmul(lv8: T.Buffer((T.int64(824), T.int64(4096)), "uint16"), lv9: T.Buffer((T.int64(103), T.int64(4096)), "float16"), p_lv6: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv6 = T.match_buffer(p_lv6, (T.int64(1), n, T.int64(4096)), "float16")
+        var_NT_matmul_intermediate = T.match_buffer(p_output0, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        decode = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv8[v_i // T.int64(5), v_j], lv9[v_i // T.int64(40), v_j])
+                T.writes(decode[v_i, v_j])
+                decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv8[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv9[v_i // T.int64(40), v_j]
+        for ax0, ax1 in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1 = T.axis.remap("SS", [ax0, ax1])
+                T.reads(decode[v_ax1, v_ax0])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1])
+                var_T_transpose_intermediate[v_ax0, v_ax1] = decode[v_ax1, v_ax0]
+        for i0, i1, i2, k in T.grid(T.int64(1), n, T.int64(4096), T.int64(4096)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv6[v_i0, v_i1, v_k], var_T_transpose_intermediate[v_i2, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2] + lv6[v_i0, v_i1, v_k] * var_T_transpose_intermediate[v_i2, v_k]
+
+    @T.prim_func
+    def fused_decode1_fused_NT_matmul_add(lv29: T.Buffer((T.int64(824), T.int64(4096)), "uint16"), lv30: T.Buffer((T.int64(103), T.int64(4096)), "float16"), p_lv41: T.handle, p_lv2: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv41 = T.match_buffer(p_lv41, (T.int64(1), n, T.int64(4096)), "float16")
+        lv2 = T.match_buffer(p_lv2, (T.int64(1), n, T.int64(4096)), "float16")
+        p_output0_intermediate = T.match_buffer(p_output0, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        decode = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), n, T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv29[v_i // T.int64(5), v_j], lv30[v_i // T.int64(40), v_j])
+                T.writes(decode[v_i, v_j])
+                decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv29[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv30[v_i // T.int64(40), v_j]
+        for ax0, ax1 in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1 = T.axis.remap("SS", [ax0, ax1])
+                T.reads(decode[v_ax1, v_ax0])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1])
+                var_T_transpose_intermediate[v_ax0, v_ax1] = decode[v_ax1, v_ax0]
+        for i0, i1, i2, k in T.grid(T.int64(1), n, T.int64(4096), T.int64(4096)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv41[v_i0, v_i1, v_k], var_T_transpose_intermediate[v_i2, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2] + lv41[v_i0, v_i1, v_k] * var_T_transpose_intermediate[v_i2, v_k]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("T_add"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv2[v_ax0, v_ax1, v_ax2], var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv2[v_ax0, v_ax1, v_ax2] + var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode2_fused_NT_matmul2_multiply(lv43: T.Buffer((T.int64(824), T.int64(11008)), "uint16"), lv44: T.Buffer((T.int64(103), T.int64(11008)), "float16"), p_lv45: T.handle, p_lv132: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv45 = T.match_buffer(p_lv45, (T.int64(1), n, T.int64(4096)), "float16")
+        lv132 = T.match_buffer(p_lv132, (T.int64(1), n, T.int64(11008)), "float16")
+        p_output0_intermediate = T.match_buffer(p_output0, (T.int64(1), n, T.int64(11008)), "float16")
+        # with T.block("root"):
+        decode = T.alloc_buffer((T.int64(4096), T.int64(11008)), "float16")
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(11008), T.int64(4096)), "float16")
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), n, T.int64(11008)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(11008)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv43[v_i // T.int64(5), v_j], lv44[v_i // T.int64(40), v_j])
+                T.writes(decode[v_i, v_j])
+                decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv43[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv44[v_i // T.int64(40), v_j]
+        for ax0, ax1 in T.grid(T.int64(11008), T.int64(4096)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1 = T.axis.remap("SS", [ax0, ax1])
+                T.reads(decode[v_ax1, v_ax0])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1])
+                var_T_transpose_intermediate[v_ax0, v_ax1] = decode[v_ax1, v_ax0]
+        for i0, i1, i2, k in T.grid(T.int64(1), n, T.int64(11008), T.int64(4096)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv45[v_i0, v_i1, v_k], var_T_transpose_intermediate[v_i2, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2] + lv45[v_i0, v_i1, v_k] * var_T_transpose_intermediate[v_i2, v_k]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(11008)):
+            with T.block("T_multiply"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv132[v_ax0, v_ax1, v_ax2], var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv132[v_ax0, v_ax1, v_ax2] * var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode2_fused_NT_matmul2_silu(lv36: T.Buffer((T.int64(824), T.int64(11008)), "uint16"), lv37: T.Buffer((T.int64(103), T.int64(11008)), "float16"), p_lv45: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv45 = T.match_buffer(p_lv45, (T.int64(1), n, T.int64(4096)), "float16")
+        p_output0_intermediate = T.match_buffer(p_output0, (T.int64(1), n, T.int64(11008)), "float16")
+        # with T.block("root"):
+        decode = T.alloc_buffer((T.int64(4096), T.int64(11008)), "float16")
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(11008), T.int64(4096)), "float16")
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), n, T.int64(11008)), "float16")
+        compute = T.alloc_buffer((T.int64(1), n, T.int64(11008)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(11008)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv36[v_i // T.int64(5), v_j], lv37[v_i // T.int64(40), v_j])
+                T.writes(decode[v_i, v_j])
+                decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv36[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv37[v_i // T.int64(40), v_j]
+        for ax0, ax1 in T.grid(T.int64(11008), T.int64(4096)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1 = T.axis.remap("SS", [ax0, ax1])
+                T.reads(decode[v_ax1, v_ax0])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1])
+                var_T_transpose_intermediate[v_ax0, v_ax1] = decode[v_ax1, v_ax0]
+        for i0, i1, i2, k in T.grid(T.int64(1), n, T.int64(11008), T.int64(4096)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv45[v_i0, v_i1, v_k], var_T_transpose_intermediate[v_i2, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2] + lv45[v_i0, v_i1, v_k] * var_T_transpose_intermediate[v_i2, v_k]
+        for i0, i1, i2 in T.grid(T.int64(1), n, T.int64(11008)):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2 = T.axis.remap("SSS", [i0, i1, i2])
+                T.reads(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                T.writes(compute[v_i0, v_i1, v_i2])
+                compute[v_i0, v_i1, v_i2] = T.sigmoid(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(11008)):
+            with T.block("T_multiply"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2], compute[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2] * compute[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode3_fused_NT_matmul3_add(lv50: T.Buffer((T.int64(2208), T.int64(4096)), "uint16"), lv51: T.Buffer((T.int64(276), T.int64(4096)), "float16"), p_lv5: T.handle, p_lv3: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv5 = T.match_buffer(p_lv5, (T.int64(1), n, T.int64(11008)), "float16")
+        lv3 = T.match_buffer(p_lv3, (T.int64(1), n, T.int64(4096)), "float16")
+        p_output0_intermediate = T.match_buffer(p_output0, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        decode = T.alloc_buffer((T.int64(11008), T.int64(4096)), "float16")
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(4096), T.int64(11008)), "float16")
+        var_NT_matmul_intermediate = T.alloc_buffer((T.int64(1), n, T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(11008), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv50[v_i // T.int64(5), v_j], lv51[v_i // T.int64(40), v_j])
+                T.writes(decode[v_i, v_j])
+                decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv50[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv51[v_i // T.int64(40), v_j]
+        for ax0, ax1 in T.grid(T.int64(4096), T.int64(11008)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1 = T.axis.remap("SS", [ax0, ax1])
+                T.reads(decode[v_ax1, v_ax0])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1])
+                var_T_transpose_intermediate[v_ax0, v_ax1] = decode[v_ax1, v_ax0]
+        for i0, i1, i2, k in T.grid(T.int64(1), n, T.int64(4096), T.int64(11008)):
+            with T.block("NT_matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv5[v_i0, v_i1, v_k], var_T_transpose_intermediate[v_i2, v_k])
+                T.writes(var_NT_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_NT_matmul_intermediate[v_i0, v_i1, v_i2] = var_NT_matmul_intermediate[v_i0, v_i1, v_i2] + lv5[v_i0, v_i1, v_k] * var_T_transpose_intermediate[v_i2, v_k]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("T_add"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv3[v_ax0, v_ax1, v_ax2], var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv3[v_ax0, v_ax1, v_ax2] + var_NT_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_min_max_triu_te_broadcast_to(p_output0: T.handle, n: T.int64):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        var_T_broadcast_to_intermediate = T.match_buffer(p_output0, (T.int64(1), T.int64(1), n, n), "float16")
+        # with T.block("root"):
+        var_make_diag_mask_te_intermediate = T.alloc_buffer((n, n), "float16")
+        for i, j in T.grid(n, n):
+            with T.block("make_diag_mask_te"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads()
+                T.writes(var_make_diag_mask_te_intermediate[v_i, v_j])
+                var_make_diag_mask_te_intermediate[v_i, v_j] = T.Select(v_i < v_j, T.float16(-65504), T.float16(65504))
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(1), n, n):
+            with T.block("T_broadcast_to"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(var_make_diag_mask_te_intermediate[v_ax2, v_ax3])
+                T.writes(var_T_broadcast_to_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_broadcast_to_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = var_make_diag_mask_te_intermediate[v_ax2, v_ax3]
+
+    @T.prim_func
+    def fused_softmax1_cast1(p_lv36: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n, m = T.int64(), T.int64()
+        lv36 = T.match_buffer(p_lv36, (T.int64(1), T.int64(32), n, m))
+        var_compute_intermediate = T.match_buffer(p_output0, (T.int64(1), T.int64(32), n, m), "float16")
+        # with T.block("root"):
+        T_softmax_maxelem = T.alloc_buffer((T.int64(1), T.int64(32), n))
+        T_softmax_exp = T.alloc_buffer((T.int64(1), T.int64(32), n, m))
+        T_softmax_expsum = T.alloc_buffer((T.int64(1), T.int64(32), n))
+        var_T_softmax_norm_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), n, m))
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_softmax_maxelem"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv36[v_i0, v_i1, v_i2, v_k])
+                T.writes(T_softmax_maxelem[v_i0, v_i1, v_i2])
+                with T.init():
+                    T_softmax_maxelem[v_i0, v_i1, v_i2] = T.float32(-3.4028234663852886e+38)
+                T_softmax_maxelem[v_i0, v_i1, v_i2] = T.max(T_softmax_maxelem[v_i0, v_i1, v_i2], lv36[v_i0, v_i1, v_i2, v_k])
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_softmax_exp"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(lv36[v_i0, v_i1, v_i2, v_i3], T_softmax_maxelem[v_i0, v_i1, v_i2])
+                T.writes(T_softmax_exp[v_i0, v_i1, v_i2, v_i3])
+                T_softmax_exp[v_i0, v_i1, v_i2, v_i3] = T.exp(lv36[v_i0, v_i1, v_i2, v_i3] - T_softmax_maxelem[v_i0, v_i1, v_i2])
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_softmax_expsum"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_i2, v_k])
+                T.writes(T_softmax_expsum[v_i0, v_i1, v_i2])
+                with T.init():
+                    T_softmax_expsum[v_i0, v_i1, v_i2] = T.float32(0)
+                T_softmax_expsum[v_i0, v_i1, v_i2] = T_softmax_expsum[v_i0, v_i1, v_i2] + T_softmax_exp[v_i0, v_i1, v_i2, v_k]
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("T_softmax_norm"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_i2, v_i3], T_softmax_expsum[v_i0, v_i1, v_i2])
+                T.writes(var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.block_attr({"axis": 3})
+                var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3] = T_softmax_exp[v_i0, v_i1, v_i2, v_i3] / T_softmax_expsum[v_i0, v_i1, v_i2]
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), n, m):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.writes(var_compute_intermediate[v_i0, v_i1, v_i2, v_i3])
+                var_compute_intermediate[v_i0, v_i1, v_i2, v_i3] = T.Cast("float16", var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+
+    @T.prim_func
+    def fused_softmax2_cast4(p_lv1613: T.handle, p_output0: T.handle):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        n = T.int64()
+        lv1613 = T.match_buffer(p_lv1613, (T.int64(1), T.int64(32), T.int64(1), n))
+        var_compute_intermediate = T.match_buffer(p_output0, (T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        # with T.block("root"):
+        T_softmax_maxelem = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1)))
+        T_softmax_exp = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n))
+        T_softmax_expsum = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1)))
+        var_T_softmax_norm_intermediate = T.alloc_buffer((T.int64(1), T.int64(32), T.int64(1), n))
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_softmax_maxelem"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv1613[v_i0, v_i1, v_i2, v_k])
+                T.writes(T_softmax_maxelem[v_i0, v_i1, v_i2])
+                with T.init():
+                    T_softmax_maxelem[v_i0, v_i1, v_i2] = T.float32(-3.4028234663852886e+38)
+                T_softmax_maxelem[v_i0, v_i1, v_i2] = T.max(T_softmax_maxelem[v_i0, v_i1, v_i2], lv1613[v_i0, v_i1, v_i2, v_k])
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_softmax_exp"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(lv1613[v_i0, v_i1, v_i2, v_i3], T_softmax_maxelem[v_i0, v_i1, v_i2])
+                T.writes(T_softmax_exp[v_i0, v_i1, v_i2, v_i3])
+                T_softmax_exp[v_i0, v_i1, v_i2, v_i3] = T.exp(lv1613[v_i0, v_i1, v_i2, v_i3] - T_softmax_maxelem[v_i0, v_i1, v_i2])
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_softmax_expsum"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_i2, v_k])
+                T.writes(T_softmax_expsum[v_i0, v_i1, v_i2])
+                with T.init():
+                    T_softmax_expsum[v_i0, v_i1, v_i2] = T.float32(0)
+                T_softmax_expsum[v_i0, v_i1, v_i2] = T_softmax_expsum[v_i0, v_i1, v_i2] + T_softmax_exp[v_i0, v_i1, v_i2, v_k]
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("T_softmax_norm"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_i2, v_i3], T_softmax_expsum[v_i0, v_i1, v_i2])
+                T.writes(var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.block_attr({"axis": 3})
+                var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3] = T_softmax_exp[v_i0, v_i1, v_i2, v_i3] / T_softmax_expsum[v_i0, v_i1, v_i2]
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(32), T.int64(1), n):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+                T.writes(var_compute_intermediate[v_i0, v_i1, v_i2, v_i3])
+                var_compute_intermediate[v_i0, v_i1, v_i2, v_i3] = T.Cast("float16", var_T_softmax_norm_intermediate[v_i0, v_i1, v_i2, v_i3])
+
+    @T.prim_func
+    def matmul3(var_A: T.handle, var_B: T.handle, var_matmul: T.handle):
+        T.func_attr({"op_pattern": 4, "tir.noalias": T.bool(True)})
+        n, m = T.int64(), T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), T.int64(32), n, m), "float16")
+        B = T.match_buffer(var_B, (T.int64(1), T.int64(32), m, T.int64(128)), "float16")
+        matmul = T.match_buffer(var_matmul, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        # with T.block("root"):
+        for i0, i1, i2, i3, k in T.grid(T.int64(1), T.int64(32), n, T.int64(128), m):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_i3, v_k = T.axis.remap("SSSSR", [i0, i1, i2, i3, k])
+                T.reads(A[v_i0, v_i1, v_i2, v_k], B[v_i0, v_i1, v_k, v_i3])
+                T.writes(matmul[v_i0, v_i1, v_i2, v_i3])
+                with T.init():
+                    matmul[v_i0, v_i1, v_i2, v_i3] = T.float16(0)
+                matmul[v_i0, v_i1, v_i2, v_i3] = matmul[v_i0, v_i1, v_i2, v_i3] + A[v_i0, v_i1, v_i2, v_k] * B[v_i0, v_i1, v_k, v_i3]
+
+    @T.prim_func
+    def matmul8(var_A: T.handle, var_B: T.handle, matmul: T.Buffer((T.int64(1), T.int64(32), T.int64(1), T.int64(128)), "float16")):
+        T.func_attr({"op_pattern": 4, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), T.int64(32), T.int64(1), n), "float16")
+        B = T.match_buffer(var_B, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        # with T.block("root"):
+        for i0, i1, i2, i3, k in T.grid(T.int64(1), T.int64(32), T.int64(1), T.int64(128), n):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_i3, v_k = T.axis.remap("SSSSR", [i0, i1, i2, i3, k])
+                T.reads(A[v_i0, v_i1, v_i2, v_k], B[v_i0, v_i1, v_k, v_i3])
+                T.writes(matmul[v_i0, v_i1, v_i2, v_i3])
+                with T.init():
+                    matmul[v_i0, v_i1, v_i2, v_i3] = T.float16(0)
+                matmul[v_i0, v_i1, v_i2, v_i3] = matmul[v_i0, v_i1, v_i2, v_i3] + A[v_i0, v_i1, v_i2, v_k] * B[v_i0, v_i1, v_k, v_i3]
+
+    @T.prim_func
+    def reshape(var_A: T.handle, var_T_reshape: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n), "int32")
+        T_reshape = T.match_buffer(var_T_reshape, (n,), "int32")
+        # with T.block("root"):
+        for ax0 in range(n):
+            with T.block("T_reshape"):
+                v_ax0 = T.axis.spatial(n, ax0)
+                T.reads(A[T.int64(0), v_ax0 % n])
+                T.writes(T_reshape[v_ax0])
+                T_reshape[v_ax0] = A[T.int64(0), v_ax0 % n]
+
+    @T.prim_func
+    def reshape1(var_A: T.handle, var_T_reshape: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (n, T.int64(4096)), "float16")
+        T_reshape = T.match_buffer(var_T_reshape, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[(v_ax2 // T.int64(4096) + v_ax0 * n + v_ax1) % n, v_ax2 % T.int64(4096)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2])
+                T_reshape[v_ax0, v_ax1, v_ax2] = A[(v_ax2 // T.int64(4096) + v_ax0 * n + v_ax1) % n, v_ax2 % T.int64(4096)]
+
+    @T.prim_func
+    def reshape2(var_A: T.handle, var_T_reshape: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(4096)), "float16")
+        T_reshape = T.match_buffer(var_T_reshape, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), n, T.int64(32), T.int64(128)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[T.int64(0), ((v_ax2 * T.int64(128) + v_ax3) // T.int64(4096) + v_ax0 * n + v_ax1) % n, (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_reshape[v_ax0, v_ax1, v_ax2, v_ax3] = A[T.int64(0), ((v_ax2 * T.int64(128) + v_ax3) // T.int64(4096) + v_ax0 * n + v_ax1) % n, (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)]
+
+    @T.prim_func
+    def reshape3(var_A: T.handle, var_T_reshape: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        m = T.int64()
+        A = T.match_buffer(var_A, (m, T.int64(32), T.int64(128)), "float16")
+        T_reshape = T.match_buffer(var_T_reshape, (T.int64(1), m, T.int64(32), T.int64(128)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), m, T.int64(32), T.int64(128)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[((v_ax3 // T.int64(128) + v_ax2) // T.int64(32) + v_ax0 * m + v_ax1) % m, (v_ax3 // T.int64(128) + v_ax2) % T.int64(32), v_ax3 % T.int64(128)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_reshape[v_ax0, v_ax1, v_ax2, v_ax3] = A[((v_ax3 // T.int64(128) + v_ax2) // T.int64(32) + v_ax0 * m + v_ax1) % m, (v_ax3 // T.int64(128) + v_ax2) % T.int64(32), v_ax3 % T.int64(128)]
+
+    @T.prim_func
+    def reshape4(var_A: T.handle, var_T_reshape: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        T_reshape = T.match_buffer(var_T_reshape, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[T.int64(0), (v_ax2 // T.int64(4096) + v_ax0 * n + v_ax1) % n, v_ax2 % T.int64(4096) // T.int64(128), v_ax2 % T.int64(128)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2])
+                T_reshape[v_ax0, v_ax1, v_ax2] = A[T.int64(0), (v_ax2 // T.int64(4096) + v_ax0 * n + v_ax1) % n, v_ax2 % T.int64(4096) // T.int64(128), v_ax2 % T.int64(128)]
+
+    @T.prim_func
+    def rms_norm(var_A: T.handle, B: T.Buffer((T.int64(4096),), "float16"), var_rms_norm: T.handle):
+        T.func_attr({"op_pattern": 4, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(4096)), "float16")
+        rms_norm_1 = T.match_buffer(var_rms_norm, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        Ared_temp = T.alloc_buffer((T.int64(1), n))
+        for bsz, i, k in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("Ared_temp"):
+                v_bsz, v_i, v_k = T.axis.remap("SSR", [bsz, i, k])
+                T.reads(A[v_bsz, v_i, v_k])
+                T.writes(Ared_temp[v_bsz, v_i])
+                with T.init():
+                    Ared_temp[v_bsz, v_i] = T.float32(0)
+                Ared_temp[v_bsz, v_i] = Ared_temp[v_bsz, v_i] + T.Cast("float32", A[v_bsz, v_i, v_k]) * T.Cast("float32", A[v_bsz, v_i, v_k])
+        for bsz, i, k in T.grid(T.int64(1), n, T.int64(4096)):
+            with T.block("rms_norm"):
+                v_bsz, v_i, v_k = T.axis.remap("SSS", [bsz, i, k])
+                T.reads(B[v_k], A[v_bsz, v_i, v_k], Ared_temp[v_bsz, v_i])
+                T.writes(rms_norm_1[v_bsz, v_i, v_k])
+                rms_norm_1[v_bsz, v_i, v_k] = T.Cast("float16", T.Cast("float32", B[v_k]) * (T.Cast("float32", A[v_bsz, v_i, v_k]) / T.sqrt(Ared_temp[v_bsz, v_i] * T.float32(0.000244140625) + T.float32(9.9999999999999995e-07))))
+
+    @T.prim_func
+    def rotary_embedding(var_A: T.handle, B: T.Buffer((T.int64(2048), T.int64(128)), "float16"), C: T.Buffer((T.int64(2048), T.int64(128)), "float16"), var_rotary: T.handle, m: T.int64):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        rotary = T.match_buffer(var_rotary, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        # with T.block("root"):
+        for i0, i1, i2, i3 in T.grid(T.int64(1), n, T.int64(32), T.int64(128)):
+            with T.block("rotary"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(B[m + v_i1 - n, v_i3], A[v_i0, v_i1, v_i2, v_i3 - T.int64(64):v_i3 - T.int64(64) + T.int64(129)], C[m + v_i1 - n, v_i3])
+                T.writes(rotary[v_i0, v_i1, v_i2, v_i3])
+                rotary[v_i0, v_i1, v_i2, v_i3] = B[m + v_i1 - n, v_i3] * A[v_i0, v_i1, v_i2, v_i3] + C[m + v_i1 - n, v_i3] * T.Select(T.int64(64) <= v_i3, A[v_i0, v_i1, v_i2, v_i3 - T.int64(64)], A[v_i0, v_i1, v_i2, v_i3 + T.int64(64)] * T.float16(-1))
+
+    @T.prim_func
+    def slice(var_A: T.handle, slice_1: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        for i, j, k in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("slice"):
+                v_i, v_j, v_k = T.axis.remap("SSS", [i, j, k])
+                T.reads(A[v_i, n - T.int64(1), v_k])
+                T.writes(slice_1[v_i, v_j, v_k])
+                slice_1[v_i, v_j, v_k] = A[v_i, n - T.int64(1), v_k]
+
+    @T.prim_func
+    def squeeze(var_A: T.handle, var_T_squeeze: T.handle):
+        T.func_attr({"op_pattern": 1, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        T_squeeze = T.match_buffer(var_T_squeeze, (n, T.int64(32), T.int64(128)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(n, T.int64(32), T.int64(128)):
+            with T.block("T_squeeze"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[T.int64(0), v_ax0, v_ax1, v_ax2])
+                T.writes(T_squeeze[v_ax0, v_ax1, v_ax2])
+                T_squeeze[v_ax0, v_ax1, v_ax2] = A[T.int64(0), v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def take_decode(A: T.Buffer((T.int64(32000), T.int64(824)), "uint16"), B: T.Buffer((T.int64(32000), T.int64(103)), "float16"), var_C: T.handle, var_take_decode: T.handle):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        C = T.match_buffer(var_C, (n,), "int32")
+        take_decode_1 = T.match_buffer(var_take_decode, (n, T.int64(4096)), "float16")
+        # with T.block("root"):
+        for i, j in T.grid(n, T.int64(4096)):
+            with T.block("take_decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(A[C[v_i], v_j // T.int64(5)], C[v_i], B[C[v_i], v_j // T.int64(40)])
+                T.writes(take_decode_1[v_i, v_j])
+                take_decode_1[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", A[C[v_i], v_j // T.int64(5)]), T.Cast("uint32", v_j % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * B[C[v_i], v_j // T.int64(40)]
+
+    @T.prim_func
+    def transpose3(var_A: T.handle, var_T_transpose: T.handle):
+        T.func_attr({"op_pattern": 2, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        T_transpose = T.match_buffer(var_T_transpose, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), n, T.int64(128)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[v_ax0, v_ax2, v_ax1, v_ax3])
+                T.writes(T_transpose[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_transpose[v_ax0, v_ax1, v_ax2, v_ax3] = A[v_ax0, v_ax2, v_ax1, v_ax3]
+
+    @T.prim_func
+    def transpose4(var_A: T.handle, var_T_transpose: T.handle):
+        T.func_attr({"op_pattern": 2, "tir.noalias": T.bool(True)})
+        n = T.int64()
+        A = T.match_buffer(var_A, (T.int64(1), T.int64(32), n, T.int64(128)), "float16")
+        T_transpose = T.match_buffer(var_T_transpose, (T.int64(1), n, T.int64(32), T.int64(128)), "float16")
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), n, T.int64(32), T.int64(128)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[v_ax0, v_ax2, v_ax1, v_ax3])
+                T.writes(T_transpose[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_transpose[v_ax0, v_ax1, v_ax2, v_ax3] = A[v_ax0, v_ax2, v_ax1, v_ax3]
+# fmt: on

debug/mod_tir_static.py

@@ -0,0 +1,364 @@
+
+from tvm.script import ir as I
+from tvm.script import tir as T
+
+# fmt: off
+# from tvm.script import ir as I
+# from tvm.script import tir as T
+
+@I.ir_module
+class Module:
+    @T.prim_func
+    def divide(A: T.Buffer((T.int64(1), T.int64(1), T.int64(32000)), "float32"), B: T.Buffer((), "float32"), T_divide: T.Buffer((T.int64(1), T.int64(1), T.int64(32000)), "float32")):
+        T.func_attr({"op_pattern": 0, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("T_divide"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[v_ax0, v_ax1, v_ax2], B[()])
+                T.writes(T_divide[v_ax0, v_ax1, v_ax2])
+                T_divide[v_ax0, v_ax1, v_ax2] = A[v_ax0, v_ax1, v_ax2] / B[()]
+
+    @T.prim_func
+    def fused_decode4_fused_matmul4_cast2(lv2931: T.Buffer((T.int64(824), T.int64(32000)), "uint16"), lv2932: T.Buffer((T.int64(103), T.int64(32000)), "float16"), lv3152: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), p_output0_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(32000)), "float32")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(4096), T.int64(32000)), "float16")
+        var_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(32000)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(32000)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv2931[v_i // T.int64(5), v_j], lv2932[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv2931[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv2932[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(32000), T.int64(4096)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv3152[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv3152[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+        for i0, i1, i2 in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2 = T.axis.remap("SSS", [i0, i1, i2])
+                T.reads(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                T.writes(p_output0_intermediate[v_i0, v_i1, v_i2])
+                p_output0_intermediate[v_i0, v_i1, v_i2] = T.Cast("float32", var_matmul_intermediate[v_i0, v_i1, v_i2])
+
+    @T.prim_func
+    def fused_decode5_fused_matmul7_add1(lv1605: T.Buffer((T.int64(824), T.int64(4096)), "uint16"), lv1606: T.Buffer((T.int64(103), T.int64(4096)), "float16"), lv197: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), lv1581: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), p_output0_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        var_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv1605[v_i // T.int64(5), v_j], lv1606[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv1605[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv1606[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(4096), T.int64(4096)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv197[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv197[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("T_add"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv1581[v_ax0, v_ax1, v_ax2], var_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv1581[v_ax0, v_ax1, v_ax2] + var_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode5_matmul7(lv1587: T.Buffer((T.int64(824), T.int64(4096)), "uint16"), lv1588: T.Buffer((T.int64(103), T.int64(4096)), "float16"), lv1583: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), var_matmul_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(4096), T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv1587[v_i // T.int64(5), v_j], lv1588[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv1587[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv1588[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(4096), T.int64(4096)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv1583[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv1583[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+
+    @T.prim_func
+    def fused_decode6_fused_matmul9_multiply1(lv1617: T.Buffer((T.int64(824), T.int64(11008)), "uint16"), lv1618: T.Buffer((T.int64(103), T.int64(11008)), "float16"), lv1622: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), lv3: T.Buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16"), p_output0_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(4096), T.int64(11008)), "float16")
+        var_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(11008)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv1617[v_i // T.int64(5), v_j], lv1618[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv1617[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv1618[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(11008), T.int64(4096)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv1622[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv1622[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(11008)):
+            with T.block("T_multiply"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv3[v_ax0, v_ax1, v_ax2], var_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv3[v_ax0, v_ax1, v_ax2] * var_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode6_fused_matmul9_silu1(lv1611: T.Buffer((T.int64(824), T.int64(11008)), "uint16"), lv1612: T.Buffer((T.int64(103), T.int64(11008)), "float16"), lv1622: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), p_output0_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(4096), T.int64(11008)), "float16")
+        var_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16")
+        compute = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16")
+        for i, j in T.grid(T.int64(4096), T.int64(11008)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv1611[v_i // T.int64(5), v_j], lv1612[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv1611[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv1612[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(11008), T.int64(4096)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv1622[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv1622[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+        for i0, i1, i2 in T.grid(T.int64(1), T.int64(1), T.int64(11008)):
+            with T.block("compute"):
+                v_i0, v_i1, v_i2 = T.axis.remap("SSS", [i0, i1, i2])
+                T.reads(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                T.writes(compute[v_i0, v_i1, v_i2])
+                compute[v_i0, v_i1, v_i2] = T.sigmoid(var_matmul_intermediate[v_i0, v_i1, v_i2])
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(11008)):
+            with T.block("T_multiply"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(var_matmul_intermediate[v_ax0, v_ax1, v_ax2], compute[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = var_matmul_intermediate[v_ax0, v_ax1, v_ax2] * compute[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_decode7_fused_matmul10_add1(lv1623: T.Buffer((T.int64(2208), T.int64(4096)), "uint16"), lv1624: T.Buffer((T.int64(276), T.int64(4096)), "float16"), lv200: T.Buffer((T.int64(1), T.int64(1), T.int64(11008)), "float16"), lv198: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), p_output0_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_decode_intermediate = T.alloc_buffer((T.int64(11008), T.int64(4096)), "float16")
+        var_matmul_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")
+        for i, j in T.grid(T.int64(11008), T.int64(4096)):
+            with T.block("decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(lv1623[v_i // T.int64(5), v_j], lv1624[v_i // T.int64(40), v_j])
+                T.writes(var_decode_intermediate[v_i, v_j])
+                var_decode_intermediate[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", lv1623[v_i // T.int64(5), v_j]), T.Cast("uint32", v_i % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * lv1624[v_i // T.int64(40), v_j]
+        for i0, i1, i2, k in T.grid(T.int64(1), T.int64(1), T.int64(4096), T.int64(11008)):
+            with T.block("matmul"):
+                v_i0, v_i1, v_i2, v_k = T.axis.remap("SSSR", [i0, i1, i2, k])
+                T.reads(lv200[v_i0, v_i1, v_k], var_decode_intermediate[v_k, v_i2])
+                T.writes(var_matmul_intermediate[v_i0, v_i1, v_i2])
+                with T.init():
+                    var_matmul_intermediate[v_i0, v_i1, v_i2] = T.float16(0)
+                var_matmul_intermediate[v_i0, v_i1, v_i2] = var_matmul_intermediate[v_i0, v_i1, v_i2] + lv200[v_i0, v_i1, v_k] * var_decode_intermediate[v_k, v_i2]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("T_add"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(lv198[v_ax0, v_ax1, v_ax2], var_matmul_intermediate[v_ax0, v_ax1, v_ax2])
+                T.writes(p_output0_intermediate[v_ax0, v_ax1, v_ax2])
+                p_output0_intermediate[v_ax0, v_ax1, v_ax2] = lv198[v_ax0, v_ax1, v_ax2] + var_matmul_intermediate[v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_reshape7_squeeze1(lv1591: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), var_T_squeeze_intermediate: T.Buffer((T.int64(1), T.int64(32), T.int64(128)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_T_reshape_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16")
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(lv1591[T.int64(0), T.int64(0), (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)])
+                T.writes(var_T_reshape_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_reshape_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = lv1591[T.int64(0), T.int64(0), (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("T_squeeze"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(var_T_reshape_intermediate[T.int64(0), v_ax0, v_ax1, v_ax2])
+                T.writes(var_T_squeeze_intermediate[v_ax0, v_ax1, v_ax2])
+                var_T_squeeze_intermediate[v_ax0, v_ax1, v_ax2] = var_T_reshape_intermediate[T.int64(0), v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def fused_transpose7_reshape8(lv1616: T.Buffer((T.int64(1), T.int64(32), T.int64(1), T.int64(128)), "float16"), var_T_reshape_intermediate: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        var_T_transpose_intermediate = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16")
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(lv1616[v_ax0, v_ax2, v_ax1, v_ax3])
+                T.writes(var_T_transpose_intermediate[v_ax0, v_ax1, v_ax2, v_ax3])
+                var_T_transpose_intermediate[v_ax0, v_ax1, v_ax2, v_ax3] = lv1616[v_ax0, v_ax2, v_ax1, v_ax3]
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(var_T_transpose_intermediate[T.int64(0), T.int64(0), v_ax2 % T.int64(4096) // T.int64(128), v_ax2 % T.int64(128)])
+                T.writes(var_T_reshape_intermediate[v_ax0, v_ax1, v_ax2])
+                var_T_reshape_intermediate[v_ax0, v_ax1, v_ax2] = var_T_transpose_intermediate[T.int64(0), T.int64(0), v_ax2 % T.int64(4096) // T.int64(128), v_ax2 % T.int64(128)]
+
+    @T.prim_func
+    def reshape5(A: T.Buffer((T.int64(1), T.int64(1)), "int32"), T_reshape: T.Buffer((T.int64(1),), "int32")):
+        T.func_attr({"op_pattern": 1, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0 in range(T.int64(1)):
+            with T.block("T_reshape"):
+                v_ax0 = T.axis.spatial(T.int64(1), ax0)
+                T.reads(A[T.int64(0), T.int64(0)])
+                T.writes(T_reshape[v_ax0])
+                T_reshape[v_ax0] = A[T.int64(0), T.int64(0)]
+
+    @T.prim_func
+    def reshape6(A: T.Buffer((T.int64(1), T.int64(4096)), "float16"), T_reshape: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"op_pattern": 2, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[T.int64(0), v_ax2 % T.int64(4096)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2])
+                T_reshape[v_ax0, v_ax1, v_ax2] = A[T.int64(0), v_ax2 % T.int64(4096)]
+
+    @T.prim_func
+    def reshape7(A: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), T_reshape: T.Buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16")):
+        T.func_attr({"op_pattern": 2, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("T_reshape"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[T.int64(0), T.int64(0), (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)])
+                T.writes(T_reshape[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_reshape[v_ax0, v_ax1, v_ax2, v_ax3] = A[T.int64(0), T.int64(0), (v_ax2 * T.int64(128) + v_ax3) % T.int64(4096)]
+
+    @T.prim_func
+    def rms_norm1(A: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), B: T.Buffer((T.int64(4096),), "float16"), rms_norm: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"op_pattern": 4, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        Ared_temp = T.alloc_buffer((T.int64(1), T.int64(1)))
+        for bsz, i, k in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("Ared_temp"):
+                v_bsz, v_i, v_k = T.axis.remap("SSR", [bsz, i, k])
+                T.reads(A[v_bsz, v_i, v_k])
+                T.writes(Ared_temp[v_bsz, v_i])
+                with T.init():
+                    Ared_temp[v_bsz, v_i] = T.float32(0)
+                Ared_temp[v_bsz, v_i] = Ared_temp[v_bsz, v_i] + T.Cast("float32", A[v_bsz, v_i, v_k]) * T.Cast("float32", A[v_bsz, v_i, v_k])
+        for bsz, i, k in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("rms_norm"):
+                v_bsz, v_i, v_k = T.axis.remap("SSS", [bsz, i, k])
+                T.reads(B[v_k], A[v_bsz, v_i, v_k], Ared_temp[v_bsz, v_i])
+                T.writes(rms_norm[v_bsz, v_i, v_k])
+                rms_norm[v_bsz, v_i, v_k] = T.Cast("float16", T.Cast("float32", B[v_k]) * (T.Cast("float32", A[v_bsz, v_i, v_k]) / T.sqrt(Ared_temp[v_bsz, v_i] * T.float32(0.000244140625) + T.float32(9.9999999999999995e-07))))
+
+    @T.prim_func
+    def rotary_embedding1(A: T.Buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16"), B: T.Buffer((T.int64(2048), T.int64(128)), "float16"), C: T.Buffer((T.int64(2048), T.int64(128)), "float16"), rotary: T.Buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16"), n: T.int64):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for i0, i1, i2, i3 in T.grid(T.int64(1), T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("rotary"):
+                v_i0, v_i1, v_i2, v_i3 = T.axis.remap("SSSS", [i0, i1, i2, i3])
+                T.reads(B[n + v_i1 - T.int64(1), v_i3], A[v_i0, v_i1, v_i2, v_i3 - T.int64(64):v_i3 - T.int64(64) + T.int64(129)], C[n + v_i1 - T.int64(1), v_i3])
+                T.writes(rotary[v_i0, v_i1, v_i2, v_i3])
+                rotary[v_i0, v_i1, v_i2, v_i3] = B[n + v_i1 - T.int64(1), v_i3] * A[v_i0, v_i1, v_i2, v_i3] + C[n + v_i1 - T.int64(1), v_i3] * T.Select(T.int64(64) <= v_i3, A[v_i0, v_i1, v_i2, v_i3 - T.int64(64)], A[v_i0, v_i1, v_i2, v_i3 + T.int64(64)] * T.float16(-1))
+
+    @T.prim_func
+    def slice1(A: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16"), slice: T.Buffer((T.int64(1), T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"op_pattern": 1, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for i, j, k in T.grid(T.int64(1), T.int64(1), T.int64(4096)):
+            with T.block("slice"):
+                v_i, v_j, v_k = T.axis.remap("SSS", [i, j, k])
+                T.reads(A[v_i, T.int64(0), v_k])
+                T.writes(slice[v_i, v_j, v_k])
+                slice[v_i, v_j, v_k] = A[v_i, T.int64(0), v_k]
+
+    @T.prim_func
+    def softmax(A: T.Buffer((T.int64(1), T.int64(1), T.int64(32000)), "float32"), T_softmax_norm: T.Buffer((T.int64(1), T.int64(1), T.int64(32000)), "float32")):
+        T.func_attr({"op_pattern": 4, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        T_softmax_maxelem = T.alloc_buffer((T.int64(1), T.int64(1)))
+        T_softmax_exp = T.alloc_buffer((T.int64(1), T.int64(1), T.int64(32000)))
+        T_softmax_expsum = T.alloc_buffer((T.int64(1), T.int64(1)))
+        for i0, i1, k in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("T_softmax_maxelem"):
+                v_i0, v_i1, v_k = T.axis.remap("SSR", [i0, i1, k])
+                T.reads(A[v_i0, v_i1, v_k])
+                T.writes(T_softmax_maxelem[v_i0, v_i1])
+                with T.init():
+                    T_softmax_maxelem[v_i0, v_i1] = T.float32(-3.4028234663852886e+38)
+                T_softmax_maxelem[v_i0, v_i1] = T.max(T_softmax_maxelem[v_i0, v_i1], A[v_i0, v_i1, v_k])
+        for i0, i1, i2 in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("T_softmax_exp"):
+                v_i0, v_i1, v_i2 = T.axis.remap("SSS", [i0, i1, i2])
+                T.reads(A[v_i0, v_i1, v_i2], T_softmax_maxelem[v_i0, v_i1])
+                T.writes(T_softmax_exp[v_i0, v_i1, v_i2])
+                T_softmax_exp[v_i0, v_i1, v_i2] = T.exp(A[v_i0, v_i1, v_i2] - T_softmax_maxelem[v_i0, v_i1])
+        for i0, i1, k in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("T_softmax_expsum"):
+                v_i0, v_i1, v_k = T.axis.remap("SSR", [i0, i1, k])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_k])
+                T.writes(T_softmax_expsum[v_i0, v_i1])
+                with T.init():
+                    T_softmax_expsum[v_i0, v_i1] = T.float32(0)
+                T_softmax_expsum[v_i0, v_i1] = T_softmax_expsum[v_i0, v_i1] + T_softmax_exp[v_i0, v_i1, v_k]
+        for i0, i1, i2 in T.grid(T.int64(1), T.int64(1), T.int64(32000)):
+            with T.block("T_softmax_norm"):
+                v_i0, v_i1, v_i2 = T.axis.remap("SSS", [i0, i1, i2])
+                T.reads(T_softmax_exp[v_i0, v_i1, v_i2], T_softmax_expsum[v_i0, v_i1])
+                T.writes(T_softmax_norm[v_i0, v_i1, v_i2])
+                T.block_attr({"axis": 2})
+                T_softmax_norm[v_i0, v_i1, v_i2] = T_softmax_exp[v_i0, v_i1, v_i2] / T_softmax_expsum[v_i0, v_i1]
+
+    @T.prim_func
+    def squeeze1(A: T.Buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16"), T_squeeze: T.Buffer((T.int64(1), T.int64(32), T.int64(128)), "float16")):
+        T.func_attr({"op_pattern": 1, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0, ax1, ax2 in T.grid(T.int64(1), T.int64(32), T.int64(128)):
+            with T.block("T_squeeze"):
+                v_ax0, v_ax1, v_ax2 = T.axis.remap("SSS", [ax0, ax1, ax2])
+                T.reads(A[T.int64(0), v_ax0, v_ax1, v_ax2])
+                T.writes(T_squeeze[v_ax0, v_ax1, v_ax2])
+                T_squeeze[v_ax0, v_ax1, v_ax2] = A[T.int64(0), v_ax0, v_ax1, v_ax2]
+
+    @T.prim_func
+    def take_decode1(A: T.Buffer((T.int64(32000), T.int64(824)), "uint16"), B: T.Buffer((T.int64(32000), T.int64(103)), "float16"), C: T.Buffer((T.int64(1),), "int32"), take_decode: T.Buffer((T.int64(1), T.int64(4096)), "float16")):
+        T.func_attr({"op_pattern": 8, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for i, j in T.grid(T.int64(1), T.int64(4096)):
+            with T.block("take_decode"):
+                v_i, v_j = T.axis.remap("SS", [i, j])
+                T.reads(A[C[v_i], v_j // T.int64(5)], C[v_i], B[C[v_i], v_j // T.int64(40)])
+                T.writes(take_decode[v_i, v_j])
+                take_decode[v_i, v_j] = (T.Cast("float16", T.bitwise_and(T.shift_right(T.Cast("uint32", A[C[v_i], v_j // T.int64(5)]), T.Cast("uint32", v_j % T.int64(5)) * T.uint32(3)), T.uint32(7))) - T.float16(3)) * B[C[v_i], v_j // T.int64(40)]
+
+    @T.prim_func
+    def transpose6(A: T.Buffer((T.int64(1), T.int64(1), T.int64(32), T.int64(128)), "float16"), T_transpose: T.Buffer((T.int64(1), T.int64(32), T.int64(1), T.int64(128)), "float16")):
+        T.func_attr({"op_pattern": 2, "tir.noalias": T.bool(True)})
+        # with T.block("root"):
+        for ax0, ax1, ax2, ax3 in T.grid(T.int64(1), T.int64(32), T.int64(1), T.int64(128)):
+            with T.block("T_transpose"):
+                v_ax0, v_ax1, v_ax2, v_ax3 = T.axis.remap("SSSS", [ax0, ax1, ax2, ax3])
+                T.reads(A[v_ax0, v_ax2, v_ax1, v_ax3])
+                T.writes(T_transpose[v_ax0, v_ax1, v_ax2, v_ax3])
+                T_transpose[v_ax0, v_ax1, v_ax2, v_ax3] = A[v_ax0, v_ax2, v_ax1, v_ax3]
+# fmt: on

mod_cache_before_build_android.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61f76a70ba5f4b9b97295c8d8497a2ce557191ef78236c1173d29ab4731775ac
+size 33453240

params/mlc-chat-config.json

@@ -0,0 +1,15 @@
+{
+    "model_lib": "vicuna-Wizard-7B-Uncensored-android-q3f16_0",
+    "local_id": "vicuna-Wizard-7B-Uncensored-android-q3f16_0",
+    "conv_template": "conv_one_shot",
+    "temperature": 0.7,
+    "repetition_penalty": 1.0,
+    "top_p": 0.95,
+    "mean_gen_len": 128,
+    "max_gen_len": 512,
+    "shift_fill_factor": 0.3,
+    "tokenizer_files": [
+        "tokenizer.json",
+        "tokenizer.model"
+    ]
+}

params/params_shard_0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05e82cb7f41683ebca9c5dac10c6c6cb3114f64c1cb92174fa1ab2eb91c8bb58
+size 52736000

params/params_shard_1.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f475ee094bbe8738202e5b90e34e6d738207ad9d60c80ccf10d779b507f27865
+size 30955008

params/params_shard_10.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90fde15cc917dba6523e863f9ba68a06ffa9a9aa6314aa958639bb35f8bd8652
+size 18141184

params/params_shard_100.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45ffa798effa1f4dcc0e18fed876e630d5158048deab79b0ce001cb35201dd1f
+size 29578240

params/params_shard_101.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:304c07013a1d51ab9044b56ebc9796f4ac9b1710bc209c4cece32f68551e1624
+size 18141184

params/params_shard_102.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46c31d3d4ab8e92ded2da394d808016276379223f728bee7cfc8f0e61a0ad5c5
+size 18141184

params/params_shard_103.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69be2551dd7b84c72230f40566ff587fc0ec7211cca086ef8a0e231b7fca7d23
+size 32643584

params/params_shard_104.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89dae65b57366525d75ef3b4c3f9c0355e381501d41988590e9c26ba4af29932
+size 30210560

params/params_shard_105.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca0dcea3d364a2ecbf5d0342013a1b05682d68fc941c069ed87af1447ca5d801
+size 18141184

params/params_shard_106.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fee3ea256c0ae4d22230451a2dac4924975b715daad071f15734d4bf3bc88290
+size 18141184

params/params_shard_107.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0dfd94eea61cc08152dd9ffd799a2fbc01eb9b528e7109e80b4746119fe252eb
+size 18087936

params/params_shard_108.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43caa8e093339b27fd7d269972a04f0e6a3528b40ce7dbcffa1845e0b0202ed4
+size 29578240

params/params_shard_109.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ea8b8e5a91f56582dcce624e269c5d93f9ca921949711967d3b884e50d3c13f
+size 18141184

params/params_shard_11.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9bc9fa98e51b0473c5eec445fb8816069e0f36455e7026cfb970a9268e70e80b
+size 18087936

params/params_shard_110.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79ddd8fafc513a13bf2cccd87349a5af7b113c78c44ea8190a74b2c992cab689
+size 18141184

params/params_shard_111.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e731157580eaa87e96639a3f2b754259030a395360bf359125923844559ac6c6
+size 32643584

params/params_shard_112.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e37507121ee529dcf48c793649622a63ed54b09f06b2fa41ff07405f61de6e2
+size 30210560

params/params_shard_113.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7220a590e7a69a483487510e9b40144965611a5f0900ba9485cc6f6efc07b29
+size 18141184

params/params_shard_114.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b8edc3a8867cb78f134e6a8658fc50204b5532a601bd7fcdcae4ad7883104b0
+size 18141184

params/params_shard_115.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b9c50d47d81180c3fc15f01cc7e2adcf3c37f8f6465eab91395d4fa7f0e8f33
+size 18087936

params/params_shard_116.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2f60e485c53239dc06cc00de12eed418233c4252229a9083add27b87c067147
+size 29578240

params/params_shard_117.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:212d6a7e47c4bf4fcff8833ca24e0d9511802adee6b9cae168b4ff0055282cd3
+size 18141184

params/params_shard_118.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65aa7f26130e465fb9444786e399b04c84c220cb23f9f1cd855ca7a14464be88
+size 18141184

params/params_shard_119.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f79cdedfcfd480c63c21017cbe1097fb6e6c1d2f8df7b0600efe466a5430cc29
+size 32643584

params/params_shard_12.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:190f3293399e9520a5efe458f5a9288e03e2faf5adc538bf35d31d9b4673d5e1
+size 29578240

params/params_shard_120.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d01cbd2eb461c329dfc89c9826bca789d4fb5b2b4afcb48f66c81f41d7408abe
+size 30210560

params/params_shard_121.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:794717e19321f502f178bda5d8ea616fb48c19907c2f8747a8d50fd20b9d7f77
+size 18141184

params/params_shard_122.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bf6c6bc03172f2a58beea56dce92aa2ed933358e7a97e98bfe06e8b747cff8f
+size 18141184

params/params_shard_123.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76d3cf47f15deda8a3598fecab044153e11c4fe88a2c6bc58e65fa2f8cdddc7c
+size 18087936

params/params_shard_124.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8db9fbc83e5a9fe7d4e294540efaefb325ba5573bdc0fb20ea6c715eaaf3f7a0
+size 29578240

params/params_shard_125.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8f2963ec1e598e6ee85a91c21dce132978347a4abc812b444b9f900ea3d45b6
+size 18141184

params/params_shard_126.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8fb390ac64f23f8782d141f6f72e11b5aa9b51bb211fb16f4b3a61bf3203784
+size 18141184

params/params_shard_127.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:012dd36b4436148eaae04869543827c5e49c29257fe383ecdd7e8bfa257d00cf
+size 32643584

params/params_shard_128.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d3304f8d32e19db6f4b19c07893ad06558cddf74f19de8c9d02da2418b23829
+size 52736000

params/params_shard_129.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97a4dd35920543a930cef9887f429cc7a7cc73aff0ddd010e9a9407e23efd825
+size 29208576

params/params_shard_13.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83d54fb1a8389d74cf9068c2c363372649ac0b46c9c15f9632b8c17bd9f77c00
+size 18141184

params/params_shard_14.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60e75e756b9d83d6e5b522144a9f958d1c03ee858f8fad5e4c9e6312cd391763
+size 18141184

params/params_shard_15.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eb0e11ce7c95f3ce42192fc27a83674e8e5da6f328353f8e7a269a952c92502
+size 32643584

params/params_shard_16.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8375ce114ca4e3dbf33f39cb697f2cd5b9fbf62a05a48a12e0ac40e1d782929
+size 30210560

params/params_shard_17.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:537be9cd347dac60a3cae2fde68c8b0fdc5c488508164aa86fc5f3fe7938f67e
+size 18141184

params/params_shard_18.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e8a3464fef817a62888684d12c56dfad343f79a68825c83278460c562a8f95c
+size 18141184

params/params_shard_19.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1d615fc53d422efa5d54033a79c34e0ca66b52bacc8b30d75163de2bd9821ec
+size 18087936

params/params_shard_2.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a5d64f7b0ff1fe6315b220755b175a2f4641e0e66591d7b25cf341d88b65afa
+size 18141184

params/params_shard_20.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f977dce5c6b01dda9e9c6b7524ce35cf5adc485cab682c7340b2fa06a231aa77
+size 29578240