From ffb6ee29b3aacd5c605d3dbd78335a4b01293c85 Mon Sep 17 00:00:00 2001
From: Christophe Guillon <christophe.guillon@inria.fr>
Date: Tue, 28 Jul 2026 02:22:51 +0200
Subject: [PATCH 1/2] tvm: refactor tvm schedule emitters to use LoopNest

---
 src/xtc/backends/tvm/TVMScheduler.py   | 522 +++++++++----------------
 src/xtc/schedules/loop_names.py        |  19 +
 src/xtc/schedules/loop_nest_builder.py |  84 ++++
 src/xtc/schedules/plain_schedule.py    | 180 +++++++++
 4 files changed, 462 insertions(+), 343 deletions(-)
 create mode 100644 src/xtc/schedules/loop_names.py
 create mode 100644 src/xtc/schedules/loop_nest_builder.py
 create mode 100644 src/xtc/schedules/plain_schedule.py

diff --git a/src/xtc/backends/tvm/TVMScheduler.py b/src/xtc/backends/tvm/TVMScheduler.py
index 911360ce..d5ae638f 100644
--- a/src/xtc/backends/tvm/TVMScheduler.py
+++ b/src/xtc/backends/tvm/TVMScheduler.py
@@ -2,19 +2,22 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2024-2026 The XTC Project Authors
 #
+from __future__ import annotations
+
 import sys
 from abc import ABC, abstractmethod
 from typing_extensions import override
 from typing import TextIO, TypeAlias
 from io import StringIO
 import numpy as np
-from dataclasses import dataclass
 from copy import deepcopy
 import functools
 
 from xtc.utils.math import pow2divisor
 from xtc.itf.schd.scheduler import DEFAULT_ROOT
+from xtc.schedules.plain_schedule import PlainNodeSchedule, PlainNodeScheduler
 from xtc.schedules.loop_nest import LoopNest, LoopNestNode
+from xtc.schedules.loop_nest_builder import LoopNestBuilder
 import xtc.backends.tvm as backend
 import xtc.itf as itf
 
@@ -25,19 +28,6 @@
 ScheduleImpl: TypeAlias = dict[str, str]
 
 
-@dataclass(frozen=True)
-class TVMPlainSchedule:
-    dims: list[str]
-    tiles: dict[str, dict[str, int]]
-    permutation: list[str]
-    parallelization: list[str]
-    unrolling: dict[str, int]
-    vectorization: list[str]
-    write_caches: list[str]
-    read_buffers: list[tuple[str, int, bool]]
-    fused: list[tuple[str, int]]
-
-
 class TVMScheduleEmitter(ABC):
     @abstractmethod
     def emit(self, scheduler: "TVMScheduler"): ...
@@ -56,116 +46,49 @@ def __init__(
         self._sch_var = sch_var
         self._outf = outf
 
-    def _parallel_dims(self, sched: TVMPlainSchedule) -> list[str]:
+    def _parallel_dims(self, sched: LoopNest) -> list[str]:
         op_dims = self._op.operator.dims()
-        return [sched.dims[op_dims.index(d)] for d in self._op.operator.dims("P")]
+        return [
+            sched.abstract_dims[op_dims.index(d)] for d in self._op.operator.dims("P")
+        ]
 
-    def _reduction_dims(self, sched: TVMPlainSchedule) -> list[str]:
+    def _reduction_dims(self, sched: LoopNest) -> list[str]:
         op_dims = self._op.operator.dims()
-        return [sched.dims[op_dims.index(d)] for d in self._op.operator.dims("R")]
-
-    def _update_schedule_for_codegen(self, sch: TVMPlainSchedule) -> TVMPlainSchedule:
-        unrolling = sch.unrolling
-        vectorization = sch.vectorization
-        adjusted_tiles = {}
-        adjusted_unrolling = {
-            k: v for k, v in sch.unrolling.items() if k not in vectorization
-        }
-        adjusted_unrolls = list(adjusted_unrolling)
-        adjusted_vectorization = sch.vectorization[:]
-        adjusted_permutation = sch.permutation[:]
-        for dim, dim_tiles in sch.tiles.items():
-            adjusted_dim_tiles = {}
-            for axis, size in dim_tiles.items():
-                adjusted_dim_tiles.update({axis: size})
-                if axis in adjusted_unrolling:
-                    assert axis not in adjusted_vectorization
-                    unroll = unrolling[axis]
-                    if unroll < size:
-                        axis_idx = adjusted_unrolls.index(axis)
-                        new_axis = f"__u_{axis}"
-                        adjusted_dim_tiles.update({new_axis: unroll})
-                        del adjusted_unrolls[axis_idx]
-                        adjusted_unrolls.insert(axis_idx, new_axis)
-                        adjusted_unrolling.update({new_axis: unroll})
-                        adjusted_permutation.insert(
-                            adjusted_permutation.index(axis) + 1,
-                            new_axis,
-                        )
-                elif axis in adjusted_vectorization:
-                    pow2 = pow2divisor(size)
-                    unroll = size // pow2
-                    if unroll > 1:
-                        axis_idx = adjusted_vectorization.index(axis)
-                        new_axis = f"__v_{axis}"
-                        adjusted_dim_tiles.update({new_axis: pow2})
-                        del adjusted_vectorization[axis_idx]
-                        adjusted_vectorization.insert(axis_idx, new_axis)
-                        adjusted_unrolls.append(axis)
-                        adjusted_unrolling.update({axis: unroll})
-                        adjusted_permutation.insert(
-                            adjusted_permutation.index(axis) + 1,
-                            new_axis,
-                        )
-            adjusted_tiles[dim] = adjusted_dim_tiles
-        adjusted_unrolling = {u: adjusted_unrolling[u] for u in adjusted_unrolls}
-        adjusted = TVMPlainSchedule(
-            dims=deepcopy(sch.dims),
-            tiles=adjusted_tiles,
-            permutation=adjusted_permutation,
-            parallelization=deepcopy(sch.parallelization),
-            unrolling=adjusted_unrolling,
-            vectorization=adjusted_vectorization,
-            write_caches=deepcopy(sch.write_caches),
-            read_buffers=deepcopy(sch.read_buffers),
-            fused=deepcopy(sch.fused),
-        )
-        return adjusted
-
-    def _full_packs(self, sched: TVMPlainSchedule) -> dict[str, tuple[int, int, int]]:
-        def factor_offset(input_idx: int, pad: bool):
-            if not pad:
-                return 0, 0
-            input_spec = self._op.np_inputs_spec()[input_idx]
-            if len(input_spec["shape"]) < 2:
-                return 0, 0
-            # Assume for CPU common number of sets and line size for L1
-            # Except to minimize conflicts by setting the inner axis
-            # size to a factor of num_sets and adding +1
-            num_sets, line_size = 64, 64
-            elt_size = np.dtype(input_spec["dtype"]).itemsize
-            elts_per_line = line_size // elt_size
-            return elts_per_line * num_sets, elts_per_line
+        return [
+            sched.abstract_dims[op_dims.index(d)] for d in self._op.operator.dims("R")
+        ]
 
+    def _full_packs(self, sched: LoopNestNode) -> dict[str, tuple[int, int, int, int]]:
         packs = {}
-        for axis, input_idx, pad in sched.read_buffers:
-            factor, offset = factor_offset(input_idx, pad)
-            packs[axis] = (input_idx, factor, offset)
+        for axis, (input_idx, _, pad) in sched.pack_at.items():
+            dim, factor, offset = tvm_cache_read_factor_offset(self._op, input_idx, pad)
+            packs[axis] = (input_idx, dim, factor, offset)
         return packs
 
-    def _full_fuses(self, sched: TVMPlainSchedule) -> dict[str, tuple[int]]:
+    def _full_fuses(self, sched: LoopNestNode) -> dict[str, tuple[int]]:
         fuses = {}
-        for axis, input_idx in sched.fused:
+        for axis, input_idx in sched.fuse_producer_at.items():
             fuses[axis] = (input_idx,)
         return fuses
 
-    def _full_tilings(self, sched: TVMPlainSchedule) -> dict[str, tuple[str, str, int]]:
-        order = sched.permutation
+    def _full_tilings(self, sched: LoopNestNode) -> dict[str, tuple[str, str, int]]:
+        order = sched.interchange
         tiles = sched.tiles
         tilings = {}
         for dim, dim_tiles in tiles.items():
-            t_axes = list(dim_tiles.keys())
-            t_sizes = list(dim_tiles.values())
-            tilings[dim] = (dim, "", t_sizes[0])
-            for idx in range(1, len(dim_tiles)):
-                tilings[t_axes[idx]] = (dim, t_axes[idx - 1], t_sizes[idx])
+            prev_axis = dim
+            tilings[dim] = (dim, "", 0)
+            for idx, (axis, size) in enumerate(dim_tiles.items()):
+                tilings[axis] = (dim, prev_axis, size)
+                prev_axis = axis
         tilings = {axis: tilings[axis] for axis in order}
         return tilings
 
     def _write_buffer_tiling(
         self,
-        sched: TVMPlainSchedule,
+        sched: LoopNestNode,
         axis: str,
+        parallel_dims: list[str],
         tilings: dict[str, tuple[str, str, int]],
     ) -> tuple[dict[str, tuple[str, str, int]], dict[str, tuple[str, str, int]]]:
         child = {
@@ -182,7 +105,6 @@ def _write_buffer_tiling(
             factor = child.get(axis, ("", "", 1))[2]
             outer_tiles[f"{dim}_"] = (dim, axis, factor)
         dims = set()
-        parallel_dims = self._parallel_dims(sched)
         for axis, (dim, parent, factor) in list(inner_tiles.items()):
             if outers_dims and dim not in outers_dims:
                 outers_dims.add(dim)
@@ -195,16 +117,19 @@ def _write_buffer_tiling(
         return outer_tiles, inner_tiles
 
     def _full_write_buffers(
-        self, sched: TVMPlainSchedule
+        self, sched: LoopNestNode, parallel_dims: list[str]
     ) -> dict[tuple[str, str, str], dict[str, tuple[str, str, int]]]:
         tilings = self._full_tilings(sched)
         reorder_idx = {axis: idx for idx, axis in enumerate(tilings)}
-        write_axis = sorted(sched.write_caches, key=lambda axis: reorder_idx[axis])
+        write_axis = list(sched.buffer_at)
+        write_axis = sorted(write_axis, key=lambda axis: reorder_idx[axis])
         buffer_tilings = {}
         out = ("O", "", "")
         tiling = tilings
         for idx, axis in enumerate(write_axis):
-            outer_tiling, inner_tiling = self._write_buffer_tiling(sched, axis, tiling)
+            outer_tiling, inner_tiling = self._write_buffer_tiling(
+                sched, axis, parallel_dims, tiling
+            )
             buffer_tilings[out] = outer_tiling
             out = (f"O_W{idx}", out[0], axis)
             tiling = inner_tiling
@@ -212,10 +137,13 @@ def _full_write_buffers(
         return buffer_tilings
 
     def _emit_assign_axis(
-        self, sched: TVMPlainSchedule, sch: str, tens: str, outf: TextIO
+        self,
+        sch: str,
+        tens: str,
+        parallel_dims: list[str],
+        reduction_dims: list[str],
+        outf: TextIO,
     ) -> None:
-        parallel_dims = self._parallel_dims(sched)
-        reduction_dims = self._reduction_dims(sched)
         if parallel_dims:
             print(f"{', '.join(parallel_dims)}, = {tens}.op.axis", file=outf)
         if reduction_dims:
@@ -223,7 +151,6 @@ def _emit_assign_axis(
 
     def _emit_assign_tilings(
         self,
-        sched: TVMPlainSchedule,
         sch: str,
         tens: str,
         tilings: dict[str, tuple[str, str, int]],
@@ -243,10 +170,20 @@ def _emit_assign_tilings(
                 print(f"{axis} = {parent}", file=outf)
         print(f"{sch}[{tens}].reorder({', '.join(tilings)})", file=outf)
 
-    def _dump_schedule(self, sched: TVMPlainSchedule):
-        tilings = self._full_write_buffers(sched)
-        packings = self._full_packs(sched)
-        fuses = self._full_fuses(sched)
+    def _dump_schedule(self, sched: LoopNest):
+        root = sched.root_node
+        if root is None:
+            return
+        self._dump_schedule_node(sched, root)
+
+    def _dump_schedule_node(self, sched: LoopNest, node: LoopNestNode):
+        assert not node.splits, "split not supported for TE Schedule"
+
+        parallel_dims = self._parallel_dims(sched)
+        reduction_dims = self._reduction_dims(sched)
+        tilings = self._full_write_buffers(node, parallel_dims)
+        packings = self._full_packs(node)
+        fuses = self._full_fuses(node)
         obj = self._obj_var
         sch = self._sch_var
         outf = self._outf
@@ -259,7 +196,7 @@ def _dump_schedule(self, sched: TVMPlainSchedule):
                 print(f'{tens} = {sch}.cache_write({parent}, "global")', file=outf)
             for tile_axis in tiles:
                 if tile_axis in packings:
-                    inp_idx, _, _ = packings[tile_axis]
+                    inp_idx, _, _, _ = packings[tile_axis]
                     print(
                         f'I_R{inp_idx} = {sch}.cache_read(INPS[{inp_idx}], "global", [{tens}])',
                         file=outf,
@@ -272,18 +209,18 @@ def _dump_schedule(self, sched: TVMPlainSchedule):
         for idx, ((tens, parent, axis), tiles) in enumerate(tilings.items()):
             if parent:
                 print(f"{sch}[{tens}].compute_at({sch}[{parent}], {axis})", file=outf)
-            self._emit_assign_axis(sched, sch, tens, outf)
-            self._emit_assign_tilings(sched, sch, tens, tiles, outf)
+            self._emit_assign_axis(sch, tens, parallel_dims, reduction_dims, outf)
+            self._emit_assign_tilings(sch, tens, tiles, outf)
             for tile_axis in tiles:
                 if tile_axis in packings:
-                    inp_idx, factor, offset = packings[tile_axis]
+                    inp_idx, dim, factor, offset = packings[tile_axis]
                     print(
                         f"{sch}[I_R{inp_idx}].compute_at({sch}[{tens}], {tile_axis})",
                         file=outf,
                     )
                     if factor != 0:
                         print(
-                            f"{sch}[I_R{inp_idx}].storage_align(I_R{inp_idx}.op.axis[-2], factor={factor}, offset={offset})",
+                            f"{sch}[I_R{inp_idx}].storage_align(I_R{inp_idx}.op.axis[{dim}], factor={factor}, offset={offset})",
                             file=outf,
                         )
                 if tile_axis in fuses:
@@ -292,29 +229,29 @@ def _dump_schedule(self, sched: TVMPlainSchedule):
                         f"{sch}[I_F{inp_idx}].compute_at({sch}[{tens}], {tile_axis})",
                         file=outf,
                     )
-            for u_axis in sched.unrolling:
+            for u_axis in node.unroll:
                 if u_axis in tiles:
                     print(f"{sch}[{tens}].unroll({u_axis})", file=outf)
-            for v_axis in sched.vectorization:
+            for v_axis in node.vectorize:
                 if v_axis in tiles:
                     print(f"{sch}[{tens}].vectorize({v_axis})", file=outf)
-            if sched.parallelization:
-                if sched.parallelization[0] in tiles:
-                    if len(sched.parallelization) > 1:
+            if node.parallelize:
+                if node.parallelize[0] in tiles:
+                    if len(node.parallelize) > 1:
                         print(
-                            f"{sched.parallelization[-1]} = {sch}[{tens}].fuse({', '.join(sched.parallelization)})",
+                            f"{node.parallelize[-1]} = {sch}[{tens}].fuse({', '.join(node.parallelize)})",
                             file=outf,
                         )
                     print(
-                        f"{sch}[{tens}].parallel({sched.parallelization[-1]})",
+                        f"{sch}[{tens}].parallel({node.parallelize[-1]})",
                         file=outf,
                     )
 
     @override
     def emit(self, scheduler: "TVMScheduler"):
-        sched = scheduler._get_plain_schedule()
-        # First adjust schedule to fix code gen limitations before emit
-        sched = self._update_schedule_for_codegen(sched)
+        sched = scheduler.get_loop_nest()
+        sched = tvm_update_loopnest_for_codegen(sched)
+        sched.check()
         self._dump_schedule(sched)
 
 
@@ -331,22 +268,6 @@ def __init__(
         self._sch_var = sch_var
         self._outf = outf
 
-    def _cache_read_factor_offset(
-        self, input_idx: int, pad: bool
-    ) -> tuple[int, int, int]:
-        if not pad:
-            return 0, 0, 0
-        input_spec = self._op.np_inputs_spec()[input_idx]
-        if len(input_spec["shape"]) < 2:
-            return 0, 0, 0
-        # Assume for CPU common number of sets and line size for L1
-        # Except to minimize conflicts by setting the inner axis
-        # size to a factor of num_sets and adding +1
-        num_sets, line_size = 64, 64
-        elt_size = np.dtype(input_spec["dtype"]).itemsize
-        elts_per_line = line_size // elt_size
-        return -2, elts_per_line * num_sets, elts_per_line
-
     def _dump_schedule(self, sched: LoopNest):
         root = sched.root_node
         if root is None:
@@ -397,7 +318,9 @@ def _dump_schedule_node(self, sched: LoopNest, node: LoopNestNode):
         if node.pack_at:
             for axis, (inp_idx, mtype, pad) in node.pack_at.items():
                 print(f"{sch}.compute_at(I_R{inp_idx}, {axis})", file=outf)
-                dim, factor, offset = self._cache_read_factor_offset(inp_idx, pad)
+                dim, factor, offset = tvm_cache_read_factor_offset(
+                    self._op, inp_idx, pad
+                )
                 if factor != 0:
                     print(
                         f"{sch}.storage_align(I_R{inp_idx}, 0, ",
@@ -425,81 +348,98 @@ def _dump_schedule_node(self, sched: LoopNest, node: LoopNestNode):
                 file=outf,
             )
 
-    @classmethod
-    def _update_loopnest_for_codegen(cls, sched: LoopNest):
-        def _update_loopnode(node: LoopNestNode) -> LoopNestNode:
-            adjusted_tiles = {}
-            adjusted_unrolling = {
-                k: v for k, v in node.unroll.items() if k not in node.vectorize
-            }
-            adjusted_unrolls = list(adjusted_unrolling)
-            adjusted_vectorization = node.vectorize[:]
-            adjusted_permutation = node.interchange[:]
-            for dim, dim_tiles in node.tiles.items():
-                adjusted_dim_tiles = {}
-                for axis, size in dim_tiles.items():
-                    adjusted_dim_tiles.update({axis: size})
-                    if axis in adjusted_unrolling:
-                        assert axis not in adjusted_vectorization
-                        unroll = adjusted_unrolling[axis]
-                        if unroll < size:
-                            axis_idx = adjusted_unrolls.index(axis)
-                            new_axis = f"__u_{axis}"
-                            adjusted_dim_tiles.update({new_axis: unroll})
-                            adjusted_unrolls[axis_idx] = new_axis
-                            del adjusted_unrolling[axis]
-                            adjusted_unrolling.update({new_axis: unroll})
-                            adjusted_permutation.insert(
-                                adjusted_permutation.index(axis) + 1,
-                                new_axis,
-                            )
-                    elif axis in adjusted_vectorization:
-                        assert axis not in adjusted_unrolling
-                        pow2 = pow2divisor(size)
-                        unroll = size // pow2
-                        if unroll > 1:
-                            axis_idx = adjusted_vectorization.index(axis)
-                            new_axis = f"__v_{axis}"
-                            adjusted_dim_tiles.update({new_axis: pow2})
-                            adjusted_vectorization[axis_idx] = new_axis
-                            adjusted_unrolls.append(axis)
-                            adjusted_unrolling.update({axis: unroll})
-                            adjusted_permutation.insert(
-                                adjusted_permutation.index(axis) + 1,
-                                new_axis,
-                            )
-                adjusted_tiles[dim] = adjusted_dim_tiles
-            adjusted_unrolling = {u: adjusted_unrolling[u] for u in adjusted_unrolls}
-            return LoopNestNode(
-                root=node.root,
-                tiles=adjusted_tiles,
-                splits=deepcopy(node.splits),
-                interchange=adjusted_permutation,
-                vectorize=adjusted_vectorization,
-                parallelize=deepcopy(node.parallelize),
-                unroll=adjusted_unrolling,
-                buffer_at=deepcopy(node.buffer_at),
-                pack_at=deepcopy(node.pack_at),
-                fuse_producer_at=deepcopy(node.fuse_producer_at),
-                fuse_consumer_at=deepcopy(node.fuse_consumer_at),
-            )
-
-        root = sched.root_node
-        if root is not None:
-            root = _update_loopnode(root)
-        return LoopNest(
-            abstract_dims=sched.abstract_dims,
-            root_node=root,
-        )
-
     @override
     def emit(self, scheduler: "TVMScheduler"):
         sched = scheduler.get_loop_nest()
-        sched = self._update_loopnest_for_codegen(sched)
+        sched = tvm_update_loopnest_for_codegen(sched)
         sched.check()
         self._dump_schedule(sched)
 
 
+def tvm_cache_read_factor_offset(
+    op: TVMOperation, input_idx: int, pad: bool
+) -> tuple[int, int, int]:
+    if not pad:
+        return 0, 0, 0
+    input_spec = op.np_inputs_spec()[input_idx]
+    if len(input_spec["shape"]) < 2:
+        return 0, 0, 0
+    # Assume for CPU common number of sets and line size for L1
+    # Except to minimize conflicts by setting the inner axis
+    # size to a factor of num_sets and adding +1
+    num_sets, line_size = 64, 64
+    elt_size = np.dtype(input_spec["dtype"]).itemsize
+    elts_per_line = line_size // elt_size
+    return -2, elts_per_line * num_sets, elts_per_line
+
+
+def tvm_update_loopnest_for_codegen(sched: LoopNest) -> LoopNest:
+    def _update_loopnode(node: LoopNestNode) -> LoopNestNode:
+        adjusted_tiles = {}
+        adjusted_unrolling = {
+            k: v for k, v in node.unroll.items() if k not in node.vectorize
+        }
+        adjusted_unrolls = list(adjusted_unrolling)
+        adjusted_vectorization = node.vectorize[:]
+        adjusted_permutation = node.interchange[:]
+        for dim, dim_tiles in node.tiles.items():
+            adjusted_dim_tiles = {}
+            for axis, size in dim_tiles.items():
+                adjusted_dim_tiles.update({axis: size})
+                if axis in adjusted_unrolling:
+                    assert axis not in adjusted_vectorization
+                    unroll = adjusted_unrolling[axis]
+                    if unroll < size:
+                        axis_idx = adjusted_unrolls.index(axis)
+                        new_axis = f"__u_{axis}"
+                        adjusted_dim_tiles.update({new_axis: unroll})
+                        adjusted_unrolls[axis_idx] = new_axis
+                        del adjusted_unrolling[axis]
+                        adjusted_unrolling.update({new_axis: unroll})
+                        adjusted_permutation.insert(
+                            adjusted_permutation.index(axis) + 1,
+                            new_axis,
+                        )
+                elif axis in adjusted_vectorization:
+                    assert axis not in adjusted_unrolling
+                    pow2 = pow2divisor(size)
+                    unroll = size // pow2
+                    if unroll > 1:
+                        axis_idx = adjusted_vectorization.index(axis)
+                        new_axis = f"__v_{axis}"
+                        adjusted_dim_tiles.update({new_axis: pow2})
+                        adjusted_vectorization[axis_idx] = new_axis
+                        adjusted_unrolls.append(axis)
+                        adjusted_unrolling.update({axis: unroll})
+                        adjusted_permutation.insert(
+                            adjusted_permutation.index(axis) + 1,
+                            new_axis,
+                        )
+            adjusted_tiles[dim] = adjusted_dim_tiles
+        adjusted_unrolling = {u: adjusted_unrolling[u] for u in adjusted_unrolls}
+        return LoopNestNode(
+            root=node.root,
+            tiles=adjusted_tiles,
+            splits=deepcopy(node.splits),
+            interchange=adjusted_permutation,
+            vectorize=adjusted_vectorization,
+            parallelize=deepcopy(node.parallelize),
+            unroll=adjusted_unrolling,
+            buffer_at=deepcopy(node.buffer_at),
+            pack_at=deepcopy(node.pack_at),
+            fuse_producer_at=deepcopy(node.fuse_producer_at),
+            fuse_consumer_at=deepcopy(node.fuse_consumer_at),
+        )
+
+    root = sched.root_node
+    if root is not None:
+        root = _update_loopnode(root)
+    return LoopNest(
+        abstract_dims=sched.abstract_dims,
+        root_node=root,
+    )
+
+
 class TVMScheduler(itf.schd.Scheduler):
     def __init__(
         self,
@@ -521,33 +461,11 @@ def __init__(
                 v for k, v in self._scheduled_ops.items() if k == default_node
             ]
         self._op = candidate_ops[-1]
-        self._abstract_dims = {d: d for d in self._op.operator.dims()}
-        self._sizes = list(self._op.operator.dims_sizes().values())
-        self.dims = list(self._op.operator.dims())
-        self.tiles: dict[str, dict[str, int]] = {
-            k: {k: v} for k, v in zip(self.dims, self._sizes)
-        }
-        self.permutation: list[str] = list(self.tiles.keys())
-        self.vectorization: list[str] = []
-        self.parallelization: list[str] = []
-        self.unrolling: dict[str, int] = {}
-        self.write_caches: list[str] = []
-        self.read_buffers: list[tuple[str, int, bool]] = []
-        self.fused: list[tuple[str, int]] = []
-        self.fused_consumers: list[str] = []
-        self._update_loops()
-
-    @property
-    def dims_sizes(self) -> dict[str, int]:
-        return {d: s for d, s in zip(self.dims, self._sizes)}
-
-    @property
-    def parallel_dims(self) -> list[str]:
-        return [self._abstract_dims[d] for d in self._op.operator.dims("P")]
-
-    @property
-    def reduction_dims(self) -> list[str]:
-        return [self._abstract_dims[d] for d in self._op.operator.dims("R")]
+        self._plain_sch = PlainNodeScheduler(
+            self._op.name,
+            self._op.name,  # TODO: ident
+            list(self._op.operator.dims()),
+        )
 
     @property
     @override
@@ -567,61 +485,30 @@ def schedule(self) -> itf.schd.Schedule:
         schedule_impl = {self._op.name: sched}
         return TVMSchedule(scheduler=self, schedule_impl=schedule_impl)
 
-    def _update_loops(self):
-        loops = dict()
-        parallels = []
-        for tile_level in range(len(max(self.tiles.values(), key=len))):
-            for k, v in self.tiles.items():
-                if tile_level >= len(v):
-                    continue
-                dim_name = list(v.keys())[tile_level]
-                loops[dim_name] = v[dim_name]
-                if k in self.parallel_dims:
-                    parallels.append(dim_name)
-        self._working_dims = loops
-        self._working_parallel_dims = parallels
-        self.permutation = list(self._working_dims.keys())
-
     @override
     def set_dims(self, dims: list[str]) -> None:
-        assert len(dims) == len(self.dims)
-        self.dims = dims[:]
-        self._abstract_dims = {d: a for d, a in zip(self._op.operator.dims(), dims)}
-        self.tiles = {k: {k: v} for k, v in zip(self.dims, self._sizes)}
-        self.permutation = list(self.tiles.keys())
+        self._plain_sch.set_dims(dims)
 
     @override
     def split(
         self, dim: str, segments: dict[str, int], root: str = DEFAULT_ROOT
-    ) -> None: ...
+    ) -> None:
+        self._plain_sch.split(dim, segments, root)
 
     @override
     def tile(self, dim: str, tiles: dict[str, int], root: str = DEFAULT_ROOT) -> None:
-        all_tiles = {dim: self.dims_sizes[dim], **tiles}
-        parent_tile_size = self.dims_sizes[dim]
-        for name, size in all_tiles.items():
-            assert size >= 1, f"unexpected tile size < 1 for axis {dim}"
-            assert parent_tile_size >= size, (
-                f"unexpected tile size < inner tile for axis {dim}"
-            )
-            self.tiles[dim][name] = size
-            parent_tile_size = size
-        self._update_loops()
+        self._plain_sch.tile(dim, tiles, root)
 
     @override
     def interchange(self, permutation: list[str], root: str = DEFAULT_ROOT) -> None:
-        for axis in self.permutation:
-            assert axis in permutation, f"missing axis {axis} in interchange"
-        for axis in permutation:
-            assert axis in self.permutation, f"unexpected axis {axis} in interchange"
-        self.permutation = permutation
+        self._plain_sch.interchange(permutation, root)
 
     @override
     def buffer_at(
         self, axis: str, mtype: str | None = None, root: str = DEFAULT_ROOT
     ) -> None:
         assert mtype is None or mtype == "global"
-        self.write_caches.append(axis)
+        self._plain_sch.buffer_at(axis, mtype, root)
 
     @override
     def pack_at(
@@ -634,36 +521,30 @@ def pack_at(
     ) -> None:
         assert mtype is None or mtype == "global"
         assert input_idx >= 0 and input_idx < len(self._op.np_inputs_spec())
-        self.read_buffers.append((axis, input_idx, pad))
+        self._plain_sch.pack_at(axis, input_idx, mtype, pad, root)
 
     @override
     def vectorize(self, axes: list[str], root: str = DEFAULT_ROOT) -> None:
-        for axis in axes:
-            assert axis in self._working_parallel_dims, f"non parallel axis {axis}"
-        self.vectorization = axes
+        self._plain_sch.vectorize(axes, root)
 
     @override
     def parallelize(self, axes: list[str], root: str = DEFAULT_ROOT) -> None:
-        for axis in axes:
-            assert axis in self._working_parallel_dims, f"non parallel axis {axis}"
-        self.parallelization = axes
+        self._plain_sch.parallelize(axes, root)
 
     @override
     def unroll(self, unrolls: dict[str, int], root: str = DEFAULT_ROOT) -> None:
-        for axis, unroll in unrolls.items():
-            assert unroll > 0, f"unroll < 1 not supported for axis {axis}"
-        self.unrolling = unrolls
+        self._plain_sch.unroll(unrolls, root)
 
     @override
     def fuse_producer_at(
         self, axis: str, input_idx: int, root: str = DEFAULT_ROOT
     ) -> None:
         assert input_idx >= 0 and input_idx < len(self._op.np_inputs_spec())
-        self.fused.append((axis, input_idx))
+        self._plain_sch.fuse_producer_at(axis, input_idx, root)
 
     @override
     def fuse_consumer_at(self, axis: str, root: str = DEFAULT_ROOT) -> None:
-        self.fused_consumers.append(axis)
+        self._plain_sch.fuse_consumer_at(axis, root)
 
     @override
     def define_memory_mesh(self, axes: dict[str, int]) -> None:
@@ -693,61 +574,16 @@ def distributed_buffer_at(
         # TODO: not implemented for now
         pass
 
-    def _get_plain_schedule(self) -> TVMPlainSchedule:
-        return TVMPlainSchedule(
-            dims=deepcopy(self.dims),
-            tiles=deepcopy(self.tiles),
-            permutation=deepcopy(self.permutation),
-            parallelization=deepcopy(self.parallelization),
-            unrolling=deepcopy(self.unrolling),
-            vectorization=deepcopy(self.vectorization),
-            write_caches=deepcopy(self.write_caches),
-            read_buffers=deepcopy(self.read_buffers),
-            fused=deepcopy(self.fused),
-        )
-
-    @override
-    def __str__(self) -> str:
-        return str(self._get_plain_schedule())
+    def _get_plain_schedule(self) -> PlainNodeSchedule:
+        return self._plain_sch.get_plain_schedule()
 
     @override
     def get_loop_nest(self) -> LoopNest:
-        loop_nest = LoopNest(abstract_dims=self.dims[:])
-        root_node = loop_nest.build_root_node(self._op.name or "op")
-
-        # Build tiles mapping
-        for axis, axis_tiles in self.tiles.items():
-            for tile_name, size in axis_tiles.items():
-                if tile_name != axis:
-                    root_node.tiles[axis][tile_name] = size
-
-        # Build interchange
-        root_node.interchange = list(self.permutation)
-
-        # Build vectorization list
-        root_node.vectorize = list(self.vectorization)
-
-        # Build parallelization list
-        root_node.parallelize = list(self.parallelization)
-
-        # Build unroll mapping
-        root_node.unroll = dict(self.unrolling)
+        return LoopNestBuilder.from_plain_node_schedule(self._get_plain_schedule())
 
-        # Build buffer_at mapping
-        root_node.buffer_at = {axis: None for axis in self.write_caches}
-
-        # Build pack_at mapping
-        root_node.pack_at = {
-            axis: (input_idx, None, pad) for axis, input_idx, pad in self.read_buffers
-        }
-
-        # Build fuse_producer_at mapping
-        root_node.fuse_producer_at = dict(self.fused)
-
-        # Build fuse_consumer_at list
-        root_node.fuse_consumer_at = list(self.fused_consumers)
-
-        return loop_nest
+    @override
+    def __str__(self) -> str:
+        return str(self._get_plain_schedule())
 
 
 class TVMSchedule(itf.schd.Schedule):
diff --git a/src/xtc/schedules/loop_names.py b/src/xtc/schedules/loop_names.py
new file mode 100644
index 00000000..f6848e90
--- /dev/null
+++ b/src/xtc/schedules/loop_names.py
@@ -0,0 +1,19 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2024-2026 The XTC Project Authors
+#
+__all__ = ["make_loop_name", "basename", "parent_name"]
+
+_LOOP_SEP = "/"
+
+
+def make_loop_name(root: str, name: str) -> str:
+    return f"{root}{_LOOP_SEP}{name}"
+
+
+def basename(loop_name: str) -> str:
+    return loop_name.split(_LOOP_SEP)[-1]
+
+
+def parent_name(loop_name: str) -> str:
+    return loop_name.rsplit(_LOOP_SEP, 1)[0]
diff --git a/src/xtc/schedules/loop_nest_builder.py b/src/xtc/schedules/loop_nest_builder.py
new file mode 100644
index 00000000..565804d2
--- /dev/null
+++ b/src/xtc/schedules/loop_nest_builder.py
@@ -0,0 +1,84 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2024-2026 The XTC Project Authors
+#
+from __future__ import annotations
+
+from .loop_names import basename
+from .plain_schedule import PlainNodeSchedule
+from .loop_nest import LoopInfo, LoopNest, LoopNestNode, SplitOrigin
+
+
+class LoopNestBuilder:
+    @staticmethod
+    def from_plain_node_schedule(node_sched: PlainNodeSchedule) -> LoopNest:
+        dims = node_sched.dims[:]
+
+        loop_nest = LoopNest(abstract_dims=dims)
+        root_node = loop_nest.build_root_node(node_sched.node_name)
+
+        # Assign splits to root_node first, stripping the root prefix from names
+        for axis, axis_splits in node_sched.splits.items():
+            root_node.splits[axis] = {basename(k): v for k, v in axis_splits.items()}
+
+        # Build mapper to get splits_info
+        mapper = LoopInfo.build_from_node(root_node)
+
+        def populate_node(node: LoopNestNode, perm: list[str]) -> None:
+            """Populate node with data for loops in its permutation."""
+            perm_set = set(perm)
+            node.interchange = [basename(n) for n in perm]
+            for axis, axis_tiles in node_sched.tiles.items():
+                for tile_name, size in axis_tiles.items():
+                    if tile_name in perm_set:
+                        if axis not in node.tiles:
+                            node.tiles[axis] = {}
+                        node.tiles[axis][basename(tile_name)] = size
+            node.vectorize = [
+                basename(v) for v in node_sched.vectorization if v in perm_set
+            ]
+            node.parallelize = [
+                basename(p) for p in node_sched.parallelization if p in perm_set
+            ]
+            node.unroll = {
+                basename(k): v for k, v in node_sched.unrolling.items() if k in perm_set
+            }
+            # TODO: loop nest supports only one buffer per axis
+            node.buffer_at = {
+                basename(k): v[0]
+                for k, v in node_sched.write_buffers.items()
+                if k in perm_set
+            }
+            # TODO: loop nest supports only one pack per axis
+            node.pack_at = {
+                basename(k): v[0]
+                for k, v in node_sched.packed_buffers.items()
+                if k in perm_set
+            }
+            # TODO: loop nest supports only one fuse per axis
+            node.fuse_producer_at = {
+                basename(k): v for k, v in node_sched.fused if k in perm_set
+            }
+            # TODO: loop nest supports only one fuse consumer per axis
+            node.fuse_consumer_at = [
+                basename(k) for k in node_sched.fused_consumers if k in perm_set
+            ]
+
+        # Process each root in permutation
+        for root, perm in node_sched.permutation.items():
+            root_name = basename(root)
+            if root_name in mapper.splits_info:
+                # This root is a split - create child node
+                axis, start, end = mapper.splits_info[root_name]
+                child = LoopNestNode(
+                    root=root_name,
+                    tiles={d: {} for d in dims},
+                    split_origin=SplitOrigin(axis=axis, start=start, end=end),
+                )
+                populate_node(child, perm)
+                root_node.add_child(child)
+            else:
+                # This is the main root
+                populate_node(root_node, perm)
+
+        return loop_nest
diff --git a/src/xtc/schedules/plain_schedule.py b/src/xtc/schedules/plain_schedule.py
new file mode 100644
index 00000000..b5924e81
--- /dev/null
+++ b/src/xtc/schedules/plain_schedule.py
@@ -0,0 +1,180 @@
+#
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2024-2026 The XTC Project Authors
+#
+from __future__ import annotations
+
+from typing_extensions import override
+from dataclasses import dataclass, asdict
+from pprint import pformat
+from copy import deepcopy
+
+from xtc.itf.schd.scheduler import DEFAULT_ROOT
+from xtc.schedules.loop_names import make_loop_name
+
+
+@dataclass(frozen=True)
+class PlainNodeSchedule:
+    node_name: str
+    node_ident: str
+    dims: list[str]
+    loop_stamps: list[str]
+    splits: dict[str, dict[str, int]]
+    tiles: dict[str, dict[str, int]]
+    permutation: dict[str, list[str]]
+    vectorization: list[str]
+    parallelization: list[str]
+    unrolling: dict[str, int]
+    packed_buffers: dict[str, list[tuple[int, str | None, bool]]]
+    write_buffers: dict[str, list[str | None]]
+    memory_mesh: dict[str, int]
+    processor_mesh: dict[str, int]
+    distribution: dict[str, str]
+    distributed_buffers: dict[str, dict]
+    fused: list[tuple[str, int]]
+    fused_consumers: list[str]
+
+    @override
+    def __str__(self):
+        return pformat(asdict(self))
+
+
+class PlainNodeScheduler:
+    def __init__(
+        self,
+        node_name: str,
+        node_ident: str,
+        dims: list[str],
+        loop_stamps: list[str] = [],
+    ) -> None:
+        self.node_name = node_name
+        self.node_ident = node_ident
+        self.dims = dims[:]
+        self.loop_stamps = loop_stamps[:]
+        self.splits: dict[str, dict[str, int]] = {}
+        self.tiles: dict[str, dict[str, int]] = {k: {} for k in self.dims}
+        self.permutation: dict[str, list[str]] = {}
+        self.vectorization: list[str] = []
+        self.parallelization: list[str] = []
+        self.unrolling: dict[str, int] = {}
+        self.packed_buffers: dict[str, list[tuple[int, str | None, bool]]] = {}
+        self.write_buffers: dict[str, list[str | None]] = {}
+        self.memory_mesh: dict[str, int] = {}
+        self.processor_mesh: dict[str, int] = {}
+        self.distribution: dict[str, str] = {}
+        self.distributed_buffers: dict[str, dict] = {}
+        self.fused: list[tuple[str, int]] = []
+        self.fused_consumers: list[str] = []
+
+    def get_plain_schedule(self) -> PlainNodeSchedule:
+        if not self.permutation:
+            self.permutation[DEFAULT_ROOT] = self.get_default_interchange(DEFAULT_ROOT)
+
+        for fuse_axis in self.fused:
+            assert fuse_axis[0] in self.permutation[next(iter(self.permutation))], (
+                "Fusion must be to an axis in the base root not the result of a split."
+            )
+
+        return PlainNodeSchedule(
+            node_name=self.node_name,
+            node_ident=self.node_ident,
+            dims=deepcopy(self.dims),
+            loop_stamps=deepcopy(self.loop_stamps),
+            tiles=deepcopy(self.tiles),
+            splits=deepcopy(self.splits),
+            permutation=deepcopy(self.permutation),
+            vectorization=deepcopy(self.vectorization),
+            parallelization=deepcopy(self.parallelization),
+            unrolling=deepcopy(self.unrolling),
+            memory_mesh=deepcopy(self.memory_mesh),
+            packed_buffers=deepcopy(self.packed_buffers),
+            write_buffers=deepcopy(self.write_buffers),
+            processor_mesh=deepcopy(self.processor_mesh),
+            distribution=deepcopy(self.distribution),
+            distributed_buffers=deepcopy(self.distributed_buffers),
+            fused=deepcopy(self.fused),
+            fused_consumers=deepcopy(self.fused_consumers),
+        )
+
+    @override
+    def __str__(self) -> str:
+        return str(self.get_plain_schedule())
+
+    def get_default_interchange(self, root: str) -> list[str]:
+        ret = [make_loop_name(root, d) for d in self.dims]
+        for tile_level in range(len(max(self.tiles.values(), key=len))):
+            for _, v in self.tiles.items():
+                if tile_level >= len(v):
+                    continue
+                dim_name = list(v.keys())[tile_level]
+                ret.append(dim_name)
+        return ret
+
+    def set_dims(self, dims: list[str]) -> None:
+        assert len(dims) == len(self.dims)
+        self.dims = dims[:]
+        self.tiles = {k: {} for k in self.dims}
+
+    def split(
+        self, dim: str, segments: dict[str, int], root: str = DEFAULT_ROOT
+    ) -> None:
+        segments_renamed = {
+            make_loop_name(root, key): val for key, val in segments.items()
+        }
+        self.splits[dim] = segments_renamed
+        for s in segments_renamed:
+            self.tiles[s] = {}
+
+    def tile(self, dim: str, tiles: dict[str, int], root: str = DEFAULT_ROOT):
+        for d, s in tiles.items():
+            tile_name = make_loop_name(root, d)
+            self.tiles[dim][tile_name] = s
+
+    def interchange(self, permutation: list[str], root: str = DEFAULT_ROOT):
+        self.permutation[root] = [make_loop_name(root, a) for a in permutation]
+
+    def vectorize(self, axes: list[str], root: str = DEFAULT_ROOT):
+        self.vectorization += [make_loop_name(root, a) for a in axes]
+
+    def parallelize(self, axes: list[str], root: str = DEFAULT_ROOT):
+        self.parallelization = [make_loop_name(root, a) for a in axes]
+
+    def unroll(self, unrolls: dict[str, int], root: str = DEFAULT_ROOT):
+        for dim, ufactor in unrolls.items():
+            self.unrolling[make_loop_name(root, dim)] = ufactor
+
+    def buffer_at(
+        self,
+        axis: str,
+        mtype: str | None = None,
+        root: str = DEFAULT_ROOT,
+    ) -> None:
+        axis_key = make_loop_name(root, axis)
+        if axis_key not in self.write_buffers.keys():
+            self.write_buffers[axis_key] = [mtype]
+        else:
+            self.write_buffers[axis_key].append(mtype)
+
+    def pack_at(
+        self,
+        axis: str,
+        input_idx: int,
+        mtype: str | None = None,
+        pad: bool = False,
+        root: str = DEFAULT_ROOT,
+    ):
+        axis_key = make_loop_name(root, axis)
+        if axis_key not in self.packed_buffers.keys():
+            self.packed_buffers[axis_key] = [(input_idx, mtype, pad)]
+        else:
+            self.packed_buffers[axis_key].append((input_idx, mtype, pad))
+
+    def fuse_producer_at(
+        self, axis: str, input_idx: int, root: str = DEFAULT_ROOT
+    ) -> None:
+        axis_key = make_loop_name(root, axis)
+        self.fused.append((axis_key, input_idx))
+
+    def fuse_consumer_at(self, axis: str, root: str = DEFAULT_ROOT) -> None:
+        axis_key = make_loop_name(root, axis)
+        self.fused_consumers.append(axis_key)

From c93629e0f0f91eae5f73ae76ba14bfab09496c3b Mon Sep 17 00:00:00 2001
From: Christophe Guillon <christophe.guillon@inria.fr>
Date: Tue, 28 Jul 2026 15:31:16 +0200
Subject: [PATCH 2/2] mlir: use factorized PlainNodeSchedule loop names and
 loop nest utils

---
 src/xtc/backends/mlir/MlirCompilerPasses.py   |   6 +-
 src/xtc/backends/mlir/MlirLoopNames.py        |  19 --
 src/xtc/backends/mlir/MlirNodeScheduler.py    | 194 ++++-----------
 src/xtc/backends/mlir/MlirScheduler.py        |  62 +----
 src/xtc/schedules/plain_schedule.py           |  80 ++++++-
 tests/filecheck/search/test_conv_oo.py        | 176 +++++++-------
 tests/filecheck/search/test_conv_pprprp.py    |  10 +-
 tests/filecheck/search/test_conv_pprprpv.py   |  10 +-
 tests/filecheck/search/test_conv_pprprpvr.py  |  10 +-
 .../search/test_conv_pprprpvr_rnd.py          |   2 +-
 tests/filecheck/search/test_conv_prp.py       | 114 ++++-----
 tests/filecheck/search/test_conv_prp_rnd.py   |   2 +-
 tests/filecheck/search/test_matmul_goto.py    | 220 +++++++++---------
 tests/filecheck/search/test_matmul_goto_r.py  | 220 +++++++++---------
 tests/filecheck/search/test_matmul_oo.py      | 110 ++++-----
 tests/filecheck/search/test_matmul_p1.py      | 220 +++++++++---------
 tests/filecheck/search/test_matmul_p1v.py     |  72 +++---
 tests/filecheck/search/test_matmul_pprprp.py  |  10 +-
 tests/filecheck/search/test_matmul_pprprpv.py |  10 +-
 .../filecheck/search/test_matmul_pprprpvr.py  |  10 +-
 .../search/test_matmul_pprprpvr_rnd.py        |   2 +-
 tests/filecheck/search/test_matmul_prp.py     |  54 ++---
 tests/filecheck/search/test_matmul_prp_rnd.py |   2 +-
 23 files changed, 756 insertions(+), 859 deletions(-)
 delete mode 100644 src/xtc/backends/mlir/MlirLoopNames.py

diff --git a/src/xtc/backends/mlir/MlirCompilerPasses.py b/src/xtc/backends/mlir/MlirCompilerPasses.py
index b766ab2a..2a0271d1 100644
--- a/src/xtc/backends/mlir/MlirCompilerPasses.py
+++ b/src/xtc/backends/mlir/MlirCompilerPasses.py
@@ -2,8 +2,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2024-2026 The XTC Project Authors
 #
-from .MlirLoopNames import parent_name
 from dataclasses import dataclass
+import subprocess
+
 from mlir.dialects import transform
 from mlir.dialects.transform import (
     NamedSequenceOp,
@@ -33,7 +34,6 @@
 )
 from mlir.passmanager import PassManager
 from mlir.ir import Module
-import subprocess
 
 # Import SDist if available
 try:
@@ -42,7 +42,7 @@
     sdist_transform = None
     pass
 
-from .MlirLoopNames import make_loop_name
+from xtc.schedules.loop_names import make_loop_name, parent_name
 from xtc.utils.ext_tools import transform_opts
 
 from .MlirProgram import RawMlirProgram
diff --git a/src/xtc/backends/mlir/MlirLoopNames.py b/src/xtc/backends/mlir/MlirLoopNames.py
deleted file mode 100644
index f6848e90..00000000
--- a/src/xtc/backends/mlir/MlirLoopNames.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2024-2026 The XTC Project Authors
-#
-__all__ = ["make_loop_name", "basename", "parent_name"]
-
-_LOOP_SEP = "/"
-
-
-def make_loop_name(root: str, name: str) -> str:
-    return f"{root}{_LOOP_SEP}{name}"
-
-
-def basename(loop_name: str) -> str:
-    return loop_name.split(_LOOP_SEP)[-1]
-
-
-def parent_name(loop_name: str) -> str:
-    return loop_name.rsplit(_LOOP_SEP, 1)[0]
diff --git a/src/xtc/backends/mlir/MlirNodeScheduler.py b/src/xtc/backends/mlir/MlirNodeScheduler.py
index 93203801..c41dfbfe 100644
--- a/src/xtc/backends/mlir/MlirNodeScheduler.py
+++ b/src/xtc/backends/mlir/MlirNodeScheduler.py
@@ -4,9 +4,9 @@
 #
 from typing_extensions import override
 from dataclasses import dataclass, asdict
-from pprint import pformat
+
 from xtc.itf.schd.scheduler import DEFAULT_ROOT
-from .MlirLoopNames import make_loop_name, basename
+from xtc.schedules.plain_schedule import PlainNodeSchedule, PlainNodeScheduler
 
 __all__ = [
     "MlirNodeScheduler",
@@ -15,58 +15,8 @@
 
 
 @dataclass(frozen=True)
-class MlirNodeSchedule:
-    node_name: str
-    node_ident: str
-    dims: list[str]
-    loop_stamps: list[str]
-    splits: dict[str, dict[str, int]]
-    tiles: dict[str, dict[str, int]]
-    permutation: dict[str, list[str]]
-    vectorization: list[str]
-    parallelization: list[str]
-    unrolling: dict[str, int]
-    packed_buffers: dict[str, list[int]]
-    memory_mesh: dict[str, int]
-    processor_mesh: dict[str, int]
-    distribution: dict[str, str]
-    distributed_buffers: dict[str, dict]
-    fused: list[tuple[str, int]]
-
-    def index_of_dim(self, dim: str) -> int:
-        return list(self.dims).index(dim)
-
-    def is_tile(self, loop_name: str) -> bool:
-        for tiles in self.tiles.values():
-            for tile in tiles:
-                if loop_name == tile:
-                    return True
-        return False
-
-    def is_base(self, loop_name: str) -> bool:
-        return basename(loop_name) in self.dims
-
-    def dim_of_tile(self, loop_name: str) -> str:
-        # Base dimension
-        bn = basename(loop_name)
-        if bn in self.dims:
-            return bn
-        # Tiled dimension
-        for dim, tiles in self.tiles.items():
-            for tile in tiles:
-                if bn == dim or loop_name == tile:
-                    return dim
-        assert False
-
-    def size_of_tile(self, tile_name: str) -> int | None:
-        for tiles in self.tiles.values():
-            if tile_name in tiles:
-                return tiles[tile_name]
-        return None
-
-    @override
-    def __str__(self):
-        return pformat(asdict(self))
+class MlirNodeSchedule(PlainNodeSchedule):
+    pass
 
 
 class MlirNodeScheduler:
@@ -93,81 +43,39 @@ def __init__(
         self.distribution: dict[str, str] = {}
         self.distributed_buffers: dict[str, dict] = {}
         self.fused: list[tuple[str, int]] = []
-
-    def mlir_node_schedule(self) -> MlirNodeSchedule:
-        if not self.permutation:
-            self.permutation[DEFAULT_ROOT] = self.get_default_interchange(DEFAULT_ROOT)
-
-        for fuse_axis in self.fused:
-            assert fuse_axis[0] in self.permutation[next(iter(self.permutation))], (
-                "Fusion must be to an axis in the base root not the result of a split."
-            )
-
-        return MlirNodeSchedule(
-            node_name=self.node_name,
-            node_ident=self.node_ident,
-            dims=self.dims,
-            loop_stamps=self.loop_stamps,
-            tiles=self.tiles,
-            splits=self.splits,
-            permutation=self.permutation,
-            vectorization=self.vectorization,
-            parallelization=self.parallelization,
-            unrolling=self.unrolling,
-            memory_mesh=self.memory_mesh,
-            packed_buffers=self.packed_buffers,
-            processor_mesh=self.processor_mesh,
-            distribution=self.distribution,
-            distributed_buffers=self.distributed_buffers,
-            fused=self.fused,
+        self._plain_sch = PlainNodeScheduler(
+            node_name,
+            node_ident,
+            dims,
         )
 
-    @override
-    def __str__(self) -> str:
-        return str(self.mlir_node_schedule())
-
-    def get_default_interchange(self, root: str) -> list[str]:
-        ret = [make_loop_name(root, d) for d in self.dims]
-        for tile_level in range(len(max(self.tiles.values(), key=len))):
-            for _, v in self.tiles.items():
-                if tile_level >= len(v):
-                    continue
-                dim_name = list(v.keys())[tile_level]
-                ret.append(dim_name)
-        return ret
-
     def set_dims(self, dims: list[str]) -> None:
-        assert len(dims) == len(self.dims)
-        self.dims = dims[:]
-        self.tiles = {k: {} for k in self.dims}
+        self._plain_sch.set_dims(dims)
 
     def split(
         self, dim: str, segments: dict[str, int], root: str = DEFAULT_ROOT
     ) -> None:
-        segments_renamed = {
-            make_loop_name(root, key): val for key, val in segments.items()
-        }
-        self.splits[dim] = segments_renamed
-        for s in segments_renamed:
-            self.tiles[s] = {}
+        self._plain_sch.split(dim, segments, root)
 
-    def tile(self, dim: str, tiles: dict[str, int], root: str = DEFAULT_ROOT):
-        for d, s in tiles.items():
-            tile_name = make_loop_name(root, d)
-            self.tiles[dim][tile_name] = s
+    def tile(self, dim: str, tiles: dict[str, int], root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.tile(dim, tiles, root)
 
-    def interchange(self, permutation: list[str], root: str = DEFAULT_ROOT):
-        self.permutation[root] = [make_loop_name(root, a) for a in permutation]
+    def interchange(self, permutation: list[str], root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.interchange(permutation, root)
 
-    def vectorize(self, axes: list[str], root: str = DEFAULT_ROOT):
-        self.vectorization += [make_loop_name(root, a) for a in axes]
+    def vectorize(self, axes: list[str], root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.vectorize(axes, root)
 
-    def parallelize(self, axes: list[str], root: str = DEFAULT_ROOT):
-        self.parallelization = [make_loop_name(root, a) for a in axes]
+    def parallelize(self, axes: list[str], root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.parallelize(axes, root)
 
-    def unroll(self, unrolls: dict[str, int], root: str = DEFAULT_ROOT):
-        for dim, ufactor in unrolls.items():
-            self.unrolling[make_loop_name(root, dim)] = ufactor
+    def unroll(self, unrolls: dict[str, int], root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.unroll(unrolls, root)
+
+    def buffer_at(
+        self, axis: str, mtype: str | None = None, root: str = DEFAULT_ROOT
+    ) -> None:
+        self._plain_sch.buffer_at(axis, mtype, root)
 
     def pack_at(
         self,
@@ -177,36 +85,16 @@ def pack_at(
         pad: bool = False,
         root: str = DEFAULT_ROOT,
     ):
-        axis_key = make_loop_name(root, axis)
-        if axis_key not in self.packed_buffers.keys():
-            self.packed_buffers[axis_key] = [input_idx]
-        else:
-            self.packed_buffers[axis_key].append(input_idx)
+        self._plain_sch.pack_at(axis, input_idx, mtype, pad, root)
 
     def define_memory_mesh(self, axes: dict[str, int]):
-        assert len(self.memory_mesh) == 0, "Memory mesh has already been defined"
-        self.memory_mesh = axes
+        self._plain_sch.define_memory_mesh(axes)
 
     def define_processor_mesh(self, axes: dict[str, int]):
-        assert len(self.processor_mesh) == 0, "Processor mesh has already been defined"
-        assert self.memory_mesh, "Memory mesh has not been defined"
-        assert len(self.memory_mesh) <= len(axes), (
-            "Memory mesh must be a subset of the processor mesh"
-        )
-        for i, memory_size in enumerate(self.memory_mesh.values()):
-            assert list(axes.values())[i] == memory_size, (
-                "Memory mesh must be a subset of the processor mesh"
-            )
-        self.processor_mesh = axes
+        self._plain_sch.define_processor_mesh(axes)
 
     def distribute(self, axis: str, processor_axis: str, root: str = DEFAULT_ROOT):
-        assert self.processor_mesh, "Processor mesh has not been defined"
-        assert processor_axis in self.processor_mesh or processor_axis == "*", (
-            "Processor axis not found in processor mesh"
-        )
-        axis_key = make_loop_name(root, axis)
-        self.parallelization.append(axis_key)
-        self.distribution[axis_key] = processor_axis
+        self._plain_sch.distribute(axis, processor_axis, root)
 
     def distributed_buffer_at(
         self,
@@ -215,18 +103,20 @@ def distributed_buffer_at(
         memory_axes: list[str],
         root: str = DEFAULT_ROOT,
     ):
-        assert self.memory_mesh, "Memory mesh has not been defined"
-        for ma in memory_axes:
-            assert ma in self.memory_mesh or ma == "*", (
-                "Memory axis not found in memory mesh"
-            )
-        axis_key = make_loop_name(root, axis)
-        self.distributed_buffers[axis_key] = {
-            "input_idx": input_idx,
-            "memory_axes": memory_axes,
-        }
+        self._plain_sch.distributed_buffer_at(axis, input_idx, memory_axes, root)
 
     def fuse_producer_at(
         self, axis: str, input_idx: int, root: str = DEFAULT_ROOT
     ) -> None:
-        self.fused.append((make_loop_name(root, axis), input_idx))
+        self._plain_sch.fuse_producer_at(axis, input_idx, root)
+
+    def fuse_consumer_at(self, axis: str, root: str = DEFAULT_ROOT) -> None:
+        self._plain_sch.fuse_consumer_at(axis, root)
+
+    def get_node_schedule(self) -> MlirNodeSchedule:
+        plain_schedule = self._plain_sch.get_plain_schedule()
+        return MlirNodeSchedule(**asdict(plain_schedule))
+
+    @override
+    def __str__(self) -> str:
+        return str(self.get_node_schedule())
diff --git a/src/xtc/backends/mlir/MlirScheduler.py b/src/xtc/backends/mlir/MlirScheduler.py
index 25d16374..3153b347 100644
--- a/src/xtc/backends/mlir/MlirScheduler.py
+++ b/src/xtc/backends/mlir/MlirScheduler.py
@@ -5,12 +5,13 @@
 from typing_extensions import override
 
 from xtc.itf.schd.scheduler import DEFAULT_ROOT
-from xtc.schedules.loop_nest import LoopNest, LoopNestNode, LoopInfo, SplitOrigin
+from xtc.schedules.loop_nest import LoopNest
+from xtc.schedules.loop_nest_builder import LoopNestBuilder
+
 import xtc.itf as itf
 import xtc.backends.mlir as backend
 
 from .MlirNodeScheduler import MlirNodeScheduler, MlirNodeSchedule
-from .MlirLoopNames import basename
 
 __all__ = [
     "MlirScheduler",
@@ -98,12 +99,12 @@ def schedule(self) -> itf.schd.Schedule:
 
         if isinstance(self._backend, MlirGraphBackend):
             nodes_schedules = [
-                scheduler._current_scheduler.mlir_node_schedule()
+                scheduler._current_scheduler.get_node_schedule()
                 for scheduler in self._nodes_schedulers
             ]
         else:
             assert isinstance(self._backend, MlirNodeBackend)
-            nodes_schedules = [self._current_scheduler.mlir_node_schedule()]
+            nodes_schedules = [self._current_scheduler.get_node_schedule()]
         return MlirSchedule(
             scheduler=self,
             nodes_schedules=nodes_schedules,
@@ -211,57 +212,8 @@ def distributed_buffer_at(
 
     @override
     def get_loop_nest(self) -> LoopNest:
-        node_sched = self._current_scheduler
-        dims = node_sched.dims[:]
-
-        loop_nest = LoopNest(abstract_dims=dims)
-        root_node = loop_nest.build_root_node(node_sched.node_name)
-
-        # Assign splits to root_node first, stripping the root prefix from names
-        for axis, axis_splits in node_sched.splits.items():
-            root_node.splits[axis] = {basename(k): v for k, v in axis_splits.items()}
-
-        # Build mapper to get splits_info
-        mapper = LoopInfo.build_from_node(root_node)
-
-        def populate_node(node: LoopNestNode, perm: list[str]) -> None:
-            """Populate node with data for loops in its permutation."""
-            perm_set = set(perm)
-            node.interchange = [basename(n) for n in perm]
-            for axis, axis_tiles in node_sched.tiles.items():
-                for tile_name, size in axis_tiles.items():
-                    if tile_name in perm_set:
-                        if axis not in node.tiles:
-                            node.tiles[axis] = {}
-                        node.tiles[axis][basename(tile_name)] = size
-            node.vectorize = [
-                basename(v) for v in node_sched.vectorization if v in perm_set
-            ]
-            node.parallelize = [
-                basename(p) for p in node_sched.parallelization if p in perm_set
-            ]
-            node.unroll = {
-                basename(k): v for k, v in node_sched.unrolling.items() if k in perm_set
-            }
-
-        # Process each root in permutation
-        for root, perm in node_sched.permutation.items():
-            root_name = basename(root)
-            if root_name in mapper.splits_info:
-                # This root is a split - create child node
-                axis, start, end = mapper.splits_info[root_name]
-                child = LoopNestNode(
-                    root=root_name,
-                    tiles={d: {} for d in dims},
-                    split_origin=SplitOrigin(axis=axis, start=start, end=end),
-                )
-                populate_node(child, perm)
-                root_node.add_child(child)
-            else:
-                # This is the main root
-                populate_node(root_node, perm)
-
-        return loop_nest
+        node_schedule = self._current_scheduler.get_node_schedule()
+        return LoopNestBuilder.from_plain_node_schedule(node_schedule)
 
 
 class MlirSchedule(itf.schd.Schedule):
diff --git a/src/xtc/schedules/plain_schedule.py b/src/xtc/schedules/plain_schedule.py
index b5924e81..5f34e972 100644
--- a/src/xtc/schedules/plain_schedule.py
+++ b/src/xtc/schedules/plain_schedule.py
@@ -10,7 +10,7 @@
 from copy import deepcopy
 
 from xtc.itf.schd.scheduler import DEFAULT_ROOT
-from xtc.schedules.loop_names import make_loop_name
+from xtc.schedules.loop_names import make_loop_name, basename
 
 
 @dataclass(frozen=True)
@@ -34,6 +34,37 @@ class PlainNodeSchedule:
     fused: list[tuple[str, int]]
     fused_consumers: list[str]
 
+    def index_of_dim(self, dim: str) -> int:
+        return list(self.dims).index(dim)
+
+    def is_tile(self, loop_name: str) -> bool:
+        for tiles in self.tiles.values():
+            for tile in tiles:
+                if loop_name == tile:
+                    return True
+        return False
+
+    def is_base(self, loop_name: str) -> bool:
+        return basename(loop_name) in self.dims
+
+    def dim_of_tile(self, loop_name: str) -> str:
+        # Base dimension
+        bn = basename(loop_name)
+        if bn in self.dims:
+            return bn
+        # Tiled dimension
+        for dim, tiles in self.tiles.items():
+            for tile in tiles:
+                if bn == dim or loop_name == tile:
+                    return dim
+        assert False
+
+    def size_of_tile(self, tile_name: str) -> int | None:
+        for tiles in self.tiles.values():
+            if tile_name in tiles:
+                return tiles[tile_name]
+        return None
+
     @override
     def __str__(self):
         return pformat(asdict(self))
@@ -68,7 +99,7 @@ def __init__(
 
     def get_plain_schedule(self) -> PlainNodeSchedule:
         if not self.permutation:
-            self.permutation[DEFAULT_ROOT] = self.get_default_interchange(DEFAULT_ROOT)
+            self.permutation[DEFAULT_ROOT] = self._get_default_interchange(DEFAULT_ROOT)
 
         for fuse_axis in self.fused:
             assert fuse_axis[0] in self.permutation[next(iter(self.permutation))], (
@@ -100,7 +131,7 @@ def get_plain_schedule(self) -> PlainNodeSchedule:
     def __str__(self) -> str:
         return str(self.get_plain_schedule())
 
-    def get_default_interchange(self, root: str) -> list[str]:
+    def _get_default_interchange(self, root: str) -> list[str]:
         ret = [make_loop_name(root, d) for d in self.dims]
         for tile_level in range(len(max(self.tiles.values(), key=len))):
             for _, v in self.tiles.items():
@@ -169,6 +200,49 @@ def pack_at(
         else:
             self.packed_buffers[axis_key].append((input_idx, mtype, pad))
 
+    def define_memory_mesh(self, axes: dict[str, int]):
+        assert len(self.memory_mesh) == 0, "Memory mesh has already been defined"
+        self.memory_mesh = axes
+
+    def define_processor_mesh(self, axes: dict[str, int]):
+        assert len(self.processor_mesh) == 0, "Processor mesh has already been defined"
+        assert self.memory_mesh, "Memory mesh has not been defined"
+        assert len(self.memory_mesh) <= len(axes), (
+            "Memory mesh must be a subset of the processor mesh"
+        )
+        for i, memory_size in enumerate(self.memory_mesh.values()):
+            assert list(axes.values())[i] == memory_size, (
+                "Memory mesh must be a subset of the processor mesh"
+            )
+        self.processor_mesh = axes
+
+    def distribute(self, axis: str, processor_axis: str, root: str = DEFAULT_ROOT):
+        assert self.processor_mesh, "Processor mesh has not been defined"
+        assert processor_axis in self.processor_mesh or processor_axis == "*", (
+            "Processor axis not found in processor mesh"
+        )
+        axis_key = make_loop_name(root, axis)
+        self.parallelization.append(axis_key)
+        self.distribution[axis_key] = processor_axis
+
+    def distributed_buffer_at(
+        self,
+        axis: str,
+        input_idx: int,
+        memory_axes: list[str],
+        root: str = DEFAULT_ROOT,
+    ):
+        assert self.memory_mesh, "Memory mesh has not been defined"
+        for ma in memory_axes:
+            assert ma in self.memory_mesh or ma == "*", (
+                "Memory axis not found in memory mesh"
+            )
+        axis_key = make_loop_name(root, axis)
+        self.distributed_buffers[axis_key] = {
+            "input_idx": input_idx,
+            "memory_axes": memory_axes,
+        }
+
     def fuse_producer_at(
         self, axis: str, input_idx: int, root: str = DEFAULT_ROOT
     ) -> None:
diff --git a/tests/filecheck/search/test_conv_oo.py b/tests/filecheck/search/test_conv_oo.py
index ff036f81..a9014e72 100644
--- a/tests/filecheck/search/test_conv_oo.py
+++ b/tests/filecheck/search/test_conv_oo.py
@@ -12,91 +12,91 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 2, 16, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 2, 16, 1, 1, 3]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 3, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 3]
-# CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 7, 1]
-# CHECK-NEXT: sample 3: [1, 1, 1, 1, 7, 1, 1]
-# CHECK-NEXT: sample 4: [1, 1, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 5: [1, 1, 1, 2, 1, 1, 3]
-# CHECK-NEXT: sample 6: [1, 1, 1, 2, 1, 7, 1]
-# CHECK-NEXT: sample 7: [1, 1, 1, 2, 7, 1, 1]
-# CHECK-NEXT: sample 8: [1, 1, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 9: [1, 1, 1, 4, 1, 1, 3]
-# CHECK-NEXT: sample 10: [1, 1, 1, 4, 1, 7, 1]
-# CHECK-NEXT: sample 11: [1, 1, 1, 4, 7, 1, 1]
-# CHECK-NEXT: sample 12: [1, 1, 1, 8, 1, 1, 1]
-# CHECK-NEXT: sample 13: [1, 1, 1, 8, 1, 1, 3]
-# CHECK-NEXT: sample 14: [1, 1, 1, 8, 1, 7, 1]
-# CHECK-NEXT: sample 15: [1, 1, 1, 8, 7, 1, 1]
-# CHECK-NEXT: sample 16: [1, 1, 1, 16, 1, 1, 1]
-# CHECK-NEXT: sample 17: [1, 1, 1, 16, 1, 1, 3]
-# CHECK-NEXT: sample 18: [1, 1, 1, 16, 1, 7, 1]
-# CHECK-NEXT: sample 19: [1, 1, 1, 16, 7, 1, 1]
-# CHECK-NEXT: sample 20: [1, 1, 1, 32, 1, 1, 1]
-# CHECK-NEXT: sample 21: [1, 1, 1, 32, 1, 1, 3]
-# CHECK-NEXT: sample 22: [1, 1, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 23: [1, 1, 2, 1, 1, 1, 3]
-# CHECK-NEXT: sample 24: [1, 1, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 25: [1, 1, 2, 2, 1, 1, 3]
-# CHECK-NEXT: sample 26: [1, 1, 2, 4, 1, 1, 1]
-# CHECK-NEXT: sample 27: [1, 1, 2, 4, 1, 1, 3]
-# CHECK-NEXT: sample 28: [1, 1, 2, 8, 1, 1, 1]
-# CHECK-NEXT: sample 29: [1, 1, 2, 8, 1, 1, 3]
-# CHECK-NEXT: sample 30: [1, 1, 2, 16, 1, 1, 1]
-# CHECK-NEXT: sample 31: [1, 1, 2, 16, 1, 1, 3]
-# CHECK-NEXT: sample 32: [1, 1, 2, 32, 1, 1, 1]
-# CHECK-NEXT: sample 33: [1, 2, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 34: [1, 2, 1, 1, 1, 1, 3]
-# CHECK-NEXT: sample 35: [1, 2, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 36: [1, 2, 1, 2, 1, 1, 3]
-# CHECK-NEXT: sample 37: [1, 2, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 38: [1, 2, 1, 4, 1, 1, 3]
-# CHECK-NEXT: sample 39: [1, 2, 1, 8, 1, 1, 1]
-# CHECK-NEXT: sample 40: [1, 2, 1, 8, 1, 1, 3]
-# CHECK-NEXT: sample 41: [1, 2, 1, 16, 1, 1, 1]
-# CHECK-NEXT: sample 42: [1, 2, 1, 16, 1, 1, 3]
-# CHECK-NEXT: sample 43: [1, 2, 1, 32, 1, 1, 1]
-# CHECK-NEXT: sample 44: [1, 2, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 45: [1, 2, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 46: [1, 2, 2, 4, 1, 1, 1]
-# CHECK-NEXT: sample 47: [1, 2, 2, 8, 1, 1, 1]
-# CHECK-NEXT: sample 48: [1, 2, 2, 16, 1, 1, 1]
-# CHECK-NEXT: sample 49: [1, 2, 2, 32, 1, 1, 1]
-# CHECK-NEXT: sample 50: [2, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 51: [2, 1, 1, 1, 1, 1, 3]
-# CHECK-NEXT: sample 52: [2, 1, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 53: [2, 1, 1, 2, 1, 1, 3]
-# CHECK-NEXT: sample 54: [2, 1, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 55: [2, 1, 1, 4, 1, 1, 3]
-# CHECK-NEXT: sample 56: [2, 1, 1, 8, 1, 1, 1]
-# CHECK-NEXT: sample 57: [2, 1, 1, 8, 1, 1, 3]
-# CHECK-NEXT: sample 58: [2, 1, 1, 16, 1, 1, 1]
-# CHECK-NEXT: sample 59: [2, 1, 1, 16, 1, 1, 3]
-# CHECK-NEXT: sample 60: [2, 1, 1, 32, 1, 1, 1]
-# CHECK-NEXT: sample 61: [2, 1, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 62: [2, 1, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 63: [2, 1, 2, 4, 1, 1, 1]
-# CHECK-NEXT: sample 64: [2, 1, 2, 8, 1, 1, 1]
-# CHECK-NEXT: sample 65: [2, 1, 2, 16, 1, 1, 1]
-# CHECK-NEXT: sample 66: [2, 1, 2, 32, 1, 1, 1]
-# CHECK-NEXT: sample 67: [2, 2, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 68: [2, 2, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 69: [2, 2, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 70: [2, 2, 1, 8, 1, 1, 1]
-# CHECK-NEXT: sample 71: [2, 2, 1, 16, 1, 1, 1]
-# CHECK-NEXT: sample 72: [2, 2, 1, 32, 1, 1, 1]
-# CHECK-NEXT: sample 73: [2, 2, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 74: [2, 2, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 75: [2, 2, 2, 4, 1, 1, 1]
-# CHECK-NEXT: sample 76: [2, 2, 2, 8, 1, 1, 1]
-# CHECK-NEXT: sample 77: [2, 2, 2, 16, 1, 1, 1]
-# CHECK-NEXT: stats {'filtered': 78, 'all': 384}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './c1': 1, './s1': 1, './r1': 1, './b1': 2}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 2, 16, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 2, 16, 1, 1, 3]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 3, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 3]
+# CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 7, 1]
+# CHECK-NEXT:  sample 3: [1, 1, 1, 1, 7, 1, 1]
+# CHECK-NEXT:  sample 4: [1, 1, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 5: [1, 1, 1, 2, 1, 1, 3]
+# CHECK-NEXT:  sample 6: [1, 1, 1, 2, 1, 7, 1]
+# CHECK-NEXT:  sample 7: [1, 1, 1, 2, 7, 1, 1]
+# CHECK-NEXT:  sample 8: [1, 1, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 9: [1, 1, 1, 4, 1, 1, 3]
+# CHECK-NEXT:  sample 10: [1, 1, 1, 4, 1, 7, 1]
+# CHECK-NEXT:  sample 11: [1, 1, 1, 4, 7, 1, 1]
+# CHECK-NEXT:  sample 12: [1, 1, 1, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 13: [1, 1, 1, 8, 1, 1, 3]
+# CHECK-NEXT:  sample 14: [1, 1, 1, 8, 1, 7, 1]
+# CHECK-NEXT:  sample 15: [1, 1, 1, 8, 7, 1, 1]
+# CHECK-NEXT:  sample 16: [1, 1, 1, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 17: [1, 1, 1, 16, 1, 1, 3]
+# CHECK-NEXT:  sample 18: [1, 1, 1, 16, 1, 7, 1]
+# CHECK-NEXT:  sample 19: [1, 1, 1, 16, 7, 1, 1]
+# CHECK-NEXT:  sample 20: [1, 1, 1, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 21: [1, 1, 1, 32, 1, 1, 3]
+# CHECK-NEXT:  sample 22: [1, 1, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 23: [1, 1, 2, 1, 1, 1, 3]
+# CHECK-NEXT:  sample 24: [1, 1, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 25: [1, 1, 2, 2, 1, 1, 3]
+# CHECK-NEXT:  sample 26: [1, 1, 2, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 27: [1, 1, 2, 4, 1, 1, 3]
+# CHECK-NEXT:  sample 28: [1, 1, 2, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 29: [1, 1, 2, 8, 1, 1, 3]
+# CHECK-NEXT:  sample 30: [1, 1, 2, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 31: [1, 1, 2, 16, 1, 1, 3]
+# CHECK-NEXT:  sample 32: [1, 1, 2, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 33: [1, 2, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 34: [1, 2, 1, 1, 1, 1, 3]
+# CHECK-NEXT:  sample 35: [1, 2, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 36: [1, 2, 1, 2, 1, 1, 3]
+# CHECK-NEXT:  sample 37: [1, 2, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 38: [1, 2, 1, 4, 1, 1, 3]
+# CHECK-NEXT:  sample 39: [1, 2, 1, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 40: [1, 2, 1, 8, 1, 1, 3]
+# CHECK-NEXT:  sample 41: [1, 2, 1, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 42: [1, 2, 1, 16, 1, 1, 3]
+# CHECK-NEXT:  sample 43: [1, 2, 1, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 44: [1, 2, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 45: [1, 2, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 46: [1, 2, 2, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 47: [1, 2, 2, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 48: [1, 2, 2, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 49: [1, 2, 2, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 50: [2, 1, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 51: [2, 1, 1, 1, 1, 1, 3]
+# CHECK-NEXT:  sample 52: [2, 1, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 53: [2, 1, 1, 2, 1, 1, 3]
+# CHECK-NEXT:  sample 54: [2, 1, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 55: [2, 1, 1, 4, 1, 1, 3]
+# CHECK-NEXT:  sample 56: [2, 1, 1, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 57: [2, 1, 1, 8, 1, 1, 3]
+# CHECK-NEXT:  sample 58: [2, 1, 1, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 59: [2, 1, 1, 16, 1, 1, 3]
+# CHECK-NEXT:  sample 60: [2, 1, 1, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 61: [2, 1, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 62: [2, 1, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 63: [2, 1, 2, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 64: [2, 1, 2, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 65: [2, 1, 2, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 66: [2, 1, 2, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 67: [2, 2, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 68: [2, 2, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 69: [2, 2, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 70: [2, 2, 1, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 71: [2, 2, 1, 16, 1, 1, 1]
+# CHECK-NEXT:  sample 72: [2, 2, 1, 32, 1, 1, 1]
+# CHECK-NEXT:  sample 73: [2, 2, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 74: [2, 2, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 75: [2, 2, 2, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 76: [2, 2, 2, 8, 1, 1, 1]
+# CHECK-NEXT:  sample 77: [2, 2, 2, 16, 1, 1, 1]
+# CHECK-NEXT:  stats {'filtered': 78, 'all': 384}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './c1': 1, './s1': 1, './r1': 1, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_pprprp.py b/tests/filecheck/search/test_conv_pprprp.py
index 092174ae..8ee0024e 100644
--- a/tests/filecheck/search/test_conv_pprprp.py
+++ b/tests/filecheck/search/test_conv_pprprp.py
@@ -13,13 +13,13 @@
 utils.print_exhaustive_samples(backend, strategy, 100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1]
@@ -121,4 +121,4 @@
 # CHECK-NEXT:  sample 98: [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 16, 1, 1, 1]
 # CHECK-NEXT:  sample 99: [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 16, 1, 1, 3]
 # CHECK-NEXT:  stats {'filtered': 100, 'all': 202}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_pprprpv.py b/tests/filecheck/search/test_conv_pprprpv.py
index f326c9e0..2de3243f 100644
--- a/tests/filecheck/search/test_conv_pprprpv.py
+++ b/tests/filecheck/search/test_conv_pprprpv.py
@@ -13,13 +13,13 @@
 utils.print_exhaustive_samples(backend, strategy, 100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 3]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 7, 1]
@@ -121,4 +121,4 @@
 # CHECK-NEXT:  sample 98: [1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 16, 7, 1, 1]
 # CHECK-NEXT:  sample 99: [1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 32, 1, 1, 1]
 # CHECK-NEXT:  stats {'filtered_vec': 100, 'filtered': 1520, 'all': 4521}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_pprprpvr.py b/tests/filecheck/search/test_conv_pprprpvr.py
index 1370a663..bb5f02e2 100644
--- a/tests/filecheck/search/test_conv_pprprpvr.py
+++ b/tests/filecheck/search/test_conv_pprprpvr.py
@@ -20,13 +20,13 @@
 utils.print_exhaustive_samples(backend, strategy, 100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 3]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 7, 1]
@@ -128,4 +128,4 @@
 # CHECK-NEXT:  sample 98: [1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 32, 1, 1, 1]
 # CHECK-NEXT:  sample 99: [1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 32, 1, 1, 3]
 # CHECK-NEXT:  stats {'filtered_l2': 100, 'filtered_l1': 102, 'filtered_reg': 132, 'filtered_vec': 134, 'filtered': 1918, 'all': 3178}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 2}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 2, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 2}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 2, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_pprprpvr_rnd.py b/tests/filecheck/search/test_conv_pprprpvr_rnd.py
index d3f24b0c..33d91bbf 100644
--- a/tests/filecheck/search/test_conv_pprprpvr_rnd.py
+++ b/tests/filecheck/search/test_conv_pprprpvr_rnd.py
@@ -39,4 +39,4 @@
 # CHECK-NEXT:  sample 18: [1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 16, 7, 1, 1]
 # CHECK-NEXT:  sample 19: [1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1, 16, 1, 1, 1]
 # CHECK-NEXT:  stats {'filtered_l2': 5, 'filtered_l1': 5, 'filtered_reg': 6, 'filtered_vec': 6, 'filtered': 100}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2, './b2': 2, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2, './b2': 2, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_prp.py b/tests/filecheck/search/test_conv_prp.py
index 67c5d27d..ff3d2362 100644
--- a/tests/filecheck/search/test_conv_prp.py
+++ b/tests/filecheck/search/test_conv_prp.py
@@ -12,60 +12,60 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 2, 16]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 2, 16]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1, 1, 1]
-# CHECK-NEXT: sample 1: [1, 1, 1, 2]
-# CHECK-NEXT: sample 2: [1, 1, 1, 4]
-# CHECK-NEXT: sample 3: [1, 1, 1, 8]
-# CHECK-NEXT: sample 4: [1, 1, 1, 16]
-# CHECK-NEXT: sample 5: [1, 1, 1, 32]
-# CHECK-NEXT: sample 6: [1, 1, 2, 1]
-# CHECK-NEXT: sample 7: [1, 1, 2, 2]
-# CHECK-NEXT: sample 8: [1, 1, 2, 4]
-# CHECK-NEXT: sample 9: [1, 1, 2, 8]
-# CHECK-NEXT: sample 10: [1, 1, 2, 16]
-# CHECK-NEXT: sample 11: [1, 1, 2, 32]
-# CHECK-NEXT: sample 12: [1, 2, 1, 1]
-# CHECK-NEXT: sample 13: [1, 2, 1, 2]
-# CHECK-NEXT: sample 14: [1, 2, 1, 4]
-# CHECK-NEXT: sample 15: [1, 2, 1, 8]
-# CHECK-NEXT: sample 16: [1, 2, 1, 16]
-# CHECK-NEXT: sample 17: [1, 2, 1, 32]
-# CHECK-NEXT: sample 18: [1, 2, 2, 1]
-# CHECK-NEXT: sample 19: [1, 2, 2, 2]
-# CHECK-NEXT: sample 20: [1, 2, 2, 4]
-# CHECK-NEXT: sample 21: [1, 2, 2, 8]
-# CHECK-NEXT: sample 22: [1, 2, 2, 16]
-# CHECK-NEXT: sample 23: [1, 2, 2, 32]
-# CHECK-NEXT: sample 24: [2, 1, 1, 1]
-# CHECK-NEXT: sample 25: [2, 1, 1, 2]
-# CHECK-NEXT: sample 26: [2, 1, 1, 4]
-# CHECK-NEXT: sample 27: [2, 1, 1, 8]
-# CHECK-NEXT: sample 28: [2, 1, 1, 16]
-# CHECK-NEXT: sample 29: [2, 1, 1, 32]
-# CHECK-NEXT: sample 30: [2, 1, 2, 1]
-# CHECK-NEXT: sample 31: [2, 1, 2, 2]
-# CHECK-NEXT: sample 32: [2, 1, 2, 4]
-# CHECK-NEXT: sample 33: [2, 1, 2, 8]
-# CHECK-NEXT: sample 34: [2, 1, 2, 16]
-# CHECK-NEXT: sample 35: [2, 1, 2, 32]
-# CHECK-NEXT: sample 36: [2, 2, 1, 1]
-# CHECK-NEXT: sample 37: [2, 2, 1, 2]
-# CHECK-NEXT: sample 38: [2, 2, 1, 4]
-# CHECK-NEXT: sample 39: [2, 2, 1, 8]
-# CHECK-NEXT: sample 40: [2, 2, 1, 16]
-# CHECK-NEXT: sample 41: [2, 2, 1, 32]
-# CHECK-NEXT: sample 42: [2, 2, 2, 1]
-# CHECK-NEXT: sample 43: [2, 2, 2, 2]
-# CHECK-NEXT: sample 44: [2, 2, 2, 4]
-# CHECK-NEXT: sample 45: [2, 2, 2, 8]
-# CHECK-NEXT: sample 46: [2, 2, 2, 16]
-# CHECK-NEXT: stats {'filtered': 47, 'all': 48}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './b1': 2}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 2, 16]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 2, 16]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1, 1, 1]
+# CHECK-NEXT:  sample 1: [1, 1, 1, 2]
+# CHECK-NEXT:  sample 2: [1, 1, 1, 4]
+# CHECK-NEXT:  sample 3: [1, 1, 1, 8]
+# CHECK-NEXT:  sample 4: [1, 1, 1, 16]
+# CHECK-NEXT:  sample 5: [1, 1, 1, 32]
+# CHECK-NEXT:  sample 6: [1, 1, 2, 1]
+# CHECK-NEXT:  sample 7: [1, 1, 2, 2]
+# CHECK-NEXT:  sample 8: [1, 1, 2, 4]
+# CHECK-NEXT:  sample 9: [1, 1, 2, 8]
+# CHECK-NEXT:  sample 10: [1, 1, 2, 16]
+# CHECK-NEXT:  sample 11: [1, 1, 2, 32]
+# CHECK-NEXT:  sample 12: [1, 2, 1, 1]
+# CHECK-NEXT:  sample 13: [1, 2, 1, 2]
+# CHECK-NEXT:  sample 14: [1, 2, 1, 4]
+# CHECK-NEXT:  sample 15: [1, 2, 1, 8]
+# CHECK-NEXT:  sample 16: [1, 2, 1, 16]
+# CHECK-NEXT:  sample 17: [1, 2, 1, 32]
+# CHECK-NEXT:  sample 18: [1, 2, 2, 1]
+# CHECK-NEXT:  sample 19: [1, 2, 2, 2]
+# CHECK-NEXT:  sample 20: [1, 2, 2, 4]
+# CHECK-NEXT:  sample 21: [1, 2, 2, 8]
+# CHECK-NEXT:  sample 22: [1, 2, 2, 16]
+# CHECK-NEXT:  sample 23: [1, 2, 2, 32]
+# CHECK-NEXT:  sample 24: [2, 1, 1, 1]
+# CHECK-NEXT:  sample 25: [2, 1, 1, 2]
+# CHECK-NEXT:  sample 26: [2, 1, 1, 4]
+# CHECK-NEXT:  sample 27: [2, 1, 1, 8]
+# CHECK-NEXT:  sample 28: [2, 1, 1, 16]
+# CHECK-NEXT:  sample 29: [2, 1, 1, 32]
+# CHECK-NEXT:  sample 30: [2, 1, 2, 1]
+# CHECK-NEXT:  sample 31: [2, 1, 2, 2]
+# CHECK-NEXT:  sample 32: [2, 1, 2, 4]
+# CHECK-NEXT:  sample 33: [2, 1, 2, 8]
+# CHECK-NEXT:  sample 34: [2, 1, 2, 16]
+# CHECK-NEXT:  sample 35: [2, 1, 2, 32]
+# CHECK-NEXT:  sample 36: [2, 2, 1, 1]
+# CHECK-NEXT:  sample 37: [2, 2, 1, 2]
+# CHECK-NEXT:  sample 38: [2, 2, 1, 4]
+# CHECK-NEXT:  sample 39: [2, 2, 1, 8]
+# CHECK-NEXT:  sample 40: [2, 2, 1, 16]
+# CHECK-NEXT:  sample 41: [2, 2, 1, 32]
+# CHECK-NEXT:  sample 42: [2, 2, 2, 1]
+# CHECK-NEXT:  sample 43: [2, 2, 2, 2]
+# CHECK-NEXT:  sample 44: [2, 2, 2, 4]
+# CHECK-NEXT:  sample 45: [2, 2, 2, 8]
+# CHECK-NEXT:  sample 46: [2, 2, 2, 16]
+# CHECK-NEXT:  stats {'filtered': 47, 'all': 48}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_conv_prp_rnd.py b/tests/filecheck/search/test_conv_prp_rnd.py
index 45ef6a7f..6744f13f 100644
--- a/tests/filecheck/search/test_conv_prp_rnd.py
+++ b/tests/filecheck/search/test_conv_prp_rnd.py
@@ -39,4 +39,4 @@
 # CHECK-NEXT:  sample 18: [2, 2, 1, 8]
 # CHECK-NEXT:  sample 19: [2, 2, 1, 4]
 # CHECK-NEXT:  stats {'filtered': 20}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 1}, 'f': {'./f1': 4}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=['./b', './h', './w', './f'], unrolling={'./f1': 4, './w1': 1, './h1': 2, './b1': 2}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 1}, 'f': {'./f1': 4}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=['./b', './h', './w', './f'], unrolling={'./f1': 4, './w1': 1, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_goto.py b/tests/filecheck/search/test_matmul_goto.py
index 444f4fb7..5928c10e 100644
--- a/tests/filecheck/search/test_matmul_goto.py
+++ b/tests/filecheck/search/test_matmul_goto.py
@@ -12,113 +12,113 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 0, 0]
-# CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 0, 1]
-# CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 1, 0]
-# CHECK-NEXT: sample 3: [1, 1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 4: [1, 1, 1, 1, 1, 2, 0, 0]
-# CHECK-NEXT: sample 5: [1, 1, 1, 1, 1, 2, 0, 1]
-# CHECK-NEXT: sample 6: [1, 1, 1, 1, 1, 2, 1, 0]
-# CHECK-NEXT: sample 7: [1, 1, 1, 1, 1, 2, 1, 1]
-# CHECK-NEXT: sample 8: [1, 1, 1, 1, 1, 3, 0, 0]
-# CHECK-NEXT: sample 9: [1, 1, 1, 1, 1, 3, 0, 1]
-# CHECK-NEXT: sample 10: [1, 1, 1, 1, 1, 3, 1, 0]
-# CHECK-NEXT: sample 11: [1, 1, 1, 1, 1, 3, 1, 1]
-# CHECK-NEXT: sample 12: [1, 1, 1, 1, 1, 4, 0, 0]
-# CHECK-NEXT: sample 13: [1, 1, 1, 1, 1, 4, 0, 1]
-# CHECK-NEXT: sample 14: [1, 1, 1, 1, 1, 4, 1, 0]
-# CHECK-NEXT: sample 15: [1, 1, 1, 1, 1, 4, 1, 1]
-# CHECK-NEXT: sample 16: [1, 1, 1, 1, 1, 6, 0, 0]
-# CHECK-NEXT: sample 17: [1, 1, 1, 1, 1, 6, 0, 1]
-# CHECK-NEXT: sample 18: [1, 1, 1, 1, 1, 6, 1, 0]
-# CHECK-NEXT: sample 19: [1, 1, 1, 1, 1, 6, 1, 1]
-# CHECK-NEXT: sample 20: [1, 1, 1, 1, 2, 1, 0, 0]
-# CHECK-NEXT: sample 21: [1, 1, 1, 1, 2, 1, 0, 1]
-# CHECK-NEXT: sample 22: [1, 1, 1, 1, 2, 1, 1, 0]
-# CHECK-NEXT: sample 23: [1, 1, 1, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 24: [1, 1, 1, 1, 2, 2, 0, 0]
-# CHECK-NEXT: sample 25: [1, 1, 1, 1, 2, 2, 0, 1]
-# CHECK-NEXT: sample 26: [1, 1, 1, 1, 2, 2, 1, 0]
-# CHECK-NEXT: sample 27: [1, 1, 1, 1, 2, 2, 1, 1]
-# CHECK-NEXT: sample 28: [1, 1, 1, 1, 2, 3, 0, 0]
-# CHECK-NEXT: sample 29: [1, 1, 1, 1, 2, 3, 0, 1]
-# CHECK-NEXT: sample 30: [1, 1, 1, 1, 2, 3, 1, 0]
-# CHECK-NEXT: sample 31: [1, 1, 1, 1, 2, 3, 1, 1]
-# CHECK-NEXT: sample 32: [1, 1, 1, 1, 2, 6, 0, 0]
-# CHECK-NEXT: sample 33: [1, 1, 1, 1, 2, 6, 0, 1]
-# CHECK-NEXT: sample 34: [1, 1, 1, 1, 2, 6, 1, 0]
-# CHECK-NEXT: sample 35: [1, 1, 1, 1, 2, 6, 1, 1]
-# CHECK-NEXT: sample 36: [1, 1, 1, 1, 3, 1, 0, 0]
-# CHECK-NEXT: sample 37: [1, 1, 1, 1, 3, 1, 0, 1]
-# CHECK-NEXT: sample 38: [1, 1, 1, 1, 3, 1, 1, 0]
-# CHECK-NEXT: sample 39: [1, 1, 1, 1, 3, 1, 1, 1]
-# CHECK-NEXT: sample 40: [1, 1, 1, 1, 3, 2, 0, 0]
-# CHECK-NEXT: sample 41: [1, 1, 1, 1, 3, 2, 0, 1]
-# CHECK-NEXT: sample 42: [1, 1, 1, 1, 3, 2, 1, 0]
-# CHECK-NEXT: sample 43: [1, 1, 1, 1, 3, 2, 1, 1]
-# CHECK-NEXT: sample 44: [1, 1, 1, 1, 3, 4, 0, 0]
-# CHECK-NEXT: sample 45: [1, 1, 1, 1, 3, 4, 0, 1]
-# CHECK-NEXT: sample 46: [1, 1, 1, 1, 3, 4, 1, 0]
-# CHECK-NEXT: sample 47: [1, 1, 1, 1, 3, 4, 1, 1]
-# CHECK-NEXT: sample 48: [1, 1, 1, 1, 4, 1, 0, 0]
-# CHECK-NEXT: sample 49: [1, 1, 1, 1, 4, 1, 0, 1]
-# CHECK-NEXT: sample 50: [1, 1, 1, 1, 4, 1, 1, 0]
-# CHECK-NEXT: sample 51: [1, 1, 1, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 52: [1, 1, 1, 1, 4, 3, 0, 0]
-# CHECK-NEXT: sample 53: [1, 1, 1, 1, 4, 3, 0, 1]
-# CHECK-NEXT: sample 54: [1, 1, 1, 1, 4, 3, 1, 0]
-# CHECK-NEXT: sample 55: [1, 1, 1, 1, 4, 3, 1, 1]
-# CHECK-NEXT: sample 56: [1, 1, 1, 1, 6, 1, 0, 0]
-# CHECK-NEXT: sample 57: [1, 1, 1, 1, 6, 1, 0, 1]
-# CHECK-NEXT: sample 58: [1, 1, 1, 1, 6, 1, 1, 0]
-# CHECK-NEXT: sample 59: [1, 1, 1, 1, 6, 1, 1, 1]
-# CHECK-NEXT: sample 60: [1, 1, 1, 1, 6, 2, 0, 0]
-# CHECK-NEXT: sample 61: [1, 1, 1, 1, 6, 2, 0, 1]
-# CHECK-NEXT: sample 62: [1, 1, 1, 1, 6, 2, 1, 0]
-# CHECK-NEXT: sample 63: [1, 1, 1, 1, 6, 2, 1, 1]
-# CHECK-NEXT: sample 64: [1, 1, 1, 1, 12, 1, 0, 0]
-# CHECK-NEXT: sample 65: [1, 1, 1, 1, 12, 1, 0, 1]
-# CHECK-NEXT: sample 66: [1, 1, 1, 1, 12, 1, 1, 0]
-# CHECK-NEXT: sample 67: [1, 1, 1, 1, 12, 1, 1, 1]
-# CHECK-NEXT: sample 68: [1, 1, 1, 2, 1, 1, 0, 0]
-# CHECK-NEXT: sample 69: [1, 1, 1, 2, 1, 1, 0, 1]
-# CHECK-NEXT: sample 70: [1, 1, 1, 2, 1, 1, 1, 0]
-# CHECK-NEXT: sample 71: [1, 1, 1, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 72: [1, 1, 1, 2, 1, 2, 0, 0]
-# CHECK-NEXT: sample 73: [1, 1, 1, 2, 1, 2, 0, 1]
-# CHECK-NEXT: sample 74: [1, 1, 1, 2, 1, 2, 1, 0]
-# CHECK-NEXT: sample 75: [1, 1, 1, 2, 1, 2, 1, 1]
-# CHECK-NEXT: sample 76: [1, 1, 1, 2, 1, 3, 0, 0]
-# CHECK-NEXT: sample 77: [1, 1, 1, 2, 1, 3, 0, 1]
-# CHECK-NEXT: sample 78: [1, 1, 1, 2, 1, 3, 1, 0]
-# CHECK-NEXT: sample 79: [1, 1, 1, 2, 1, 3, 1, 1]
-# CHECK-NEXT: sample 80: [1, 1, 1, 2, 1, 4, 0, 0]
-# CHECK-NEXT: sample 81: [1, 1, 1, 2, 1, 4, 0, 1]
-# CHECK-NEXT: sample 82: [1, 1, 1, 2, 1, 4, 1, 0]
-# CHECK-NEXT: sample 83: [1, 1, 1, 2, 1, 4, 1, 1]
-# CHECK-NEXT: sample 84: [1, 1, 1, 2, 1, 6, 0, 0]
-# CHECK-NEXT: sample 85: [1, 1, 1, 2, 1, 6, 0, 1]
-# CHECK-NEXT: sample 86: [1, 1, 1, 2, 1, 6, 1, 0]
-# CHECK-NEXT: sample 87: [1, 1, 1, 2, 1, 6, 1, 1]
-# CHECK-NEXT: sample 88: [1, 1, 1, 2, 2, 1, 0, 0]
-# CHECK-NEXT: sample 89: [1, 1, 1, 2, 2, 1, 0, 1]
-# CHECK-NEXT: sample 90: [1, 1, 1, 2, 2, 1, 1, 0]
-# CHECK-NEXT: sample 91: [1, 1, 1, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 92: [1, 1, 1, 2, 2, 2, 0, 0]
-# CHECK-NEXT: sample 93: [1, 1, 1, 2, 2, 2, 0, 1]
-# CHECK-NEXT: sample 94: [1, 1, 1, 2, 2, 2, 1, 0]
-# CHECK-NEXT: sample 95: [1, 1, 1, 2, 2, 2, 1, 1]
-# CHECK-NEXT: sample 96: [1, 1, 1, 2, 2, 3, 0, 0]
-# CHECK-NEXT: sample 97: [1, 1, 1, 2, 2, 3, 0, 1]
-# CHECK-NEXT: sample 98: [1, 1, 1, 2, 2, 3, 1, 0]
-# CHECK-NEXT: sample 99: [1, 1, 1, 2, 2, 3, 1, 1]
-# CHECK-NEXT: stats {'filtered': 100, 'all': 108}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 2, './j2': 2}, 'k': {'./k1': 2}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 3}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 0, 0]
+# CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 0, 1]
+# CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 1, 1, 0]
+# CHECK-NEXT:  sample 3: [1, 1, 1, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 4: [1, 1, 1, 1, 1, 2, 0, 0]
+# CHECK-NEXT:  sample 5: [1, 1, 1, 1, 1, 2, 0, 1]
+# CHECK-NEXT:  sample 6: [1, 1, 1, 1, 1, 2, 1, 0]
+# CHECK-NEXT:  sample 7: [1, 1, 1, 1, 1, 2, 1, 1]
+# CHECK-NEXT:  sample 8: [1, 1, 1, 1, 1, 3, 0, 0]
+# CHECK-NEXT:  sample 9: [1, 1, 1, 1, 1, 3, 0, 1]
+# CHECK-NEXT:  sample 10: [1, 1, 1, 1, 1, 3, 1, 0]
+# CHECK-NEXT:  sample 11: [1, 1, 1, 1, 1, 3, 1, 1]
+# CHECK-NEXT:  sample 12: [1, 1, 1, 1, 1, 4, 0, 0]
+# CHECK-NEXT:  sample 13: [1, 1, 1, 1, 1, 4, 0, 1]
+# CHECK-NEXT:  sample 14: [1, 1, 1, 1, 1, 4, 1, 0]
+# CHECK-NEXT:  sample 15: [1, 1, 1, 1, 1, 4, 1, 1]
+# CHECK-NEXT:  sample 16: [1, 1, 1, 1, 1, 6, 0, 0]
+# CHECK-NEXT:  sample 17: [1, 1, 1, 1, 1, 6, 0, 1]
+# CHECK-NEXT:  sample 18: [1, 1, 1, 1, 1, 6, 1, 0]
+# CHECK-NEXT:  sample 19: [1, 1, 1, 1, 1, 6, 1, 1]
+# CHECK-NEXT:  sample 20: [1, 1, 1, 1, 2, 1, 0, 0]
+# CHECK-NEXT:  sample 21: [1, 1, 1, 1, 2, 1, 0, 1]
+# CHECK-NEXT:  sample 22: [1, 1, 1, 1, 2, 1, 1, 0]
+# CHECK-NEXT:  sample 23: [1, 1, 1, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 24: [1, 1, 1, 1, 2, 2, 0, 0]
+# CHECK-NEXT:  sample 25: [1, 1, 1, 1, 2, 2, 0, 1]
+# CHECK-NEXT:  sample 26: [1, 1, 1, 1, 2, 2, 1, 0]
+# CHECK-NEXT:  sample 27: [1, 1, 1, 1, 2, 2, 1, 1]
+# CHECK-NEXT:  sample 28: [1, 1, 1, 1, 2, 3, 0, 0]
+# CHECK-NEXT:  sample 29: [1, 1, 1, 1, 2, 3, 0, 1]
+# CHECK-NEXT:  sample 30: [1, 1, 1, 1, 2, 3, 1, 0]
+# CHECK-NEXT:  sample 31: [1, 1, 1, 1, 2, 3, 1, 1]
+# CHECK-NEXT:  sample 32: [1, 1, 1, 1, 2, 6, 0, 0]
+# CHECK-NEXT:  sample 33: [1, 1, 1, 1, 2, 6, 0, 1]
+# CHECK-NEXT:  sample 34: [1, 1, 1, 1, 2, 6, 1, 0]
+# CHECK-NEXT:  sample 35: [1, 1, 1, 1, 2, 6, 1, 1]
+# CHECK-NEXT:  sample 36: [1, 1, 1, 1, 3, 1, 0, 0]
+# CHECK-NEXT:  sample 37: [1, 1, 1, 1, 3, 1, 0, 1]
+# CHECK-NEXT:  sample 38: [1, 1, 1, 1, 3, 1, 1, 0]
+# CHECK-NEXT:  sample 39: [1, 1, 1, 1, 3, 1, 1, 1]
+# CHECK-NEXT:  sample 40: [1, 1, 1, 1, 3, 2, 0, 0]
+# CHECK-NEXT:  sample 41: [1, 1, 1, 1, 3, 2, 0, 1]
+# CHECK-NEXT:  sample 42: [1, 1, 1, 1, 3, 2, 1, 0]
+# CHECK-NEXT:  sample 43: [1, 1, 1, 1, 3, 2, 1, 1]
+# CHECK-NEXT:  sample 44: [1, 1, 1, 1, 3, 4, 0, 0]
+# CHECK-NEXT:  sample 45: [1, 1, 1, 1, 3, 4, 0, 1]
+# CHECK-NEXT:  sample 46: [1, 1, 1, 1, 3, 4, 1, 0]
+# CHECK-NEXT:  sample 47: [1, 1, 1, 1, 3, 4, 1, 1]
+# CHECK-NEXT:  sample 48: [1, 1, 1, 1, 4, 1, 0, 0]
+# CHECK-NEXT:  sample 49: [1, 1, 1, 1, 4, 1, 0, 1]
+# CHECK-NEXT:  sample 50: [1, 1, 1, 1, 4, 1, 1, 0]
+# CHECK-NEXT:  sample 51: [1, 1, 1, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 52: [1, 1, 1, 1, 4, 3, 0, 0]
+# CHECK-NEXT:  sample 53: [1, 1, 1, 1, 4, 3, 0, 1]
+# CHECK-NEXT:  sample 54: [1, 1, 1, 1, 4, 3, 1, 0]
+# CHECK-NEXT:  sample 55: [1, 1, 1, 1, 4, 3, 1, 1]
+# CHECK-NEXT:  sample 56: [1, 1, 1, 1, 6, 1, 0, 0]
+# CHECK-NEXT:  sample 57: [1, 1, 1, 1, 6, 1, 0, 1]
+# CHECK-NEXT:  sample 58: [1, 1, 1, 1, 6, 1, 1, 0]
+# CHECK-NEXT:  sample 59: [1, 1, 1, 1, 6, 1, 1, 1]
+# CHECK-NEXT:  sample 60: [1, 1, 1, 1, 6, 2, 0, 0]
+# CHECK-NEXT:  sample 61: [1, 1, 1, 1, 6, 2, 0, 1]
+# CHECK-NEXT:  sample 62: [1, 1, 1, 1, 6, 2, 1, 0]
+# CHECK-NEXT:  sample 63: [1, 1, 1, 1, 6, 2, 1, 1]
+# CHECK-NEXT:  sample 64: [1, 1, 1, 1, 12, 1, 0, 0]
+# CHECK-NEXT:  sample 65: [1, 1, 1, 1, 12, 1, 0, 1]
+# CHECK-NEXT:  sample 66: [1, 1, 1, 1, 12, 1, 1, 0]
+# CHECK-NEXT:  sample 67: [1, 1, 1, 1, 12, 1, 1, 1]
+# CHECK-NEXT:  sample 68: [1, 1, 1, 2, 1, 1, 0, 0]
+# CHECK-NEXT:  sample 69: [1, 1, 1, 2, 1, 1, 0, 1]
+# CHECK-NEXT:  sample 70: [1, 1, 1, 2, 1, 1, 1, 0]
+# CHECK-NEXT:  sample 71: [1, 1, 1, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 72: [1, 1, 1, 2, 1, 2, 0, 0]
+# CHECK-NEXT:  sample 73: [1, 1, 1, 2, 1, 2, 0, 1]
+# CHECK-NEXT:  sample 74: [1, 1, 1, 2, 1, 2, 1, 0]
+# CHECK-NEXT:  sample 75: [1, 1, 1, 2, 1, 2, 1, 1]
+# CHECK-NEXT:  sample 76: [1, 1, 1, 2, 1, 3, 0, 0]
+# CHECK-NEXT:  sample 77: [1, 1, 1, 2, 1, 3, 0, 1]
+# CHECK-NEXT:  sample 78: [1, 1, 1, 2, 1, 3, 1, 0]
+# CHECK-NEXT:  sample 79: [1, 1, 1, 2, 1, 3, 1, 1]
+# CHECK-NEXT:  sample 80: [1, 1, 1, 2, 1, 4, 0, 0]
+# CHECK-NEXT:  sample 81: [1, 1, 1, 2, 1, 4, 0, 1]
+# CHECK-NEXT:  sample 82: [1, 1, 1, 2, 1, 4, 1, 0]
+# CHECK-NEXT:  sample 83: [1, 1, 1, 2, 1, 4, 1, 1]
+# CHECK-NEXT:  sample 84: [1, 1, 1, 2, 1, 6, 0, 0]
+# CHECK-NEXT:  sample 85: [1, 1, 1, 2, 1, 6, 0, 1]
+# CHECK-NEXT:  sample 86: [1, 1, 1, 2, 1, 6, 1, 0]
+# CHECK-NEXT:  sample 87: [1, 1, 1, 2, 1, 6, 1, 1]
+# CHECK-NEXT:  sample 88: [1, 1, 1, 2, 2, 1, 0, 0]
+# CHECK-NEXT:  sample 89: [1, 1, 1, 2, 2, 1, 0, 1]
+# CHECK-NEXT:  sample 90: [1, 1, 1, 2, 2, 1, 1, 0]
+# CHECK-NEXT:  sample 91: [1, 1, 1, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 92: [1, 1, 1, 2, 2, 2, 0, 0]
+# CHECK-NEXT:  sample 93: [1, 1, 1, 2, 2, 2, 0, 1]
+# CHECK-NEXT:  sample 94: [1, 1, 1, 2, 2, 2, 1, 0]
+# CHECK-NEXT:  sample 95: [1, 1, 1, 2, 2, 2, 1, 1]
+# CHECK-NEXT:  sample 96: [1, 1, 1, 2, 2, 3, 0, 0]
+# CHECK-NEXT:  sample 97: [1, 1, 1, 2, 2, 3, 0, 1]
+# CHECK-NEXT:  sample 98: [1, 1, 1, 2, 2, 3, 1, 0]
+# CHECK-NEXT:  sample 99: [1, 1, 1, 2, 2, 3, 1, 1]
+# CHECK-NEXT:  stats {'filtered': 100, 'all': 108}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 2, './j2': 2}, 'k': {'./k1': 2}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_goto_r.py b/tests/filecheck/search/test_matmul_goto_r.py
index e46f7319..09dabd6a 100644
--- a/tests/filecheck/search/test_matmul_goto_r.py
+++ b/tests/filecheck/search/test_matmul_goto_r.py
@@ -12,113 +12,113 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 0, 0, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [3, 1, 2, 1, 1, 1, 0, 0]
-# CHECK-NEXT: sample 1: [3, 1, 2, 1, 1, 1, 0, 1]
-# CHECK-NEXT: sample 2: [3, 1, 2, 1, 1, 1, 1, 0]
-# CHECK-NEXT: sample 3: [3, 1, 2, 1, 1, 1, 1, 1]
-# CHECK-NEXT: sample 4: [3, 1, 2, 1, 1, 2, 0, 0]
-# CHECK-NEXT: sample 5: [3, 1, 2, 1, 1, 2, 0, 1]
-# CHECK-NEXT: sample 6: [3, 1, 2, 1, 1, 2, 1, 0]
-# CHECK-NEXT: sample 7: [3, 1, 2, 1, 1, 2, 1, 1]
-# CHECK-NEXT: sample 8: [3, 1, 2, 1, 1, 3, 0, 0]
-# CHECK-NEXT: sample 9: [3, 1, 2, 1, 1, 3, 0, 1]
-# CHECK-NEXT: sample 10: [3, 1, 2, 1, 1, 3, 1, 0]
-# CHECK-NEXT: sample 11: [3, 1, 2, 1, 1, 3, 1, 1]
-# CHECK-NEXT: sample 12: [3, 1, 2, 1, 2, 1, 0, 0]
-# CHECK-NEXT: sample 13: [3, 1, 2, 1, 2, 1, 0, 1]
-# CHECK-NEXT: sample 14: [3, 1, 2, 1, 2, 1, 1, 0]
-# CHECK-NEXT: sample 15: [3, 1, 2, 1, 2, 1, 1, 1]
-# CHECK-NEXT: sample 16: [3, 1, 2, 1, 2, 2, 0, 0]
-# CHECK-NEXT: sample 17: [3, 1, 2, 1, 2, 2, 0, 1]
-# CHECK-NEXT: sample 18: [3, 1, 2, 1, 2, 2, 1, 0]
-# CHECK-NEXT: sample 19: [3, 1, 2, 1, 2, 2, 1, 1]
-# CHECK-NEXT: sample 20: [3, 1, 2, 1, 2, 3, 0, 0]
-# CHECK-NEXT: sample 21: [3, 1, 2, 1, 2, 3, 0, 1]
-# CHECK-NEXT: sample 22: [3, 1, 2, 1, 2, 3, 1, 0]
-# CHECK-NEXT: sample 23: [3, 1, 2, 1, 2, 3, 1, 1]
-# CHECK-NEXT: sample 24: [3, 1, 2, 1, 3, 1, 0, 0]
-# CHECK-NEXT: sample 25: [3, 1, 2, 1, 3, 1, 0, 1]
-# CHECK-NEXT: sample 26: [3, 1, 2, 1, 3, 1, 1, 0]
-# CHECK-NEXT: sample 27: [3, 1, 2, 1, 3, 1, 1, 1]
-# CHECK-NEXT: sample 28: [3, 1, 2, 1, 3, 2, 0, 0]
-# CHECK-NEXT: sample 29: [3, 1, 2, 1, 3, 2, 0, 1]
-# CHECK-NEXT: sample 30: [3, 1, 2, 1, 3, 2, 1, 0]
-# CHECK-NEXT: sample 31: [3, 1, 2, 1, 3, 2, 1, 1]
-# CHECK-NEXT: sample 32: [3, 1, 2, 1, 4, 1, 0, 0]
-# CHECK-NEXT: sample 33: [3, 1, 2, 1, 4, 1, 0, 1]
-# CHECK-NEXT: sample 34: [3, 1, 2, 1, 4, 1, 1, 0]
-# CHECK-NEXT: sample 35: [3, 1, 2, 1, 4, 1, 1, 1]
-# CHECK-NEXT: sample 36: [3, 1, 2, 1, 4, 3, 0, 0]
-# CHECK-NEXT: sample 37: [3, 1, 2, 1, 4, 3, 0, 1]
-# CHECK-NEXT: sample 38: [3, 1, 2, 1, 4, 3, 1, 0]
-# CHECK-NEXT: sample 39: [3, 1, 2, 1, 4, 3, 1, 1]
-# CHECK-NEXT: sample 40: [3, 1, 2, 1, 6, 1, 0, 0]
-# CHECK-NEXT: sample 41: [3, 1, 2, 1, 6, 1, 0, 1]
-# CHECK-NEXT: sample 42: [3, 1, 2, 1, 6, 1, 1, 0]
-# CHECK-NEXT: sample 43: [3, 1, 2, 1, 6, 1, 1, 1]
-# CHECK-NEXT: sample 44: [3, 1, 2, 1, 6, 2, 0, 0]
-# CHECK-NEXT: sample 45: [3, 1, 2, 1, 6, 2, 0, 1]
-# CHECK-NEXT: sample 46: [3, 1, 2, 1, 6, 2, 1, 0]
-# CHECK-NEXT: sample 47: [3, 1, 2, 1, 6, 2, 1, 1]
-# CHECK-NEXT: sample 48: [3, 1, 2, 1, 12, 1, 0, 0]
-# CHECK-NEXT: sample 49: [3, 1, 2, 1, 12, 1, 0, 1]
-# CHECK-NEXT: sample 50: [3, 1, 2, 1, 12, 1, 1, 0]
-# CHECK-NEXT: sample 51: [3, 1, 2, 1, 12, 1, 1, 1]
-# CHECK-NEXT: sample 52: [3, 1, 2, 2, 1, 1, 0, 0]
-# CHECK-NEXT: sample 53: [3, 1, 2, 2, 1, 1, 0, 1]
-# CHECK-NEXT: sample 54: [3, 1, 2, 2, 1, 1, 1, 0]
-# CHECK-NEXT: sample 55: [3, 1, 2, 2, 1, 1, 1, 1]
-# CHECK-NEXT: sample 56: [3, 1, 2, 2, 1, 2, 0, 0]
-# CHECK-NEXT: sample 57: [3, 1, 2, 2, 1, 2, 0, 1]
-# CHECK-NEXT: sample 58: [3, 1, 2, 2, 1, 2, 1, 0]
-# CHECK-NEXT: sample 59: [3, 1, 2, 2, 1, 2, 1, 1]
-# CHECK-NEXT: sample 60: [3, 1, 2, 2, 1, 3, 0, 0]
-# CHECK-NEXT: sample 61: [3, 1, 2, 2, 1, 3, 0, 1]
-# CHECK-NEXT: sample 62: [3, 1, 2, 2, 1, 3, 1, 0]
-# CHECK-NEXT: sample 63: [3, 1, 2, 2, 1, 3, 1, 1]
-# CHECK-NEXT: sample 64: [3, 1, 2, 2, 2, 1, 0, 0]
-# CHECK-NEXT: sample 65: [3, 1, 2, 2, 2, 1, 0, 1]
-# CHECK-NEXT: sample 66: [3, 1, 2, 2, 2, 1, 1, 0]
-# CHECK-NEXT: sample 67: [3, 1, 2, 2, 2, 1, 1, 1]
-# CHECK-NEXT: sample 68: [3, 1, 2, 2, 2, 2, 0, 0]
-# CHECK-NEXT: sample 69: [3, 1, 2, 2, 2, 2, 0, 1]
-# CHECK-NEXT: sample 70: [3, 1, 2, 2, 2, 2, 1, 0]
-# CHECK-NEXT: sample 71: [3, 1, 2, 2, 2, 2, 1, 1]
-# CHECK-NEXT: sample 72: [3, 1, 2, 2, 2, 3, 0, 0]
-# CHECK-NEXT: sample 73: [3, 1, 2, 2, 2, 3, 0, 1]
-# CHECK-NEXT: sample 74: [3, 1, 2, 2, 2, 3, 1, 0]
-# CHECK-NEXT: sample 75: [3, 1, 2, 2, 2, 3, 1, 1]
-# CHECK-NEXT: sample 76: [3, 1, 2, 2, 3, 1, 0, 0]
-# CHECK-NEXT: sample 77: [3, 1, 2, 2, 3, 1, 0, 1]
-# CHECK-NEXT: sample 78: [3, 1, 2, 2, 3, 1, 1, 0]
-# CHECK-NEXT: sample 79: [3, 1, 2, 2, 3, 1, 1, 1]
-# CHECK-NEXT: sample 80: [3, 1, 2, 2, 3, 2, 0, 0]
-# CHECK-NEXT: sample 81: [3, 1, 2, 2, 3, 2, 0, 1]
-# CHECK-NEXT: sample 82: [3, 1, 2, 2, 3, 2, 1, 0]
-# CHECK-NEXT: sample 83: [3, 1, 2, 2, 3, 2, 1, 1]
-# CHECK-NEXT: sample 84: [3, 1, 2, 2, 4, 1, 0, 0]
-# CHECK-NEXT: sample 85: [3, 1, 2, 2, 4, 1, 0, 1]
-# CHECK-NEXT: sample 86: [3, 1, 2, 2, 4, 1, 1, 0]
-# CHECK-NEXT: sample 87: [3, 1, 2, 2, 4, 1, 1, 1]
-# CHECK-NEXT: sample 88: [3, 1, 2, 2, 4, 3, 0, 0]
-# CHECK-NEXT: sample 89: [3, 1, 2, 2, 4, 3, 0, 1]
-# CHECK-NEXT: sample 90: [3, 1, 2, 2, 4, 3, 1, 0]
-# CHECK-NEXT: sample 91: [3, 1, 2, 2, 4, 3, 1, 1]
-# CHECK-NEXT: sample 92: [3, 1, 2, 2, 6, 1, 0, 0]
-# CHECK-NEXT: sample 93: [3, 1, 2, 2, 6, 1, 0, 1]
-# CHECK-NEXT: sample 94: [3, 1, 2, 2, 6, 1, 1, 0]
-# CHECK-NEXT: sample 95: [3, 1, 2, 2, 6, 1, 1, 1]
-# CHECK-NEXT: sample 96: [3, 1, 2, 2, 6, 2, 0, 0]
-# CHECK-NEXT: sample 97: [3, 1, 2, 2, 6, 2, 0, 1]
-# CHECK-NEXT: sample 98: [3, 1, 2, 2, 6, 2, 1, 0]
-# CHECK-NEXT: sample 99: [3, 1, 2, 2, 6, 2, 1, 1]
-# CHECK-NEXT: stats {'filtered': 3256, 'all': 6620}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1}, 'j': {'./j1': 4, './j2': 2}, 'k': {'./k1': 6}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 2}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 1, 1, 1, 0, 0, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [3, 1, 2, 1, 1, 1, 0, 0]
+# CHECK-NEXT:  sample 1: [3, 1, 2, 1, 1, 1, 0, 1]
+# CHECK-NEXT:  sample 2: [3, 1, 2, 1, 1, 1, 1, 0]
+# CHECK-NEXT:  sample 3: [3, 1, 2, 1, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 4: [3, 1, 2, 1, 1, 2, 0, 0]
+# CHECK-NEXT:  sample 5: [3, 1, 2, 1, 1, 2, 0, 1]
+# CHECK-NEXT:  sample 6: [3, 1, 2, 1, 1, 2, 1, 0]
+# CHECK-NEXT:  sample 7: [3, 1, 2, 1, 1, 2, 1, 1]
+# CHECK-NEXT:  sample 8: [3, 1, 2, 1, 1, 3, 0, 0]
+# CHECK-NEXT:  sample 9: [3, 1, 2, 1, 1, 3, 0, 1]
+# CHECK-NEXT:  sample 10: [3, 1, 2, 1, 1, 3, 1, 0]
+# CHECK-NEXT:  sample 11: [3, 1, 2, 1, 1, 3, 1, 1]
+# CHECK-NEXT:  sample 12: [3, 1, 2, 1, 2, 1, 0, 0]
+# CHECK-NEXT:  sample 13: [3, 1, 2, 1, 2, 1, 0, 1]
+# CHECK-NEXT:  sample 14: [3, 1, 2, 1, 2, 1, 1, 0]
+# CHECK-NEXT:  sample 15: [3, 1, 2, 1, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 16: [3, 1, 2, 1, 2, 2, 0, 0]
+# CHECK-NEXT:  sample 17: [3, 1, 2, 1, 2, 2, 0, 1]
+# CHECK-NEXT:  sample 18: [3, 1, 2, 1, 2, 2, 1, 0]
+# CHECK-NEXT:  sample 19: [3, 1, 2, 1, 2, 2, 1, 1]
+# CHECK-NEXT:  sample 20: [3, 1, 2, 1, 2, 3, 0, 0]
+# CHECK-NEXT:  sample 21: [3, 1, 2, 1, 2, 3, 0, 1]
+# CHECK-NEXT:  sample 22: [3, 1, 2, 1, 2, 3, 1, 0]
+# CHECK-NEXT:  sample 23: [3, 1, 2, 1, 2, 3, 1, 1]
+# CHECK-NEXT:  sample 24: [3, 1, 2, 1, 3, 1, 0, 0]
+# CHECK-NEXT:  sample 25: [3, 1, 2, 1, 3, 1, 0, 1]
+# CHECK-NEXT:  sample 26: [3, 1, 2, 1, 3, 1, 1, 0]
+# CHECK-NEXT:  sample 27: [3, 1, 2, 1, 3, 1, 1, 1]
+# CHECK-NEXT:  sample 28: [3, 1, 2, 1, 3, 2, 0, 0]
+# CHECK-NEXT:  sample 29: [3, 1, 2, 1, 3, 2, 0, 1]
+# CHECK-NEXT:  sample 30: [3, 1, 2, 1, 3, 2, 1, 0]
+# CHECK-NEXT:  sample 31: [3, 1, 2, 1, 3, 2, 1, 1]
+# CHECK-NEXT:  sample 32: [3, 1, 2, 1, 4, 1, 0, 0]
+# CHECK-NEXT:  sample 33: [3, 1, 2, 1, 4, 1, 0, 1]
+# CHECK-NEXT:  sample 34: [3, 1, 2, 1, 4, 1, 1, 0]
+# CHECK-NEXT:  sample 35: [3, 1, 2, 1, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 36: [3, 1, 2, 1, 4, 3, 0, 0]
+# CHECK-NEXT:  sample 37: [3, 1, 2, 1, 4, 3, 0, 1]
+# CHECK-NEXT:  sample 38: [3, 1, 2, 1, 4, 3, 1, 0]
+# CHECK-NEXT:  sample 39: [3, 1, 2, 1, 4, 3, 1, 1]
+# CHECK-NEXT:  sample 40: [3, 1, 2, 1, 6, 1, 0, 0]
+# CHECK-NEXT:  sample 41: [3, 1, 2, 1, 6, 1, 0, 1]
+# CHECK-NEXT:  sample 42: [3, 1, 2, 1, 6, 1, 1, 0]
+# CHECK-NEXT:  sample 43: [3, 1, 2, 1, 6, 1, 1, 1]
+# CHECK-NEXT:  sample 44: [3, 1, 2, 1, 6, 2, 0, 0]
+# CHECK-NEXT:  sample 45: [3, 1, 2, 1, 6, 2, 0, 1]
+# CHECK-NEXT:  sample 46: [3, 1, 2, 1, 6, 2, 1, 0]
+# CHECK-NEXT:  sample 47: [3, 1, 2, 1, 6, 2, 1, 1]
+# CHECK-NEXT:  sample 48: [3, 1, 2, 1, 12, 1, 0, 0]
+# CHECK-NEXT:  sample 49: [3, 1, 2, 1, 12, 1, 0, 1]
+# CHECK-NEXT:  sample 50: [3, 1, 2, 1, 12, 1, 1, 0]
+# CHECK-NEXT:  sample 51: [3, 1, 2, 1, 12, 1, 1, 1]
+# CHECK-NEXT:  sample 52: [3, 1, 2, 2, 1, 1, 0, 0]
+# CHECK-NEXT:  sample 53: [3, 1, 2, 2, 1, 1, 0, 1]
+# CHECK-NEXT:  sample 54: [3, 1, 2, 2, 1, 1, 1, 0]
+# CHECK-NEXT:  sample 55: [3, 1, 2, 2, 1, 1, 1, 1]
+# CHECK-NEXT:  sample 56: [3, 1, 2, 2, 1, 2, 0, 0]
+# CHECK-NEXT:  sample 57: [3, 1, 2, 2, 1, 2, 0, 1]
+# CHECK-NEXT:  sample 58: [3, 1, 2, 2, 1, 2, 1, 0]
+# CHECK-NEXT:  sample 59: [3, 1, 2, 2, 1, 2, 1, 1]
+# CHECK-NEXT:  sample 60: [3, 1, 2, 2, 1, 3, 0, 0]
+# CHECK-NEXT:  sample 61: [3, 1, 2, 2, 1, 3, 0, 1]
+# CHECK-NEXT:  sample 62: [3, 1, 2, 2, 1, 3, 1, 0]
+# CHECK-NEXT:  sample 63: [3, 1, 2, 2, 1, 3, 1, 1]
+# CHECK-NEXT:  sample 64: [3, 1, 2, 2, 2, 1, 0, 0]
+# CHECK-NEXT:  sample 65: [3, 1, 2, 2, 2, 1, 0, 1]
+# CHECK-NEXT:  sample 66: [3, 1, 2, 2, 2, 1, 1, 0]
+# CHECK-NEXT:  sample 67: [3, 1, 2, 2, 2, 1, 1, 1]
+# CHECK-NEXT:  sample 68: [3, 1, 2, 2, 2, 2, 0, 0]
+# CHECK-NEXT:  sample 69: [3, 1, 2, 2, 2, 2, 0, 1]
+# CHECK-NEXT:  sample 70: [3, 1, 2, 2, 2, 2, 1, 0]
+# CHECK-NEXT:  sample 71: [3, 1, 2, 2, 2, 2, 1, 1]
+# CHECK-NEXT:  sample 72: [3, 1, 2, 2, 2, 3, 0, 0]
+# CHECK-NEXT:  sample 73: [3, 1, 2, 2, 2, 3, 0, 1]
+# CHECK-NEXT:  sample 74: [3, 1, 2, 2, 2, 3, 1, 0]
+# CHECK-NEXT:  sample 75: [3, 1, 2, 2, 2, 3, 1, 1]
+# CHECK-NEXT:  sample 76: [3, 1, 2, 2, 3, 1, 0, 0]
+# CHECK-NEXT:  sample 77: [3, 1, 2, 2, 3, 1, 0, 1]
+# CHECK-NEXT:  sample 78: [3, 1, 2, 2, 3, 1, 1, 0]
+# CHECK-NEXT:  sample 79: [3, 1, 2, 2, 3, 1, 1, 1]
+# CHECK-NEXT:  sample 80: [3, 1, 2, 2, 3, 2, 0, 0]
+# CHECK-NEXT:  sample 81: [3, 1, 2, 2, 3, 2, 0, 1]
+# CHECK-NEXT:  sample 82: [3, 1, 2, 2, 3, 2, 1, 0]
+# CHECK-NEXT:  sample 83: [3, 1, 2, 2, 3, 2, 1, 1]
+# CHECK-NEXT:  sample 84: [3, 1, 2, 2, 4, 1, 0, 0]
+# CHECK-NEXT:  sample 85: [3, 1, 2, 2, 4, 1, 0, 1]
+# CHECK-NEXT:  sample 86: [3, 1, 2, 2, 4, 1, 1, 0]
+# CHECK-NEXT:  sample 87: [3, 1, 2, 2, 4, 1, 1, 1]
+# CHECK-NEXT:  sample 88: [3, 1, 2, 2, 4, 3, 0, 0]
+# CHECK-NEXT:  sample 89: [3, 1, 2, 2, 4, 3, 0, 1]
+# CHECK-NEXT:  sample 90: [3, 1, 2, 2, 4, 3, 1, 0]
+# CHECK-NEXT:  sample 91: [3, 1, 2, 2, 4, 3, 1, 1]
+# CHECK-NEXT:  sample 92: [3, 1, 2, 2, 6, 1, 0, 0]
+# CHECK-NEXT:  sample 93: [3, 1, 2, 2, 6, 1, 0, 1]
+# CHECK-NEXT:  sample 94: [3, 1, 2, 2, 6, 1, 1, 0]
+# CHECK-NEXT:  sample 95: [3, 1, 2, 2, 6, 1, 1, 1]
+# CHECK-NEXT:  sample 96: [3, 1, 2, 2, 6, 2, 0, 0]
+# CHECK-NEXT:  sample 97: [3, 1, 2, 2, 6, 2, 0, 1]
+# CHECK-NEXT:  sample 98: [3, 1, 2, 2, 6, 2, 1, 0]
+# CHECK-NEXT:  sample 99: [3, 1, 2, 2, 6, 2, 1, 1]
+# CHECK-NEXT:  stats {'filtered': 3256, 'all': 6620}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1}, 'j': {'./j1': 4, './j2': 2}, 'k': {'./k1': 6}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_oo.py b/tests/filecheck/search/test_matmul_oo.py
index 084cd50c..d26bfa18 100644
--- a/tests/filecheck/search/test_matmul_oo.py
+++ b/tests/filecheck/search/test_matmul_oo.py
@@ -12,58 +12,58 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 16, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [3, 16, 12]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 12, './i1': 3}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1, 1]
-# CHECK-NEXT: sample 1: [1, 1, 2]
-# CHECK-NEXT: sample 2: [1, 1, 3]
-# CHECK-NEXT: sample 3: [1, 1, 4]
-# CHECK-NEXT: sample 4: [1, 1, 6]
-# CHECK-NEXT: sample 5: [1, 2, 1]
-# CHECK-NEXT: sample 6: [1, 2, 2]
-# CHECK-NEXT: sample 7: [1, 2, 3]
-# CHECK-NEXT: sample 8: [1, 2, 4]
-# CHECK-NEXT: sample 9: [1, 2, 6]
-# CHECK-NEXT: sample 10: [1, 4, 1]
-# CHECK-NEXT: sample 11: [1, 4, 2]
-# CHECK-NEXT: sample 12: [1, 4, 3]
-# CHECK-NEXT: sample 13: [1, 4, 4]
-# CHECK-NEXT: sample 14: [1, 4, 6]
-# CHECK-NEXT: sample 15: [1, 8, 1]
-# CHECK-NEXT: sample 16: [1, 8, 2]
-# CHECK-NEXT: sample 17: [1, 8, 3]
-# CHECK-NEXT: sample 18: [1, 8, 4]
-# CHECK-NEXT: sample 19: [1, 8, 6]
-# CHECK-NEXT: sample 20: [1, 16, 1]
-# CHECK-NEXT: sample 21: [1, 16, 2]
-# CHECK-NEXT: sample 22: [1, 16, 3]
-# CHECK-NEXT: sample 23: [1, 16, 4]
-# CHECK-NEXT: sample 24: [1, 16, 6]
-# CHECK-NEXT: sample 25: [1, 32, 1]
-# CHECK-NEXT: sample 26: [1, 32, 2]
-# CHECK-NEXT: sample 27: [1, 32, 3]
-# CHECK-NEXT: sample 28: [1, 32, 4]
-# CHECK-NEXT: sample 29: [3, 1, 1]
-# CHECK-NEXT: sample 30: [3, 1, 2]
-# CHECK-NEXT: sample 31: [3, 2, 1]
-# CHECK-NEXT: sample 32: [3, 2, 2]
-# CHECK-NEXT: sample 33: [3, 4, 1]
-# CHECK-NEXT: sample 34: [3, 4, 2]
-# CHECK-NEXT: sample 35: [3, 8, 1]
-# CHECK-NEXT: sample 36: [3, 8, 2]
-# CHECK-NEXT: sample 37: [3, 16, 1]
-# CHECK-NEXT: sample 38: [3, 16, 2]
-# CHECK-NEXT: sample 39: [3, 32, 1]
-# CHECK-NEXT: sample 40: [7, 1, 1]
-# CHECK-NEXT: sample 41: [7, 2, 1]
-# CHECK-NEXT: sample 42: [7, 4, 1]
-# CHECK-NEXT: sample 43: [7, 8, 1]
-# CHECK-NEXT: sample 44: [7, 16, 1]
-# CHECK-NEXT: stats {'filtered': 45, 'all': 144}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 7}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 16, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [3, 16, 12]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 12, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1, 1]
+# CHECK-NEXT:  sample 1: [1, 1, 2]
+# CHECK-NEXT:  sample 2: [1, 1, 3]
+# CHECK-NEXT:  sample 3: [1, 1, 4]
+# CHECK-NEXT:  sample 4: [1, 1, 6]
+# CHECK-NEXT:  sample 5: [1, 2, 1]
+# CHECK-NEXT:  sample 6: [1, 2, 2]
+# CHECK-NEXT:  sample 7: [1, 2, 3]
+# CHECK-NEXT:  sample 8: [1, 2, 4]
+# CHECK-NEXT:  sample 9: [1, 2, 6]
+# CHECK-NEXT:  sample 10: [1, 4, 1]
+# CHECK-NEXT:  sample 11: [1, 4, 2]
+# CHECK-NEXT:  sample 12: [1, 4, 3]
+# CHECK-NEXT:  sample 13: [1, 4, 4]
+# CHECK-NEXT:  sample 14: [1, 4, 6]
+# CHECK-NEXT:  sample 15: [1, 8, 1]
+# CHECK-NEXT:  sample 16: [1, 8, 2]
+# CHECK-NEXT:  sample 17: [1, 8, 3]
+# CHECK-NEXT:  sample 18: [1, 8, 4]
+# CHECK-NEXT:  sample 19: [1, 8, 6]
+# CHECK-NEXT:  sample 20: [1, 16, 1]
+# CHECK-NEXT:  sample 21: [1, 16, 2]
+# CHECK-NEXT:  sample 22: [1, 16, 3]
+# CHECK-NEXT:  sample 23: [1, 16, 4]
+# CHECK-NEXT:  sample 24: [1, 16, 6]
+# CHECK-NEXT:  sample 25: [1, 32, 1]
+# CHECK-NEXT:  sample 26: [1, 32, 2]
+# CHECK-NEXT:  sample 27: [1, 32, 3]
+# CHECK-NEXT:  sample 28: [1, 32, 4]
+# CHECK-NEXT:  sample 29: [3, 1, 1]
+# CHECK-NEXT:  sample 30: [3, 1, 2]
+# CHECK-NEXT:  sample 31: [3, 2, 1]
+# CHECK-NEXT:  sample 32: [3, 2, 2]
+# CHECK-NEXT:  sample 33: [3, 4, 1]
+# CHECK-NEXT:  sample 34: [3, 4, 2]
+# CHECK-NEXT:  sample 35: [3, 8, 1]
+# CHECK-NEXT:  sample 36: [3, 8, 2]
+# CHECK-NEXT:  sample 37: [3, 16, 1]
+# CHECK-NEXT:  sample 38: [3, 16, 2]
+# CHECK-NEXT:  sample 39: [3, 32, 1]
+# CHECK-NEXT:  sample 40: [7, 1, 1]
+# CHECK-NEXT:  sample 41: [7, 2, 1]
+# CHECK-NEXT:  sample 42: [7, 4, 1]
+# CHECK-NEXT:  sample 43: [7, 8, 1]
+# CHECK-NEXT:  sample 44: [7, 16, 1]
+# CHECK-NEXT:  stats {'filtered': 45, 'all': 144}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_p1.py b/tests/filecheck/search/test_matmul_p1.py
index df637d08..a287430c 100644
--- a/tests/filecheck/search/test_matmul_p1.py
+++ b/tests/filecheck/search/test_matmul_p1.py
@@ -12,113 +12,113 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1, 1, 0]
-# CHECK-NEXT: sample 1: [1, 1, 1, 1]
-# CHECK-NEXT: sample 2: [1, 1, 1, 2]
-# CHECK-NEXT: sample 3: [1, 1, 1, 3]
-# CHECK-NEXT: sample 4: [1, 1, 1, 4]
-# CHECK-NEXT: sample 5: [1, 1, 1, 5]
-# CHECK-NEXT: sample 6: [1, 1, 2, 0]
-# CHECK-NEXT: sample 7: [1, 1, 2, 1]
-# CHECK-NEXT: sample 8: [1, 1, 2, 2]
-# CHECK-NEXT: sample 9: [1, 1, 2, 3]
-# CHECK-NEXT: sample 10: [1, 1, 2, 4]
-# CHECK-NEXT: sample 11: [1, 1, 2, 5]
-# CHECK-NEXT: sample 12: [1, 1, 3, 0]
-# CHECK-NEXT: sample 13: [1, 1, 3, 1]
-# CHECK-NEXT: sample 14: [1, 1, 3, 2]
-# CHECK-NEXT: sample 15: [1, 1, 3, 3]
-# CHECK-NEXT: sample 16: [1, 1, 3, 4]
-# CHECK-NEXT: sample 17: [1, 1, 3, 5]
-# CHECK-NEXT: sample 18: [1, 1, 4, 0]
-# CHECK-NEXT: sample 19: [1, 1, 4, 1]
-# CHECK-NEXT: sample 20: [1, 1, 4, 2]
-# CHECK-NEXT: sample 21: [1, 1, 4, 3]
-# CHECK-NEXT: sample 22: [1, 1, 4, 4]
-# CHECK-NEXT: sample 23: [1, 1, 4, 5]
-# CHECK-NEXT: sample 24: [1, 1, 6, 0]
-# CHECK-NEXT: sample 25: [1, 1, 6, 1]
-# CHECK-NEXT: sample 26: [1, 1, 6, 2]
-# CHECK-NEXT: sample 27: [1, 1, 6, 3]
-# CHECK-NEXT: sample 28: [1, 1, 6, 4]
-# CHECK-NEXT: sample 29: [1, 1, 6, 5]
-# CHECK-NEXT: sample 30: [1, 2, 1, 0]
-# CHECK-NEXT: sample 31: [1, 2, 1, 1]
-# CHECK-NEXT: sample 32: [1, 2, 1, 2]
-# CHECK-NEXT: sample 33: [1, 2, 1, 3]
-# CHECK-NEXT: sample 34: [1, 2, 1, 4]
-# CHECK-NEXT: sample 35: [1, 2, 1, 5]
-# CHECK-NEXT: sample 36: [1, 2, 2, 0]
-# CHECK-NEXT: sample 37: [1, 2, 2, 1]
-# CHECK-NEXT: sample 38: [1, 2, 2, 2]
-# CHECK-NEXT: sample 39: [1, 2, 2, 3]
-# CHECK-NEXT: sample 40: [1, 2, 2, 4]
-# CHECK-NEXT: sample 41: [1, 2, 2, 5]
-# CHECK-NEXT: sample 42: [1, 2, 3, 0]
-# CHECK-NEXT: sample 43: [1, 2, 3, 1]
-# CHECK-NEXT: sample 44: [1, 2, 3, 2]
-# CHECK-NEXT: sample 45: [1, 2, 3, 3]
-# CHECK-NEXT: sample 46: [1, 2, 3, 4]
-# CHECK-NEXT: sample 47: [1, 2, 3, 5]
-# CHECK-NEXT: sample 48: [1, 2, 4, 0]
-# CHECK-NEXT: sample 49: [1, 2, 4, 1]
-# CHECK-NEXT: sample 50: [1, 2, 4, 2]
-# CHECK-NEXT: sample 51: [1, 2, 4, 3]
-# CHECK-NEXT: sample 52: [1, 2, 4, 4]
-# CHECK-NEXT: sample 53: [1, 2, 4, 5]
-# CHECK-NEXT: sample 54: [1, 2, 6, 1]
-# CHECK-NEXT: sample 55: [1, 2, 6, 4]
-# CHECK-NEXT: sample 56: [1, 4, 1, 0]
-# CHECK-NEXT: sample 57: [1, 4, 1, 1]
-# CHECK-NEXT: sample 58: [1, 4, 1, 2]
-# CHECK-NEXT: sample 59: [1, 4, 1, 3]
-# CHECK-NEXT: sample 60: [1, 4, 1, 4]
-# CHECK-NEXT: sample 61: [1, 4, 1, 5]
-# CHECK-NEXT: sample 62: [1, 4, 2, 0]
-# CHECK-NEXT: sample 63: [1, 4, 2, 1]
-# CHECK-NEXT: sample 64: [1, 4, 2, 2]
-# CHECK-NEXT: sample 65: [1, 4, 2, 3]
-# CHECK-NEXT: sample 66: [1, 4, 2, 4]
-# CHECK-NEXT: sample 67: [1, 4, 2, 5]
-# CHECK-NEXT: sample 68: [1, 4, 3, 1]
-# CHECK-NEXT: sample 69: [1, 4, 3, 4]
-# CHECK-NEXT: sample 70: [1, 4, 4, 1]
-# CHECK-NEXT: sample 71: [1, 4, 4, 4]
-# CHECK-NEXT: sample 72: [1, 4, 6, 1]
-# CHECK-NEXT: sample 73: [1, 4, 6, 4]
-# CHECK-NEXT: sample 74: [1, 8, 1, 0]
-# CHECK-NEXT: sample 75: [1, 8, 1, 1]
-# CHECK-NEXT: sample 76: [1, 8, 1, 2]
-# CHECK-NEXT: sample 77: [1, 8, 1, 3]
-# CHECK-NEXT: sample 78: [1, 8, 1, 4]
-# CHECK-NEXT: sample 79: [1, 8, 1, 5]
-# CHECK-NEXT: sample 80: [1, 8, 2, 1]
-# CHECK-NEXT: sample 81: [1, 8, 2, 4]
-# CHECK-NEXT: sample 82: [1, 8, 3, 1]
-# CHECK-NEXT: sample 83: [1, 8, 3, 4]
-# CHECK-NEXT: sample 84: [1, 8, 4, 1]
-# CHECK-NEXT: sample 85: [1, 8, 4, 4]
-# CHECK-NEXT: sample 86: [1, 8, 6, 1]
-# CHECK-NEXT: sample 87: [1, 8, 6, 4]
-# CHECK-NEXT: sample 88: [1, 16, 1, 1]
-# CHECK-NEXT: sample 89: [1, 16, 1, 4]
-# CHECK-NEXT: sample 90: [1, 16, 2, 1]
-# CHECK-NEXT: sample 91: [1, 16, 2, 4]
-# CHECK-NEXT: sample 92: [1, 16, 3, 1]
-# CHECK-NEXT: sample 93: [1, 16, 3, 4]
-# CHECK-NEXT: sample 94: [1, 16, 4, 1]
-# CHECK-NEXT: sample 95: [1, 16, 4, 4]
-# CHECK-NEXT: sample 96: [1, 16, 6, 1]
-# CHECK-NEXT: sample 97: [1, 16, 6, 4]
-# CHECK-NEXT: sample 98: [1, 32, 1, 1]
-# CHECK-NEXT: sample 99: [1, 32, 1, 4]
-# CHECK-NEXT: stats {'filtered': 100, 'all': 185}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 32}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 32, './i1': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1, 1, 0]
+# CHECK-NEXT:  sample 1: [1, 1, 1, 1]
+# CHECK-NEXT:  sample 2: [1, 1, 1, 2]
+# CHECK-NEXT:  sample 3: [1, 1, 1, 3]
+# CHECK-NEXT:  sample 4: [1, 1, 1, 4]
+# CHECK-NEXT:  sample 5: [1, 1, 1, 5]
+# CHECK-NEXT:  sample 6: [1, 1, 2, 0]
+# CHECK-NEXT:  sample 7: [1, 1, 2, 1]
+# CHECK-NEXT:  sample 8: [1, 1, 2, 2]
+# CHECK-NEXT:  sample 9: [1, 1, 2, 3]
+# CHECK-NEXT:  sample 10: [1, 1, 2, 4]
+# CHECK-NEXT:  sample 11: [1, 1, 2, 5]
+# CHECK-NEXT:  sample 12: [1, 1, 3, 0]
+# CHECK-NEXT:  sample 13: [1, 1, 3, 1]
+# CHECK-NEXT:  sample 14: [1, 1, 3, 2]
+# CHECK-NEXT:  sample 15: [1, 1, 3, 3]
+# CHECK-NEXT:  sample 16: [1, 1, 3, 4]
+# CHECK-NEXT:  sample 17: [1, 1, 3, 5]
+# CHECK-NEXT:  sample 18: [1, 1, 4, 0]
+# CHECK-NEXT:  sample 19: [1, 1, 4, 1]
+# CHECK-NEXT:  sample 20: [1, 1, 4, 2]
+# CHECK-NEXT:  sample 21: [1, 1, 4, 3]
+# CHECK-NEXT:  sample 22: [1, 1, 4, 4]
+# CHECK-NEXT:  sample 23: [1, 1, 4, 5]
+# CHECK-NEXT:  sample 24: [1, 1, 6, 0]
+# CHECK-NEXT:  sample 25: [1, 1, 6, 1]
+# CHECK-NEXT:  sample 26: [1, 1, 6, 2]
+# CHECK-NEXT:  sample 27: [1, 1, 6, 3]
+# CHECK-NEXT:  sample 28: [1, 1, 6, 4]
+# CHECK-NEXT:  sample 29: [1, 1, 6, 5]
+# CHECK-NEXT:  sample 30: [1, 2, 1, 0]
+# CHECK-NEXT:  sample 31: [1, 2, 1, 1]
+# CHECK-NEXT:  sample 32: [1, 2, 1, 2]
+# CHECK-NEXT:  sample 33: [1, 2, 1, 3]
+# CHECK-NEXT:  sample 34: [1, 2, 1, 4]
+# CHECK-NEXT:  sample 35: [1, 2, 1, 5]
+# CHECK-NEXT:  sample 36: [1, 2, 2, 0]
+# CHECK-NEXT:  sample 37: [1, 2, 2, 1]
+# CHECK-NEXT:  sample 38: [1, 2, 2, 2]
+# CHECK-NEXT:  sample 39: [1, 2, 2, 3]
+# CHECK-NEXT:  sample 40: [1, 2, 2, 4]
+# CHECK-NEXT:  sample 41: [1, 2, 2, 5]
+# CHECK-NEXT:  sample 42: [1, 2, 3, 0]
+# CHECK-NEXT:  sample 43: [1, 2, 3, 1]
+# CHECK-NEXT:  sample 44: [1, 2, 3, 2]
+# CHECK-NEXT:  sample 45: [1, 2, 3, 3]
+# CHECK-NEXT:  sample 46: [1, 2, 3, 4]
+# CHECK-NEXT:  sample 47: [1, 2, 3, 5]
+# CHECK-NEXT:  sample 48: [1, 2, 4, 0]
+# CHECK-NEXT:  sample 49: [1, 2, 4, 1]
+# CHECK-NEXT:  sample 50: [1, 2, 4, 2]
+# CHECK-NEXT:  sample 51: [1, 2, 4, 3]
+# CHECK-NEXT:  sample 52: [1, 2, 4, 4]
+# CHECK-NEXT:  sample 53: [1, 2, 4, 5]
+# CHECK-NEXT:  sample 54: [1, 2, 6, 1]
+# CHECK-NEXT:  sample 55: [1, 2, 6, 4]
+# CHECK-NEXT:  sample 56: [1, 4, 1, 0]
+# CHECK-NEXT:  sample 57: [1, 4, 1, 1]
+# CHECK-NEXT:  sample 58: [1, 4, 1, 2]
+# CHECK-NEXT:  sample 59: [1, 4, 1, 3]
+# CHECK-NEXT:  sample 60: [1, 4, 1, 4]
+# CHECK-NEXT:  sample 61: [1, 4, 1, 5]
+# CHECK-NEXT:  sample 62: [1, 4, 2, 0]
+# CHECK-NEXT:  sample 63: [1, 4, 2, 1]
+# CHECK-NEXT:  sample 64: [1, 4, 2, 2]
+# CHECK-NEXT:  sample 65: [1, 4, 2, 3]
+# CHECK-NEXT:  sample 66: [1, 4, 2, 4]
+# CHECK-NEXT:  sample 67: [1, 4, 2, 5]
+# CHECK-NEXT:  sample 68: [1, 4, 3, 1]
+# CHECK-NEXT:  sample 69: [1, 4, 3, 4]
+# CHECK-NEXT:  sample 70: [1, 4, 4, 1]
+# CHECK-NEXT:  sample 71: [1, 4, 4, 4]
+# CHECK-NEXT:  sample 72: [1, 4, 6, 1]
+# CHECK-NEXT:  sample 73: [1, 4, 6, 4]
+# CHECK-NEXT:  sample 74: [1, 8, 1, 0]
+# CHECK-NEXT:  sample 75: [1, 8, 1, 1]
+# CHECK-NEXT:  sample 76: [1, 8, 1, 2]
+# CHECK-NEXT:  sample 77: [1, 8, 1, 3]
+# CHECK-NEXT:  sample 78: [1, 8, 1, 4]
+# CHECK-NEXT:  sample 79: [1, 8, 1, 5]
+# CHECK-NEXT:  sample 80: [1, 8, 2, 1]
+# CHECK-NEXT:  sample 81: [1, 8, 2, 4]
+# CHECK-NEXT:  sample 82: [1, 8, 3, 1]
+# CHECK-NEXT:  sample 83: [1, 8, 3, 4]
+# CHECK-NEXT:  sample 84: [1, 8, 4, 1]
+# CHECK-NEXT:  sample 85: [1, 8, 4, 4]
+# CHECK-NEXT:  sample 86: [1, 8, 6, 1]
+# CHECK-NEXT:  sample 87: [1, 8, 6, 4]
+# CHECK-NEXT:  sample 88: [1, 16, 1, 1]
+# CHECK-NEXT:  sample 89: [1, 16, 1, 4]
+# CHECK-NEXT:  sample 90: [1, 16, 2, 1]
+# CHECK-NEXT:  sample 91: [1, 16, 2, 4]
+# CHECK-NEXT:  sample 92: [1, 16, 3, 1]
+# CHECK-NEXT:  sample 93: [1, 16, 3, 4]
+# CHECK-NEXT:  sample 94: [1, 16, 4, 1]
+# CHECK-NEXT:  sample 95: [1, 16, 4, 4]
+# CHECK-NEXT:  sample 96: [1, 16, 6, 1]
+# CHECK-NEXT:  sample 97: [1, 16, 6, 4]
+# CHECK-NEXT:  sample 98: [1, 32, 1, 1]
+# CHECK-NEXT:  sample 99: [1, 32, 1, 4]
+# CHECK-NEXT:  stats {'filtered': 100, 'all': 185}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 32}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 32, './i1': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_p1v.py b/tests/filecheck/search/test_matmul_p1v.py
index 9d20ea9d..4dce0903 100644
--- a/tests/filecheck/search/test_matmul_p1v.py
+++ b/tests/filecheck/search/test_matmul_p1v.py
@@ -12,39 +12,39 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1, 1, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1, 1, 0]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [1, 1, 1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 16, 1, 1]
-# CHECK-NEXT: sample 1: [1, 16, 1, 4]
-# CHECK-NEXT: sample 2: [1, 16, 2, 1]
-# CHECK-NEXT: sample 3: [1, 16, 2, 4]
-# CHECK-NEXT: sample 4: [1, 16, 3, 1]
-# CHECK-NEXT: sample 5: [1, 16, 3, 4]
-# CHECK-NEXT: sample 6: [1, 16, 4, 1]
-# CHECK-NEXT: sample 7: [1, 16, 4, 4]
-# CHECK-NEXT: sample 8: [1, 16, 6, 1]
-# CHECK-NEXT: sample 9: [1, 16, 6, 4]
-# CHECK-NEXT: sample 10: [1, 32, 1, 1]
-# CHECK-NEXT: sample 11: [1, 32, 1, 4]
-# CHECK-NEXT: sample 12: [1, 32, 2, 1]
-# CHECK-NEXT: sample 13: [1, 32, 2, 4]
-# CHECK-NEXT: sample 14: [1, 32, 3, 1]
-# CHECK-NEXT: sample 15: [1, 32, 3, 4]
-# CHECK-NEXT: sample 16: [1, 32, 4, 1]
-# CHECK-NEXT: sample 17: [1, 32, 4, 4]
-# CHECK-NEXT: sample 18: [3, 16, 1, 1]
-# CHECK-NEXT: sample 19: [3, 16, 1, 4]
-# CHECK-NEXT: sample 20: [3, 16, 2, 1]
-# CHECK-NEXT: sample 21: [3, 16, 2, 4]
-# CHECK-NEXT: sample 22: [3, 32, 1, 1]
-# CHECK-NEXT: sample 23: [3, 32, 1, 4]
-# CHECK-NEXT: sample 24: [7, 16, 1, 1]
-# CHECK-NEXT: sample 25: [7, 16, 1, 4]
-# CHECK-NEXT: stats {'filtered': 154, 'all': 864}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1, 1, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1, 1, 0]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [1, 1, 1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 16, 1, 1]
+# CHECK-NEXT:  sample 1: [1, 16, 1, 4]
+# CHECK-NEXT:  sample 2: [1, 16, 2, 1]
+# CHECK-NEXT:  sample 3: [1, 16, 2, 4]
+# CHECK-NEXT:  sample 4: [1, 16, 3, 1]
+# CHECK-NEXT:  sample 5: [1, 16, 3, 4]
+# CHECK-NEXT:  sample 6: [1, 16, 4, 1]
+# CHECK-NEXT:  sample 7: [1, 16, 4, 4]
+# CHECK-NEXT:  sample 8: [1, 16, 6, 1]
+# CHECK-NEXT:  sample 9: [1, 16, 6, 4]
+# CHECK-NEXT:  sample 10: [1, 32, 1, 1]
+# CHECK-NEXT:  sample 11: [1, 32, 1, 4]
+# CHECK-NEXT:  sample 12: [1, 32, 2, 1]
+# CHECK-NEXT:  sample 13: [1, 32, 2, 4]
+# CHECK-NEXT:  sample 14: [1, 32, 3, 1]
+# CHECK-NEXT:  sample 15: [1, 32, 3, 4]
+# CHECK-NEXT:  sample 16: [1, 32, 4, 1]
+# CHECK-NEXT:  sample 17: [1, 32, 4, 4]
+# CHECK-NEXT:  sample 18: [3, 16, 1, 1]
+# CHECK-NEXT:  sample 19: [3, 16, 1, 4]
+# CHECK-NEXT:  sample 20: [3, 16, 2, 1]
+# CHECK-NEXT:  sample 21: [3, 16, 2, 4]
+# CHECK-NEXT:  sample 22: [3, 32, 1, 1]
+# CHECK-NEXT:  sample 23: [3, 32, 1, 4]
+# CHECK-NEXT:  sample 24: [7, 16, 1, 1]
+# CHECK-NEXT:  sample 25: [7, 16, 1, 4]
+# CHECK-NEXT:  stats {'filtered': 154, 'all': 864}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_pprprp.py b/tests/filecheck/search/test_matmul_pprprp.py
index ef8fc0d4..6e9bbd2c 100644
--- a/tests/filecheck/search/test_matmul_pprprp.py
+++ b/tests/filecheck/search/test_matmul_pprprp.py
@@ -13,13 +13,13 @@
 utils.print_exhaustive_samples(backend, strategy,100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 16, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 3, 1, 1, 16, 12]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 1, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 1, 2]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 1, 3]
@@ -121,4 +121,4 @@
 # CHECK-NEXT:  sample 98: [1, 1, 1, 1, 16, 2, 6]
 # CHECK-NEXT:  sample 99: [1, 1, 1, 1, 32, 1, 1]
 # CHECK-NEXT:  stats {'filtered': 100, 'all': 121}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_pprprpv.py b/tests/filecheck/search/test_matmul_pprprpv.py
index 822e546c..5ab1d535 100644
--- a/tests/filecheck/search/test_matmul_pprprpv.py
+++ b/tests/filecheck/search/test_matmul_pprprpv.py
@@ -13,13 +13,13 @@
 utils.print_exhaustive_samples(backend, strategy,100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 16, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 3, 1, 1, 16, 12]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 16, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 16, 2]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 16, 3]
@@ -121,4 +121,4 @@
 # CHECK-NEXT:  sample 98: [3, 1, 1, 1, 1, 16, 3]
 # CHECK-NEXT:  sample 99: [3, 1, 1, 1, 1, 16, 4]
 # CHECK-NEXT:  stats {'filtered_vec': 100, 'filtered': 1472, 'all': 3052}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 4}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 4}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 4}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 4}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_pprprpvr.py b/tests/filecheck/search/test_matmul_pprprpvr.py
index dfe2fb9c..aa30d488 100644
--- a/tests/filecheck/search/test_matmul_pprprpvr.py
+++ b/tests/filecheck/search/test_matmul_pprprpvr.py
@@ -20,13 +20,13 @@
 utils.print_exhaustive_samples(backend, strategy,100)
 
 # CHECK:       schedule O0: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O1: [1, 1, 1, 1, 1, 1, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O2: [1, 1, 1, 1, 1, 16, 1]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  schedule O3: [1, 1, 3, 1, 1, 16, 12]
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
 # CHECK-NEXT:  sample 0: [1, 1, 1, 1, 1, 16, 1]
 # CHECK-NEXT:  sample 1: [1, 1, 1, 1, 1, 16, 2]
 # CHECK-NEXT:  sample 2: [1, 1, 1, 1, 1, 16, 3]
@@ -128,4 +128,4 @@
 # CHECK-NEXT:  sample 98: [1, 21, 1, 1, 1, 32, 3]
 # CHECK-NEXT:  sample 99: [1, 21, 1, 1, 2, 16, 1]
 # CHECK-NEXT:  stats {'filtered_l2': 100, 'filtered_l1': 105, 'filtered_reg': 115, 'filtered_vec': 154, 'filtered': 2126, 'all': 2749}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 21, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 21, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_pprprpvr_rnd.py b/tests/filecheck/search/test_matmul_pprprpvr_rnd.py
index ff1fa2cb..e1b1ac3d 100644
--- a/tests/filecheck/search/test_matmul_pprprpvr_rnd.py
+++ b/tests/filecheck/search/test_matmul_pprprpvr_rnd.py
@@ -39,4 +39,4 @@
 # CHECK-NEXT:  sample 18: [1, 1, 1, 1, 2, 16, 3]
 # CHECK-NEXT:  sample 19: [7, 1, 3, 1, 1, 16, 2]
 # CHECK-NEXT:  stats {'filtered_l2': 2, 'filtered_l1': 2, 'filtered_reg': 3, 'filtered_vec': 3, 'filtered': 70}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 2}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 2}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 2}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_prp.py b/tests/filecheck/search/test_matmul_prp.py
index 967afc2c..011051bc 100644
--- a/tests/filecheck/search/test_matmul_prp.py
+++ b/tests/filecheck/search/test_matmul_prp.py
@@ -12,30 +12,30 @@
 utils.print_all_opt_schedules(backend, strategy)
 utils.print_exhaustive_samples(backend, strategy, 100)
 
-# CHECK: schedule O0: [1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O1: [1, 1]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O2: [1, 16]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 1}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: schedule O3: [3, 16]
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 3}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
-# CHECK-NEXT: sample 0: [1, 1]
-# CHECK-NEXT: sample 1: [1, 2]
-# CHECK-NEXT: sample 2: [1, 4]
-# CHECK-NEXT: sample 3: [1, 8]
-# CHECK-NEXT: sample 4: [1, 16]
-# CHECK-NEXT: sample 5: [1, 32]
-# CHECK-NEXT: sample 6: [3, 1]
-# CHECK-NEXT: sample 7: [3, 2]
-# CHECK-NEXT: sample 8: [3, 4]
-# CHECK-NEXT: sample 9: [3, 8]
-# CHECK-NEXT: sample 10: [3, 16]
-# CHECK-NEXT: sample 11: [3, 32]
-# CHECK-NEXT: sample 12: [7, 1]
-# CHECK-NEXT: sample 13: [7, 2]
-# CHECK-NEXT: sample 14: [7, 4]
-# CHECK-NEXT: sample 15: [7, 8]
-# CHECK-NEXT: sample 16: [7, 16]
-# CHECK-NEXT: stats {'filtered': 17, 'all': 24}
-# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK:       schedule O0: [1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O1: [1, 1]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O2: [1, 16]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  schedule O3: [3, 16]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
+# CHECK-NEXT:  sample 0: [1, 1]
+# CHECK-NEXT:  sample 1: [1, 2]
+# CHECK-NEXT:  sample 2: [1, 4]
+# CHECK-NEXT:  sample 3: [1, 8]
+# CHECK-NEXT:  sample 4: [1, 16]
+# CHECK-NEXT:  sample 5: [1, 32]
+# CHECK-NEXT:  sample 6: [3, 1]
+# CHECK-NEXT:  sample 7: [3, 2]
+# CHECK-NEXT:  sample 8: [3, 4]
+# CHECK-NEXT:  sample 9: [3, 8]
+# CHECK-NEXT:  sample 10: [3, 16]
+# CHECK-NEXT:  sample 11: [3, 32]
+# CHECK-NEXT:  sample 12: [7, 1]
+# CHECK-NEXT:  sample 13: [7, 2]
+# CHECK-NEXT:  sample 14: [7, 4]
+# CHECK-NEXT:  sample 15: [7, 8]
+# CHECK-NEXT:  sample 16: [7, 16]
+# CHECK-NEXT:  stats {'filtered': 17, 'all': 24}
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]
diff --git a/tests/filecheck/search/test_matmul_prp_rnd.py b/tests/filecheck/search/test_matmul_prp_rnd.py
index 2e6fc5fe..b2218181 100644
--- a/tests/filecheck/search/test_matmul_prp_rnd.py
+++ b/tests/filecheck/search/test_matmul_prp_rnd.py
@@ -39,4 +39,4 @@
 # CHECK-NEXT:  sample 18: [3, 2]
 # CHECK-NEXT:  sample 19: [21, 8]
 # CHECK-NEXT:  stats {'filtered': 19}
-# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21}, 'j': {'./j1': 8}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=['./i', './j'], unrolling={'./j1': 8, './i1': 21}, packed_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[])]
+# CHECK-NEXT:  [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21}, 'j': {'./j1': 8}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=['./i', './j'], unrolling={'./j1': 8, './i1': 21}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])]