From d9bc71619f0052b5b2e8a72ce7fbbff111c613b0 Mon Sep 17 00:00:00 2001
From: Chao Chen <chao.chen@intel.com>
Date: Mon, 16 Dec 2024 22:29:29 +0000
Subject: [PATCH] Remove old implementation of XeTile-Blocking which generates
 4D representations

---
 .../imex/Dialect/XeTile/Transforms/Passes.td  |    5 +-
 lib/Dialect/XeTile/Transforms/Blocking.cpp    | 1305 ++------------
 .../XeTile/Transforms/BlockingAnalysis.cpp    |   12 +-
 test/Conversion/XeTileToXeGPU/gemm_preop.mlir |    2 +-
 .../sg_gemm_1k_1k_1k_f16_f32.mlir             |    2 +-
 .../sg_gemm_1k_1k_1k_f16_f32_slm.mlir         |    2 +-
 .../XeTileToXeGPU/sg_init_tile.mlir           |    2 +-
 .../XeTileToXeGPU/sg_load_tile.mlir           |    3 +-
 .../XeTileToXeGPU/sg_mixed_scf.mlir           |    4 +-
 .../XeTileToXeGPU/sg_scattered_ops.mlir       |    2 +-
 test/Conversion/XeTileToXeGPU/sg_scf_for.mlir |    2 +-
 test/Conversion/XeTileToXeGPU/sg_softmax.mlir |    2 +-
 .../XeTileToXeGPU/sg_store_tile.mlir          |    2 +-
 .../Conversion/XeTileToXeGPU/sg_tile_mma.mlir |    2 +-
 .../XeTileToXeGPU/test_blocking.mlir          |   60 -
 test/Conversion/XeTileToXeGPU/test_order.mlir |    2 +-
 .../Blocking/persistent_kernel.mlir           |   77 +-
 .../Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir    |   85 +-
 .../sg_gemm_1k_1k_1k_f16_f32_slm.mlir         |   28 +-
 .../Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir     |   59 +-
 .../Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir    |   70 +-
 .../Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir     |   82 +-
 .../Transforms/Blocking/unit_tests.mlir       | 1538 ++++++++++++----
 .../Blocking/unit_tests_transform.mlir        | 1585 -----------------
 .../Dialect/XeTile/xetile-to-func-vc.pp       |    2 +-
 .../Dialect/XeTile/xetile-wg-to-func-vc.pp    |    2 +-
 26 files changed, 1607 insertions(+), 3330 deletions(-)
 delete mode 100644 test/Conversion/XeTileToXeGPU/test_blocking.mlir
 delete mode 100644 test/Dialect/XeTile/Transforms/Blocking/unit_tests_transform.mlir

diff --git a/include/imex/Dialect/XeTile/Transforms/Passes.td b/include/imex/Dialect/XeTile/Transforms/Passes.td
index 4f4883aec..83c141718 100644
--- a/include/imex/Dialect/XeTile/Transforms/Passes.td
+++ b/include/imex/Dialect/XeTile/Transforms/Passes.td
@@ -91,10 +91,7 @@ def XeTileBlocking : Pass<"xetile-blocking", "::mlir::gpu::GPUModuleOp">{
   let options = [
      Option<"device", "device", "std::string",
             /*default=*/"\"pvc\"",
-            "gpu platform architecture where these ops are running">,
-     Option<"EnableTransform", "enable-2d-transform", "bool",
-            /*default=*/"false",
-            "Using 2D transform or 4D Conversion.">
+            "gpu platform architecture where these ops are running">
  ];
 }
 
diff --git a/lib/Dialect/XeTile/Transforms/Blocking.cpp b/lib/Dialect/XeTile/Transforms/Blocking.cpp
index 2d36cd00a..337f18f22 100644
--- a/lib/Dialect/XeTile/Transforms/Blocking.cpp
+++ b/lib/Dialect/XeTile/Transforms/Blocking.cpp
@@ -60,9 +60,6 @@ namespace imex {
 #include "imex/Dialect/XeTile/Transforms/Passes.h.inc"
 } // namespace imex
 
-// TODO: Remove it after consolidation
-bool Enable2DBlockingTransform = false;
-
 namespace imex {
 // Blocking is to decompose ops working on big tile or vector size
 // into a set of ops working on smaller tile or vector size, that
@@ -106,11 +103,10 @@ static const char *const packAttrName = "__xetile_blocking_pack__";
 static const char *const unpackAttrName = "__xetile_blocking_unpack__";
 static const char *const blockAttrName = "__xetile_blocking_inner_block__";
 
-static mlir::Value
-unpackWithUnrealizedCastOp(mlir::ValueRange srcs, mlir::Type destTy,
-                           llvm::ArrayRef<int64_t> innerBlock,
-                           mlir::Location loc,
-                           mlir::PatternRewriter &rewriter) {
+static mlir::Value addUnpackOp(mlir::ValueRange srcs, mlir::Type destTy,
+                               llvm::ArrayRef<int64_t> innerBlock,
+                               mlir::Location loc,
+                               mlir::PatternRewriter &rewriter) {
   auto attr = mlir::NamedAttribute(rewriter.getStringAttr(unpackAttrName),
                                    rewriter.getUnitAttr());
   auto innerBlkAttr =
@@ -122,10 +118,10 @@ unpackWithUnrealizedCastOp(mlir::ValueRange srcs, mlir::Type destTy,
   return castOp.getResult(0);
 }
 
-static mlir::ValueRange
-packWithUnrealizedCastOp(mlir::Value src, mlir::TypeRange destTypes,
-                         llvm::ArrayRef<int64_t> innerBlock, mlir::Location loc,
-                         mlir::PatternRewriter &rewriter) {
+static mlir::ValueRange addPackOp(mlir::Value src, mlir::TypeRange destTypes,
+                                  llvm::ArrayRef<int64_t> innerBlock,
+                                  mlir::Location loc,
+                                  mlir::PatternRewriter &rewriter) {
   auto attr = mlir::NamedAttribute(rewriter.getStringAttr(packAttrName),
                                    rewriter.getUnitAttr());
   auto innerBlkAttr =
@@ -580,8 +576,8 @@ class RewriteArithConstantOp
           newOps.push_back(newOp);
         }
       }
-      auto castOp = unpackWithUnrealizedCastOp(
-          newOps, value.getType(), blockSize.asArrayRef(), loc, rewriter);
+      auto castOp = addUnpackOp(newOps, value.getType(), blockSize.asArrayRef(),
+                                loc, rewriter);
       rewriter.replaceOp(op, castOp);
       return mlir::success();
     }
@@ -620,8 +616,8 @@ class RewriteInitTileOp
       auto convertedTileTypes = convertTypes(tileTy, blockSize.asArrayRef());
       auto newIndicesTypes = convertTypes(indicesTy, blockSize.asArrayRef());
 
-      auto subIndices = packWithUnrealizedCastOp(
-          indices, newIndicesTypes, blockSize.asArrayRef(), loc, rewriter);
+      auto subIndices = addPackOp(indices, newIndicesTypes,
+                                  blockSize.asArrayRef(), loc, rewriter);
 
       for (auto [t, i] : llvm::zip(convertedTileTypes, subIndices)) {
         llvm::SmallVector<mlir::Value> operands({op.getSource(), i});
@@ -676,8 +672,8 @@ class RewriteInitTileOp
         }
       }
     }
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, tileTy, blockSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, tileTy, blockSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -703,8 +699,8 @@ class RewritePrefetchTileOp
     if (!blockSize || shape == blockSize.asArrayRef())
       return failure();
     auto convertedTileTypes = convertTypes(tileTy, blockSize.asArrayRef());
-    auto convertedTiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto convertedTiles = addPackOp(tile, convertedTileTypes,
+                                    blockSize.asArrayRef(), loc, rewriter);
 
     for (auto [t, ty] : llvm::zip_equal(convertedTiles, convertedTileTypes)) {
       rewriter.create<xetile::PrefetchTileOp>(loc, ty, t, op->getAttrs());
@@ -735,8 +731,8 @@ class RewriteLoadTileOp
       return failure();
 
     auto convertedTileTypes = convertTypes(tileTy, blockSize.asArrayRef());
-    auto convertedTiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto convertedTiles = addPackOp(tile, convertedTileTypes,
+                                    blockSize.asArrayRef(), loc, rewriter);
 
     auto vecTy = ::mlir::VectorType::get(blockSize.asArrayRef(),
                                          tileTy.getElementType());
@@ -748,8 +744,8 @@ class RewriteLoadTileOp
       newOps.push_back(newOp);
     }
 
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, op.getType(), blockSize.asArrayRef(), loc, rewriter);
+    auto castOp = addUnpackOp(newOps, op.getType(), blockSize.asArrayRef(), loc,
+                              rewriter);
 
     rewriter.replaceOp(op, castOp);
     return mlir::success();
@@ -779,10 +775,10 @@ class RewriteStoreTileOp
 
     auto convertedValTypes = convertTypes(valTy, blockSize.asArrayRef());
     auto convertedTileTypes = convertTypes(tileTy, blockSize.asArrayRef());
-    auto convertedValues = packWithUnrealizedCastOp(
-        value, convertedValTypes, blockSize.asArrayRef(), loc, rewriter);
-    auto convertedTiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto convertedValues = addPackOp(value, convertedValTypes,
+                                     blockSize.asArrayRef(), loc, rewriter);
+    auto convertedTiles = addPackOp(tile, convertedTileTypes,
+                                    blockSize.asArrayRef(), loc, rewriter);
 
     for (auto [v, t] : llvm::zip(convertedValues, convertedTiles)) {
       rewriter.create<xetile::StoreTileOp>(loc, v, t, op.getL1HintAttr(),
@@ -819,10 +815,10 @@ class RewriteLoadGatherOp
     auto convertedMaskTypes =
         convertTypes(mask.getType(), blockSize.asArrayRef());
 
-    auto tiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
-    auto masks = packWithUnrealizedCastOp(
-        mask, convertedMaskTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto tiles = addPackOp(tile, convertedTileTypes, blockSize.asArrayRef(),
+                           loc, rewriter);
+    auto masks = addPackOp(mask, convertedMaskTypes, blockSize.asArrayRef(),
+                           loc, rewriter);
     auto newValueTy = mlir::VectorType::get(blockSize.asArrayRef(), elemTy);
     llvm::SmallVector<mlir::Value> newOps;
     for (auto [t, m] : llvm::zip(tiles, masks)) {
@@ -832,8 +828,8 @@ class RewriteLoadGatherOp
       newOps.push_back(newOp);
     }
 
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, op.getType(), blockSize.asArrayRef(), loc, rewriter);
+    auto castOp = addUnpackOp(newOps, op.getType(), blockSize.asArrayRef(), loc,
+                              rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -869,12 +865,12 @@ class RewriteStoreScatterOp
     auto convertedMaskTypes =
         convertTypes(mask.getType(), blockSize.asArrayRef());
 
-    auto values = packWithUnrealizedCastOp(
-        value, convertedValTypes, blockSize.asArrayRef(), loc, rewriter);
-    auto tiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
-    auto masks = packWithUnrealizedCastOp(
-        mask, convertedMaskTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto values = addPackOp(value, convertedValTypes, blockSize.asArrayRef(),
+                            loc, rewriter);
+    auto tiles = addPackOp(tile, convertedTileTypes, blockSize.asArrayRef(),
+                           loc, rewriter);
+    auto masks = addPackOp(mask, convertedMaskTypes, blockSize.asArrayRef(),
+                           loc, rewriter);
 
     for (auto [v, t, m] : llvm::zip(values, tiles, masks)) {
       (void)rewriter.create<xetile::StoreScatterOp>(
@@ -909,8 +905,8 @@ class RewriteUpdateTileOffsetOp
       return mlir::failure();
 
     auto convertedTileTypes = convertTypes(tileTy, blockSize.asArrayRef());
-    auto convertedTiles = packWithUnrealizedCastOp(
-        tile, convertedTileTypes, blockSize.asArrayRef(), loc, rewriter);
+    auto convertedTiles = addPackOp(tile, convertedTileTypes,
+                                    blockSize.asArrayRef(), loc, rewriter);
 
     llvm::SmallVector<mlir::Value> newOps;
 
@@ -922,9 +918,8 @@ class RewriteUpdateTileOffsetOp
 
       auto convertedIndicesTypes =
           convertTypes(indicesTy, blockSize.asArrayRef());
-      auto convertedIndices =
-          packWithUnrealizedCastOp(indices, convertedIndicesTypes,
-                                   blockSize.asArrayRef(), loc, rewriter);
+      auto convertedIndices = addPackOp(indices, convertedIndicesTypes,
+                                        blockSize.asArrayRef(), loc, rewriter);
 
       for (auto [t, i] : llvm::zip(convertedTiles, convertedIndices)) {
         auto newOp = rewriter.create<xetile::UpdateTileOffsetOp>(
@@ -939,8 +934,8 @@ class RewriteUpdateTileOffsetOp
       }
     }
 
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, op.getType(), blockSize.asArrayRef(), loc, rewriter);
+    auto castOp = addUnpackOp(newOps, op.getType(), blockSize.asArrayRef(), loc,
+                              rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -985,8 +980,7 @@ class RewriteTileMMAOp
       if (type.getShape() == blockSize)
         return llvm::SmallVector<mlir::Value>({val});
       auto convertedTypes = convertTypes(type, blockSize);
-      auto values = packWithUnrealizedCastOp(val, convertedTypes, blockSize,
-                                             loc, rewriter);
+      auto values = addPackOp(val, convertedTypes, blockSize, loc, rewriter);
       return llvm::to_vector(values);
     };
 
@@ -1031,8 +1025,8 @@ class RewriteTileMMAOp
         newOps.push_back(tmpC);
       }
     }
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resultTy, Block().asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resultTy, Block().asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -1076,8 +1070,8 @@ class RewriteTileReductionOp
       return rewriter.notifyMatchFailure(op, "Invalid blocking size");
 
     auto convertedSrcTypes = convertTypes(srcTy, blkSize.asArrayRef());
-    auto convertedSrcs = packWithUnrealizedCastOp(
-        src, convertedSrcTypes, blkSize.asArrayRef(), loc, rewriter);
+    auto convertedSrcs =
+        addPackOp(src, convertedSrcTypes, blkSize.asArrayRef(), loc, rewriter);
 
     int64_t grid[2] = {shape[0] / blkSize[0], shape[1] / blkSize[1]};
 
@@ -1108,8 +1102,8 @@ class RewriteTileReductionOp
     }
 
     blkSize[dims[0]] = 1;
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, op.getType(), blkSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, op.getType(), blkSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
 
     return mlir::success();
@@ -1144,8 +1138,8 @@ class RewriteTileBroadcastOp
       return rewriter.notifyMatchFailure(op, "No need to block");
 
     auto convertedSrcTypes = convertTypes(srcTy, srcBlkSize.asArrayRef());
-    auto convertedSrcs = packWithUnrealizedCastOp(
-        src, convertedSrcTypes, srcBlkSize.asArrayRef(), loc, rewriter);
+    auto convertedSrcs = addPackOp(src, convertedSrcTypes,
+                                   srcBlkSize.asArrayRef(), loc, rewriter);
 
     auto resTy = op.getResult().getType();
     int64_t resultGrid[2] = {resTy.getShape()[0] / resBlkSize[0],
@@ -1202,8 +1196,8 @@ class RewriteTileBroadcastOp
     } else {
       return mlir::failure();
     }
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resTy, resBlkSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resTy, resBlkSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -1243,8 +1237,8 @@ class RewriteTileTransposeOp
     auto convertedResultTypes =
         convertTypes(resultTy, outBlockSize.asArrayRef());
 
-    auto convertedInputs = packWithUnrealizedCastOp(
-        input, convertedInputTypes, inBlockSize.asArrayRef(), loc, rewriter);
+    auto convertedInputs = addPackOp(input, convertedInputTypes,
+                                     inBlockSize.asArrayRef(), loc, rewriter);
 
     int64_t grids[2] = {resultShape[0] / outBlockSize[0],
                         resultShape[1] / outBlockSize[1]};
@@ -1258,8 +1252,8 @@ class RewriteTileTransposeOp
         newOps.push_back(res);
       }
     }
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resultTy, outBlockSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resultTy, outBlockSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -1301,8 +1295,8 @@ class RewriteVectorizableOp
       if (!oprTy || oprTy.getRank() != 2)
         newOperands.emplace_back(opr);
       auto convertedTypes = convertTypes(oprTy, blockSize.asArrayRef());
-      auto convertedValues = packWithUnrealizedCastOp(
-          opr, convertedTypes, blockSize.asArrayRef(), loc, rewriter);
+      auto convertedValues =
+          addPackOp(opr, convertedTypes, blockSize.asArrayRef(), loc, rewriter);
       newOperands.push_back(convertedValues);
     }
 
@@ -1330,8 +1324,8 @@ class RewriteVectorizableOp
       }
     }
 
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resType, blockSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resType, blockSize.asArrayRef(), loc, rewriter);
 
     rewriter.replaceOp(op, castOp);
     return mlir::success();
@@ -1378,8 +1372,8 @@ class RewriteSCFForOp
       } else {
         auto newTypes = convertTypes(type, blockSZ.asArrayRef());
         argConversion.addInputs(i, newTypes);
-        auto values = packWithUnrealizedCastOp(
-            v, newTypes, blockSZ.asArrayRef(), loc, rewriter);
+        auto values =
+            addPackOp(v, newTypes, blockSZ.asArrayRef(), loc, rewriter);
         convertedInitArgs.append(values.begin(), values.end());
       }
     }
@@ -1410,7 +1404,7 @@ class RewriteSCFForOp
       if (!inputMap || inputMap->size == 1) {
         castArgs.push_back(convertedArgs[inputMap->inputNo]);
       } else {
-        auto arg = unpackWithUnrealizedCastOp(
+        auto arg = addUnpackOp(
             convertedArgs.slice(inputMap->inputNo, inputMap->size),
             regionArgs[i].getType(), blockSZs[i].asArrayRef(), loc, rewriter);
         castArgs.push_back(arg);
@@ -1426,7 +1420,7 @@ class RewriteSCFForOp
       if (!inputMap || inputMap->size == 1) {
         castResults.push_back(convertedResults[inputMap->inputNo]);
       } else {
-        auto res = unpackWithUnrealizedCastOp(
+        auto res = addUnpackOp(
             convertedResults.slice(inputMap->inputNo, inputMap->size),
             results[i].getType(), blockSZs[i].asArrayRef(), loc, rewriter);
         castResults.push_back(res);
@@ -1455,8 +1449,8 @@ class RewriteSCFYieldOp
       auto type = mlir::dyn_cast<mlir::ShapedType>(res.getType());
       if (blockSZ && type && type.getShape() != blockSZ.asArrayRef()) {
         auto newTypes = convertTypes(type, blockSZ.asArrayRef());
-        auto values = packWithUnrealizedCastOp(
-            res, newTypes, blockSZ.asArrayRef(), loc, rewriter);
+        auto values =
+            addPackOp(res, newTypes, blockSZ.asArrayRef(), loc, rewriter);
         convertedResults.append(values.begin(), values.end());
       } else {
         convertedResults.push_back(res);
@@ -1517,8 +1511,8 @@ class RewriteCreateMaskOp
       }
       x = sub(x, blockSize[0]);
     }
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resTy, blockSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resTy, blockSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
@@ -1549,911 +1543,26 @@ class RewriteSplatOp
         loc, newTy, op->getOperands(), op->getAttrs());
     auto numOps = resTy.getNumElements() / newTy.getNumElements();
     llvm::SmallVector<mlir::Value> newOps(numOps, newOp);
-    auto castOp = unpackWithUnrealizedCastOp(
-        newOps, resTy, blockSize.asArrayRef(), loc, rewriter);
+    auto castOp =
+        addUnpackOp(newOps, resTy, blockSize.asArrayRef(), loc, rewriter);
     rewriter.replaceOp(op, castOp);
     return mlir::success();
   }
 };
-
-// ====================== Old 4D blocking patterns ========================
-static xetile::TileUnpackOp
-addUnpackOp(mlir::Value src, mlir::ConversionPatternRewriter &rewriter) {
-  auto srcTy = llvm::dyn_cast_if_present<mlir::VectorType>(src.getType());
-  assert(srcTy && srcTy.getRank() == 4);
-  auto shape = srcTy.getShape();
-  auto grids = shape.take_front(2);
-  auto innerBlocks = shape.take_back(2);
-  llvm::SmallVector<int64_t> unpackShape(
-      {grids[0] * innerBlocks[0], grids[1] * innerBlocks[1]});
-
-  auto unpackTy = mlir::VectorType::get(unpackShape, srcTy.getElementType());
-  return rewriter.create<xetile::TileUnpackOp>(
-      src.getLoc(), unpackTy, src,
-      mlir::DenseI64ArrayAttr::get(src.getContext(), innerBlocks));
-}
-
-static mlir::Value addPackOp(mlir::Value src,
-                             llvm::ArrayRef<int64_t> targetBlkSizes,
-                             mlir::ConversionPatternRewriter &rewriter) {
-  auto srcTy = mlir::dyn_cast<mlir::VectorType>(src.getType());
-  assert(srcTy && targetBlkSizes.size() == 2);
-  auto shape = srcTy.getShape();
-  llvm::SmallVector<int64_t> packShape({shape[0] / targetBlkSizes[0],
-                                        shape[1] / targetBlkSizes[1],
-                                        targetBlkSizes[0], targetBlkSizes[1]});
-
-  auto packTy = mlir::VectorType::get(packShape, srcTy.getElementType());
-  auto packOp = rewriter.create<xetile::TilePackOp>(
-      src.getLoc(), packTy, src,
-      mlir::DenseI64ArrayAttr::get(src.getContext(), targetBlkSizes));
-  return packOp;
-}
-
-/// OpConversionPatternWithAnalysis is a wrapper around OpConversionPattern
-/// but takes an extra AnalysisT object as an argument, such that patterns
-/// can leverage the analysis results.
-template <typename SourceOp, typename AnalysisT>
-class OpConversionPatternWithAnalysis
-    : public mlir::OpConversionPattern<SourceOp> {
-public:
-  using OpPatternRewriter = typename mlir::ConversionPatternRewriter;
-
-  OpConversionPatternWithAnalysis(mlir::MLIRContext *context,
-                                  AnalysisT &analysis)
-      : mlir::OpConversionPattern<SourceOp>(context), analysis(analysis) {}
-
-protected:
-  AnalysisT &analysis;
-};
-
-/// OpTraitConversionPatternWithAnalysis is a wrapper around
-/// OpTraitConversionPattern but takes an extra AnalysisT object as an argument,
-/// such that patterns can leverage the analysis results.
-template <template <typename> class TraitType, typename AnalysisT>
-class OpTraitConversionPatternWithAnalysis
-    : public mlir::OpTraitConversionPattern<TraitType> {
-public:
-  OpTraitConversionPatternWithAnalysis(mlir::MLIRContext *context,
-                                       AnalysisT &analysis,
-                                       PatternBenefit benefit = 1)
-      : mlir::OpTraitConversionPattern<TraitType>(context, benefit),
-        analysis(analysis) {}
-
-protected:
-  AnalysisT &analysis;
-};
-
-// It blocks/extends a 2D constant dense vector into a
-// 4D vector with the last 2 dim corresponding to block size.
-// which is chosed based on requests from its users.
-// example: arith.constant dense<0.0>: vector<32x32xf16>
-//      --> arith.constant dense<0.0>: vector<4x2x8x16xf16>
-// assuming [8, 16] is the block size.
-struct ArithConstantOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::arith::ConstantOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::arith::ConstantOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::arith::ConstantOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto value = llvm::dyn_cast<mlir::DenseElementsAttr>(op.getValue());
-
-    // TODO: it maybe unstable to determine whether doing blocking or not
-    //  for a constant op simply based on its 2D shape.
-    if (!value || value.getType().getRank() != 2)
-      return mlir::failure();
-
-    auto blockSize = analysis.getDefBlockSize(op.getResult());
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto shape = value.getType().getShape();
-    auto newTy =
-        mlir::VectorType::get({shape[0] / blockSize[0], shape[1] / blockSize[1],
-                               blockSize[0], blockSize[1]},
-                              value.getElementType());
-
-    // TODO: it is logically incorrect to reshape a dense value.
-    // it doesn't show the impact of pack effect. It works on some
-    // cases in which all elements has the same value, but not general.
-    value = value.reshape(newTy);
-    auto loc = op.getLoc();
-    auto newOp = rewriter.create<mlir::arith::ConstantOp>(loc, value);
-    auto unpack = addUnpackOp(newOp, rewriter);
-
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-// It updates init_tile by attaching innerBlock attribute to the result
-// tile. The block size is choosed based on requests from its users.
-struct InitTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::InitTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::InitTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::InitTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tileTy = op.getType();
-    auto shape = tileTy.getShape();
-    if (tileTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "Skipped InitTileOp because the result tile is not rank 2.\n");
-
-    auto innerBlockAttr = tileTy.getInnerBlocks();
-
-    // skip it if innerBlocks has been set by user or compiler.
-    if (innerBlockAttr)
-      return mlir::failure();
-
-    auto blockSize = analysis.getDefBlockSize(op.getTile());
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    innerBlockAttr =
-        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
-
-    if (innerBlockAttr.empty())
-      return rewriter.notifyMatchFailure(op, "Invalid inner block sizes ");
-
-    auto attr = imex::xetile::XeTileAttr::get(
-        op.getContext(), tileTy.getSgMap(), tileTy.getWgMap(),
-        tileTy.getOrder(), innerBlockAttr, tileTy.getMemorySpace(),
-        tileTy.getScatterAttr());
-
-    auto elemTy = tileTy.getElementType();
-    auto newTileTy = imex::xetile::TileType::get(shape, elemTy, attr);
-
-    llvm::SmallVector<mlir::Value> operands =
-        llvm::to_vector(adaptor.getOperands());
-    if (tileTy.getScatterAttr() == mlir::BoolAttr::get(getContext(), true)) {
-      auto indices =
-          addPackOp(adaptor.getIndices(), blockSize.asArrayRef(), rewriter);
-      operands[1] = indices;
-    }
-
-    auto newOp = rewriter.create<xetile::InitTileOp>(
-        op.getLoc(), mlir::TypeRange({newTileTy}), operands, op->getAttrs());
-
-    rewriter.replaceOp(op, newOp);
-
-    return mlir::success();
-  }
-};
-
-// It updates tile operand of prefetch_tile.
-struct PrefetchTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::PrefetchTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::PrefetchTileOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::PrefetchTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    // define op is not updated yet.
-    if (!blockSize)
-      return failure();
-
-    rewriter.startOpModification(op);
-    op->setOperand(0, tile);
-    rewriter.finalizeOpModification(op);
-
-    return mlir::success();
-  }
-};
-
-// It updates load_tile to reveal effects of innerblock attribute by
-// representing value as 4D vector. An unpack op is added at the end
-// to make this change to be transparent to its users.
-struct LoadTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::LoadTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::LoadTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::LoadTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto source = adaptor.getSource();
-    auto tileTy = mlir::cast<xetile::TileType>(source.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    auto rank = op.getValue().getType().getRank();
-
-    if (!blockSize || rank == 4)
-      return rewriter.notifyMatchFailure(
-          op, "Input is not updated or the op has been updated.\n");
-
-    auto shape = tileTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / blockSize[0],
-                                          shape[1] / blockSize[1], blockSize[0],
-                                          blockSize[1]},
-                                         tileTy.getElementType());
-    mlir::Value newOp = rewriter.create<xetile::LoadTileOp>(
-        op.getLoc(), vecTy, adaptor.getSource(),
-        op.getPadding().value_or(mlir::Attribute()), op.getL1HintAttr(),
-        op.getL2HintAttr(), op.getL3HintAttr());
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct LoadGatherOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::LoadGatherOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::LoadGatherOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::LoadGatherOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto source = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(source.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    auto rank = op.getValue().getType().getRank();
-
-    if (!blockSize || rank == 4)
-      return rewriter.notifyMatchFailure(
-          op, "Input is not updated or the op has been updated.\n");
-
-    auto shape = tileTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / blockSize[0],
-                                          shape[1] / blockSize[1], blockSize[0],
-                                          blockSize[1]},
-                                         tileTy.getElementType());
-    auto mask = addPackOp(adaptor.getMask(), blockSize.asArrayRef(), rewriter);
-    mlir::Value newOp = rewriter.create<xetile::LoadGatherOp>(
-        op.getLoc(), vecTy, source, mask,
-        op.getPadding().value_or(mlir::Attribute()), op.getL1HintAttr(),
-        op.getL2HintAttr(), op.getL3HintAttr());
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-// It updates store_tile to reveal effects of innerblock attribute.
-// It uses pack op to align the shape of its vector value to the tile shape.
-struct StoreTileOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::StoreTileOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::StoreTileOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::StoreTileOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto value = adaptor.getValue();
-    auto valTy = mlir::dyn_cast<mlir::VectorType>(value.getType());
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-
-    // its inputs has not been updated yet.
-    if (blockSize && valTy.getRank() == 2) {
-      value = addPackOp(value, blockSize.asArrayRef(), rewriter);
-      rewriter.replaceOpWithNewOp<xetile::StoreTileOp>(
-          op, value, tile, op.getL1HintAttr(), op.getL2HintAttr(),
-          op.getL3HintAttr());
-      return mlir::success();
-    }
-    return mlir::failure();
-  }
-};
-
-struct StoreScatterOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::StoreScatterOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::StoreScatterOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::StoreScatterOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto value = adaptor.getValue();
-    auto valTy = mlir::dyn_cast<mlir::VectorType>(value.getType());
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-
-    // its inputs has not been updated yet.
-    if (blockSize && valTy.getRank() == 2) {
-      value = addPackOp(value, blockSize.asArrayRef(), rewriter);
-      auto mask =
-          addPackOp(adaptor.getMask(), blockSize.asArrayRef(), rewriter);
-      rewriter.replaceOpWithNewOp<xetile::StoreScatterOp>(
-          op, value, tile, mask, op.getL1HintAttr(), op.getL2HintAttr(),
-          op.getL3HintAttr());
-      return mlir::success();
-    }
-    return mlir::failure();
-  }
-};
-
-// It updates update_tile_offset to reveal effects of innerblock attribute
-// by updating the type of it result.
-struct UpdateTileOffsetOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::UpdateTileOffsetOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::UpdateTileOffsetOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::UpdateTileOffsetOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto tile = adaptor.getTile();
-    auto tileTy = mlir::cast<xetile::TileType>(tile.getType());
-    auto blockSize = tileTy.getInnerBlocks();
-    // define op is not updated yet.
-    if (!blockSize)
-      return failure();
-
-    llvm::SmallVector<mlir::Value> operands =
-        llvm::to_vector(adaptor.getOperands());
-    if (tileTy.getScatterAttr() == mlir::BoolAttr::get(getContext(), true)) {
-      auto indices =
-          addPackOp(adaptor.getIndices(), blockSize.asArrayRef(), rewriter);
-      operands[1] = indices;
-    }
-    rewriter.replaceOpWithNewOp<xetile::UpdateTileOffsetOp>(op, operands,
-                                                            op->getAttrs());
-    return mlir::success();
-  }
-};
-
-// It updates tile_mma to reveal effects of innerblock attribute.
-// Values will be reprented as 4D vectors. An unpack op is applied
-// to its result to make the change transparent to its users.
-struct TileMMAOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::TileMMAOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::TileMMAOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(xetile::TileMMAOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto resultTy = op.getResult().getType();
-    if (resultTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(
-          op, "The result of tile_mma must be 2D vector.\n");
-
-    auto a = adaptor.getA();
-    auto b = adaptor.getB();
-    auto c = adaptor.getC();
-
-    assert(a && b && "a operand or b operand is (are) missing.\n");
-
-    auto getBlockingSize = [&](mlir::Value val,
-                               int pos) -> mlir::FailureOr<Block> {
-      auto blk = analysis.getUseBlockSize(val, op->getOpOperand(pos));
-      if (!blk)
-        return rewriter.notifyMatchFailure(op, "Invalid block size.");
-      return blk;
-    };
-
-    auto aBlockSize = getBlockingSize(op.getA(), 0);
-    auto bBlockSize = getBlockingSize(op.getB(), 1);
-    if (mlir::failed(aBlockSize) || mlir::failed(bBlockSize))
-      return mlir::failure();
-    if (c) {
-      auto cBlockSize = getBlockingSize(op.getC(), 2);
-      if (mlir::failed(cBlockSize))
-        return mlir::failure();
-      c = addPackOp(c, cBlockSize->asArrayRef(), rewriter);
-    }
-
-    a = addPackOp(a, aBlockSize->asArrayRef(), rewriter);
-    b = addPackOp(b, bBlockSize->asArrayRef(), rewriter);
-
-    assert(
-        mlir::dyn_cast<mlir::VectorType>(a.getType()).getRank() == 4 &&
-        mlir::dyn_cast<mlir::VectorType>(b.getType()).getRank() == 4 &&
-        (!c || mlir::dyn_cast<mlir::VectorType>(c.getType()).getRank() == 4) &&
-        "a, b and c (if has) should be transformed into 4D vectors.\n");
-
-    Block dBlockSize(aBlockSize->asArrayRef()[0], bBlockSize->asArrayRef()[1]);
-    auto shape = resultTy.getShape();
-    auto vecTy = ::mlir::VectorType::get({shape[0] / dBlockSize[0],
-                                          shape[1] / dBlockSize[1],
-                                          dBlockSize[0], dBlockSize[1]},
-                                         resultTy.getElementType());
-
-    mlir::Value newOp = rewriter.create<imex::xetile::TileMMAOp>(
-        op.getLoc(), vecTy, a, b, c, nullptr, nullptr, nullptr);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileReductionOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::ReductionOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::ReductionOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::ReductionOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto source = op.getSource();
-    auto srcTy = source.getType();
-    auto reductionDims = op.getReductionDims();
-
-    if (srcTy.getRank() != 2 || reductionDims.size() != 1)
-      return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or reduction dims are not 1");
-
-    auto blkSize = analysis.getUseBlockSize(source, op->getOpOperand(0));
-    if (!blkSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    // reduction on one dim becomes reduction on two dims after blocking.
-    // For example:
-    // reduce<add>, %e [1]: vector<16x32xf16> to vector<16x1xf16>
-    // will be transformed to
-    // reduce<add>, %e [1, 3]: vector<16x2x1x16xf16> to
-    // vector<16x1x1x1xf16>
-    auto dim = reductionDims[0];
-
-    auto ctx = op.getContext();
-    auto shape = srcTy.getShape();
-    auto newReductionDims = mlir::DenseI64ArrayAttr::get(ctx, {dim, dim + 2});
-    llvm::SmallVector<int64_t> resultShape(
-        {shape[0] / blkSize[0], shape[1] / blkSize[1], blkSize[0], blkSize[1]});
-    for (auto dim : newReductionDims.asArrayRef())
-      resultShape[dim] = 1;
-
-    auto elemTy = srcTy.getElementType();
-    auto resultType = mlir::VectorType::get(resultShape, elemTy);
-
-    auto newSource = addPackOp(source, {blkSize[0], blkSize[1]}, rewriter);
-    mlir::Value newOp = rewriter.create<xetile::ReductionOp>(
-        op.getLoc(), resultType, op.getKind(), newSource, newReductionDims);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileBroadcastOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::BroadcastOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      xetile::BroadcastOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::BroadcastOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto loc = op.getLoc();
-    auto src = op.getSource();
-    auto srcTy = src.getType();
-    auto elemTy = srcTy.getElementType();
-    auto broadcastDims = op.getBroadcastDim();
-
-    if (srcTy.getRank() != 2 || broadcastDims.size() != 1)
-      return rewriter.notifyMatchFailure(
-          op, "source type is not 2D vector or rank of broadcastDims is not 1");
-
-    auto srcBlkSize = analysis.getUseBlockSize(src, op->getOpOperand(0));
-    auto resBlkSize = analysis.getDefBlockSize(op.getResult());
-    if (!srcBlkSize || !resBlkSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto outShape = op.getResult().getType().getShape();
-
-    // TODO: move this into analysis
-    llvm::SmallVector<int64_t> resultShape(
-        {outShape[0], outShape[1] / resBlkSize[1], 1, resBlkSize[1]});
-
-    auto newSource = addPackOp(adaptor.getSource(),
-                               {srcBlkSize[0], srcBlkSize[1]}, rewriter);
-
-    auto resultType = mlir::VectorType::get(resultShape, elemTy);
-
-    // broadcast on one dim becomes broadcast on two dims after blocking.
-    // For example:
-    // broadcast %a [0]: vector<1x32xf16> to vector<16x32xf16>
-    // will be transformed to
-    // broadcast %a [0, 2]: vector<1x2x1x16xf16> to vector<16x2x1x16xf16>
-    auto dim = broadcastDims[0];
-    auto newBroadcastDims =
-        mlir::DenseI64ArrayAttr::get(op.getContext(), {dim, dim + 2});
-    mlir::Value newOp = rewriter.create<xetile::BroadcastOp>(
-        loc, resultType, newSource, newBroadcastDims);
-    newOp = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-struct TileTransposeOpPattern
-    : public OpConversionPatternWithAnalysis<xetile::TransposeOp,
-                                             BlockingAnalysis> {
-  using OpConversionPatternWithAnalysis<
-      xetile::TransposeOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(xetile::TransposeOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto input = op.getVector();
-    auto inputTy = input.getType();
-    auto result = op.getResult();
-    auto resultTy = result.getType();
-    if (resultTy.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    auto permutation = op.getPermutation();
-    if (permutation != mlir::ArrayRef<int64_t>({1, 0}))
-      return rewriter.notifyMatchFailure(op, "Unsupported permutation");
-
-    auto inBlockSize = analysis.getUseBlockSize(input, op->getOpOperand(0));
-    auto outBlockSize = analysis.getDefBlockSize(result);
-    if (!inBlockSize || !outBlockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto srcShape = inputTy.getShape();
-    auto newSrcTy = mlir::VectorType::get({srcShape[0] / inBlockSize[0],
-                                           srcShape[1] / inBlockSize[1],
-                                           inBlockSize[0], inBlockSize[1]},
-                                          inputTy.getElementType());
-    auto resShape = resultTy.getShape();
-    auto newDstTy = mlir::VectorType::get({resShape[0] / outBlockSize[0],
-                                           resShape[1] / outBlockSize[1],
-                                           outBlockSize[0], outBlockSize[1]},
-                                          resultTy.getElementType());
-
-    mlir::Value src = adaptor.getVector();
-
-    auto ctxt = op.getContext();
-    auto blockAttr =
-        mlir::DenseI64ArrayAttr::get(ctxt, inBlockSize.asArrayRef());
-    Location loc = op->getLoc();
-    mlir::Value pack =
-        rewriter.create<xetile::TilePackOp>(loc, newSrcTy, src, blockAttr);
-
-    int64_t newPermutation[4] = {1, 0, 3, 2};
-    mlir::Value transpose = rewriter.create<xetile::TransposeOp>(
-        loc, newDstTy, pack, newPermutation);
-
-    blockAttr = mlir::DenseI64ArrayAttr::get(ctxt, outBlockSize.asArrayRef());
-    mlir::Value unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resultTy, transpose, blockAttr);
-
-    rewriter.replaceOp(op, unpack);
-
-    return mlir::success();
-  }
-};
-
-struct VectorizableOpPattern
-    : public OpTraitConversionPatternWithAnalysis<mlir::OpTrait::Vectorizable,
-                                                  BlockingAnalysis> {
-
-  using OpTraitConversionPatternWithAnalysis::
-      OpTraitConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::Operation *op, llvm::ArrayRef<mlir::Value> operands,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    if (op->getNumResults() != 1)
-      return rewriter.notifyMatchFailure(op, "op must have 1 result");
-
-    auto res = op->getResult(0);
-    auto resType = mlir::dyn_cast<mlir::VectorType>(res.getType());
-    if (!resType || resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    auto blockSize =
-        analysis.getUseBlockSize(op->getOperand(0), op->getOpOperand(0));
-    if (!blockSize)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    auto shape = resType.getShape();
-    auto elemTy = resType.getElementType();
-    auto blockSizeAttr =
-        mlir::DenseI64ArrayAttr::get(getContext(), blockSize.asArrayRef());
-    int64_t packShape[] = {shape[0] / blockSize[0], shape[1] / blockSize[1],
-                           blockSize[0], blockSize[1]};
-
-    auto newTy = mlir::VectorType::get(packShape, elemTy);
-
-    Location loc = op->getLoc();
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    llvm::SmallVector<mlir::Value> newOperands;
-    for (auto &&[i, arg] : llvm::enumerate(operands)) {
-      auto argTy = mlir::dyn_cast<mlir::VectorType>(arg.getType());
-      if (!argTy || argTy.getRank() != 2) {
-        newOperands.push_back(arg);
-        continue;
-      }
-      mlir::Value packOp = addPackOp(arg, blockSize.asArrayRef(), rewriter);
-      newOperands.push_back(packOp);
-    }
-
-    mlir::OperationState opState(loc, op->getName(), newOperands,
-                                 mlir::TypeRange(newTy), op->getAttrs(),
-                                 op->getSuccessors());
-
-    auto newOp = rewriter.create(opState);
-    auto unpack = rewriter.create<xetile::TileUnpackOp>(
-        loc, resType, newOp->getResult(0), blockSizeAttr);
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-// It rewrites the SCF forOp, it mainly updates the arguments of its
-// region block. unpack ops are added for VectorType operands if needed.
-struct SCFForOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::scf::ForOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::scf::ForOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(mlir::scf::ForOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    // we don't need to update the forOp if it has no region
-    // iter args, or the region iter args type are not changed.
-    bool changed = false;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getInitArgs(), adaptor.getInitArgs())) {
-      changed |= (arg1 != arg2);
-    }
-    if (!changed)
-      return mlir::failure();
-
-    // add packOp for vector type operands if needed.
-    llvm::SmallVector<mlir::Value> newInitArgs;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getRegionIterArgs(), adaptor.getInitArgs())) {
-      if (mlir::isa<mlir::VectorType>(arg1.getType())) {
-        auto block = analysis.getDefBlockSize(arg1);
-        if (!block) { // block could be null if the arg is not used in the loop
-          auto argNo = arg1.getArgNumber() - 1;
-          auto yieldOp = op.getBody()->getTerminator();
-          auto opr = yieldOp->getOperand(argNo);
-          block = analysis.getDefBlockSize(opr);
-        }
-        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
-        newInitArgs.push_back(pack);
-      } else {
-        newInitArgs.push_back(arg2);
-      }
-    }
-
-    auto newOp = rewriter.create<mlir::scf::ForOp>(
-        op.getLoc(), adaptor.getLowerBound(), adaptor.getUpperBound(),
-        adaptor.getStep(), newInitArgs);
-
-    mlir::Block *newBlock = newOp.getBody();
-    // remove the terminator of the new block
-    if (newBlock->mightHaveTerminator())
-      rewriter.eraseOp(newBlock->getTerminator());
-
-    auto savedIP = rewriter.saveInsertionPoint();
-    mlir::OpBuilder::InsertionGuard g(rewriter);
-    rewriter.setInsertionPointToStart(newBlock);
-
-    mlir::Block *block = op.getBody();
-
-    // contruct the inputs for the new scf::for block.
-    // An unpackOp is inserted for the corresponding init arg
-    // of the new block if its init value is updated with a pack op.
-    llvm::SmallVector<mlir::Value> newArguments;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(block->getArguments(), newBlock->getArguments())) {
-      auto block = analysis.getDefBlockSize(arg1);
-      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
-        auto unpack = addUnpackOp(arg2, rewriter);
-        newArguments.push_back(unpack);
-      } else {
-        newArguments.push_back(arg2);
-      }
-    }
-
-    rewriter.restoreInsertionPoint(savedIP);
-    rewriter.mergeBlocks(block, newBlock, newArguments);
-
-    llvm::SmallVector<mlir::Value> newValues;
-    for (auto [i, result] : llvm::enumerate(newOp->getResults())) {
-      // if corresponding init arg is updated with a pack op
-      // an unpack op is needed for the result to make it
-      // transparent to its users.
-      if (newInitArgs[i].getDefiningOp<xetile::TilePackOp>()) {
-        auto unpack = addUnpackOp(result, rewriter);
-        newValues.push_back(unpack);
-      } else {
-        newValues.push_back(result);
-      }
-    }
-    rewriter.replaceOp(op, newValues);
-    return mlir::success();
-  }
-};
-
-// It serves to insert pack ops for approriate vales if needed.
-// for example, tile_mma result is vector<32x32xf16> (after unpack),
-// but its corresponding argument in forOp is with type vector<1x2x32x16xf16>
-// This op pattern will insert a pack op to make it consistent with the
-// corresponding argument type.
-struct SCFYieldOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::scf::YieldOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::scf::YieldOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  ::mlir::LogicalResult
-  matchAndRewrite(mlir::scf::YieldOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-
-    llvm::SmallVector<mlir::Value> newResults;
-    for (auto [arg1, arg2] :
-         llvm::zip_equal(op.getResults(), adaptor.getResults())) {
-      auto block = analysis.getDefBlockSize(arg1);
-      if (mlir::isa<mlir::VectorType>(arg1.getType()) && block) {
-        auto pack = addPackOp(arg2, block.asArrayRef(), rewriter);
-        newResults.push_back(pack);
-      } else {
-        newResults.push_back(arg2);
-      }
-    }
-
-    auto newOp = rewriter.create<mlir::scf::YieldOp>(op.getLoc(), newResults);
-    rewriter.replaceOp(op, newOp);
-    return mlir::success();
-  }
-};
-
-// Blocks a vector.create_mask op such that, ideally, it matches its consuming
-// select op (which is an elementwise op). In this way, during the lowering to
-// XeGPU, there will be a one-to-one correspondence and an
-// unrealized_conversion_cast will not be needed.
-struct VectorCreateMaskOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::vector::CreateMaskOp,
-                                             BlockingAnalysis> {
-
-  using OpConversionPatternWithAnalysis<
-      mlir::vector::CreateMaskOp,
-      BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::vector::CreateMaskOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto res = op.getResult();
-    auto resType = res.getType();
-    if (resType.getRank() != 2)
-      return rewriter.notifyMatchFailure(op, "type is not 2D vector");
-
-    // Only two cases are supported for now:
-    // 1.The first operand is a constant equal to the first dimension of the
-    // output shape (i.e., all rows are enabled). In other words, masking
-    // columns within a row is supported.
-    // 2.The second operand is a constant equal to the second dimension of the
-    // output shape (i.e., all columns are enabled).
-    auto shape = resType.getShape();
-    APInt cstOp0, cstOp1;
-    if (!(matchPattern(op->getOperand(0), m_ConstantInt(&cstOp0)) &&
-          cstOp0.getSExtValue() == shape[0]) &&
-        !(matchPattern(op->getOperand(1), m_ConstantInt(&cstOp1)) &&
-          cstOp1.getSExtValue() == shape[1])) {
-      op->emitOpError() << "Unsupported operands";
-      return mlir::failure();
-    }
-
-    auto block = analysis.getDefBlockSize(res);
-    if (!block)
-      return rewriter.notifyMatchFailure(op, "Invalid block size.");
-
-    // TODO: support blocking the outer dimension.
-    if (block[0] != 1) {
-      op->emitOpError() << "Unsupported inner block sizes";
-      return mlir::failure();
-    }
-
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / block[0], shape[1] / block[1], block[0], block[1]},
-        resType.getElementType());
-
-    // Due to the simplifications mentioned above, for now, the index operands
-    // are not adjusted. In fact, only the first index operand (masked rows) or
-    // the second index operand (masked columns) will be used during the
-    // lowering to XeGPU.
-    auto operands = op.getOperands();
-    auto newOp = rewriter.create<mlir::vector::CreateMaskOp>(
-        op.getLoc(), newTy,
-        ValueRange({operands[0], operands[1], operands[0], operands[1]}),
-        op->getAttrs());
-    auto unpack = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
-struct VectorSplatOpPattern
-    : public OpConversionPatternWithAnalysis<mlir::vector::SplatOp,
-                                             BlockingAnalysis> {
-  using OpConversionPatternWithAnalysis<
-      mlir::vector::SplatOp, BlockingAnalysis>::OpConversionPatternWithAnalysis;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::vector::SplatOp op, OpAdaptor adaptor,
-                  OpPatternRewriter &rewriter) const override {
-    auto res = op.getAggregate();
-    auto resTy = res.getType();
-    auto block = analysis.getDefBlockSize(res);
-    if (!block || resTy.getRank() != 2)
-      return mlir::failure();
-
-    auto shape = resTy.getShape();
-    auto newTy = mlir::VectorType::get(
-        {shape[0] / block[0], shape[1] / block[1], block[0], block[1]},
-        resTy.getElementType());
-
-    auto newOp = rewriter.create<mlir::vector::SplatOp>(
-        op.getLoc(), newTy, op->getOperands(), op->getAttrs());
-    auto unpack = addUnpackOp(newOp, rewriter);
-    rewriter.replaceOp(op, unpack);
-    return mlir::success();
-  }
-};
-
 } // namespace Blocking
 
 void populateXeTileBlockingPatterns(mlir::RewritePatternSet &patterns,
                                     BlockingAnalysis &analysis) {
-  if (Enable2DBlockingTransform) {
-    patterns.insert<
-        Blocking::RewriteArithConstantOp, Blocking::RewriteInitTileOp,
-        Blocking::RewritePrefetchTileOp, Blocking::RewriteLoadTileOp,
-        Blocking::RewriteStoreTileOp, Blocking::RewriteLoadGatherOp,
-        Blocking::RewriteStoreScatterOp, Blocking::RewriteUpdateTileOffsetOp,
-        Blocking::RewriteTileMMAOp, Blocking::RewriteTileReductionOp,
-        Blocking::RewriteTileBroadcastOp, Blocking::RewriteTileTransposeOp,
-        Blocking::RewriteVectorizableOp, Blocking::RewriteSCFForOp,
-        Blocking::RewriteSCFYieldOp, Blocking::RewriteCreateMaskOp,
-        Blocking::RewriteCreateMaskOp>(patterns.getContext(), analysis);
-  } else {
-    // TODO: remove this block after the 2D transform is fully supported.
-    patterns.insert<
-        Blocking::ArithConstantOpPattern, Blocking::InitTileOpPattern,
-        Blocking::PrefetchTileOpPattern, Blocking::LoadTileOpPattern,
-        Blocking::StoreTileOpPattern, Blocking::UpdateTileOffsetOpPattern,
-        Blocking::LoadGatherOpPattern, Blocking::StoreScatterOpPattern,
-        Blocking::TileMMAOpPattern, Blocking::TileReductionOpPattern,
-        Blocking::TileBroadcastOpPattern, Blocking::TileTransposeOpPattern,
-        Blocking::VectorizableOpPattern, Blocking::SCFForOpPattern,
-        Blocking::SCFYieldOpPattern, Blocking::VectorCreateMaskOpPattern,
-        Blocking::VectorSplatOpPattern>(patterns.getContext(), analysis);
-  }
+  patterns.insert<
+      Blocking::RewriteArithConstantOp, Blocking::RewriteInitTileOp,
+      Blocking::RewritePrefetchTileOp, Blocking::RewriteLoadTileOp,
+      Blocking::RewriteStoreTileOp, Blocking::RewriteLoadGatherOp,
+      Blocking::RewriteStoreScatterOp, Blocking::RewriteUpdateTileOffsetOp,
+      Blocking::RewriteTileMMAOp, Blocking::RewriteTileReductionOp,
+      Blocking::RewriteTileBroadcastOp, Blocking::RewriteTileTransposeOp,
+      Blocking::RewriteVectorizableOp, Blocking::RewriteSCFForOp,
+      Blocking::RewriteSCFYieldOp, Blocking::RewriteCreateMaskOp,
+      Blocking::RewriteCreateMaskOp>(patterns.getContext(), analysis);
 }
 
 // Lowers XeTile to blocked layout with high-dim vector
@@ -2479,7 +1588,6 @@ class XeTileBlockingPass : public impl::XeTileBlockingBase<XeTileBlockingPass> {
       uArchInterface = std::make_shared<imex::XePVCuArch>();
     else
       return errorHandler(llvm::Twine("Invalid device: ") + device);
-    Enable2DBlockingTransform = EnableTransform;
     return mlir::success();
   }
 
@@ -2505,181 +1613,108 @@ class XeTileBlockingPass : public impl::XeTileBlockingBase<XeTileBlockingPass> {
 
     mlir::MLIRContext &context = getContext();
 
-    if (EnableTransform) {
-      mlir::GreedyRewriteConfig config;
-      config.strictMode = GreedyRewriteStrictness::ExistingOps;
-      // ops inside regions, e.g., body of scf.for, needs to be processed
-      // before the op (e.g., scf.for) containing the region; otherwise
-      // the blocking analysis result for region args will be destroyed
-      // after scf.for is updated, leading to their users cannot be updated
-      // correctly.
-      mod.walk([&](mlir::Region *region) {
-        config.scope = region;
-        mlir::RewritePatternSet patterns(&context);
-        populateXeTileBlockingPatterns(patterns, analysis);
-        llvm::SmallVector<mlir::Operation *> ops;
-        region->walk([&](mlir::Operation *op) {
-          if (op->getParentRegion() == region)
-            ops.push_back(op);
-        });
-        if (mlir::failed(
-                mlir::applyOpPatternsAndFold(ops, std::move(patterns), config)))
-          return signalPassFailure();
+    mlir::GreedyRewriteConfig config;
+    config.strictMode = GreedyRewriteStrictness::ExistingOps;
+    // ops inside regions, e.g., body of scf.for, needs to be processed
+    // before the op (e.g., scf.for) containing the region; otherwise
+    // the blocking analysis result for region args will be destroyed
+    // after scf.for is updated, leading to their users cannot be updated
+    // correctly.
+    mod.walk([&](mlir::Region *region) {
+      config.scope = region;
+      mlir::RewritePatternSet patterns(&context);
+      populateXeTileBlockingPatterns(patterns, analysis);
+      llvm::SmallVector<mlir::Operation *> ops;
+      region->walk([&](mlir::Operation *op) {
+        if (op->getParentRegion() == region)
+          ops.push_back(op);
       });
-
-      // run CSE and Canonicalizer again to remove identical packOps,
-      // and fold pack/unpack ops with the same block size.
-      mlir::PassManager pm(&context);
-      pm.addPass(mlir::createCanonicalizerPass());
-      pm.addPass(mlir::createCSEPass());
-      if (mlir::failed(pm.run(mod)))
+      if (mlir::failed(
+              mlir::applyOpPatternsAndFold(ops, std::move(patterns), config)))
         return signalPassFailure();
+    });
+
+    // run CSE and Canonicalizer again to remove identical packOps,
+    // and fold pack/unpack ops with the same block size.
+    mlir::PassManager pm(&context);
+    pm.addPass(mlir::createCanonicalizerPass());
+    pm.addPass(mlir::createCSEPass());
+    if (mlir::failed(pm.run(mod)))
+      return signalPassFailure();
 
-      // Resolve unfoldable Unpack and Pack Ops
-      mod.walk([&](mlir::UnrealizedConversionCastOp castOp) {
-        // remove dead castOp.
-        if (castOp->use_empty()) {
-          castOp.erase();
-          return mlir::WalkResult::advance();
-        }
+    // Resolve unfoldable Unpack and Pack Ops
+    mod.walk([&](mlir::UnrealizedConversionCastOp castOp) {
+      // remove dead castOp.
+      if (castOp->use_empty()) {
+        castOp.erase();
+        return mlir::WalkResult::advance();
+      }
 
-        mlir::OpBuilder builder(castOp);
-        auto context = castOp.getContext();
-
-        // handle unpack op
-        if (Blocking::isUnpackOp(castOp)) {
-          auto user = mlir::dyn_cast<mlir::UnrealizedConversionCastOp>(
-              *castOp->user_begin());
-
-          auto [inGrids, inBlkSizes] = Blocking::getGridAndBlockSizes(castOp);
-          mlir::DenseI64ArrayAttr outBlkSizes, outGrids;
-
-          // if unpack op is used by a pack op,
-          if (castOp->hasOneUse() && Blocking::isPackOp(user) &&
-              Blocking::isUnpackPackCompatible(castOp, user)) {
-            std::tie(outGrids, outBlkSizes) =
-                Blocking::getGridAndBlockSizes(user);
-          } else {
-            auto outTy = mlir::dyn_cast<mlir::ShapedType>(
-                castOp->getResult(0).getType());
-            outGrids = mlir::DenseI64ArrayAttr::get(context, {1, 1});
-            outBlkSizes =
-                mlir::DenseI64ArrayAttr::get(context, outTy.getShape());
-          }
+      mlir::OpBuilder builder(castOp);
+      auto context = castOp.getContext();
 
-          builder.setInsertionPointAfter(castOp);
-          auto newOps = Blocking::lowerUnpackOrPack(
-              castOp.getInputs(), inBlkSizes, outBlkSizes, inGrids, outGrids,
-              castOp.getLoc(), builder);
-          if (newOps.size() == 1) {
-            castOp->getResult(0).replaceAllUsesWith(newOps[0]);
-          } else {
-            for (auto [n, c] : llvm::zip_equal(newOps, user->getResults()))
-              c.replaceAllUsesWith(n);
-          }
-          return mlir::WalkResult::advance();
+      // handle unpack op
+      if (Blocking::isUnpackOp(castOp)) {
+        auto user = mlir::dyn_cast<mlir::UnrealizedConversionCastOp>(
+            *castOp->user_begin());
+
+        auto [inGrids, inBlkSizes] = Blocking::getGridAndBlockSizes(castOp);
+        mlir::DenseI64ArrayAttr outBlkSizes, outGrids;
+
+        // if unpack op is used by a pack op,
+        if (castOp->hasOneUse() && Blocking::isPackOp(user) &&
+            Blocking::isUnpackPackCompatible(castOp, user)) {
+          std::tie(outGrids, outBlkSizes) =
+              Blocking::getGridAndBlockSizes(user);
+        } else {
+          auto outTy =
+              mlir::dyn_cast<mlir::ShapedType>(castOp->getResult(0).getType());
+          outGrids = mlir::DenseI64ArrayAttr::get(context, {1, 1});
+          outBlkSizes = mlir::DenseI64ArrayAttr::get(context, outTy.getShape());
         }
 
-        // handle pack op
-        if (Blocking::isPackOp(castOp)) {
-          auto opr = castOp->getOperand(0)
-                         .getDefiningOp<mlir::UnrealizedConversionCastOp>();
-          // should be handled as a pair of unpack and pack op in above.
-          if (Blocking::isUnpackOp(opr) && opr->hasOneUse() &&
-              Blocking::isUnpackPackCompatible(opr, castOp))
-            return mlir::WalkResult::advance();
-
-          auto inTy =
-              mlir::dyn_cast<mlir::ShapedType>(castOp->getOperand(0).getType());
-          auto inGrids = mlir::DenseI64ArrayAttr::get(context, {1, 1});
-          auto inBlkSizes =
-              mlir::DenseI64ArrayAttr::get(context, inTy.getShape());
-          auto [outGrids, outBlkSizes] = Blocking::getGridAndBlockSizes(castOp);
-          auto newOps = Blocking::lowerUnpackOrPack(
-              castOp.getInputs(), inBlkSizes, outBlkSizes, inGrids, outGrids,
-              castOp.getLoc(), builder);
-          for (auto [n, c] : llvm::zip_equal(newOps, castOp->getResults()))
+        builder.setInsertionPointAfter(castOp);
+        auto newOps = Blocking::lowerUnpackOrPack(
+            castOp.getInputs(), inBlkSizes, outBlkSizes, inGrids, outGrids,
+            castOp.getLoc(), builder);
+        if (newOps.size() == 1) {
+          castOp->getResult(0).replaceAllUsesWith(newOps[0]);
+        } else {
+          for (auto [n, c] : llvm::zip_equal(newOps, user->getResults()))
             c.replaceAllUsesWith(n);
         }
         return mlir::WalkResult::advance();
-      });
-
-      // remove dead castOp.
-      mod.walk([&](mlir::UnrealizedConversionCastOp castOp) {
-        if (castOp->use_empty())
-          castOp.erase();
-      });
-    } else {
-      // update blocked ops
-      mlir::RewritePatternSet patterns(&context);
-      populateXeTileBlockingPatterns(patterns, analysis);
+      }
 
-      mlir::ConversionTarget target(context);
-      target.addLegalOp<xetile::TilePackOp>();
-      target.addLegalOp<xetile::TileUnpackOp>();
-      target.addLegalOp<mlir::func::ReturnOp>();
-      target.addLegalOp<mlir::vector::ShapeCastOp>();
-      target.addLegalOp<mlir::vector::StoreOp>();
-      target.addLegalOp<mlir::vector::LoadOp>();
-
-      target.addDynamicallyLegalOp<mlir::arith::ConstantOp>(
-          [&](mlir::arith::ConstantOp op) -> bool {
-            auto vecTy = mlir::dyn_cast<mlir::VectorType>(op.getType());
-            return (!vecTy || vecTy.getRank() != 2);
-          });
-
-      target.addDynamicallyLegalOp<xetile::InitTileOp>(
-          [&](xetile::InitTileOp op) -> bool {
-            return (op && op.getTile().getType().getInnerBlocks());
-          });
-
-      target.addDynamicallyLegalOp<xetile::PrefetchTileOp>(
-          [&](xetile::PrefetchTileOp op) -> bool {
-            return (op && op.getTile().getType().getInnerBlocks());
-          });
-
-      target.addDynamicallyLegalOp<xetile::UpdateTileOffsetOp>(
-          [&](xetile::UpdateTileOffsetOp op) -> bool {
-            return (op && op.getTile().getType().getInnerBlocks());
-          });
-
-      target.addDynamicallyLegalOp<xetile::LoadTileOp>(
-          [&](xetile::LoadTileOp op) -> bool {
-            return (op && op.getValue().getType().getRank() == 4);
-          });
-
-      target.addDynamicallyLegalOp<xetile::StoreTileOp>(
-          [&](xetile::StoreTileOp op) -> bool {
-            return (op && op.getValue().getType().getRank() == 4);
-          });
-
-      target.addDynamicallyLegalOp<xetile::TileMMAOp>(
-          [&](xetile::TileMMAOp op) -> bool {
-            return (op && op.getOutput().getType().getRank() == 4);
-          });
-
-      target.markUnknownOpDynamicallyLegal([&](mlir::Operation *op) {
-        bool result = true;
-        for (auto ty : op->getOperandTypes()) {
-          if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
-            result &= (vecTy.getRank() != 2);
-          if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
-            result &= bool(tileTy.getInnerBlocks());
-        }
-        for (auto ty : op->getResultTypes()) {
-          if (auto vecTy = mlir::dyn_cast<mlir::VectorType>(ty))
-            result &= (vecTy.getRank() != 2);
-          if (auto tileTy = mlir::dyn_cast<xetile::TileType>(ty))
-            result &= bool(tileTy.getInnerBlocks());
-        }
-        return result;
-      });
+      // handle pack op
+      if (Blocking::isPackOp(castOp)) {
+        auto opr = castOp->getOperand(0)
+                       .getDefiningOp<mlir::UnrealizedConversionCastOp>();
+        // should be handled as a pair of unpack and pack op in above.
+        if (Blocking::isUnpackOp(opr) && opr->hasOneUse() &&
+            Blocking::isUnpackPackCompatible(opr, castOp))
+          return mlir::WalkResult::advance();
 
-      auto status = applyPartialConversion(mod, target, std::move(patterns));
-      if (failed(status)) {
-        return signalPassFailure();
+        auto inTy =
+            mlir::dyn_cast<mlir::ShapedType>(castOp->getOperand(0).getType());
+        auto inGrids = mlir::DenseI64ArrayAttr::get(context, {1, 1});
+        auto inBlkSizes =
+            mlir::DenseI64ArrayAttr::get(context, inTy.getShape());
+        auto [outGrids, outBlkSizes] = Blocking::getGridAndBlockSizes(castOp);
+        auto newOps = Blocking::lowerUnpackOrPack(
+            castOp.getInputs(), inBlkSizes, outBlkSizes, inGrids, outGrids,
+            castOp.getLoc(), builder);
+        for (auto [n, c] : llvm::zip_equal(newOps, castOp->getResults()))
+          c.replaceAllUsesWith(n);
       }
-    }
+      return mlir::WalkResult::advance();
+    });
+
+    // remove dead castOp.
+    mod.walk([&](mlir::UnrealizedConversionCastOp castOp) {
+      if (castOp->use_empty())
+        castOp.erase();
+    });
   }
 
 private:
diff --git a/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp b/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
index a169c4ac3..95c1a628f 100644
--- a/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
+++ b/lib/Dialect/XeTile/Transforms/BlockingAnalysis.cpp
@@ -4,8 +4,6 @@
 
 #include "imex/Dialect/XeTile/Transforms/BlockingAnalysis.h"
 
-extern bool Enable2DBlockingTransform;
-
 namespace llvm {
 using imex::Block;
 // Implementation of llvm::DenseMapInfo for Block, required for
@@ -741,7 +739,7 @@ void BlockingAnalysisImpl::visitCreateMaskOp(
 
   auto lattice = results[0]->getValue();
 
-  if (Enable2DBlockingTransform && !op->use_empty() && !lattice.isInitialized())
+  if (!op->use_empty() && !lattice.isInitialized())
     return;
 
   BlockingRequests &def = getLatticeElement(op->getResult(0))->getValue();
@@ -752,11 +750,9 @@ void BlockingAnalysisImpl::visitCreateMaskOp(
 
   // TODO: need to enable the following code after 2D lowering in
   // GPUToSPIRV is enabled.
-  // if (Enable2DBlockingTransform) {
-  //   for (auto &req : lattice.getRequests()) {
-  //     block[0] = std::max(block[0], req[0]);
-  //     block[1] = std::min(block[1], req[1]);
-  //   }
+  // for (auto &req : lattice.getRequests()) {
+  //   block[0] = std::max(block[0], req[0]);
+  //   block[1] = std::min(block[1], req[1]);
   // }
   def.updateDefBlock(block);
 }
diff --git a/test/Conversion/XeTileToXeGPU/gemm_preop.mlir b/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
index d19a4d607..19d471218 100755
--- a/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
+++ b/test/Conversion/XeTileToXeGPU/gemm_preop.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" --cse \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --cse \
 // RUN: --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 #map = affine_map<() -> (0)>
 #map1 = affine_map<() -> (64)>
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
index dc30fc3d8..020c93458 100644
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" --canonicalize \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --canonicalize \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -o -| FileCheck %s
 // CHECK-LABEL: gpu.module @test_kernel {
 gpu.module @test_kernel {
diff --git a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32_slm.mlir b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
index de526420c..ad84fbc62 100644
--- a/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" --canonicalize \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking --canonicalize \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -o -| FileCheck %s
 
 
diff --git a/test/Conversion/XeTileToXeGPU/sg_init_tile.mlir b/test/Conversion/XeTileToXeGPU/sg_init_tile.mlir
index 1cf526729..de664b2ae 100644
--- a/test/Conversion/XeTileToXeGPU/sg_init_tile.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_init_tile.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 
 gpu.module @test_kernel {
diff --git a/test/Conversion/XeTileToXeGPU/sg_load_tile.mlir b/test/Conversion/XeTileToXeGPU/sg_load_tile.mlir
index 9772f4884..099adf3cb 100644
--- a/test/Conversion/XeTileToXeGPU/sg_load_tile.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_load_tile.mlir
@@ -1,6 +1,5 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
-
 gpu.module @test_kernel {
   //CHECK: gpu.func @sg_load_tile(%[[arg0:.*]]: memref<1024x1024xf16>, %[[arg1:.*]]: memref<1024x1024xf16>, %[[arg2:.*]]: memref<1024x1024xf32>) {
   gpu.func @sg_load_tile(%a: memref<1024x1024xf16>, %b: memref<1024x1024xf16>, %c: memref<1024x1024xf32>) {
diff --git a/test/Conversion/XeTileToXeGPU/sg_mixed_scf.mlir b/test/Conversion/XeTileToXeGPU/sg_mixed_scf.mlir
index ccdcf9c5d..b4e5bfb94 100755
--- a/test/Conversion/XeTileToXeGPU/sg_mixed_scf.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_mixed_scf.mlir
@@ -1,8 +1,6 @@
 
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse --canonicalize %s -verify-diagnostics -o -| FileCheck %s
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
-// RUN: --cse --convert-xetile-to-xegpu="enable-2d-transform=true" --cse --canonicalize %s -verify-diagnostics -o -| FileCheck %s
 
 //CHECK-LABEL: gpu.module @postop_reduce_m
 gpu.module @postop_reduce_m attributes {spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [Addresses, Float16Buffer, Int64, Int16, Int8, Bfloat16ConversionINTEL, Kernel, Linkage, Vector16, GenericPointer, Groups, Float16, Float64, AtomicFloat32AddEXT, ExpectAssumeKHR, VectorAnyINTEL], [SPV_INTEL_bfloat16_conversion, SPV_EXT_shader_atomic_float_add, SPV_KHR_expect_assume, SPV_INTEL_vector_compute]>, api=OpenCL, #spirv.resource_limits<>>} {
diff --git a/test/Conversion/XeTileToXeGPU/sg_scattered_ops.mlir b/test/Conversion/XeTileToXeGPU/sg_scattered_ops.mlir
index 4a344ba2c..4ded872f7 100644
--- a/test/Conversion/XeTileToXeGPU/sg_scattered_ops.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_scattered_ops.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse --canonicalize --cse %s -verify-diagnostics -o -| FileCheck %s
 
 gpu.module @test {
diff --git a/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir b/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
index caec6f383..b3c013c92 100644
--- a/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_scf_for.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 gpu.module @test_kernel {
   //CHECK: gpu.func @sglevel_tiled_gemm(%[[arg0:.*]]: memref<1024x1024xf16>, %[[arg1:.*]]: memref<1024x1024xf16>)
diff --git a/test/Conversion/XeTileToXeGPU/sg_softmax.mlir b/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
index 990d56e0d..3f4b1ed2b 100644
--- a/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_softmax.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 gpu.module @test_kernel {
     //CHECK-LABEL: @sglevel_softmax_dim_0
diff --git a/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir b/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
index aa07f69d7..026d14d94 100644
--- a/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_store_tile.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 
 gpu.module @test_kernel {
diff --git a/test/Conversion/XeTileToXeGPU/sg_tile_mma.mlir b/test/Conversion/XeTileToXeGPU/sg_tile_mma.mlir
index 1c3ba97a4..17b5261aa 100644
--- a/test/Conversion/XeTileToXeGPU/sg_tile_mma.mlir
+++ b/test/Conversion/XeTileToXeGPU/sg_tile_mma.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-init-duplicate --xetile-blocking \
 // RUN: --convert-xetile-to-xegpu %s -verify-diagnostics -o -| FileCheck %s
 gpu.module @test_kernel {
   //CHECK: s_tiled_gemm(%[[arg0:.*]]: memref<1024x1024xf16>, %[[arg1:.*]]: memref<1024x1024xf16>)
diff --git a/test/Conversion/XeTileToXeGPU/test_blocking.mlir b/test/Conversion/XeTileToXeGPU/test_blocking.mlir
deleted file mode 100644
index e24bcf568..000000000
--- a/test/Conversion/XeTileToXeGPU/test_blocking.mlir
+++ /dev/null
@@ -1,60 +0,0 @@
-// RUN: imex-opt --split-input-file --xetile-blocking %s -verify-diagnostics -o -| FileCheck %s
-
-gpu.module @test_kernel {
-
-// CHECK-LABEL: test_blocking_elementwise
-//  CHECK-SAME: (%[[A_ORIG:.*]]: vector<64x64xf16>, %[[B_ORIG:.*]]: vector<64x64xf16>)
-//       CHECK: %[[A1:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
-//       CHECK: %[[B1:.*]] = xetile.tile_pack %[[B_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
-//       CHECK: %[[RES1:.*]] = arith.addf %[[A1]], %[[B1]] : vector<1x2x64x32xf16>
-//       CHECK: %[[RES_UNP1:.*]] = xetile.tile_unpack %[[RES1]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
-//       CHECK: %[[A2:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
-//       CHECK: %[[RES2:.*]] = arith.negf %[[A2]] : vector<1x2x64x32xf16>
-//       CHECK: %[[RES_UNP2:.*]] = xetile.tile_unpack %[[RES2]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
-//       CHECK: %[[A3:.*]] = xetile.tile_pack %[[A_ORIG]] {inner_blocks = array<i64: 64, 32>} : vector<64x64xf16> -> vector<1x2x64x32xf16>
-//       CHECK: %[[RES3:.*]] = math.exp %[[A3]] : vector<1x2x64x32xf16>
-//       CHECK: %[[RES_UNP3:.*]] = xetile.tile_unpack %[[RES3]] {inner_blocks = array<i64: 64, 32>} : vector<1x2x64x32xf16> -> vector<64x64xf16>
-//       CHECK: return %[[RES_UNP1]], %[[RES_UNP2]], %[[RES_UNP3]] : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>
-func.func @test_blocking_elementwise(%a: vector<64x64xf16>, %b: vector<64x64xf16>) -> (vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>) {
-// Elementwise arith ops are handled in unified way, check some
-  %0 = arith.addf %a, %b: vector<64x64xf16>
-  %1 = arith.negf %a: vector<64x64xf16>
-  %2 = math.exp %a: vector<64x64xf16>
-  return %0, %1, %2 : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>
-}
-
-}
-
-// -----
-
-gpu.module @test_kernel {
-
-// CHECK-LABEL: test_blocking_transpose
-//  CHECK-SAME: (%[[SRC:.*]]: vector<64x32xf16>)
-//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 64, 32>} : vector<64x32xf16> -> vector<1x1x64x32xf16>
-//       CHECK: %[[T:.*]] = xetile.transpose %[[PACK]], [1, 0, 3, 2] : vector<1x1x64x32xf16> -> vector<1x1x32x64xf16>
-//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 32, 64>} : vector<1x1x32x64xf16> -> vector<32x64xf16>
-//       CHECK: return %[[UNPACK]] : vector<32x64xf16>
-func.func @test_blocking_transpose(%a: vector<64x32xf16>) -> vector<32x64xf16> {
-  %0 = xetile.transpose %a, [1, 0]: vector<64x32xf16> -> vector<32x64xf16>
-  return %0 : vector<32x64xf16>
-}
-
-}
-
-// -----
-
-gpu.module @test_kernel {
-
-// CHECK-LABEL: test_blocking_transpose_small
-//  CHECK-SAME: (%[[SRC:.*]]: vector<16x8xf16>)
-//       CHECK: %[[PACK:.*]] = xetile.tile_pack %[[SRC]] {inner_blocks = array<i64: 16, 8>} : vector<16x8xf16> -> vector<1x1x16x8xf16>
-//       CHECK: %[[T:.*]] = xetile.transpose %[[PACK]], [1, 0, 3, 2] : vector<1x1x16x8xf16> -> vector<1x1x8x16xf16>
-//       CHECK: %[[UNPACK:.*]] = xetile.tile_unpack %[[T]] {inner_blocks = array<i64: 8, 16>} : vector<1x1x8x16xf16> -> vector<8x16xf16>
-//       CHECK: return %[[UNPACK]] : vector<8x16xf16>
-func.func @test_blocking_transpose_small(%a: vector<16x8xf16>) -> vector<8x16xf16> {
-  %0 = xetile.transpose %a, [1, 0]: vector<16x8xf16> -> vector<8x16xf16>
-  return %0 : vector<8x16xf16>
-}
-
-}
diff --git a/test/Conversion/XeTileToXeGPU/test_order.mlir b/test/Conversion/XeTileToXeGPU/test_order.mlir
index 2672328ef..031377beb 100644
--- a/test/Conversion/XeTileToXeGPU/test_order.mlir
+++ b/test/Conversion/XeTileToXeGPU/test_order.mlir
@@ -1,4 +1,4 @@
-// RUN: imex-opt --split-input-file --xetile-canonicalization --xetile-blocking="enable-2d-transform=true" \
+// RUN: imex-opt --split-input-file --xetile-canonicalization --xetile-blocking \
 // RUN: --cse --convert-xetile-to-xegpu --cse %s -verify-diagnostics -o -| FileCheck %s
 
 // CHECK-LABEL: @test_func
diff --git a/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir b/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
index 55832f989..cf5bd2cf0 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/persistent_kernel.mlir
@@ -4,9 +4,12 @@ module @gemm attributes {gpu.container_module} {
 
     //CHECK: gpu.func @test_kernel(%[[arg0:.*]]: memref<4096x4096xf16>, %[[arg1:.*]]: memref<4096x4096xf16>, %[[arg2:.*]]: memref<4096x4096xf32>) kernel attributes {VectorComputeFunctionINTEL, spirv.entry_point_abi = #spirv.entry_point_abi<>} {
     gpu.func @test_kernel(%A: memref<4096x4096xf16>, %B: memref<4096x4096xf16>, %C: memref<4096x4096xf32>) kernel attributes {VectorComputeFunctionINTEL, spirv.entry_point_abi = #spirv.entry_point_abi<>} {
+      //CHECK: %[[c24:.*]] = arith.constant 24 : index
       //CHECK: %[[c0_i8:.*]] = arith.constant 0 : i8
       //CHECK: %[[c1_i8:.*]] = arith.constant 1 : i8
-      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x4x8x16xf32>
+      //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
+      //CHECK: %[[c48:.*]] = arith.constant 48 : index
+      //CHECK: %[[c16:.*]] = arith.constant 16 : index
       //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
       //CHECK: %[[c64:.*]] = arith.constant 64 : index
       //CHECK: %[[c8:.*]] = arith.constant 8 : index
@@ -65,13 +68,13 @@ module @gemm attributes {gpu.container_module} {
         %A_sg_prefetch_offset_x_temp = arith.muli %local_sg_id, %c8 : index
         %A_sg_prefetch_offset_x = arith.addi %A_sg_prefetch_offset_x_temp, %wg_tile_offset_x : index
 
-        //CHECK: %[[R14:.*]] = xetile.init_tile %[[arg0]][%[[R13]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R14]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R15:.*]] = xetile.update_tile_offset %[[R14]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R15]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R16:.*]] = xetile.update_tile_offset %[[R15]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R16]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R17:.*]] = xetile.update_tile_offset %[[R16]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+        //CHECK: %[[R14:.*]] = xetile.init_tile %[[arg0]][%[[R13]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R14]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R15:.*]] = xetile.update_tile_offset %[[R14]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R15]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R16:.*]] = xetile.update_tile_offset %[[R15]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R16]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R17:.*]] = xetile.update_tile_offset %[[R16]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16>
         //CHECK: %[[R18:.*]] = arith.remui %[[R4]], %[[c4]] : index
         //CHECK: %[[R19:.*]] = arith.muli %[[R18]], %[[c8]] : index
         //CHECK: %[[R20:.*]] = arith.muli %[[R5]], %[[c64]] : index
@@ -96,15 +99,23 @@ module @gemm attributes {gpu.container_module} {
         %B_sg_prefetch_offset_y_temp3 = arith.addi %B_sg_prefetch_offset_y_temp0, %B_sg_prefetch_offset_y_temp2 : index
         %B_sg_prefetch_offset_y = arith.addi %wg_tile_offset_y, %B_sg_prefetch_offset_y_temp3 : index
 
-        //CHECK: %[[R25:.*]] = xetile.init_tile %[[arg1]][%[[R19]], %[[R24]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R25]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R26:.*]] = xetile.update_tile_offset %[[R25]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R26]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R27:.*]] = xetile.update_tile_offset %[[R26]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: xetile.prefetch_tile %[[R27]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R28:.*]] = xetile.update_tile_offset %[[R27]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-        //CHECK: %[[R29:.*]] = xetile.init_tile %[[arg0]][%[[R6]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-        //CHECK: %[[R30:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R7]]] : memref<4096x4096xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+        //CHECK: %[[R25:.*]] = xetile.init_tile %[[arg1]][%[[R19]], %[[R24]]] : memref<4096x4096xf16> -> !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R25]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R26:.*]] = xetile.update_tile_offset %[[R25]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R26]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R27:.*]] = xetile.update_tile_offset %[[R26]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16>
+        //CHECK: xetile.prefetch_tile %[[R27]] : !xetile.tile<8x32xf16>
+        //CHECK: %[[R28:.*]] = xetile.update_tile_offset %[[R27]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16>
+
+        //CHECK: %[[R25:.*]] = xetile.init_tile %[[arg0]][%[[R6]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
+        //CHECK: %[[R26:.*]] = xetile.init_tile %[[arg0]][%[[R6]], %[[c16]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
+        //CHECK: %[[R27:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R7]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
+        //CHECK: %[[R28:.*]] = arith.addi %[[R7]], %[[c16]] : index
+        //CHECK: %[[R29:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R28]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
+        //CHECK: %[[R30:.*]] = arith.addi %[[R7]], %[[c32]] : index
+        //CHECK: %[[R31:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R30]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
+        //CHECK: %[[R32:.*]] = arith.addi %[[R7]], %[[c48]] : index
+        //CHECK: %[[R33:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R32]]] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
         //CHECK: xegpu.alloc_nbarrier 16
         %B_sg_prefetch_tile_iter0 = xetile.init_tile %B[%B_sg_prefetch_offset_x, %B_sg_prefetch_offset_y]  : memref<4096x4096xf16> -> !xetile.tile<8x32xf16>
         xetile.prefetch_tile %B_sg_prefetch_tile_iter0 : !xetile.tile<8x32xf16>
@@ -122,7 +133,7 @@ module @gemm attributes {gpu.container_module} {
         %nbarrier_role = arith.constant 0 : i8
         //CHECK: %[[R31:.*]] = xegpu.init_nbarrier %[[c1_i8]], %[[c0_i8]] : i8, i8 -> !xegpu.nbarrier
         %nbarrier = xegpu.init_nbarrier %nbarrier_id, %nbarrier_role : i8, i8 -> !xegpu.nbarrier
-        //CHECK: %[[R32:.*]]:5 = scf.for %[[arg4:.*]] = %[[c0]] to %[[c4096]] step %[[c32]] iter_args(%[[arg5:.*]] = %[[R29]], %[[arg6:.*]] = %[[R30]], %[[arg7:.*]] = %[[cst]], %[[arg8:.*]] = %[[R17]], %[[arg9:.*]] = %[[R28]]) -> (!xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x4x8x16xf32>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>) {
+        //CHECK: %[[R32:.*]]24 = scf.for %[[arg4:.*]] = %[[c0]] to %[[c4096]] step %[[c32]] iter_args({{.*}}) -> (!xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, !xetile.tile<8x32xf16>, !xetile.tile<8x32xf16>) {
         %k_loop_result:5 = scf.for %k = %c0 to %c4096 step %c32 iter_args (
             %A_tile = %A_sg_init_tile,
             %B_tile = %B_sg_init_tile,
@@ -147,33 +158,28 @@ module @gemm attributes {gpu.container_module} {
             //CHECK: xegpu.nbarrier_arrive %[[R31]] : !xegpu.nbarrier
             xegpu.nbarrier_arrive %nbarrier : !xegpu.nbarrier
           }
-          //CHECK: %[[R39:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-          //CHECK: %[[R40:.*]] = xetile.tile_unpack %[[R39]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
+          //CHECK-COUNT-2: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+          //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
           %a_val = xetile.load_tile %A_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-          //CHECK: %[[R41:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x4x32x16xf16>
-          //CHECK: %[[R42:.*]] = xetile.tile_unpack %[[R41]] {inner_blocks = array<i64: 32, 16>}  : vector<1x4x32x16xf16> -> vector<32x64xf16>
+          //CHECK-COUNT-4: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+          //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
           %b_val = xetile.load_tile %B_tile  : !xetile.tile<32x64xf16> -> vector<32x64xf16>
           //CHECK: xegpu.compile_hint
           xegpu.compile_hint
-          //CHECK: xetile.prefetch_tile %[[arg8]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: xetile.prefetch_tile %[[arg9]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+          //CHECK-COUNT-2: xetile.prefetch_tile %{{.*}} : !xetile.tile<8x32xf16>
           xetile.prefetch_tile %A_prefetch_tile : !xetile.tile<8x32xf16>
           xetile.prefetch_tile %B_prefetch_tile : !xetile.tile<8x32xf16>
           //CHECK: xegpu.compile_hint
           xegpu.compile_hint
-          //CHECK: %[[R43:.*]] = xetile.update_tile_offset %[[arg8]], [%[[c0]],  %[[c32]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: %[[R44:.*]] = xetile.update_tile_offset %[[arg9]], [%[[c32]],  %[[c0]]] : !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-          //CHECK: %[[R45:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-          //CHECK: %[[R46:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+          //CHECK-COUNT-2: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}},  %{{.*}}] : !xetile.tile<8x32xf16>
+          //CHECK-COUNT-6: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
           %next_A_prefetch_tile = xetile.update_tile_offset %A_prefetch_tile, [%c0, %c32] : !xetile.tile<8x32xf16>
           %next_B_prefetch_tile = xetile.update_tile_offset %B_prefetch_tile, [%c32, %c0] : !xetile.tile<8x32xf16>
           %next_A_tile = xetile.update_tile_offset %A_tile, [%c0, %c32]  :  !xetile.tile<32x32xf16>
           %next_B_tile = xetile.update_tile_offset %B_tile, [%c32, %c0]  : !xetile.tile<32x64xf16>
           //CHECK: xegpu.compile_hint
           xegpu.compile_hint
-          //CHECK: %[[R47:.*]] = xetile.tile_pack %[[R40]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-          //CHECK: %[[R48:.*]] = xetile.tile_pack %[[R42]] {inner_blocks = array<i64: 16, 16>}  : vector<32x64xf16> -> vector<2x4x16x16xf16>
-          //CHECK: %[[R51:.*]] = xetile.tile_mma %[[R47]], %[[R48]], %[[arg7]] : vector<4x2x8x16xf16>, vector<2x4x16x16xf16>, vector<4x4x8x16xf32> -> vector<4x4x8x16xf32>
+          //CHECK-COUNT-32: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
           %new_c_val = xetile.tile_mma %a_val, %b_val, %c_val : vector<32x32xf16>, vector<32x64xf16>, vector<32x64xf32> -> vector<32x64xf32>
           //CHECK: xegpu.compile_hint
           xegpu.compile_hint
@@ -183,15 +189,18 @@ module @gemm attributes {gpu.container_module} {
             xegpu.nbarrier_wait %nbarrier : !xegpu.nbarrier
           }
 
-          //CHECK: scf.yield %[[R45]], %[[R46]], %[[R51]], %[[R43]], %[[R44]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x4x8x16xf32>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>, !xetile.tile<8x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+          //CHECK: scf.yield %{{.*}} : !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, !xetile.tile<8x32xf16>, !xetile.tile<8x32xf16>
           scf.yield %next_A_tile, %next_B_tile, %new_c_val,
                     %next_A_prefetch_tile, %next_B_prefetch_tile
                     : !xetile.tile<32x32xf16>, !xetile.tile<32x64xf16>, vector<32x64xf32>,
                     !xetile.tile<8x32xf16>, !xetile.tile<8x32xf16>
         }
-        //CHECK: %[[R34:.*]] = xetile.init_tile %[[arg2]][%[[R6]], %[[R7]]] : memref<4096x4096xf32> -> !xetile.tile<32x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+        //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+        //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+        //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+        //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
         %c_sg_tile = xetile.init_tile %C[%C_sg_tile_offset_x, %C_sg_tile_offset_y] : memref<4096x4096xf32> -> !xetile.tile<32x64xf32>
-        //CHECK: xetile.store_tile %[[R32]]#2,  %[[R34]] : vector<4x4x8x16xf32>, !xetile.tile<32x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+        //CHECK-COUNT-16: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
         xetile.store_tile %k_loop_result#2 , %c_sg_tile : vector<32x64xf32>, !xetile.tile<32x64xf32>
       }
       //CHECK: gpu.return
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
index 3377fd6db..b08a49576 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32.mlir
@@ -4,94 +4,57 @@
 gpu.module @test_kernel {
   // CHECK: gpu.func @test_gemm(%[[A:.*]]: memref<1024x1024xf16>, %[[B:.*]]: memref<1024x1024xf16>, %[[C:.*]]: memref<1024x1024xf32>)
   gpu.func @test_gemm(%A: memref<1024x1024xf16>, %B: memref<1024x1024xf16>, %C: memref<1024x1024xf32>) {
-
-    //CHECK: %[[C0:.*]] = arith.constant 0 : index
     %c0 = arith.constant 0 : index
-
-    //CHECK: %[[C1:.*]] = arith.constant 64 : index
     %c64 = arith.constant 64 : index
-
-    //CHECK: %[[C2:.*]] = arith.constant 1024 : index
     %c1024 = arith.constant 1024 : index
-
-    //CHECK: %[[X:.*]] = gpu.block_id  x
     %block_id_x = gpu.block_id x
-
-    //CHECK: %[[Y:.*]] = gpu.block_id  y
     %block_id_y = gpu.block_id y
-
-    //CHECK: %[[R0:.*]] = arith.muli %[[X]], %[[C1]] : index
     %m = arith.muli %block_id_x, %c64 : index
-
-    //CHECK: %[[R1:.*]] = arith.muli %[[Y]], %[[C1]] : index
     %n = arith.muli %block_id_y, %c64 : index
 
-    //CHECK: %[[R2:.*]] = xetile.init_tile %[[C]][%[[R0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xf32> -> !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R3:.*]] = xetile.init_tile %[[C]][%[[R0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xf32> -> !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[C]][%{{.*}}, %{{.*}}] : memref<1024x1024xf32> -> !xetile.tile<32x16xf32>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xf32> -> !xetile.tile<64x64xf32>
-
-    //CHECK: %[[R4:.*]] = xetile.load_tile %[[R3]]
-    //CHECK-SAME: !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf32>
-    //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf32> -> vector<64x64xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf32> -> vector<32x16xf32>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x64xf32> -> vector<64x64xf32>
-
-    //CHECK: %[[R6:.*]] = xetile.init_tile %[[A]][%[[R0]], %[[C0]]]
-    //CHECK-SAME: memref<1024x1024xf16> -> !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<32x16xf16>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[B]][%[[C0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xf16> -> !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<32x16xf16>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xf16> -> !xetile.tile<64x64xf16>
-
-    // compute the value of C tile by iterating over tiles in k-dimension and doing dpas
-    //CHECK: %[[R8:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xf32> -> vector<8x4x8x16xf32>
-    //CHECK: %[[R9:.*]]:3 = scf.for %[[arg3:.*]] = %[[C0]] to %[[C2]] step %[[C1]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[R6]], %[[arg5:.*]] = %[[R7]], %[[arg6:.*]] = %[[R8]])
-    //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x4x8x16xf32>
     %out:3 = scf.for %k = %c0 to %c1024 step %c64
       iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
       -> (!xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>) {
-
-      //CHECK: %[[R12:.*]] = xetile.load_tile %[[arg4]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf16>
-      //CHECK: %[[R13:.*]] = xetile.tile_unpack %[[R12]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf16> -> vector<64x64xf16>
+      //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
 
-      //CHECK: %[[R14:.*]] = xetile.load_tile %[[arg5]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xf16>
-      //CHECK: %[[R15:.*]] = xetile.tile_unpack %[[R14]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xf16> -> vector<64x64xf16>
+      //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK-COUNT-16: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<64x64xf16> -> vector<64x64xf16>
 
-      // perform dpas and accumulate
-      //CHECK: %[[R16:.*]] = xetile.tile_pack %[[R13]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xf16> -> vector<8x4x8x16xf16>
-      //CHECK: %[[R17:.*]] = xetile.tile_pack %[[R15]] {inner_blocks = array<i64: 16, 16>}  : vector<64x64xf16> -> vector<4x4x16x16xf16>
-      //CHECK: %[[R20:.*]] = xetile.tile_mma %[[R16]], %[[R17]], %[[arg6]] : vector<8x4x8x16xf16>, vector<4x4x16x16xf16>, vector<8x4x8x16xf32> -> vector<8x4x8x16xf32>
+      //CHECK-COUNT-128: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf32> -> vector<64x64xf32>
 
-      // update the offsets for A and B tiles
-      //CHECK: %[[R22:.*]] = xetile.update_tile_offset %[[arg4]], [%[[C0]],  %[[C1]]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+      //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c64] : !xetile.tile<64x64xf16>
-
-      //CHECK: %[[R23:.*]] = xetile.update_tile_offset %[[arg5]], [%[[C1]],  %[[C0]]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+      //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c64, %c0] : !xetile.tile<64x64xf16>
-
-      //CHECK: scf.yield %[[R22]], %[[R23]], %[[R20]]
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK-SAME: !xetile.tile<64x64xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x4x8x16xf32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value
         : !xetile.tile<64x64xf16>, !xetile.tile<64x64xf16>, vector<64x64xf32>
     }
-
-    // store the final accumulated C tile result back to memory
-    //CHECK: xetile.store_tile %[[R9]]#2,  %[[R2]] : vector<8x4x8x16xf32>, !xetile.tile<64x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK-COUNT-32: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
     xetile.store_tile %out#2, %c_init_tile: vector<64x64xf32>, !xetile.tile<64x64xf32>
-
-    //CHECK: gpu.return
     gpu.return
   }
 }
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
index 32c848607..72d30ebc1 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_f16_f32_slm.mlir
@@ -6,39 +6,45 @@
 gpu.module @test_kernel {
   //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<128x128xf16, 3>, %[[arg1:.*]]: memref<128x128xf16, 3>, %[[arg2:.*]]: memref<128x128xf32>) {
   gpu.func @test_gemm(%arg0: memref<128x128xf16, 3>, %arg1: memref<128x128xf16, 3>, %arg2: memref<128x128xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
     %c0 = arith.constant 0 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
     %c16 = arith.constant 16 : index
     %c128 = arith.constant 128 : index
 
-    //CHECK: %[[block_id_x:.*]] = gpu.block_id  x
-    //CHECK: %[[block_id_y:.*]] = gpu.block_id  y
-    //CHECK: %[[r0:.*]] = arith.muli %block_id_x, %[[c16]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %block_id_y, %[[c16]] : index
     %block_id_x = gpu.block_id  x
     %block_id_y = gpu.block_id  y
     %0 = arith.muli %block_id_x, %c16 : index
     %1 = arith.muli %block_id_y, %c16 : index
 
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<128x128xf32> -> !xetile.tile<8x16xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r2]] {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf32, #xetile.tile_attr<inner_blocks = [8, 16]>> -> vector<1x1x8x16xf32>
+    // CHECK: %{{.*}} = xetile.init_tile %{{.*}}[%{{.}}, %{{.*}}] : memref<128x128xf32> -> !xetile.tile<8x16xf32>
     %2 = xetile.init_tile %arg2[%0, %1] : memref<128x128xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<8x16xf32> -> vector<8x16xf32>
     %3 = xetile.load_tile %2 {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf32> -> vector<8x16xf32>
-
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<128x128xf16, 3> -> !xetile.tile<8x16xf16, #xetile.tile_attr<inner_blocks = [1, 16], memory_space = 3 : i64>>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<128x128xf16, 3> -> !xetile.tile<16x16xf16, #xetile.tile_attr<inner_blocks = [1, 16], memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
+    // CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
     %4 = xetile.init_tile %arg0[%0, %c0] : memref<128x128xf16, 3> -> !xetile.tile<8x16xf16, #slm>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<128x128xf16, 3> -> !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
     %5 = xetile.init_tile %arg1[%c0, %1] : memref<128x128xf16, 3> -> !xetile.tile<16x16xf16, #slm>
     %6:3 = scf.for %arg3 = %c0 to %c128 step %c16 iter_args(%arg4 = %4, %arg5 = %5, %arg6 = %3)
           -> (!xetile.tile<8x16xf16, #slm>, !xetile.tile<16x16xf16, #slm>, vector<8x16xf32>) {
+      //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>> -> vector<1x16xf16>
       %7 = xetile.load_tile %arg4 {padding = 0.000000e+00 : f32}  : !xetile.tile<8x16xf16, #slm> -> vector<8x16xf16>
+      //CHECK-COUNT-16: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>> -> vector<1x16xf16>
       %8 = xetile.load_tile %arg5 {padding = 0.000000e+00 : f32}  : !xetile.tile<16x16xf16, #slm> -> vector<16x16xf16>
+      //CHECK: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
       %9 = xetile.tile_mma %7, %8, %arg6 : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
       %10 = xetile.update_tile_offset %arg4, [%c0,  %c16] : !xetile.tile<8x16xf16, #slm>
+      //CHECK-COUNT-16: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<1x16xf16, #xetile.tile_attr<memory_space = 3 : i64>>
       %11 = xetile.update_tile_offset %arg5, [%c16,  %c0] : !xetile.tile<16x16xf16, #slm>
       scf.yield %10, %11, %9 : !xetile.tile<8x16xf16, #slm>, !xetile.tile<16x16xf16, #slm>, vector<8x16xf32>
     }
+    //CHECK: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
     xetile.store_tile %6#2,  %2 : vector<8x16xf32>, !xetile.tile<8x16xf32>
     gpu.return
   }
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
index 38c986c67..8f53867cb 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_1k_1k_1k_i8_i32.mlir
@@ -5,13 +5,6 @@ gpu.module @test_kernel {
 
   //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<1024x1024xi8>, %[[arg1:.*]]: memref<1024x1024xi8>, %[[arg2:.*]]: memref<1024x1024xi32>)
   gpu.func @test_gemm(%A: memref<1024x1024xi8>, %B: memref<1024x1024xi8>, %C: memref<1024x1024xi32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c64:.*]] = arith.constant 64 : index
-    //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
-    //CHECK: %[[X:.*]] = gpu.block_id  x
-    //CHECK: %[[Y:.*]] = gpu.block_id  y
-    //CHECK: %[[R0:.*]] = arith.muli %[[X]], %[[c64]] : index
-    //CHECK: %[[R1:.*]] = arith.muli %[[Y]], %[[c64]] : index
     %c0 = arith.constant 0 : index
     %c64 = arith.constant 64 : index
     %c1024 = arith.constant 1024 : index
@@ -20,58 +13,52 @@ gpu.module @test_kernel {
     %m = arith.muli %block_id_x, %c64 : index
     %n = arith.muli %block_id_y, %c64 : index
 
-    //CHECK: %[[R2:.*]] = xetile.init_tile %[[arg2]][%[[R0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xi32> -> !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[R3:.*]] = xetile.init_tile %[[arg2]][%[[R0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xi32> -> !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<1024x1024xi32> -> !xetile.tile<32x16xi32>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<1024x1024xi32> -> !xetile.tile<64x64xi32>
 
-    //CHECK: %[[R4:.*]] = xetile.load_tile %[[R3]]
-    //CHECK-SAME: !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xi32>
-    //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 32, 16>}  : vector<2x4x32x16xi32> -> vector<64x64xi32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xi32> -> vector<32x16xi32>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xi32> to vector<8x16xi32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x64xi32> -> vector<64x64xi32>
 
-    //CHECK: %[[R6:.*]] = xetile.init_tile %[[arg0]][%[[R0]], %[[c0]]]
-    //CHECK-SAME: memref<1024x1024xi8> -> !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xi8> -> !xetile.tile<32x32xi8>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<1024x1024xi8> -> !xetile.tile<64x64xi8>
 
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[R1]]]
-    //CHECK-SAME: memref<1024x1024xi8> -> !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1024x1024xi8> -> !xetile.tile<32x16xi8>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<1024x1024xi8> -> !xetile.tile<64x64xi8>
 
-    //CHECK: %[[R8:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 8, 16>}  : vector<64x64xi32> -> vector<8x4x8x16xi32>
-    //CHECK: %[[R9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c1024]] step %[[c64]] iter_args(%[[arg4:.*]] = %[[R6]], %[[arg5:.*]] = %[[R7]], %[[arg6:.*]] = %[[R8]])
-    //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x4x8x16xi32>
     %out:3 = scf.for %k = %c0 to %c1024 step %c64 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
                   -> (!xetile.tile<64x64xi8>, !xetile.tile<64x64xi8>, vector<64x64xi32>) {
-      //CHECK: %[[R10:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<2x2x32x32xi8>
-      //CHECK: %[[R11:.*]] = xetile.tile_unpack %[[R10]] {inner_blocks = array<i64: 32, 32>}  : vector<2x2x32x32xi8> -> vector<64x64xi8>
+      //CHECK-COUNT-4: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x32xi8> -> vector<32x32xi8>
+      //CHECK-COUNT-16: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<64x64xi8> -> vector<64x64xi8>
 
-      //CHECK: %[[R12:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x4x32x16xi8>
+      //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xi8> -> vector<32x16xi8>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<64x64xi8> -> vector<64x64xi8>
 
-      //CHECK: %[[R13:.*]] = xetile.tile_pack %[[R11]] {inner_blocks = array<i64: 8, 32>}  : vector<64x64xi8> -> vector<8x2x8x32xi8>
-      //CHECK: %[[R14:.*]] = xetile.tile_mma %[[R13]], %[[R12]], %[[arg6]] : vector<8x2x8x32xi8>, vector<2x4x32x16xi8>, vector<8x4x8x16xi32> -> vector<8x4x8x16xi32>
+      //CHECK-COUNT-64: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x32xi8>, vector<32x16xi8>, vector<8x16xi32> -> vector<8x16xi32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value : vector<64x64xi8>, vector<64x64xi8>, vector<64x64xi32> -> vector<64x64xi32>
 
-      //CHECK: %[[R15:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c64]]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
+      //CHECK-COUNT-4: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x32xi8>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c64] : !xetile.tile<64x64xi8>
 
-      //CHECK: %[[R16:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c64]],  %[[c0]]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
+      //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xi8>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c64, %c0] : !xetile.tile<64x64xi8>
 
-      //CHECK: scf.yield %[[R15]], %[[R16]], %[[R14]]
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      //CHECK-SAME: !xetile.tile<64x64xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x4x8x16xi32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<64x64xi8>, !xetile.tile<64x64xi8>, vector<64x64xi32>
     }
-    //CHECK: xetile.store_tile %[[R9]]#2,  %[[R2]] : vector<8x4x8x16xi32>, !xetile.tile<64x64xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK-COUNT-32: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xi32>, !xetile.tile<8x16xi32>
     xetile.store_tile %out#2, %c_init_tile {innner_blocks = [8, 16]}: vector<64x64xi32>, !xetile.tile<64x64xi32>
-
-    //CHECK: gpu.return
     gpu.return
   }
 }
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
index 89a5b6d77..b6d3992e7 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_f16_f32.mlir
@@ -4,12 +4,6 @@ gpu.module @test_kernel {
 
   //CHECK:  gpu.func @test_gemm(%[[arg0:.*]]: memref<4096x4096xf16>, %[[arg1:.*]]: memref<4096x4096xf16>, %[[arg2:.*]]: memref<4096x4096xf32>)
   gpu.func @test_gemm(%A: memref<4096x4096xf16>, %B: memref<4096x4096xf16>, %C: memref<4096x4096xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c64:.*]] = arith.constant 64 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
-    //CHECK: %[[x:.*]] = gpu.block_id  x
-    //CHECK: %[[y:.*]] = gpu.block_id  y
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %c64 = arith.constant 64 : index
@@ -17,67 +11,63 @@ gpu.module @test_kernel {
     %c4096 = arith.constant 4096 : index
     %block_id_x = gpu.block_id x
     %block_id_y = gpu.block_id y
-
-    //CHECK: %[[r0:.*]] = arith.muli %[[x]], %[[c64]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %[[y]], %[[c128]] : index
     %m = arith.muli %block_id_x, %c64 : index
     %n = arith.muli %block_id_y, %c128 : index
 
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xf32> -> !xetile.tile<32x16xf32>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<4096x4096xf32> -> !xetile.tile<64x128xf32>
 
-    //CHECK: %[[r4:.*]] = xetile.load_tile %[[r3]] : !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x8x32x16xf32>
-    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 32, 16>} : vector<2x8x32x16xf32> -> vector<64x128xf32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf32> -> vector<32x16xf32>
+    //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf32> to vector<8x16xf32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<64x128xf32> -> vector<64x128xf32>
 
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<4096x4096xf16> -> !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<4096x4096xf16> -> !xetile.tile<64x128xf16>
 
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<4096x4096xf16> -> !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+    //CHECK-COUNT-32: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}] : memref<4096x4096xf16> -> !xetile.tile<32x16xf16>
     %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xf16> -> !xetile.tile<128x128xf16>
 
-    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 8, 16>} : vector<64x128xf32> -> vector<8x8x8x16xf32>
-    //CHECK: %[[r9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c128]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r6]], %[[arg5:.*]] = %[[r7]], %[[arg6:.*]] = %[[r8]])
-    //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x8x8x16xf32>
     %out:3 = scf.for %k = %c0 to %c4096 step %c128
       iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
       -> (!xetile.tile<64x128xf16>, !xetile.tile<128x128xf16>, vector<64x128xf32>) {
-      //CHECK: %[[r10:.*]] = xetile.load_tile %[[arg4]]
-      //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<2x8x32x16xf16>
-      //CHECK: %[[r11:.*]] = xetile.tile_unpack %[[r10]] {inner_blocks = array<i64: 32, 16>}  : vector<2x8x32x16xf16> -> vector<64x128xf16>
+      //CHECK-COUNT-16: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<64x128xf16> -> vector<64x128xf16>
 
-      //CHECK: %[[r12:.*]] = xetile.load_tile %[[arg5]]
-      //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<4x8x32x16xf16>
-      //CHECK: %[[r13:.*]] = xetile.tile_unpack %[[r12]] {inner_blocks = array<i64: 32, 16>}  : vector<4x8x32x16xf16> -> vector<128x128xf16>
+      //CHECK-COUNT-32: %{{.*}} = xetile.load_tile %{{.*}}: !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<128x128xf16> -> vector<128x128xf16>
 
-      //CHECK: %[[r14:.*]] = xetile.tile_pack %[[r11]] {inner_blocks = array<i64: 8, 16>}  : vector<64x128xf16> -> vector<8x8x8x16xf16>
-      //CHECK: %[[r15:.*]] = xetile.tile_pack %[[r13]] {inner_blocks = array<i64: 16, 16>}  : vector<128x128xf16> -> vector<8x8x16x16xf16>
-      //CHECK: %[[r16:.*]] = xetile.tile_mma %[[r14]], %[[r15]], %[[arg6]] : vector<8x8x8x16xf16>, vector<8x8x16x16xf16>, vector<8x8x8x16xf32> -> vector<8x8x8x16xf32>
+      //CHECK-COUNT-512: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value
         : vector<64x128xf16>, vector<128x128xf16>, vector<64x128xf32> -> vector<64x128xf32>
 
-      //CHECK: %[[r17:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c128]]]
-      //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: %[[r18:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c128]],  %[[c0]]]
-      //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c128] : !xetile.tile<64x128xf16> %b_next_tile = xetile.update_tile_offset %b_tile, [%c128, %c0]
+      //CHECK-COUNT-16: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}] : !xetile.tile<32x16xf16>
+      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c128] : !xetile.tile<64x128xf16>
+
+      //CHECK-COUNT-32: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}] : !xetile.tile<32x16xf16>
+      %b_next_tile = xetile.update_tile_offset %b_tile, [%c128, %c0]
         : !xetile.tile<128x128xf16>
 
-      //CHECK: scf.yield %[[r17]], %[[r18]], %[[r16]]
-      //CHECK-SAME: !xetile.tile<64x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK-SAME: !xetile.tile<128x128xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<8x8x8x16xf32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value
         : !xetile.tile<64x128xf16>, !xetile.tile<128x128xf16>, vector<64x128xf32>
     }
-    //CHECK: xetile.store_tile %[[r9]]#2,  %[[r2]] : vector<8x8x8x16xf32>, !xetile.tile<64x128xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK-COUNT-64: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
     xetile.store_tile %out#2, %c_init_tile : vector<64x128xf32>, !xetile.tile<64x128xf32>
-
-    //CHECK: gpu.return
     gpu.return
   }
 }
diff --git a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir
index 74969a701..a275a231a 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/sg_gemm_4k_4k_4k_i8_i32.mlir
@@ -4,27 +4,6 @@ gpu.module @test_kernel {
 
   //CHECK: gpu.func @test_gemm(%[[arg0:.*]]: memref<4096x4096xi8>, %[[arg1:.*]]: memref<4096x4096xi8>, %[[arg2:.*]]: memref<4096x4096xi32>) {
   gpu.func @test_gemm(%A: memref<4096x4096xi8>, %B: memref<4096x4096xi8>, %C: memref<4096x4096xi32>) {
-
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[c256:.*]] = arith.constant 256 : index
-    //CHECK: %[[c4096:.*]] = arith.constant 4096 : index
-
-
-    //CHECK: %[[x:.*]] = gpu.block_id  x
-    //CHECK: %[[y:.*]] = gpu.block_id  y
-    //CHECK: %[[r0:.*]] = arith.muli %[[x]], %[[c128]] : index
-    //CHECK: %[[r1:.*]] = arith.muli %[[y]], %[[c256]] : index
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg2]][%[[r0]], %[[r1]]] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK: %[[r4:.*]] = xetile.load_tile %[[r3]] : !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<4x16x32x16xi32>
-    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 32, 16>} : vector<4x16x32x16xi32> -> vector<128x256xi32>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]][%[[r0]], %[[c0]]] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[r1]]] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 8, 16>} : vector<128x256xi32> -> vector<16x16x8x16xi32>
-
-
-
     %c0 = arith.constant 0 : index
     %c1 = arith.constant 1 : index
     %c128 = arith.constant 128 : index
@@ -34,44 +13,73 @@ gpu.module @test_kernel {
     %block_id_y = gpu.block_id y
     %m = arith.muli %block_id_x, %c128 : index
     %n = arith.muli %block_id_y, %c256 : index
-
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<8x16xi32>
+    //CHECK-COUNT-64: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}] : memref<4096x4096xi32> -> !xetile.tile<32x16xi32>
     %c_init_tile = xetile.init_tile %C[%m, %n] : memref<4096x4096xi32> -> !xetile.tile<128x256xi32>
 
+    //CHECK-COUNT-64: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xi32> -> vector<32x16xi32>
+    //CHECK-COUNT-256: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xi32> to vector<8x16xi32>
     %c_init_value = xetile.load_tile %c_init_tile : !xetile.tile<128x256xi32> -> vector<128x256xi32>
 
+    //CHECK-COUNT-32: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}] : memref<4096x4096xi8> -> !xetile.tile<32x32xi8>
     %a_init_tile = xetile.init_tile %A[%m, %c0] : memref<4096x4096xi8> -> !xetile.tile<128x256xi8>
-    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8>
 
+    //CHECK-COUNT-128: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}] : memref<4096x4096xi8> -> !xetile.tile<32x16xi8>
+    %b_init_tile = xetile.init_tile %B[%c0, %n] : memref<4096x4096xi8> -> !xetile.tile<256x256xi8>
 
-    //CHECK: %[[r9:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c4096]] step %[[c256]]
-    //CHECK-SAME: iter_args(%[[arg4:.*]] = %[[r6]], %[[arg5:.*]] = %[[r7]], %[[arg6:.*]] = %[[r8]])
-    //CHECK-SAME: !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-    //CHECK-SAME: !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<16x16x8x16xi32>
     %out:3 = scf.for %k = %c0 to %c4096 step %c256 iter_args(%a_tile = %a_init_tile, %b_tile = %b_init_tile, %c_value = %c_init_value)
                                                           -> (!xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>) {
 
-      //CHECK: %[[r10:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<4x8x32x32xi8>
-      //CHECK: %[[r11:.*]] = xetile.tile_unpack %[[r10]] {inner_blocks = array<i64: 32, 32>} : vector<4x8x32x32xi8> -> vector<128x256xi8>
+      //CHECK-COUNT-32: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x32xi8> -> vector<32x32xi8>
+      //CHECK-COUNT-128: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xi8> to vector<8x32xi8>
       %a_value = xetile.load_tile %a_tile : !xetile.tile<128x256xi8> -> vector<128x256xi8>
 
-      //CHECK: %[[r12:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<8x16x32x16xi8>
+      //CHECK-COUNT-128: %{{.*}} = xetile.load_tile %{{.*}}: !xetile.tile<32x16xi8> -> vector<32x16xi8>
       %b_value = xetile.load_tile %b_tile : !xetile.tile<256x256xi8> -> vector<256x256xi8>
 
-      //CHECK: %[[r13:.*]] = xetile.tile_pack %[[r11]] {inner_blocks = array<i64: 8, 32>} : vector<128x256xi8> -> vector<16x8x8x32xi8>
-      //CHECK: %[[r14:.*]] = xetile.tile_mma %[[r13]], %[[r12]], %[[arg6]] : vector<16x8x8x32xi8>, vector<8x16x32x16xi8>, vector<16x16x8x16xi32> -> vector<16x16x8x16xi32>
+      //CHECK-COUNT-2048: %{{.*}} = xetile.tile_mma %{{.*}} : vector<8x32xi8>, vector<32x16xi8>, vector<8x16xi32> -> vector<8x16xi32>
       %c_new_value = xetile.tile_mma %a_value, %b_value, %c_value
         : vector<128x256xi8>, vector<256x256xi8>, vector<128x256xi32> -> vector<128x256xi32>
 
-      //CHECK: %[[r15:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c256]]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>
-      //CHECK: %[[r16:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c256]],  %[[c0]]] : !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>
+      //CHECK-COUNT-32: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}] : !xetile.tile<32x32xi8>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c256] : !xetile.tile<128x256xi8>
+      //CHECK-COUNT-128: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}] : !xetile.tile<32x16xi8>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c256, %c0] : !xetile.tile<256x256xi8>
 
-      //CHECK: scf.yield %[[r15]], %[[r16]], %[[r14]] : !xetile.tile<128x256xi8, #xetile.tile_attr<inner_blocks = [32, 32]>>, !xetile.tile<256x256xi8, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<16x16x8x16xi32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<128x256xi8>, !xetile.tile<256x256xi8>, vector<128x256xi32>
     }
-
-    //CHECK: xetile.store_tile %[[r9]]#2,  %[[r2]] : vector<16x16x8x16xi32>, !xetile.tile<128x256xi32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+    //CHECK-COUNT-256: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xi32>, !xetile.tile<8x16xi32>
     xetile.store_tile %out#2, %c_init_tile : vector<128x256xi32>, !xetile.tile<128x256xi32>
     gpu.return
   }
diff --git a/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir b/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
index 3525254cf..2280a0872 100644
--- a/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
+++ b/test/Dialect/XeTile/Transforms/Blocking/unit_tests.mlir
@@ -1,11 +1,27 @@
-// RUN: imex-opt --split-input-file --xetile-blocking --canonicalize %s -verify-diagnostics -o -| FileCheck %s
+// RUN: imex-opt --split-input-file --xetile-blocking %s -verify-diagnostics -o -| FileCheck %s
 
 gpu.module @test_kernel {
+
+  // CHECK-LABEL: test_blocking_elementwise
+  //  CHECK-SAME: (%[[A:.*]]: vector<64x64xf16>, %[[B:.*]]: vector<64x64xf16>)
+  func.func @test_blocking_elementwise(%a: vector<64x64xf16>, %b: vector<64x64xf16>) -> (vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>) {
+    // Elementwise arith ops are handled in unified way, check some
+    //CHECK-COUNT-2: %{{.*}} = vector.extract_strided_slice %[[A]] {offsets = [0, {{.*}}], sizes = [64, 32], strides = [1, 1]} : vector<64x64xf16> to vector<64x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.extract_strided_slice %[[B]] {offsets = [0, {{.*}}], sizes = [64, 32], strides = [1, 1]} : vector<64x64xf16> to vector<64x32xf16>
+    %0 = arith.addf %a, %b: vector<64x64xf16>
+
+    //CHECK-COUNT-2: %{{.*}} = arith.negf %{{.*}} : vector<64x32xf16>
+    %1 = arith.negf %a: vector<64x64xf16>
+    //CHECK-COUNT-2: %{{.*}} = math.exp %{{.*}} : vector<64x32xf16>
+    %2 = math.exp %a: vector<64x64xf16>
+    return %0, %1, %2 : vector<64x64xf16>, vector<64x64xf16>, vector<64x64xf16>
+  }
+
   //CHECK: gpu.func @sg_load_tile(%[[arg0:.*]]: memref<32x32xf16>)
-  //CHECK: %[[c0:.*]] = arith.constant 0 : index
-  //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
-  //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x1x32x32xf16>
   gpu.func @sg_load_tile(%a: memref<32x32xf16>) {
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
     %c0 = arith.constant 0 : index
   	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
     %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
@@ -13,184 +29,276 @@ gpu.module @test_kernel {
   }
 
   //CHECK: gpu.func @sg_load_tile_unaligned(%[[arg0:.*]]: memref<128x128xf16>)
-  //CHECK: %[[c0:.*]] = arith.constant 0 : index
-  //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<85x76xf16, #xetile.tile_attr<inner_blocks = [17, 19]>>
-  //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<85x76xf16, #xetile.tile_attr<inner_blocks = [17, 19]>> -> vector<5x4x17x19xf16>
-  //CHECK: gpu.return
   gpu.func @sg_load_tile_unaligned(%a: memref<128x128xf16>) {
     %c0 = arith.constant 0 : index
+    //CHECK-COUNT-20: xetile.init_tile %arg0[{{.*}}] : memref<128x128xf16> -> !xetile.tile<17x19xf16>
     %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<85x76xf16>
+    //CHECK-COUNT-20: xetile.load_tile {{.*}} : !xetile.tile<17x19xf16> -> vector<17x19xf16>
     %2 = xetile.load_tile %1 : !xetile.tile<85x76xf16> -> vector<85x76xf16>
-   gpu.return
+    //CHECK: gpu.return
+    gpu.return
   }
 
   //CHECK: gpu.func @sg_store_tile(%[[arg0:.*]]: memref<32x32xf32>)
-  //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x2x8x16xf32>
-  //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  //CHECK: xetile.store_tile %[[cst]],  %[[R0]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-
-  //CHECK-2D: gpu.func @sg_store_tile(%[[arg0:.*]]: memref<32x32xf32>)
-  //CHECK-2D: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
-  //CHECK-2D-COUNT-8: %0 = xetile.init_tile %arg0[%{{.*}}, %{{.*}}] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-  //CHECK-2D-COUNT-8: xetile.store_tile %[[cst]],  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
 	gpu.func @sg_store_tile(%a: memref<32x32xf32>) {
+    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
 		%result = arith.constant dense<0.0>: vector<32x32xf32>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %arg0[%{{.*}}, %{{.*}}] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
 		%1 = xetile.init_tile %a[0, 0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
+    //CHECK-COUNT-8: xetile.store_tile %[[cst]],  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
 		xetile.store_tile %result, %1: vector<32x32xf32>, !xetile.tile<32x32xf32>
+    //CHECK: gpu.return
 		gpu.return
 	}
 
   //CHECK: gpu.func @create_mask
-  //CHECK: %[[MASK:.*]] = vector.constant_mask [32, 1, 1, 20] : vector<32x1x1x32xi1>
+  //CHECK-SAME: %[[arg0:.*]]: vector<32x32xf16>, %[[arg1:.*]]: vector<32x32xf16>, %[[arg2:.*]]: memref<32x32xf16>
   gpu.func @create_mask(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
     %c32 = arith.constant 32 : index
     %c20 = arith.constant 20 : index
+
+    //CHECK-2D-FOR-LATER: %[[r0:.*]] = vector.constant_mask [8, 20] : vector<8x32xi1>
+    //CHECK: %[[r0:.*]] = vector.constant_mask [1, 20] : vector<1x32xi1>
     %mask = vector.create_mask %c32, %c20 : vector<32x32xi1>
+
+    //CHECK-2D-FOR-LATER-COUNT-4: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-2D-FOR-LATER-COUNT-4: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-2D-FOR-LATER-COUNT-4: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<8x32xi1>, vector<8x32xf16>
+    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<1x32xi1>, vector<1x32xf16>
     %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
+
+    //CHECK-COUNT-4: xetile.init_tile %[[arg2]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<8x32xf16>
     %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
+
+    //CHECK-COUNT-4: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
+
+    //CHECK: gpu.return
     gpu.return
   }
 
   //CHECK: gpu.func @create_mask_2
-  //CHECK: %[[MASK:.*]] = vector.constant_mask [20, 1, 1, 32] : vector<32x1x1x32xi1>
+  //CHECK-SAME: %[[arg0:.*]]: vector<32x32xf16>, %[[arg1:.*]]: vector<32x32xf16>, %[[arg2:.*]]: memref<32x32xf16>
   gpu.func @create_mask_2(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
     %c20 = arith.constant 20 : index
     %c32 = arith.constant 32 : index
+    //CHECK-2D-FOR-LATER: %[[r0:.*]] = vector.constant_mask [8, 32] : vector<8x32xi1>
+    //CHECK-2D-FOR-LATER: %[[r1:.*]] = vector.constant_mask [4, 32] : vector<8x32xi1>
+    //CHECK-2D-FOR-LATER: %[[r2:.*]] = vector.constant_mask [0, 0] : vector<8x32xi1>
+    //CHECK: %[[r0:.*]] = vector.constant_mask [1, 32] : vector<1x32xi1>
+    //CHECK: %[[r1:.*]] = vector.constant_mask [0, 0] : vector<1x32xi1>
     %mask = vector.create_mask %c20, %c32 : vector<32x32xi1>
+
+    //CHECK-2D-FOR-LATER-COUNT: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-2D-FOR-LATER-COUNT: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-2D-FOR-LATER-COUNT: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<8x32xi1>, vector<8x32xf16>
+    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<1x32xi1>, vector<1x32xf16>
     %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
+
+    //CHECK-COUNT-4: xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<32x32xf16> -> !xetile.tile<8x32xf16>
     %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
+    //CHECK-COUNT-4: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
     gpu.return
   }
 
-  //CHECK: gpu.func @sg_store_tile_unaligned(%[[arg0:.*]]: memref<128x128xf32>)
-  //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<11x19x4x2xf32>
-  //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<128x128xf32> -> !xetile.tile<44x38xf32, #xetile.tile_attr<inner_blocks = [4, 2]>>
-  //CHECK: xetile.store_tile %[[cst]],  %[[R0]] : vector<11x19x4x2xf32>, !xetile.tile<44x38xf32, #xetile.tile_attr<inner_blocks = [4, 2]>>
-  //CHECK: gpu.return
-	gpu.func @sg_store_tile_unaligned(%a: memref<128x128xf32>) {
-	  %result = arith.constant dense<0.0>: vector<44x38xf32>
-	  %1 = xetile.init_tile %a[0, 0] : memref<128x128xf32> -> !xetile.tile<44x38xf32>
-	  xetile.store_tile %result, %1: vector<44x38xf32>, !xetile.tile<44x38xf32>
-	  gpu.return
-	}
-
   //CHECK: gpu.func @sg_tile_mma(%[[arg0:.*]]: memref<32x32xf16>, %[[arg1:.*]]: memref<32x32xf16>)
+  //CHECK-COUNT-2: xetile.init_tile %[[arg0]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<32x16xf16>
+  //CHECK-COUNT-2: xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+  //CHECK-COUNT-8: vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+  //CHECK-COUNT-2: xetile.init_tile %[[arg1]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<32x16xf16>
+  //CHECK-COUNT-2: xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+  //CHECK-COUNT-4: vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+  //CHECK-COUNT-16: xetile.tile_mma %{{.*}}, %{{.*}}{{.*}} : vector<8x16xf16>, vector<16x16xf16>{{.*}} -> vector<8x16xf32>
   gpu.func @sg_tile_mma(%a: memref<32x32xf16>, %b: memref<32x32xf16>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
     %c0 = arith.constant 0 : index
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
   	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
     %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-    //CHECK: %[[R3:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
   	%3 = xetile.init_tile %b[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R4:.*]] = xetile.load_tile %[[R3]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-    //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
     %4 = xetile.load_tile %3 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-    //CHECK: %[[R6:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-    //CHECK: %[[R7:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-    //CHECK: %[[R8:.*]] = xetile.tile_mma %[[R6]], %[[R7]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16> -> vector<4x2x8x16xf32>
     %5 = xetile.tile_mma %2, %4: vector<32x32xf16>, vector<32x32xf16> -> vector<32x32xf32>
   	gpu.return
   }
 
-  ///-CHECK: gpu.func @tile_mma_irregular(%[[arg0:.*]]: memref<128x128xf16>, %[[arg1:.*]]: memref<128x128xf16>)
-  ///-CHECK: %[[c0:.*]] = arith.constant 0 : index
-  ///-CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<90x76xf16, #xetile.tile_attr<inner_blocks = [30, 19]>>
-  ///-CHECK: %[[R1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1], inner_blocks = [19, 6]>>
-  ///-  gpu.func @tile_mma_irregular(%a: memref<128x128xf16>, %b: memref<128x128xf16>) {
-  ///-    %c0 = arith.constant 0 : index
-  ///-    %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<90x76xf16>
-  ///-    %2 = xetile.init_tile %b[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>>
-  ///-    %3 = xetile.load_tile %1 : !xetile.tile<90x76xf16> -> vector<90x76xf16>
-  ///-    %4 = xetile.load_tile %2 : !xetile.tile<76x90xf16, #xetile.tile_attr<order = [0, 1]>> -> vector<76x90xf16>
-  ///-    %5 = xetile.tile_mma %3, %4: vector<90x76xf16>, vector<76x90xf16> -> vector<90x90xf32>
-  ///-    gpu.return
-  ///-  }
-
-
-  //CHECK: gpu.func @sg_gemm(%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
-  gpu.func @sg_gemm(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    %c0 = arith.constant 0 : index
-
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    %c32 = arith.constant 32 : index
-
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    %c128 = arith.constant 128 : index
-
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x2x8x16xf32>
-    %cst = arith.constant dense<0.0>: vector<32x32xf32>
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK: %[[R2:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[R0]], %[[arg5:.*]] = %[[R1]], %[[arg6:.*]] = %[[cst]]) -> (!xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>) {
-    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
-        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      //CHECK: %[[R4:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      //CHECK: %[[R6:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[R7:.*]] = xetile.tile_unpack %[[R6]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
-      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[R8:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: %[[R9:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]:  !xetile.tile<32x32xf16>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]:  !xetile.tile<32x32xf16>
-      //CHECK: %[[R10:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-      //CHECK: %[[R11:.*]] = xetile.tile_pack %[[R7]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-      //CHECK: %[[R12:.*]] = xetile.tile_mma %[[R10]], %[[R11]], %[[arg6]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16>, vector<4x2x8x16xf32> -> vector<4x2x8x16xf32>
-      %c_new_value = xetile.tile_mma %3, %4, %c_value:
-        vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-      //CHECK: scf.yield %[[R8]], %[[R9]], %[[R12]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
-    }
-
-    //CHECK: %[[R3]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-    //CHECK: xetile.store_tile %[[R2]]#2,  %[[R3]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
-  	gpu.return
-  }
-
   // CHECK-LABEL: gpu.func @inner_reduction
   // CHECK-SAME: (%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>)
   gpu.func @inner_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
+    //CHECK: %[[c15_i32:.*]] = arith.constant 15 : i32
+    //CHECK: %[[c14_i32:.*]] = arith.constant 14 : i32
+    //CHECK: %[[c13_i32:.*]] = arith.constant 13 : i32
+    //CHECK: %[[c12_i32:.*]] = arith.constant 12 : i32
+    //CHECK: %[[c11_i32:.*]] = arith.constant 11 : i32
+    //CHECK: %[[c10_i32:.*]] = arith.constant 10 : i32
+    //CHECK: %[[c9_i32:.*]] = arith.constant 9 : i32
+    //CHECK: %[[c8_i32:.*]] = arith.constant 8 : i32
+    //CHECK: %[[c7_i32:.*]] = arith.constant 7 : i32
+    //CHECK: %[[c6_i32:.*]] = arith.constant 6 : i32
+    //CHECK: %[[c5_i32:.*]] = arith.constant 5 : i32
+    //CHECK: %[[c4_i32:.*]] = arith.constant 4 : i32
+    //CHECK: %[[c3_i32:.*]] = arith.constant 3 : i32
+    //CHECK: %[[c2_i32:.*]] = arith.constant 2 : i32
+    //CHECK: %[[c1_i32:.*]] = arith.constant 1 : i32
+    //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
     //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<16x32xf16> -> vector<16x32xf16>
+    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r18:.*]] = math.exp %[[r2]] : vector<1x32xf16>
+    //CHECK: %[[r19:.*]] = math.exp %[[r3]] : vector<1x32xf16>
+    //CHECK: %[[r20:.*]] = math.exp %[[r4]] : vector<1x32xf16>
+    //CHECK: %[[r21:.*]] = math.exp %[[r5]] : vector<1x32xf16>
+    //CHECK: %[[r22:.*]] = math.exp %[[r6]] : vector<1x32xf16>
+    //CHECK: %[[r23:.*]] = math.exp %[[r7]] : vector<1x32xf16>
+    //CHECK: %[[r24:.*]] = math.exp %[[r8]] : vector<1x32xf16>
+    //CHECK: %[[r25:.*]] = math.exp %[[r9]] : vector<1x32xf16>
+    //CHECK: %[[r26:.*]] = math.exp %[[r10]] : vector<1x32xf16>
+    //CHECK: %[[r27:.*]] = math.exp %[[r11]] : vector<1x32xf16>
+    //CHECK: %[[r28:.*]] = math.exp %[[r12]] : vector<1x32xf16>
+    //CHECK: %[[r29:.*]] = math.exp %[[r13]] : vector<1x32xf16>
+    //CHECK: %[[r30:.*]] = math.exp %[[r14]] : vector<1x32xf16>
+    //CHECK: %[[r31:.*]] = math.exp %[[r15]] : vector<1x32xf16>
+    //CHECK: %[[r32:.*]] = math.exp %[[r16]] : vector<1x32xf16>
+    //CHECK: %[[r33:.*]] = math.exp %[[r17]] : vector<1x32xf16>
+    //CHECK: %[[r34:.*]] = vector.shape_cast %[[r18]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r35:.*]] = vector.shape_cast %[[r19]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r36:.*]] = vector.shape_cast %[[r20]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r37:.*]] = vector.shape_cast %[[r21]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r38:.*]] = vector.shape_cast %[[r22]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r39:.*]] = vector.shape_cast %[[r23]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r40:.*]] = vector.shape_cast %[[r24]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r41:.*]] = vector.shape_cast %[[r25]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r42:.*]] = vector.shape_cast %[[r26]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r43:.*]] = vector.shape_cast %[[r27]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r44:.*]] = vector.shape_cast %[[r28]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r45:.*]] = vector.shape_cast %[[r29]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r46:.*]] = vector.shape_cast %[[r30]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r47:.*]] = vector.shape_cast %[[r31]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r48:.*]] = vector.shape_cast %[[r32]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r49:.*]] = vector.shape_cast %[[r33]] : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r50:.*]] = vector.shuffle %[[r34]], %[[r35]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r51:.*]] = vector.shuffle %[[r34]], %[[r35]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r52:.*]] = arith.addf %[[r50]], %[[r51]] : vector<32xf16>
+    //CHECK: %[[r53:.*]] = vector.shuffle %[[r36]], %[[r37]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r54:.*]] = vector.shuffle %[[r36]], %[[r37]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r55:.*]] = arith.addf %[[r53]], %[[r54]] : vector<32xf16>
+    //CHECK: %[[r56:.*]] = vector.shuffle %[[r38]], %[[r39]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r57:.*]] = vector.shuffle %[[r38]], %[[r39]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r58:.*]] = arith.addf %[[r56]], %[[r57]] : vector<32xf16>
+    //CHECK: %[[r59:.*]] = vector.shuffle %[[r40]], %[[r41]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r60:.*]] = vector.shuffle %[[r40]], %[[r41]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r61:.*]] = arith.addf %[[r59]], %[[r60]] : vector<32xf16>
+    //CHECK: %[[r62:.*]] = vector.shuffle %[[r42]], %[[r43]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r63:.*]] = vector.shuffle %[[r42]], %[[r43]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r64:.*]] = arith.addf %[[r62]], %[[r63]] : vector<32xf16>
+    //CHECK: %[[r65:.*]] = vector.shuffle %[[r44]], %[[r45]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r66:.*]] = vector.shuffle %[[r44]], %[[r45]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r67:.*]] = arith.addf %[[r65]], %[[r66]] : vector<32xf16>
+    //CHECK: %[[r68:.*]] = vector.shuffle %[[r46]], %[[r47]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r69:.*]] = vector.shuffle %[[r46]], %[[r47]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r70:.*]] = arith.addf %[[r68]], %[[r69]] : vector<32xf16>
+    //CHECK: %[[r71:.*]] = vector.shuffle %[[r48]], %[[r49]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r72:.*]] = vector.shuffle %[[r48]], %[[r49]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r73:.*]] = arith.addf %[[r71]], %[[r72]] : vector<32xf16>
+    //CHECK: %[[r74:.*]] = vector.shuffle %[[r52]], %[[r55]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r75:.*]] = vector.shuffle %[[r52]], %[[r55]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r76:.*]] = arith.addf %[[r74]], %[[r75]] : vector<32xf16>
+    //CHECK: %[[r77:.*]] = vector.shuffle %[[r58]], %[[r61]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r78:.*]] = vector.shuffle %[[r58]], %[[r61]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r79:.*]] = arith.addf %[[r77]], %[[r78]] : vector<32xf16>
+    //CHECK: %[[r80:.*]] = vector.shuffle %[[r64]], %[[r67]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r81:.*]] = vector.shuffle %[[r64]], %[[r67]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r82:.*]] = arith.addf %[[r80]], %[[r81]] : vector<32xf16>
+    //CHECK: %[[r83:.*]] = vector.shuffle %[[r70]], %[[r73]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r84:.*]] = vector.shuffle %[[r70]], %[[r73]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r85:.*]] = arith.addf %[[r83]], %[[r84]] : vector<32xf16>
+    //CHECK: %[[r86:.*]] = vector.shuffle %[[r76]], %[[r79]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r87:.*]] = vector.shuffle %[[r76]], %[[r79]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r88:.*]] = arith.addf %[[r86]], %[[r87]] : vector<32xf16>
+    //CHECK: %[[r89:.*]] = vector.shuffle %[[r82]], %[[r85]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r90:.*]] = vector.shuffle %[[r82]], %[[r85]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r91:.*]] = arith.addf %[[r89]], %[[r90]] : vector<32xf16>
+    //CHECK: %[[r92:.*]] = vector.shuffle %[[r88]], %[[r91]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r93:.*]] = vector.shuffle %[[r88]], %[[r91]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r94:.*]] = arith.addf %[[r92]], %[[r93]] : vector<32xf16>
+    //CHECK: %[[r95:.*]] = vector.shuffle %[[r94]], %[[r94]] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r96:.*]] = vector.shuffle %[[r94]], %[[r94]] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r97:.*]] = arith.addf %[[r95]], %[[r96]] : vector<16xf16>
+    //CHECK: %[[r98:.*]] = vector.extractelement %[[r97]][%[[c0_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r99:.*]] = vector.splat %[[r98]] : vector<1x1xf16>
+    //CHECK: %[[r100:.*]] = vector.extractelement %[[r97]][%[[c1_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r101:.*]] = vector.splat %[[r100]] : vector<1x1xf16>
+    //CHECK: %[[r102:.*]] = vector.extractelement %[[r97]][%[[c2_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r103:.*]] = vector.splat %[[r102]] : vector<1x1xf16>
+    //CHECK: %[[r104:.*]] = vector.extractelement %[[r97]][%[[c3_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r105:.*]] = vector.splat %[[r104]] : vector<1x1xf16>
+    //CHECK: %[[r106:.*]] = vector.extractelement %[[r97]][%[[c4_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r107:.*]] = vector.splat %[[r106]] : vector<1x1xf16>
+    //CHECK: %[[r108:.*]] = vector.extractelement %[[r97]][%[[c5_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r109:.*]] = vector.splat %[[r108]] : vector<1x1xf16>
+    //CHECK: %[[r110:.*]] = vector.extractelement %[[r97]][%[[c6_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r111:.*]] = vector.splat %[[r110]] : vector<1x1xf16>
+    //CHECK: %[[r112:.*]] = vector.extractelement %[[r97]][%[[c7_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r113:.*]] = vector.splat %[[r112]] : vector<1x1xf16>
+    //CHECK: %[[r114:.*]] = vector.extractelement %[[r97]][%[[c8_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r115:.*]] = vector.splat %[[r114]] : vector<1x1xf16>
+    //CHECK: %[[r116:.*]] = vector.extractelement %[[r97]][%[[c9_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r117:.*]] = vector.splat %[[r116]] : vector<1x1xf16>
+    //CHECK: %[[r118:.*]] = vector.extractelement %[[r97]][%[[c10_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r119:.*]] = vector.splat %[[r118]] : vector<1x1xf16>
+    //CHECK: %[[r120:.*]] = vector.extractelement %[[r97]][%[[c11_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r121:.*]] = vector.splat %[[r120]] : vector<1x1xf16>
+    //CHECK: %[[r122:.*]] = vector.extractelement %[[r97]][%[[c12_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r123:.*]] = vector.splat %[[r122]] : vector<1x1xf16>
+    //CHECK: %[[r124:.*]] = vector.extractelement %[[r97]][%[[c13_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r125:.*]] = vector.splat %[[r124]] : vector<1x1xf16>
+    //CHECK: %[[r126:.*]] = vector.extractelement %[[r97]][%[[c14_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r127:.*]] = vector.splat %[[r126]] : vector<1x1xf16>
+    //CHECK: %[[r128:.*]] = vector.extractelement %[[r97]][%[[c15_i32]] : i32] : vector<16xf16>
+    //CHECK: %[[r129:.*]] = vector.splat %[[r128]] : vector<1x1xf16>
+    //CHECK: %[[r130:.*]] = vector.shuffle %[[r99]], %[[r101]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r131:.*]] = vector.shuffle %[[r103]], %[[r105]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r132:.*]] = vector.shuffle %[[r107]], %[[r109]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r133:.*]] = vector.shuffle %[[r111]], %[[r113]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r134:.*]] = vector.shuffle %[[r115]], %[[r117]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r135:.*]] = vector.shuffle %[[r119]], %[[r121]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r136:.*]] = vector.shuffle %[[r123]], %[[r125]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r137:.*]] = vector.shuffle %[[r127]], %[[r129]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
+    //CHECK: %[[r138:.*]] = vector.shuffle %[[r130]], %[[r131]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
+    //CHECK: %[[r139:.*]] = vector.shuffle %[[r132]], %[[r133]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
+    //CHECK: %[[r140:.*]] = vector.shuffle %[[r134]], %[[r135]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
+    //CHECK: %[[r141:.*]] = vector.shuffle %[[r136]], %[[r137]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
+    //CHECK: %[[r142:.*]] = vector.shuffle %[[r138]], %[[r139]] [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf16>, vector<4x1xf16>
+    //CHECK: %[[r143:.*]] = vector.shuffle %[[r140]], %[[r141]] [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf16>, vector<4x1xf16>
+    //CHECK: %[[r144:.*]] = vector.shuffle %[[r142]], %[[r143]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x1xf16>, vector<8x1xf16>
+    //CHECK: %[[r145:.*]] = vector.shape_cast %[[r144]] : vector<16x1xf16> to vector<2x8xf16>
+    //CHECK: %[[r146:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
+    //CHECK: xetile.store_tile %[[r145]],  %[[r146]] : vector<2x8xf16>, !xetile.tile<2x8xf16>
     %c0 = arith.constant 0 : index
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>>
     %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>> -> vector<1x1x16x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 16, 32>}  : vector<1x1x16x32xf16> -> vector<16x32xf16>
     %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<16x32xf16> -> vector<16x1x1x32xf16>
-    //CHECK: %[[R4:.*]] = math.exp %[[R3]] : vector<16x1x1x32xf16>
     %e = math.exp %v: vector<16x32xf16>
-
-    //CHECK: %[[R5:.*]] = xetile.reduction <add>, %[[R4]] [1, 3] : vector<16x1x1x32xf16> -> vector<16x1x1x1xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_unpack %[[R5]] {inner_blocks = array<i64: 1, 1>} : vector<16x1x1x1xf16> -> vector<16x1xf16>
     %r = xetile.reduction <add>, %e [1] : vector<16x32xf16> -> vector<16x1xf16>
-    //CHECK: %[[R7:.*]] = vector.shape_cast %[[R6]] : vector<16x1xf16> to vector<2x8xf16>
     %c = vector.shape_cast %r: vector<16x1xf16> to vector<2x8xf16>
-    //CHECK: %[[R8:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<2x8xf16, #xetile.tile_attr<inner_blocks = [2, 8]>>
     %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
-    //CHECK: %[[R9:.*]] = xetile.tile_pack %[[R7]] {inner_blocks = array<i64: 2, 8>}  : vector<2x8xf16> -> vector<1x1x2x8xf16>
-    //CHECK: xetile.store_tile %[[R9]],  %[[R8]] : vector<1x1x2x8xf16>, !xetile.tile<2x8xf16, #xetile.tile_attr<inner_blocks = [2, 8]>>
     xetile.store_tile %c, %s : vector<2x8xf16>, !xetile.tile<2x8xf16>
     gpu.return
   }
@@ -198,82 +306,255 @@ gpu.module @test_kernel {
   //CHECK: gpu.func @outter_reduction(%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>) {
   gpu.func @outter_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
     //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<16x32xf16> -> vector<16x32xf16>
+    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r18:.*]] = math.exp %[[r2:.*]] : vector<1x32xf16>
+    //CHECK: %[[r19:.*]] = math.exp %[[r3:.*]] : vector<1x32xf16>
+    //CHECK: %[[r20:.*]] = math.exp %[[r4:.*]] : vector<1x32xf16>
+    //CHECK: %[[r21:.*]] = math.exp %[[r5:.*]] : vector<1x32xf16>
+    //CHECK: %[[r22:.*]] = math.exp %[[r6:.*]] : vector<1x32xf16>
+    //CHECK: %[[r23:.*]] = math.exp %[[r7:.*]] : vector<1x32xf16>
+    //CHECK: %[[r24:.*]] = math.exp %[[r8:.*]] : vector<1x32xf16>
+    //CHECK: %[[r25:.*]] = math.exp %[[r9:.*]] : vector<1x32xf16>
+    //CHECK: %[[r26:.*]] = math.exp %[[r10:.*]] : vector<1x32xf16>
+    //CHECK: %[[r27:.*]] = math.exp %[[r11:.*]] : vector<1x32xf16>
+    //CHECK: %[[r28:.*]] = math.exp %[[r12:.*]] : vector<1x32xf16>
+    //CHECK: %[[r29:.*]] = math.exp %[[r13:.*]] : vector<1x32xf16>
+    //CHECK: %[[r30:.*]] = math.exp %[[r14:.*]] : vector<1x32xf16>
+    //CHECK: %[[r31:.*]] = math.exp %[[r15:.*]] : vector<1x32xf16>
+    //CHECK: %[[r32:.*]] = math.exp %[[r16:.*]] : vector<1x32xf16>
+    //CHECK: %[[r33:.*]] = math.exp %[[r17:.*]] : vector<1x32xf16>
+    //CHECK: %[[r34:.*]] = arith.addf %[[r18]], %[[r19]] : vector<1x32xf16>
+    //CHECK: %[[r35:.*]] = arith.addf %[[r34]], %[[r20]] : vector<1x32xf16>
+    //CHECK: %[[r36:.*]] = arith.addf %[[r35]], %[[r21]] : vector<1x32xf16>
+    //CHECK: %[[r37:.*]] = arith.addf %[[r36]], %[[r22]] : vector<1x32xf16>
+    //CHECK: %[[r38:.*]] = arith.addf %[[r37]], %[[r23]] : vector<1x32xf16>
+    //CHECK: %[[r39:.*]] = arith.addf %[[r38]], %[[r24]] : vector<1x32xf16>
+    //CHECK: %[[r40:.*]] = arith.addf %[[r39]], %[[r25]] : vector<1x32xf16>
+    //CHECK: %[[r41:.*]] = arith.addf %[[r40]], %[[r26]] : vector<1x32xf16>
+    //CHECK: %[[r42:.*]] = arith.addf %[[r41]], %[[r27]] : vector<1x32xf16>
+    //CHECK: %[[r43:.*]] = arith.addf %[[r42]], %[[r28]] : vector<1x32xf16>
+    //CHECK: %[[r44:.*]] = arith.addf %[[r43]], %[[r29]] : vector<1x32xf16>
+    //CHECK: %[[r45:.*]] = arith.addf %[[r44]], %[[r30]] : vector<1x32xf16>
+    //CHECK: %[[r46:.*]] = arith.addf %[[r45]], %[[r31]] : vector<1x32xf16>
+    //CHECK: %[[r47:.*]] = arith.addf %[[r46]], %[[r32]] : vector<1x32xf16>
+    //CHECK: %[[r48:.*]] = arith.addf %[[r47]], %[[r33]] : vector<1x32xf16>
+    //CHECK: %[[r49:.*]] = vector.shape_cast %[[r48]] : vector<1x32xf16> to vector<4x8xf16>
+    //CHECK: %[[r50:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
+    //CHECK: xetile.store_tile %[[r49]],  %[[r50]] : vector<4x8xf16>, !xetile.tile<4x8xf16>
     %c0 = arith.constant 0 : index
-
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>>
     %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<16x32xf16, #xetile.tile_attr<inner_blocks = [16, 32]>> -> vector<1x1x16x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 16, 32>}  : vector<1x1x16x32xf16> -> vector<16x32xf16>
     %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<16x32xf16> -> vector<16x1x1x32xf16>
-    //CHECK: %[[R4:.*]] = math.exp %[[R3]] : vector<16x1x1x32xf16>
     %e = math.exp %v: vector<16x32xf16>
-
-    //CHECK: %[[R5:.*]] = xetile.reduction <add>, %4 [0, 2] : vector<16x1x1x32xf16> -> vector<1x1x1x32xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_unpack %5 {inner_blocks = array<i64: 1, 32>}  : vector<1x1x1x32xf16> -> vector<1x32xf16>
     %r = xetile.reduction <add>, %e [0] : vector<16x32xf16> -> vector<1x32xf16>
-
-    //CHECK: %[[R7:.*]] = vector.shape_cast %6 : vector<1x32xf16> to vector<4x8xf16>
     %c = vector.shape_cast %r: vector<1x32xf16> to vector<4x8xf16>
-
-    //CHECK: %[[R8:.*]] = xetile.init_tile %arg1[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<4x8xf16, #xetile.tile_attr<inner_blocks = [4, 8]>>
     %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
-
-    //CHECK: %[[R9:.*]] = xetile.tile_pack %7 {inner_blocks = array<i64: 4, 8>}  : vector<4x8xf16> -> vector<1x1x4x8xf16>
-    //CHECK: xetile.store_tile %9,  %8 : vector<1x1x4x8xf16>, !xetile.tile<4x8xf16, #xetile.tile_attr<inner_blocks = [4, 8]>>
     xetile.store_tile %c, %s : vector<4x8xf16>, !xetile.tile<4x8xf16>
     gpu.return
   }
 
+  //CHECK-LABEL: gpu.func @sg_gemm
+  //CHECK-SAME: (%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
+  gpu.func @sg_gemm(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
+
+    //CHECK: %[[c24:.*]] = arith.constant 24 : index
+    //CHECK: %[[c8:.*]] = arith.constant 8 : index
+    //CHECK: %[[c16:.*]] = arith.constant 16 : index
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[c32:.*]] = arith.constant 32 : index
+    //CHECK: %[[c128:.*]] = arith.constant 128 : index
+    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c16]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c16]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
+    %c0 = arith.constant 0 : index
+    %c32 = arith.constant 32 : index
+    %c128 = arith.constant 128 : index
+    %cst = arith.constant dense<0.0>: vector<32x32xf32>
+  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
+  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r4:.*]]:12 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6:.*]] = %[[r2]], %[[arg7:.*]] = %[[r3]], %[[arg8:.*]] = %[[cst]], %[[arg9:.*]] = %[[cst]], %[[arg10:.*]] = %[[cst]], %[[arg11:.*]] = %[[cst]], %[[arg12:.*]] = %[[cst]], %[[arg13:.*]] = %[[cst]], %[[arg14:.*]] = %[[cst]], %[[arg15:.*]] = %[[cst]]) -> (!xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>) {
+    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
+        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
+      //CHECK: %[[r13:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK: %[[r14:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r18:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r19:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r20:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r21:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r22:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+      //CHECK: %[[r23:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK: %[[r24:.*]] = xetile.load_tile %[[arg7]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+      //CHECK: %[[r25:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+      //CHECK: %[[r26:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+      //CHECK: %[[r27:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+      //CHECK: %[[r28:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+      //CHECK: %[[r29:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
+      //CHECK: %[[r30:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
+      //CHECK: %[[r31:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
+      //CHECK: %[[r32:.*]] = xetile.update_tile_offset %[[arg7]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
+      //CHECK: %[[r33:.*]] = xetile.tile_mma %[[r15]], %[[r25]], %[[arg8]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r34:.*]] = xetile.tile_mma %[[r19]], %[[r26]], %[[r33]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r35:.*]] = xetile.tile_mma %[[r15]], %[[r27]], %[[arg9]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r36:.*]] = xetile.tile_mma %[[r19]], %[[r28]], %[[r35]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r37:.*]] = xetile.tile_mma %[[r16]], %[[r25]], %[[arg10]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r38:.*]] = xetile.tile_mma %[[r20]], %[[r26]], %[[r37]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r39:.*]] = xetile.tile_mma %[[r16]], %[[r27]], %[[arg11]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r40:.*]] = xetile.tile_mma %[[r20]], %[[r28]], %[[r39]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r41:.*]] = xetile.tile_mma %[[r17]], %[[r25]], %[[arg12]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r42:.*]] = xetile.tile_mma %[[r21]], %[[r26]], %[[r41]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r43:.*]] = xetile.tile_mma %[[r17]], %[[r27]], %[[arg13]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r44:.*]] = xetile.tile_mma %[[r21]], %[[r28]], %[[r43]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r45:.*]] = xetile.tile_mma %[[r18]], %[[r25]], %[[arg14]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r46:.*]] = xetile.tile_mma %[[r22]], %[[r26]], %[[r45]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r47:.*]] = xetile.tile_mma %[[r18]], %[[r27]], %[[arg15]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      //CHECK: %[[r48:.*]] = xetile.tile_mma %[[r22]], %[[r28]], %[[r47]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]:  !xetile.tile<32x32xf16>
+      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]:  !xetile.tile<32x32xf16>
+      %c_new_value = xetile.tile_mma %3, %4, %c_value:
+        vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
+      //CHECK: scf.yield %[[r29]], %[[r30]], %[[r31]], %[[r32]], %[[r34]], %[[r36]], %[[r38]], %[[r40]], %[[r42]], %[[r44]], %[[r46]], %[[r48]] : !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>
+      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
+    }
+
+    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r8:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r10:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
+
+    //CHECK: xetile.store_tile %[[r4]]#4,  %[[r5]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#5,  %[[r6]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#6,  %[[r7]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#7,  %[[r8]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#8,  %[[r9]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#9,  %[[r10]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#10,  %[[r11]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#11,  %[[r12]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
+  	gpu.return
+  }
+
   //CHECK-LABEL: gpu.func @sg_gemm_with_preops_for_c
   //CHECK-SAME: (%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
   gpu.func @sg_gemm_with_preops_for_c(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
+    //CHECK: %[[c24:.*]] = arith.constant 24 : index
+    //CHECK: %[[c8:.*]] = arith.constant 8 : index
+    //CHECK: %[[c16:.*]] = arith.constant 16 : index
     //CHECK: %[[c0:.*]] = arith.constant 0 : index
     //CHECK: %[[c32:.*]] = arith.constant 32 : index
     //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x2x8x16xf32>
+    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
+    //CHECK: %[[r0]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r1]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c16]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r2]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r3]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c16]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
+    //CHECK: %[[r4]]:12 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6:.*]] = %[[r2]], %[[arg7:.*]] = %[[r3]], %[[arg8:.*]] = %[[cst]], %[[arg9:.*]] = %[[cst]], %[[arg10:.*]] = %[[cst]], %[[arg11:.*]] = %[[cst]], %[[arg12:.*]] = %[[cst]], %[[arg13:.*]] = %[[cst]], %[[arg14:.*]] = %[[cst]], %[[arg15:.*]] = %[[cst]]) -> (!xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>) {
+    //CHECK:   %[[r13:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+    //CHECK:   %[[r14:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+    //CHECK:   %[[r15:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r16:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r17:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r18:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r19:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r20:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r21:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r22:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
+    //CHECK:   %[[r23:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+    //CHECK:   %[[r24:.*]] = xetile.load_tile %[[arg7]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+    //CHECK:   %[[r25:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+    //CHECK:   %[[r26:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+    //CHECK:   %[[r27:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+    //CHECK:   %[[r28:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
+    //CHECK:   %[[r29:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
+    //CHECK:   %[[r30:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
+    //CHECK:   %[[r31:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
+    //CHECK:   %[[r32:.*]] = xetile.update_tile_offset %[[arg7]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
+    //CHECK:   %[[r33:.*]] = arith.addf %[[arg8]], %[[arg8]] : vector<8x16xf32>
+    //CHECK:   %[[r34:.*]] = arith.addf %[[arg9]], %[[arg9]] : vector<8x16xf32>
+    //CHECK:   %[[r35:.*]] = arith.addf %[[arg10]], %[[arg10]] : vector<8x16xf32>
+    //CHECK:   %[[r36:.*]] = arith.addf %[[arg11]], %[[arg11]] : vector<8x16xf32>
+    //CHECK:   %[[r37:.*]] = arith.addf %[[arg12]], %[[arg12]] : vector<8x16xf32>
+    //CHECK:   %[[r38:.*]] = arith.addf %[[arg13]], %[[arg13]] : vector<8x16xf32>
+    //CHECK:   %[[r39:.*]] = arith.addf %[[arg14]], %[[arg14]] : vector<8x16xf32>
+    //CHECK:   %[[r40:.*]] = arith.addf %[[arg15]], %[[arg15]] : vector<8x16xf32>
+    //CHECK:   %[[r41:.*]] = xetile.tile_mma %[[r15]], %[[r25]], %[[r33]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r42:.*]] = xetile.tile_mma %[[r19]], %[[r26]], %[[r41]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r43:.*]] = xetile.tile_mma %[[r15]], %[[r27]], %[[r34]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r44:.*]] = xetile.tile_mma %[[r19]], %[[r28]], %[[r43]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r45:.*]] = xetile.tile_mma %[[r16]], %[[r25]], %[[r35]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r46:.*]] = xetile.tile_mma %[[r20]], %[[r26]], %[[r45]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r47:.*]] = xetile.tile_mma %[[r16]], %[[r27]], %[[r36]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r48:.*]] = xetile.tile_mma %[[r20]], %[[r28]], %[[r47]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r49:.*]] = xetile.tile_mma %[[r17]], %[[r25]], %[[r37]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r50:.*]] = xetile.tile_mma %[[r21]], %[[r26]], %[[r49]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r51:.*]] = xetile.tile_mma %[[r17]], %[[r27]], %[[r38]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r52:.*]] = xetile.tile_mma %[[r21]], %[[r28]], %[[r51]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r53:.*]] = xetile.tile_mma %[[r18]], %[[r25]], %[[r39]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r54:.*]] = xetile.tile_mma %[[r22]], %[[r26]], %[[r53]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r55:.*]] = xetile.tile_mma %[[r18]], %[[r27]], %[[r40]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   %[[r56:.*]] = xetile.tile_mma %[[r22]], %[[r28]], %[[r55]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
+    //CHECK:   scf.yield %[[r29]], %[[r30]], %[[r31]], %[[r32]], %[[r42]], %[[r44]], %[[r46]], %[[r48]], %[[r50]], %[[r52]], %[[r54]], %[[r56]] : !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>
+    //CHECK: }
+    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r8:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r10:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#4,  %[[r5]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#5,  %[[r6]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#6,  %[[r7]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#7,  %[[r8]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#8,  %[[r9]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#9,  %[[r10]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#10,  %[[r11]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
+    //CHECK: xetile.store_tile %[[r4]]#11,  %[[r12]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
     %c0 = arith.constant 0 : index
     %c32 = arith.constant 32 : index
     %c128 = arith.constant 128 : index
     %cst = arith.constant dense<0.0>: vector<32x32xf32>
-
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
   	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
   	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]]:3 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6:.*]] = %[[cst]]) -> (!xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>) {
     %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
         -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      //CHECK: %[[r7:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[r8:.*]] = xetile.tile_unpack %[[r7]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
       %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[r9:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>> -> vector<1x2x32x16xf16>
-      //CHECK: %[[r10:.*]] = xetile.tile_unpack %[[r9]] {inner_blocks = array<i64: 32, 16>}  : vector<1x2x32x16xf16> -> vector<32x32xf16>
       %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-
-      //CHECK: %[[r11:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]],  %[[c32]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: %[[r12:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c32]],  %[[c0]]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
       %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]:  !xetile.tile<32x32xf16>
       %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]:  !xetile.tile<32x32xf16>
-
-      //CHECK: %[[r15:.*]] = arith.addf %[[arg6]], %[[arg6]] : vector<4x2x8x16xf32>
       %5 = arith.addf %c_value, %c_value: vector<32x32xf32>
-
-      //CHECK: %[[r17:.*]] = xetile.tile_pack %[[r8]] {inner_blocks = array<i64: 8, 16>}  : vector<32x32xf16> -> vector<4x2x8x16xf16>
-      //CHECK: %[[r18:.*]] = xetile.tile_pack %[[r10]] {inner_blocks = array<i64: 16, 16>}  : vector<32x32xf16> -> vector<2x2x16x16xf16>
-      //CHECK: %[[r20:.*]] = xetile.tile_mma %[[r17]], %[[r18]], %[[r15]] : vector<4x2x8x16xf16>, vector<2x2x16x16xf16>, vector<4x2x8x16xf32> -> vector<4x2x8x16xf32>
       %c_new_value = xetile.tile_mma %3, %4, %5: vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-      //CHECK: scf.yield %[[r11]], %[[r12]], %[[r20]] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>, vector<4x2x8x16xf32>
       scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
     }
-
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
   	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-
-    //CHECK: xetile.store_tile %[[r2]]#2,  %[[r4]] : vector<4x2x8x16xf32>, !xetile.tile<32x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
     xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
   	gpu.return
   }
@@ -281,21 +562,52 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_dim_0
   //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_reduction_broadcast_dim_0(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+
+    //CHECK: %[[c24:.*]] = arith.constant 24 : index
+    //CHECK: %[[c16:.*]] = arith.constant 16 : index
+    //CHECK: %[[c8:.*]] = arith.constant 8 : index
+    //CHECK: %[[c32:.*]] = arith.constant 32 : index
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-62: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
     %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R4:.*]] = xetile.reduction <add>, %[[R3]] [0, 2] : vector<32x2x1x32xf16> -> vector<1x2x1x32xf16>
     %3 = xetile.reduction <add>, %2 [0]: vector<32x64xf16> -> vector<1x64xf16>
-    //CHECK: %[[R5:.*]] = xetile.broadcast %[[R4]] [0, 2] : vector<1x2x1x32xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_unpack %[[R5]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
     %4 = xetile.broadcast %3 [0]: vector<1x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     %5 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R8:.*]] = xetile.tile_pack %[[R6]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: xetile.store_tile %[[R8]],  %[[R7]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     xetile.store_tile %4, %5: vector<32x64xf16>, !xetile.tile<32x64xf16>
     gpu.return
   }
@@ -304,21 +616,210 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_dim_1
   //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_reduction_broadcast_dim_1(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+
+    //CHECK: %[[c24:.*]] = arith.constant 24 : index
+    //CHECK: %[[c16:.*]] = arith.constant 16 : index
+    //CHECK: %[[c8:.*]] = arith.constant 8 : index
+    //CHECK: %[[c32:.*]] = arith.constant 32 : index
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
+
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
     %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R4:.*]] = xetile.reduction <add>, %[[R3]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
     %3 = xetile.reduction <add>, %2 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    //CHECK: %[[R5:.*]] = xetile.broadcast %[[R4]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_unpack %[[R5]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
     %4 = xetile.broadcast %3 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    //CHECK: %[[R7:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     %5 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R8:.*]] = xetile.tile_pack %[[R6]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: xetile.store_tile %[[R8]],  %[[R7]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     xetile.store_tile %4, %5: vector<32x64xf16>, !xetile.tile<32x64xf16>
     gpu.return
   }
@@ -327,23 +828,325 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_transpose
   //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_reduction_broadcast_transpose(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK: %[[c56:.*]] = arith.constant 56 : index
+    //CHECK: %[[c48:.*]] = arith.constant 48 : index
+    //CHECK: %[[c40:.*]] = arith.constant 40 : index
+    //CHECK: %[[c24:.*]] = arith.constant 24 : index
+    //CHECK: %[[c16:.*]] = arith.constant 16 : index
+    //CHECK: %[[c8:.*]] = arith.constant 8 : index
+    //CHECK: %[[c31_i32:.*]] = arith.constant 31 : i32
+    //CHECK: %[[c30_i32:.*]] = arith.constant 30 : i32
+    //CHECK: %[[c29_i32:.*]] = arith.constant 29 : i32
+    //CHECK: %[[c28_i32:.*]] = arith.constant 28 : i32
+    //CHECK: %[[c27_i32:.*]] = arith.constant 27 : i32
+    //CHECK: %[[c26_i32:.*]] = arith.constant 26 : i32
+    //CHECK: %[[c25_i32:.*]] = arith.constant 25 : i32
+    //CHECK: %[[c24_i32:.*]] = arith.constant 24 : i32
+    //CHECK: %[[c23_i32:.*]] = arith.constant 23 : i32
+    //CHECK: %[[c22_i32:.*]] = arith.constant 22 : i32
+    //CHECK: %[[c21_i32:.*]] = arith.constant 21 : i32
+    //CHECK: %[[c20_i32:.*]] = arith.constant 20 : i32
+    //CHECK: %[[c19_i32:.*]] = arith.constant 19 : i32
+    //CHECK: %[[c18_i32:.*]] = arith.constant 18 : i32
+    //CHECK: %[[c17_i32:.*]] = arith.constant 17 : i32
+    //CHECK: %[[c16_i32:.*]] = arith.constant 16 : i32
+    //CHECK: %[[c15_i32:.*]] = arith.constant 15 : i32
+    //CHECK: %[[c14_i32:.*]] = arith.constant 14 : i32
+    //CHECK: %[[c13_i32:.*]] = arith.constant 13 : i32
+    //CHECK: %[[c12_i32:.*]] = arith.constant 12 : i32
+    //CHECK: %[[c11_i32:.*]] = arith.constant 11 : i32
+    //CHECK: %[[c10_i32:.*]] = arith.constant 10 : i32
+    //CHECK: %[[c9_i32:.*]] = arith.constant 9 : i32
+    //CHECK: %[[c8_i32:.*]] = arith.constant 8 : i32
+    //CHECK: %[[c7_i32:.*]] = arith.constant 7 : i32
+    //CHECK: %[[c6_i32:.*]] = arith.constant 6 : i32
+    //CHECK: %[[c5_i32:.*]] = arith.constant 5 : i32
+    //CHECK: %[[c4_i32:.*]] = arith.constant 4 : i32
+    //CHECK: %[[c3_i32:.*]] = arith.constant 3 : i32
+    //CHECK: %[[c2_i32:.*]] = arith.constant 2 : i32
+    //CHECK: %[[c1_i32:.*]] = arith.constant 1 : i32
+    //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
+    //CHECK: %[[c32:.*]] = arith.constant 32 : index
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r18:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r19:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r20:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [16, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r21:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [17, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r22:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [18, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r23:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [19, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r24:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [20, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r25:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [21, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r26:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [22, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r27:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [23, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r28:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [24, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r29:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [25, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r30:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [26, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r31:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [27, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r32:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [28, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r33:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [29, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r34:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [30, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r35:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [31, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r36:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r37:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r38:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r39:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r40:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r41:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r42:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r43:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r44:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r45:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r46:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r47:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r48:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r49:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r50:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r51:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r52:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [16, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r53:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [17, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r54:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [18, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r55:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [19, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r56:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [20, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r57:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [21, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r58:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [22, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r59:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [23, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r60:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [24, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r61:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [25, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r62:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [26, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r63:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [27, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r64:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [28, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r65:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [29, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r66:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [30, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r67:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [31, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
+    //CHECK: %[[r68:.*]] = arith.addf %4, %36 : vector<1x32xf16>
+    //CHECK: %[[r69:.*]] = vector.shape_cast %68 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r70:.*]] = arith.addf %5, %37 : vector<1x32xf16>
+    //CHECK: %[[r71:.*]] = vector.shape_cast %70 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r72:.*]] = arith.addf %6, %38 : vector<1x32xf16>
+    //CHECK: %[[r73:.*]] = vector.shape_cast %72 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r74:.*]] = arith.addf %7, %39 : vector<1x32xf16>
+    //CHECK: %[[r75:.*]] = vector.shape_cast %74 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r76:.*]] = arith.addf %8, %40 : vector<1x32xf16>
+    //CHECK: %[[r77:.*]] = vector.shape_cast %76 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r78:.*]] = arith.addf %9, %41 : vector<1x32xf16>
+    //CHECK: %[[r79:.*]] = vector.shape_cast %78 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r80:.*]] = arith.addf %10, %42 : vector<1x32xf16>
+    //CHECK: %[[r81:.*]] = vector.shape_cast %80 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r82:.*]] = arith.addf %11, %43 : vector<1x32xf16>
+    //CHECK: %[[r83:.*]] = vector.shape_cast %82 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r84:.*]] = arith.addf %12, %44 : vector<1x32xf16>
+    //CHECK: %[[r85:.*]] = vector.shape_cast %84 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r86:.*]] = arith.addf %13, %45 : vector<1x32xf16>
+    //CHECK: %[[r87:.*]] = vector.shape_cast %86 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r88:.*]] = arith.addf %14, %46 : vector<1x32xf16>
+    //CHECK: %[[r89:.*]] = vector.shape_cast %88 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r90:.*]] = arith.addf %15, %47 : vector<1x32xf16>
+    //CHECK: %[[r91:.*]] = vector.shape_cast %90 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r92:.*]] = arith.addf %16, %48 : vector<1x32xf16>
+    //CHECK: %[[r93:.*]] = vector.shape_cast %92 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r94:.*]] = arith.addf %17, %49 : vector<1x32xf16>
+    //CHECK: %[[r95:.*]] = vector.shape_cast %94 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r96:.*]] = arith.addf %18, %50 : vector<1x32xf16>
+    //CHECK: %[[r97:.*]] = vector.shape_cast %96 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r98:.*]] = arith.addf %19, %51 : vector<1x32xf16>
+    //CHECK: %[[r99:.*]] = vector.shape_cast %98 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r100:.*]] = arith.addf %20, %52 : vector<1x32xf16>
+    //CHECK: %[[r101:.*]] = vector.shape_cast %100 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r102:.*]] = arith.addf %21, %53 : vector<1x32xf16>
+    //CHECK: %[[r103:.*]] = vector.shape_cast %102 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r104:.*]] = arith.addf %22, %54 : vector<1x32xf16>
+    //CHECK: %[[r105:.*]] = vector.shape_cast %104 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r106:.*]] = arith.addf %23, %55 : vector<1x32xf16>
+    //CHECK: %[[r107:.*]] = vector.shape_cast %106 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r108:.*]] = arith.addf %24, %56 : vector<1x32xf16>
+    //CHECK: %[[r109:.*]] = vector.shape_cast %108 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r110:.*]] = arith.addf %25, %57 : vector<1x32xf16>
+    //CHECK: %[[r111:.*]] = vector.shape_cast %110 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r112:.*]] = arith.addf %26, %58 : vector<1x32xf16>
+    //CHECK: %[[r113:.*]] = vector.shape_cast %112 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r114:.*]] = arith.addf %27, %59 : vector<1x32xf16>
+    //CHECK: %[[r115:.*]] = vector.shape_cast %114 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r116:.*]] = arith.addf %28, %60 : vector<1x32xf16>
+    //CHECK: %[[r117:.*]] = vector.shape_cast %116 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r118:.*]] = arith.addf %29, %61 : vector<1x32xf16>
+    //CHECK: %[[r119:.*]] = vector.shape_cast %118 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r120:.*]] = arith.addf %30, %62 : vector<1x32xf16>
+    //CHECK: %[[r121:.*]] = vector.shape_cast %120 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r122:.*]] = arith.addf %31, %63 : vector<1x32xf16>
+    //CHECK: %[[r123:.*]] = vector.shape_cast %122 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r124:.*]] = arith.addf %32, %64 : vector<1x32xf16>
+    //CHECK: %[[r125:.*]] = vector.shape_cast %124 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r126:.*]] = arith.addf %33, %65 : vector<1x32xf16>
+    //CHECK: %[[r127:.*]] = vector.shape_cast %126 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r128:.*]] = arith.addf %34, %66 : vector<1x32xf16>
+    //CHECK: %[[r129:.*]] = vector.shape_cast %128 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r130:.*]] = arith.addf %35, %67 : vector<1x32xf16>
+    //CHECK: %[[r131:.*]] = vector.shape_cast %130 : vector<1x32xf16> to vector<32xf16>
+    //CHECK: %[[r132:.*]] = vector.shuffle %[[r69]], %[[r71]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r133:.*]] = vector.shuffle %[[r69]], %[[r71]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r134:.*]] = arith.addf %132, %133 : vector<32xf16>
+    //CHECK: %[[r135:.*]] = vector.shuffle %[[r73]], %[[r75]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r136:.*]] = vector.shuffle %[[r73]], %[[r75]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r137:.*]] = arith.addf %135, %136 : vector<32xf16>
+    //CHECK: %[[r138:.*]] = vector.shuffle %[[r77]], %[[r79]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r139:.*]] = vector.shuffle %[[r77]], %[[r79]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r140:.*]] = arith.addf %138, %139 : vector<32xf16>
+    //CHECK: %[[r141:.*]] = vector.shuffle %[[r81]], %[[r83]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r142:.*]] = vector.shuffle %[[r81]], %[[r83]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r143:.*]] = arith.addf %141, %142 : vector<32xf16>
+    //CHECK: %[[r144:.*]] = vector.shuffle %[[r85]], %[[r87]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r145:.*]] = vector.shuffle %[[r85]], %[[r87]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r146:.*]] = arith.addf %144, %145 : vector<32xf16>
+    //CHECK: %[[r147:.*]] = vector.shuffle %[[r89]], %[[r91]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r148:.*]] = vector.shuffle %[[r89]], %[[r91]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r149:.*]] = arith.addf %147, %148 : vector<32xf16>
+    //CHECK: %[[r150:.*]] = vector.shuffle %[[r93]], %[[r95]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r151:.*]] = vector.shuffle %[[r93]], %[[r95]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r152:.*]] = arith.addf %150, %151 : vector<32xf16>
+    //CHECK: %[[r153:.*]] = vector.shuffle %[[r97]], %[[r99]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r154:.*]] = vector.shuffle %[[r97]], %[[r99]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r155:.*]] = arith.addf %153, %154 : vector<32xf16>
+    //CHECK: %[[r156:.*]] = vector.shuffle %[[r101]], %[[r103]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r157:.*]] = vector.shuffle %[[r101]], %[[r103]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r158:.*]] = arith.addf %156, %157 : vector<32xf16>
+    //CHECK: %[[r159:.*]] = vector.shuffle %[[r105]], %[[r107]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r160:.*]] = vector.shuffle %[[r105]], %[[r107]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r161:.*]] = arith.addf %159, %160 : vector<32xf16>
+    //CHECK: %[[r162:.*]] = vector.shuffle %[[r109]], %[[r111]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r163:.*]] = vector.shuffle %[[r109]], %[[r111]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r164:.*]] = arith.addf %162, %163 : vector<32xf16>
+    //CHECK: %[[r165:.*]] = vector.shuffle %[[r113]], %[[r115]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r166:.*]] = vector.shuffle %[[r113]], %[[r115]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r167:.*]] = arith.addf %165, %166 : vector<32xf16>
+    //CHECK: %[[r168:.*]] = vector.shuffle %[[r117]], %[[r119]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r169:.*]] = vector.shuffle %[[r117]], %[[r119]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r170:.*]] = arith.addf %168, %169 : vector<32xf16>
+    //CHECK: %[[r171:.*]] = vector.shuffle %[[r121]], %[[r123]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r172:.*]] = vector.shuffle %[[r121]], %[[r123]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r173:.*]] = arith.addf %171, %172 : vector<32xf16>
+    //CHECK: %[[r174:.*]] = vector.shuffle %[[r125]], %[[r127]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r175:.*]] = vector.shuffle %[[r125]], %[[r127]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r176:.*]] = arith.addf %174, %175 : vector<32xf16>
+    //CHECK: %[[r177:.*]] = vector.shuffle %[[r129]], %[[r131]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r178:.*]] = vector.shuffle %[[r129]], %[[r131]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r179:.*]] = arith.addf %177, %178 : vector<32xf16>
+    //CHECK: %[[r180:.*]] = vector.shuffle %[[r134]], %[[r137]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r181:.*]] = vector.shuffle %[[r134]], %[[r137]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r182:.*]] = arith.addf %180, %181 : vector<32xf16>
+    //CHECK: %[[r183:.*]] = vector.shuffle %[[r140]], %[[r143]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r184:.*]] = vector.shuffle %[[r140]], %[[r143]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r185:.*]] = arith.addf %183, %184 : vector<32xf16>
+    //CHECK: %[[r186:.*]] = vector.shuffle %[[r146]], %[[r149]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r187:.*]] = vector.shuffle %[[r146]], %[[r149]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r188:.*]] = arith.addf %186, %187 : vector<32xf16>
+    //CHECK: %[[r189:.*]] = vector.shuffle %[[r152]], %[[r155]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r190:.*]] = vector.shuffle %[[r152]], %[[r155]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r191:.*]] = arith.addf %189, %190 : vector<32xf16>
+    //CHECK: %[[r192:.*]] = vector.shuffle %[[r158]], %[[r161]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r193:.*]] = vector.shuffle %[[r158]], %[[r161]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r194:.*]] = arith.addf %192, %193 : vector<32xf16>
+    //CHECK: %[[r195:.*]] = vector.shuffle %[[r164]], %[[r167]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r196:.*]] = vector.shuffle %[[r164]], %[[r167]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r197:.*]] = arith.addf %195, %196 : vector<32xf16>
+    //CHECK: %[[r198:.*]] = vector.shuffle %[[r170]], %[[r173]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r199:.*]] = vector.shuffle %[[r170]], %[[r173]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r200:.*]] = arith.addf %198, %199 : vector<32xf16>
+    //CHECK: %[[r201:.*]] = vector.shuffle %[[r176]], %[[r179]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r202:.*]] = vector.shuffle %[[r176]], %[[r179]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r203:.*]] = arith.addf %201, %202 : vector<32xf16>
+    //CHECK: %[[r204:.*]] = vector.shuffle %[[r182]], %[[r185]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r205:.*]] = vector.shuffle %[[r182]], %[[r185]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r206:.*]] = arith.addf %204, %205 : vector<32xf16>
+    //CHECK: %[[r207:.*]] = vector.shuffle %[[r188]], %[[r191]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r208:.*]] = vector.shuffle %[[r188]], %[[r191]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r209:.*]] = arith.addf %207, %208 : vector<32xf16>
+    //CHECK: %[[r210:.*]] = vector.shuffle %[[r194]], %[[r197]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r211:.*]] = vector.shuffle %[[r194]], %[[r197]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r212:.*]] = arith.addf %210, %211 : vector<32xf16>
+    //CHECK: %[[r213:.*]] = vector.shuffle %[[r200]], %[[r203]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r214:.*]] = vector.shuffle %[[r200]], %[[r203]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r215:.*]] = arith.addf %213, %214 : vector<32xf16>
+    //CHECK: %[[r216:.*]] = vector.shuffle %[[r206]], %[[r209]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r217:.*]] = vector.shuffle %[[r206]], %[[r209]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r218:.*]] = arith.addf %216, %217 : vector<32xf16>
+    //CHECK: %[[r219:.*]] = vector.shuffle %[[r212]], %[[r215]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r220:.*]] = vector.shuffle %[[r212]], %[[r215]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r221:.*]] = arith.addf %219, %220 : vector<32xf16>
+    //CHECK: %[[r222:.*]] = vector.shuffle %[[r218]], %[[r221]] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r223:.*]] = vector.shuffle %[[r218]], %[[r221]] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %[[r224:.*]] = arith.addf %222, %223 : vector<32xf16>
+
+    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x8xf16>
+
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
+
+    //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<32x8xf16> -> vector<8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
     %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R4:.*]] = xetile.reduction <add>, %[[R3]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
     %3 = xetile.reduction <add>, %2 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    //CHECK: %[[R5:.*]] = xetile.broadcast %[[R4]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x8x1x8xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_unpack %[[R5]] {inner_blocks = array<i64: 1, 8>} : vector<32x8x1x8xf16> -> vector<32x64xf16>
     %4 = xetile.broadcast %3 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    //CHECK: %[[R7:.*]] = xetile.tile_pack %[[R6]] {inner_blocks = array<i64: 32, 8>} : vector<32x64xf16> -> vector<1x8x32x8xf16>
-    //CHECK: %[[R8:.*]] = xetile.transpose %[[R7]], [1, 0, 3, 2] : vector<1x8x32x8xf16> -> vector<8x1x8x32xf16>
     %5 = xetile.transpose %4, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
-    //CHECK: %[[R9:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     %6 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
-    //CHECK: xetile.store_tile %[[R8]],  %[[R9]] : vector<8x1x8x32xf16>, !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     xetile.store_tile %5, %6: vector<64x32xf16>, !xetile.tile<64x32xf16>
     gpu.return
   }
@@ -352,58 +1155,125 @@ gpu.module @test_kernel {
   //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_softmax_dim_0(%a: memref<1024x1024xf16>) {
 
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
     %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-    //CHECK: %[[R2:.*]] = xetile.tile_unpack %[[R1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
+
+    //CHECK-COUNT-2: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x32xf16> -> vector<32x32xf16>
     %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R3:.*]] = xetile.tile_pack %[[R2]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: %[[R4:.*]] = math.exp %[[R3]] : vector<4x2x8x32xf16>
-    //CHECK: %[[R5:.*]] = xetile.tile_unpack %[[R4]] {inner_blocks = array<i64: 8, 32>}  : vector<4x2x8x32xf16> -> vector<32x64xf16>
+
+    //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x32xf16>
     %3 = math.exp %2: vector<32x64xf16>
-    //CHECK: %[[R6:.*]] = xetile.tile_pack %[[R5]] {inner_blocks = array<i64: 1, 32>}  : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R7:.*]] = xetile.reduction <add>, %[[R6]] [0, 2] : vector<32x2x1x32xf16> -> vector<1x2x1x32xf16>
+
+    //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<8x32xf16> to vector<1x32xf16>
+    //CHECK-COUNT-62: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
     %4 = xetile.reduction <add>, %3 [0]: vector<32x64xf16> -> vector<1x64xf16>
-    //CHECK: %[[R8:.*]] = xetile.broadcast %[[R7]] [0, 2] : vector<1x2x1x32xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[R9:.*]] = xetile.tile_unpack %[[R8]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
     %5 = xetile.broadcast %4 [0]: vector<1x64xf16> -> vector<32x64xf16>
-    //CHECK: %[[R10:.*]] = xetile.tile_pack %[[R9]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: %[[R11:.*]] = arith.divf %[[R4]], %[[R10]] : vector<4x2x8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<8x32xf16>
     %6 = arith.divf %3, %5: vector<32x64xf16>
-    //CHECK: %[[R12:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
     %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: xetile.store_tile %[[R11]],  %[[R12]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
     gpu.return
   }
 
   //CHECK: (%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_softmax_dim_1(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>>
+    //CHECK: %[[c32:.*]] = arith.constant 32 : index
+    //CHECK: %[[c0:.*]] = arith.constant 0 : index
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x32xf16>
+    //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<8x32xf16> to vector<1x32xf16>
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
+    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
+
+    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
+
+    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 32]>> -> vector<1x2x32x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.tile_unpack %[[r1]] {inner_blocks = array<i64: 32, 32>}  : vector<1x2x32x32xf16> -> vector<32x64xf16>
     %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-
-    //CHECK: %[[r3:.*]] = xetile.tile_pack %[[r2]] {inner_blocks = array<i64: 8, 32>} : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: %[[r4:.*]] = math.exp %[[r3]] : vector<4x2x8x32xf16>
     %3 = math.exp %2: vector<32x64xf16>
-
-    //CHECK: %[[r5:.*]] = xetile.tile_unpack %[[r4]] {inner_blocks = array<i64: 8, 32>} : vector<4x2x8x32xf16> -> vector<32x64xf16>
-    //CHECK: %[[r6:.*]] = xetile.tile_pack %[[r5]] {inner_blocks = array<i64: 1, 32>} : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[r7:.*]] = xetile.reduction <add>, %[[r6]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
     %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    //CHECK: %[[r8:.*]] = xetile.broadcast %[[r7]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[r9:.*]] = xetile.tile_unpack %[[r8]] {inner_blocks = array<i64: 1, 32>} : vector<32x2x1x32xf16> -> vector<32x64xf16>
     %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-
-    //CHECK: %[[r10:.*]] = xetile.tile_pack %[[r9]] {inner_blocks = array<i64: 8, 32>} : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: %[[r11:.*]] = arith.divf %[[r4]], %[[r10]] : vector<4x2x8x32xf16>
     %6 = arith.divf %3, %5: vector<32x64xf16>
-    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK: xetile.store_tile %[[r11]],  %[[r12]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
     gpu.return
   }
@@ -411,39 +1281,35 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @sglevel_softmax_transpose
   //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
   gpu.func @sglevel_softmax_transpose(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 8]>>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
 
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [32, 8]>> -> vector<1x8x32x8xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
 
-    //CHECK: %[[r2:.*]] = math.exp %[[r1]] : vector<1x8x32x8xf16>
-    //CHECK: %[[r3:.*]] = xetile.tile_unpack %[[r2]] {inner_blocks = array<i64: 32, 8>} : vector<1x8x32x8xf16> -> vector<32x64xf16>
-    %3 = math.exp %2: vector<32x64xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
+    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x8xf16>
 
-    //CHECK: %[[r4:.*]] = xetile.tile_pack %[[r3]] {inner_blocks = array<i64: 1, 32>} : vector<32x64xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[r5:.*]] = xetile.reduction <add>, %[[r4]] [1, 3] : vector<32x2x1x32xf16> -> vector<32x1x1x1xf16>
-    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
+    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
 
-    //CHECK: %[[r6:.*]] = xetile.broadcast %[[r5]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x8x1x8xf16>
-    //CHECK: %[[r7:.*]] = xetile.tile_unpack %[[r6]] {inner_blocks = array<i64: 1, 8>} : vector<32x8x1x8xf16> -> vector<32x64xf16>
+    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<32x8xf16>
+    //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<32x8xf16> -> vector<8x32xf16>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
+    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
+    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
+    %3 = math.exp %2: vector<32x64xf16>
+    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
     %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-
-    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r7]] {inner_blocks = array<i64: 32, 8>} : vector<32x64xf16> -> vector<1x8x32x8xf16>
-    //CHECK: %[[r9:.*]] = arith.divf %[[r2]], %[[r8]] : vector<1x8x32x8xf16>
     %6 = arith.divf %3, %5: vector<32x64xf16>
-
-    //CHECK: %[[r10:.*]] = xetile.transpose %[[r9]], [1, 0, 3, 2] : vector<1x8x32x8xf16> -> vector<8x1x8x32xf16>
     %7 = xetile.transpose %6, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
-
-    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     %8 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
-
-    //CHECK: xetile.store_tile %[[r10]],  %[[r11]] : vector<8x1x8x32xf16>, !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     xetile.store_tile %7, %8: vector<64x32xf16>, !xetile.tile<64x32xf16>
     gpu.return
   }
 
+  //CHECK-LABEL: gpu.func @sglevel_unregular_gemm
+  //CHECK-SAME: %[[arg0:.*]]: memref<16384x12288xf16>, %[[arg1:.*]]: memref<1536x12288xf16>, %[[arg2:.*]]: memref<16384x1536xf32>
   gpu.func @sglevel_unregular_gemm(%arg0: memref<16384x12288xf16>, %arg1: memref<1536x12288xf16>, %arg2: memref<16384x1536xf32>) attributes {gemm_tiles_b = 1 : i64, gemm_tiles_x = dense<[8, 2, 4, 8]> : vector<4xi64>, gemm_tiles_y = dense<[1, 1, 8, 4]> : vector<4xi64>, physical_nd_range = dense<[8, 32]> : vector<2xi64>, region_partition = 0 : i64, region_size = 32 : i64, syn.fusion_successful, syn.tensor_signature = (tensor<16384x12288xf16>, tensor<1536x12288xf16>) -> tensor<16384x1536xf32>, synFusionGenOps = 6 : i64, synFusionRequiredBeamSize = 1 : i64, synFusionTotalCost = 1007562515.4 : f64} {
     %c64 = arith.constant 64 : index
     %cst = arith.constant dense<0.000000e+00> : vector<32x64xf32>
@@ -474,9 +1340,22 @@ gpu.module @test_kernel {
     %12 = index.remu %8, %c4
     %13 = index.mul %12, %c64
     %14 = index.add %2, %13
+
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
+
     %15 = xetile.init_tile %arg2[%11, %14] : memref<16384x1536xf32> -> !xetile.tile<32x64xf32>
     %16 = index.remu %8, %c1
     %17 = index.mul %16, %c32
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
+    //CHECK: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
+    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
+    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
     %18 = xetile.init_tile %arg0[%11, %17] : memref<16384x12288xf16> -> !xetile.tile<32x32xf16>
     %19 = index.floordivs %6, %c8
     %20 = index.remu %6, %c8
@@ -485,84 +1364,115 @@ gpu.module @test_kernel {
     %23 = index.add %2, %22
     %24 = index.remu %20, %c1
     %25 = index.mul %24, %c32
-
-    // CHECK: xetile.init_tile %{{.*}} : memref<1536x12288xf16> -> !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [16, 16]>>
+    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
     %26 = xetile.init_tile %arg1[%23, %25] : memref<1536x12288xf16> -> !xetile.tile<64x32xf16>
     %27:2 = scf.for %arg15 = %c0 to %c2 step %c1 iter_args(%arg16 = %15, %arg17 = %18) -> (!xetile.tile<32x64xf32>, !xetile.tile<32x32xf16>) {
-      //CHECK: xetile.update_tile_offset %{{.*}}, [%c1024,  %c0] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
-      //CHECK: xetile.update_tile_offset %{{.*}}, [%c1024,  %c0] : !xetile.tile<32x64xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
+      //CHECK-COUNT-2: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
+      //CHECK-COUNT-16: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<8x16xf32>
       %28 = xetile.update_tile_offset %arg17, [%c1024,  %c0] :  !xetile.tile<32x32xf16>
       %29 = xetile.update_tile_offset %arg16, [%c1024,  %c0] : !xetile.tile<32x64xf32>
+      //CHECK: %{{.*}}:26 = scf.for %[[arg22:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args({{.*}}) -> (vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>) {
       %30:3 = scf.for %arg18 = %c0 to %c12288 step %c32 iter_args(%arg19 = %cst, %arg20 = %arg17, %arg21 = %26) -> (vector<32x64xf32>, !xetile.tile<32x32xf16>, !xetile.tile<64x32xf16>) {
-        //CHECK: xetile.update_tile_offset %{{.*}}, [%c0,  %c32] : !xetile.tile<64x32xf16, #xetile.tile_attr<inner_blocks = [16, 16]>>
-        //CHECK: xetile.update_tile_offset %{{.*}}, [%c0,  %c32] : !xetile.tile<32x32xf16, #xetile.tile_attr<inner_blocks = [32, 16]>>
+        //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<16x16xf16>
+        //CHECK-COUNT-2: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
         %32 = xetile.update_tile_offset %arg21, [%c0,  %c32] : !xetile.tile<64x32xf16>
         %33 = xetile.update_tile_offset %arg20, [%c0,  %c32] :  !xetile.tile<32x32xf16>
+        //CHECK-COUNT-2: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
+        //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
         %34 = xetile.load_tile %arg20 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xf16> -> vector<32x32xf16>
+        //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x16xf16>
         %35 = math.exp %34 : vector<32x32xf16>
+        //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<16x16xf16> -> vector<16x16xf16>
         %36 = xetile.load_tile %arg21 {padding = 0.000000e+00 : f32}  : !xetile.tile<64x32xf16> -> vector<64x32xf16>
+        //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<16x16xf16> -> vector<16x16xf16>
         %37 = xetile.transpose %36, [1, 0] : vector<64x32xf16> -> vector<32x64xf16>
+        //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<16x16xf16>
         %38 = math.exp %37 : vector<32x64xf16>
+        //CHECK: xegpu.compile_hint
         xegpu.compile_hint
+        //CHECK-COUNT-32: %{{.*}} = xetile.tile_mma %{{.*}}, %{{.*}}, %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
         %39 = xetile.tile_mma %35, %38, %cst : vector<32x32xf16>, vector<32x64xf16>, vector<32x64xf32> -> vector<32x64xf32>
+        //CHECK: xegpu.compile_hint
         xegpu.compile_hint
+        //CHECK-COUNT-16: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<8x16xf32>
         %40 = arith.addf %arg19, %39 : vector<32x64xf32>
         scf.yield %40, %33, %32 : vector<32x64xf32>, !xetile.tile<32x32xf16>, !xetile.tile<64x32xf16>
       }
+      //CHECK-COUNT-16: %{{.*}} = math.exp %{{.*}} : vector<8x16xf32>
       %31 = math.exp %30#0 : vector<32x64xf32>
+      //CHECK-COUNT-16: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
       xetile.store_tile %31,  %arg16 : vector<32x64xf32>, !xetile.tile<32x64xf32>
       scf.yield %29, %28 : !xetile.tile<32x64xf32>, !xetile.tile<32x32xf16>
     }
     gpu.return
   }
 
+  //CHECK-LABEL: gpu.func @sglevel_transpose_broadcast_dim_0
+  //CHECK-SAME(%[[arg0:.*]]: memref<384x1xf32>, %[[arg1:.*]]: memref<256x384xf32>)
   gpu.func @sglevel_transpose_broadcast_dim_0(%arg0: memref<384x1xf32>, %arg1: memref<256x384xf32>) {
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][{{.*}}] : memref<384x1xf32> -> !xetile.tile<16x1xf32>
+    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][{{.*}}] : memref<384x1xf32> -> !xetile.tile<16x1xf32>
     %1 = xetile.init_tile %arg0[0, 0] : memref<384x1xf32> -> !xetile.tile<32x1xf32>
+    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32} : !xetile.tile<16x1xf32> -> vector<16x1xf32>
+    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] {padding = 0.000000e+00 : f32} : !xetile.tile<16x1xf32> -> vector<16x1xf32>
     %2 = xetile.load_tile %1 {padding = 0.000000e+00 : f32} : !xetile.tile<32x1xf32> -> vector<32x1xf32>
+    //CHECK: %[[r4:.*]] = xetile.transpose %[[r2]], [1, 0] : vector<16x1xf32> -> vector<1x16xf32>
+    //CHECK: %[[r5:.*]] = xetile.transpose %[[r3]], [1, 0] : vector<16x1xf32> -> vector<1x16xf32>
     %3 = xetile.transpose %2, [1, 0] : vector<32x1xf32> -> vector<1x32xf32>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x16xf32>, vector<1x16xf32>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x16xf32>, vector<2x16xf32>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x16xf32>, vector<4x16xf32>
     %4 = xetile.broadcast %3 [0] : vector<1x32xf32> -> vector<64x32xf32>
+
+    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<256x384xf32> -> !xetile.tile<8x16xf32>
     %5 = xetile.init_tile %arg1[0, 0] : memref<256x384xf32> -> !xetile.tile<64x32xf32>
+    //CHECK-COUNT-16: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
     xetile.store_tile %4, %5 : vector<64x32xf32>, !xetile.tile<64x32xf32>
-
-    //CHECK: %[[r0:.*]] = xetile.init_tile %{{.*}}[0, 0] : memref<384x1xf32> -> !xetile.tile<32x1xf32, #xetile.tile_attr<inner_blocks = [16, 1]>>
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32}  : !xetile.tile<32x1xf32, #xetile.tile_attr<inner_blocks = [16, 1]>> -> vector<2x1x16x1xf32>
-    //CHECK: %[[r2:.*]] = xetile.transpose %[[r1]], [1, 0, 3, 2] : vector<2x1x16x1xf32> -> vector<1x2x1x16xf32>
-    //CHECK: %[[r3:.*]] = xetile.broadcast %[[r2]] [0, 2] : vector<1x2x1x16xf32> -> vector<64x2x1x16xf32>
-    //CHECK: %[[r4:.*]] = xetile.tile_unpack %[[r3]] {inner_blocks = array<i64: 1, 16>}  : vector<64x2x1x16xf32> -> vector<64x32xf32>
-    //CHECK: %[[r5:.*]] = xetile.init_tile %{{.*}}[0, 0] : memref<256x384xf32> -> !xetile.tile<64x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
-    //CHECK: %[[r6:.*]] = xetile.tile_pack %[[r4]] {inner_blocks = array<i64: 8, 16>}  : vector<64x32xf32> -> vector<8x2x8x16xf32>
-    //CHECK: xetile.store_tile %[[r6]],  %[[r5]] : vector<8x2x8x16xf32>, !xetile.tile<64x32xf32, #xetile.tile_attr<inner_blocks = [8, 16]>>
     gpu.return
   }
 
   gpu.func @sglevel_transpose_broadcast_dim_1(%arg0: memref<1x384xf16>, %arg1: memref<384x256xf16>) {
+
+    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1x384xf16> -> !xetile.tile<1x32xf16>
+    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32} : !xetile.tile<1x32xf16> -> vector<1x32xf16>
+    //CHECK: %[[r2:.*]] = xetile.transpose %[[r1]], [1, 0] : vector<1x32xf16> -> vector<32x1xf16>
     %1 = xetile.init_tile %arg0[0, 0] : memref<1x384xf16> -> !xetile.tile<1x32xf16>
     %2 = xetile.load_tile %1 {padding = 0.000000e+00 : f32} : !xetile.tile<1x32xf16> -> vector<1x32xf16>
     %3 = xetile.transpose %2, [1, 0] : vector<1x32xf16> -> vector<32x1xf16>
+
+    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}, 0], sizes = [1, 1], strides = [1, 1]} : vector<32x1xf16> to vector<1x1xf16>
+
+    //CHECK: %{{.*}} = vector.extract %{{.*}}[0, 0] : f16 from vector<1x1xf16>
+    //CHECK: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
+
+    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
+    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
+    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
     %4 = xetile.broadcast %3 [1] : vector<32x1xf16> -> vector<32x64xf16>
+    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<384x256xf16> -> !xetile.tile<8x32xf16>
     %5 = xetile.init_tile %arg1[0, 0] : memref<384x256xf16> -> !xetile.tile<32x64xf16>
+    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
     xetile.store_tile %4, %5 : vector<32x64xf16>, !xetile.tile<32x64xf16>
-
-    //CHECK: %[[r0:.*]] = xetile.init_tile %{{.*}}[0, 0] : memref<1x384xf16> -> !xetile.tile<1x32xf16, #xetile.tile_attr<inner_blocks = [1, 32]>>
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32}  : !xetile.tile<1x32xf16, #xetile.tile_attr<inner_blocks = [1, 32]>> -> vector<1x1x1x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.transpose %[[r1]], [1, 0, 3, 2] : vector<1x1x1x32xf16> -> vector<1x1x32x1xf16>
-    //CHECK: %[[r3:.*]] = xetile.tile_unpack %[[r2]] {inner_blocks = array<i64: 32, 1>}  : vector<1x1x32x1xf16> -> vector<32x1xf16>
-    //CHECK: %[[r4:.*]] = xetile.tile_pack %[[r3]] {inner_blocks = array<i64: 1, 1>}  : vector<32x1xf16> -> vector<32x1x1x1xf16>
-    //CHECK: %[[r5:.*]] = xetile.broadcast %[[r4]] [1, 3] : vector<32x1x1x1xf16> -> vector<32x2x1x32xf16>
-    //CHECK: %[[r6:.*]] = xetile.tile_unpack %[[r5]] {inner_blocks = array<i64: 1, 32>}  : vector<32x2x1x32xf16> -> vector<32x64xf16>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %{{.*}}[0, 0] : memref<384x256xf16> -> !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
-    //CHECK: %[[r8:.*]] = xetile.tile_pack %[[r6]] {inner_blocks = array<i64: 8, 32>}  : vector<32x64xf16> -> vector<4x2x8x32xf16>
-    //CHECK: xetile.store_tile %[[r8]],  %[[r7]] : vector<4x2x8x32xf16>, !xetile.tile<32x64xf16, #xetile.tile_attr<inner_blocks = [8, 32]>>
     gpu.return
   }
 
   //CHECK-LABEL: gpu.func @sg_loadgather
   //CHECK-SAME: %[[arg0:.*]]: memref<1024xf16>, %[[arg1:.*]]: vector<4x32xindex>
   gpu.func @sg_loadgather(%a: memref<1024xf16>, %indices: vector<4x32xindex>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<4x1x1x32xi1>
-    //CHECK: %[[r0:.*]] = xetile.tile_pack %[[arg1]] {inner_blocks = array<i64: 1, 32>} : vector<4x32xindex> -> vector<4x1x1x32xindex>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<4x1x1x32xindex> -> !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>
-    //CHECK: %[[r2:.*]] = xetile.load %[[r1]], %[[cst]] : !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>, vector<4x1x1x32xi1> -> vector<4x1x1x32xf16>
+    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<1x32xi1>
+    //CHECK: %[[r0:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r1:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]], %[[r1]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]], %[[r2]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg0]], %[[r3]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r8:.*]] = xetile.load %[[r4]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
+    //CHECK: %[[r9:.*]] = xetile.load %[[r5]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
+    //CHECK: %[[r10:.*]] = xetile.load %[[r6]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
+    //CHECK: %[[r11:.*]] = xetile.load %[[r7]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
     %mask = arith.constant dense<1> : vector<4x32xi1>
     %1 = xetile.init_tile %a, %indices : memref<1024xf16>, vector<4x32xindex> -> !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>
     %2 = xetile.load %1, %mask : !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>, vector<4x32xi1> -> vector<4x32xf16>
@@ -572,15 +1482,29 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @sg_storescatter
   //CHECK-SAME: %[[arg0:.*]]: memref<1024xf16>, %[[arg1:.*]]: vector<4x32xindex>
   gpu.func @sg_storescatter(%a: memref<1024xf16>, %indices: vector<4x32xindex>) {
-
-    //CHECK: %[[cst:.*]] = arith.constant dense<4.200000e+01> : vector<4x1x1x32xf16>
-    //CHECK: %[[cst_0:.*]] = arith.constant dense<true> : vector<4x1x1x32xi1>
-    //CHECK: %[[cst_1:.*]] = arith.constant dense<1> : vector<4x1x1x32xindex>
-    //CHECK: %[[r0:.*]] = xetile.tile_pack %[[arg1]] {inner_blocks = array<i64: 1, 32>} : vector<4x32xindex> -> vector<4x1x1x32xindex>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<4x1x1x32xindex> -> !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>
-    //CHECK: xetile.store %[[cst]], %[[r1]], %[[cst_0]] : vector<4x1x1x32xf16>, !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>, vector<4x1x1x32xi1>
-    //CHECK: %[[r2]] = xetile.update_tile_offset %[[r1]], %[[cst_1]] : !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>, vector<4x1x1x32xindex>
-    //CHECK: xetile.store %[[cst]], %[[r2]], %[[cst_0]] : vector<4x1x1x32xf16>, !xetile.tile<4x32xf16, #xetile.tile_attr<inner_blocks = [1, 32], scattered = true>>, vector<4x1x1x32xi1>
+    //CHECK: %[[cst:.*]] = arith.constant dense<4.200000e+01> : vector<1x32xf16>
+    //CHECK: %[[cst_0:.*]] = arith.constant dense<true> : vector<1x32xi1>
+    //CHECK: %[[cst_1:.*]] = arith.constant dense<1> : vector<1x32xindex>
+    //CHECK: %[[r0:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r1:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
+    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]], %[[r1]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]], %[[r2]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg0]], %[[r3]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
+    //CHECK: xetile.store %[[cst]], %[[r4]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r5]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r6]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r7]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: %[[r8:.*]] = xetile.update_tile_offset %[[r4]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
+    //CHECK: %[[r9:.*]] = xetile.update_tile_offset %[[r5]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
+    //CHECK: %[[r10:.*]] = xetile.update_tile_offset %[[r6]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
+    //CHECK: %[[r11:.*]] = xetile.update_tile_offset %[[r7]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
+    //CHECK: xetile.store %[[cst]], %[[r8]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r9]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r10]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
+    //CHECK: xetile.store %[[cst]], %[[r11]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
     %offsets = arith.constant dense<1> : vector<4x32xindex>
     %mask = arith.constant dense<1> : vector<4x32xi1>
     %data = arith.constant dense<42.0> : vector<4x32xf16>
@@ -594,21 +1518,31 @@ gpu.module @test_kernel {
   //CHECK-LABEL: gpu.func @add_kernel
   //CHECK-SAME: %[[arg0:.*]]: memref<*xf32>, %[[arg1:.*]]: memref<*xf32>, %[[arg2:.*]]: memref<*xf32>
   gpu.func @add_kernel(%arg0: memref<*xf32>, %arg1: memref<*xf32>, %arg2: memref<*xf32>) {
+
     //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<1x2x1x16xi1>
-    //CHECK: %[[cast:.*]] = memref.cast %[[arg0:.*]] : memref<*xf32> to memref<?xf32>
-    //CHECK: %[[cast_0:.*]] = memref.cast %[[arg1:.*]] : memref<*xf32> to memref<?xf32>
-    //CHECK: %[[cast_1:.*]] = memref.cast %[[arg2:.*]] : memref<*xf32> to memref<?xf32>
+    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<1x16xi1>
+    //CHECK: %[[cast:.*]] = memref.cast %[[arg0]] : memref<*xf32> to memref<?xf32>
+    //CHECK: %[[cast_0:.*]] = memref.cast %[[arg1]] : memref<*xf32> to memref<?xf32>
+    //CHECK: %[[cast_1:.*]] = memref.cast %[[arg2]] : memref<*xf32> to memref<?xf32>
     //CHECK: %[[block_id_x:.*]] = gpu.block_id  x
-    //CHECK: %[[r0:.*]] = arith.muli %[[block_id_x]], %c1024 : index
-    //CHECK: %[[r1:.*]] = vector.splat %[[r0]] : vector<1x2x1x16xindex>
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[cast]], %[[r1]] : memref<?xf32>, vector<1x2x1x16xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>
-    //CHECK: %[[r3:.*]] = xetile.load %[[r2]], %[[cst]] : !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>, vector<1x2x1x16xi1> -> vector<1x2x1x16xf32>
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[cast_0]], %[[r1]] : memref<?xf32>, vector<1x2x1x16xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>
-    //CHECK: %[[r5:.*]] = xetile.load %[[r4]], %[[cst]] : !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>, vector<1x2x1x16xi1> -> vector<1x2x1x16xf32>
-    //CHECK: %[[r6:.*]] = arith.addf %[[r3]], %[[r5]] : vector<1x2x1x16xf32>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[cast_1]], %[[r1]] : memref<?xf32>, vector<1x2x1x16xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>
-    //CHECK: xetile.store %[[r6]], %[[r7]], %[[cst]] : vector<1x2x1x16xf32>, !xetile.tile<1x32xf32, #xetile.tile_attr<inner_blocks = [1, 16], scattered = true>>, vector<1x2x1x16xi1>
+    //CHECK: %[[r0:.*]] = arith.muli %[[block_id_x]], %[[c1024]] : index
+    //CHECK: %[[r1:.*]] = vector.splat %[[r0]] : vector<1x32xindex>
+    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 16], strides = [1, 1]} : vector<1x32xindex> to vector<1x16xindex>
+    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 16], sizes = [1, 16], strides = [1, 1]} : vector<1x32xindex> to vector<1x16xindex>
+    //CHECK: %[[r4:.*]] = xetile.init_tile %[[cast]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r5:.*]] = xetile.init_tile %[[cast]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r6:.*]] = xetile.load %[[r4]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
+    //CHECK: %[[r7:.*]] = xetile.load %[[r5]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
+    //CHECK: %[[r8:.*]] = xetile.init_tile %[[cast_0]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r9:.*]] = xetile.init_tile %[[cast_0]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r10:.*]] = xetile.load %[[r8]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
+    //CHECK: %[[r11:.*]] = xetile.load %[[r9]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
+    //CHECK: %[[r12:.*]] = arith.addf %[[r6]], %[[r10]] : vector<1x16xf32>
+    //CHECK: %[[r13:.*]] = arith.addf %[[r7]], %[[r11]] : vector<1x16xf32>
+    //CHECK: %[[r14:.*]] = xetile.init_tile %[[cast_1]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: %[[r15:.*]] = xetile.init_tile %[[cast_1]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
+    //CHECK: xetile.store %[[r12]], %[[r14]], %[[cst]] : vector<1x16xf32>, !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1>
+    //CHECK: xetile.store %[[r13]], %[[r15]], %[[cst]] : vector<1x16xf32>, !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1>
 
     %cst = arith.constant dense<true> : vector<1x32xi1>
     %c1024 = arith.constant 1024 : index
diff --git a/test/Dialect/XeTile/Transforms/Blocking/unit_tests_transform.mlir b/test/Dialect/XeTile/Transforms/Blocking/unit_tests_transform.mlir
deleted file mode 100644
index a30b7b283..000000000
--- a/test/Dialect/XeTile/Transforms/Blocking/unit_tests_transform.mlir
+++ /dev/null
@@ -1,1585 +0,0 @@
-// RUN: imex-opt --split-input-file --xetile-blocking="enable-2d-transform=true" %s -verify-diagnostics -o -| FileCheck %s
-
-gpu.module @test_kernel {
-  //CHECK: gpu.func @sg_load_tile(%[[arg0:.*]]: memref<32x32xf16>)
-  gpu.func @sg_load_tile(%a: memref<32x32xf16>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[R0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[R1:.*]] = xetile.load_tile %[[R0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    %c0 = arith.constant 0 : index
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-  	gpu.return
-  }
-
-  //CHECK: gpu.func @sg_load_tile_unaligned(%[[arg0:.*]]: memref<128x128xf16>)
-  gpu.func @sg_load_tile_unaligned(%a: memref<128x128xf16>) {
-    %c0 = arith.constant 0 : index
-    //CHECK-COUNT-20: xetile.init_tile %arg0[{{.*}}] : memref<128x128xf16> -> !xetile.tile<17x19xf16>
-    %1 = xetile.init_tile %a[%c0, %c0] : memref<128x128xf16> -> !xetile.tile<85x76xf16>
-    //CHECK-COUNT-20: xetile.load_tile {{.*}} : !xetile.tile<17x19xf16> -> vector<17x19xf16>
-    %2 = xetile.load_tile %1 : !xetile.tile<85x76xf16> -> vector<85x76xf16>
-    //CHECK: gpu.return
-    gpu.return
-  }
-
-  //CHECK: gpu.func @sg_store_tile(%[[arg0:.*]]: memref<32x32xf32>)
-	gpu.func @sg_store_tile(%a: memref<32x32xf32>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
-		%result = arith.constant dense<0.0>: vector<32x32xf32>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %arg0[%{{.*}}, %{{.*}}] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-		%1 = xetile.init_tile %a[0, 0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-    //CHECK-COUNT-8: xetile.store_tile %[[cst]],  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
-		xetile.store_tile %result, %1: vector<32x32xf32>, !xetile.tile<32x32xf32>
-    //CHECK: gpu.return
-		gpu.return
-	}
-
-  //CHECK: gpu.func @create_mask
-  //CHECK-SAME: %[[arg0:.*]]: vector<32x32xf16>, %[[arg1:.*]]: vector<32x32xf16>, %[[arg2:.*]]: memref<32x32xf16>
-  gpu.func @create_mask(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
-    %c32 = arith.constant 32 : index
-    %c20 = arith.constant 20 : index
-
-    //CHECK-2D-FOR-LATER: %[[r0:.*]] = vector.constant_mask [8, 20] : vector<8x32xi1>
-    //CHECK: %[[r0:.*]] = vector.constant_mask [1, 20] : vector<1x32xi1>
-    %mask = vector.create_mask %c32, %c20 : vector<32x32xi1>
-
-    //CHECK-2D-FOR-LATER-COUNT-4: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-2D-FOR-LATER-COUNT-4: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-2D-FOR-LATER-COUNT-4: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<8x32xi1>, vector<8x32xf16>
-    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<1x32xi1>, vector<1x32xf16>
-    %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
-
-    //CHECK-COUNT-4: xetile.init_tile %[[arg2]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<8x32xf16>
-    %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-
-    //CHECK-COUNT-4: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
-
-    //CHECK: gpu.return
-    gpu.return
-  }
-
-  //CHECK: gpu.func @create_mask_2
-  //CHECK-SAME: %[[arg0:.*]]: vector<32x32xf16>, %[[arg1:.*]]: vector<32x32xf16>, %[[arg2:.*]]: memref<32x32xf16>
-  gpu.func @create_mask_2(%a: vector<32x32xf16>, %b: vector<32x32xf16>, %c: memref<32x32xf16>) {
-    %c20 = arith.constant 20 : index
-    %c32 = arith.constant 32 : index
-    //CHECK-2D-FOR-LATER: %[[r0:.*]] = vector.constant_mask [8, 32] : vector<8x32xi1>
-    //CHECK-2D-FOR-LATER: %[[r1:.*]] = vector.constant_mask [4, 32] : vector<8x32xi1>
-    //CHECK-2D-FOR-LATER: %[[r2:.*]] = vector.constant_mask [0, 0] : vector<8x32xi1>
-    //CHECK: %[[r0:.*]] = vector.constant_mask [1, 32] : vector<1x32xi1>
-    //CHECK: %[[r1:.*]] = vector.constant_mask [0, 0] : vector<1x32xi1>
-    %mask = vector.create_mask %c20, %c32 : vector<32x32xi1>
-
-    //CHECK-2D-FOR-LATER-COUNT: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-2D-FOR-LATER-COUNT: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-2D-FOR-LATER-COUNT: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<8x32xi1>, vector<8x32xf16>
-    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg0]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: vector.extract_strided_slice %[[arg1]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: arith.select %{{.*}}, %{{.*}}, %{{.*}} : vector<1x32xi1>, vector<1x32xf16>
-    %select = arith.select %mask, %a, %b : vector<32x32xi1>, vector<32x32xf16>
-
-    //CHECK-COUNT-4: xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<32x32xf16> -> !xetile.tile<8x32xf16>
-    %tile = xetile.init_tile %c[0, 0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    //CHECK-COUNT-4: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    xetile.store_tile %select, %tile: vector<32x32xf16>, !xetile.tile<32x32xf16>
-    gpu.return
-  }
-
-  //CHECK: gpu.func @sg_store_tile_unaligned(%[[arg0:.*]]: memref<128x128xf32>)
-	gpu.func @sg_store_tile_unaligned(%a: memref<128x128xf32>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<4x2xf32>
-	  %result = arith.constant dense<0.0>: vector<44x38xf32>
-    //CHECK-COUNT-209: xetile.init_tile %[[arg0]][{{.*}}] : memref<128x128xf32> -> !xetile.tile<4x2xf32>
-	  %1 = xetile.init_tile %a[0, 0] : memref<128x128xf32> -> !xetile.tile<44x38xf32>
-    //CHECK-COUNT-209: xetile.store_tile %[[cst]],  %{{.*}} : vector<4x2xf32>, !xetile.tile<4x2xf32>
-	  xetile.store_tile %result, %1: vector<44x38xf32>, !xetile.tile<44x38xf32>
-    //CHECK: gpu.return
-	  gpu.return
-	}
-
-  //CHECK: gpu.func @sg_tile_mma(%[[arg0:.*]]: memref<32x32xf16>, %[[arg1:.*]]: memref<32x32xf16>)
-  //CHECK-COUNT-2: xetile.init_tile %[[arg0]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<32x16xf16>
-  //CHECK-COUNT-2: xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-  //CHECK-COUNT-8: vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-  //CHECK-COUNT-2: xetile.init_tile %[[arg1]][{{.*}}] : memref<32x32xf16> -> !xetile.tile<32x16xf16>
-  //CHECK-COUNT-2: xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-  //CHECK-COUNT-4: vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-  //CHECK-COUNT-16: xetile.tile_mma %{{.*}}, %{{.*}}{{.*}} : vector<8x16xf16>, vector<16x16xf16>{{.*}} -> vector<8x16xf32>
-  gpu.func @sg_tile_mma(%a: memref<32x32xf16>, %b: memref<32x32xf16>) {
-    %c0 = arith.constant 0 : index
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    %2 = xetile.load_tile %1 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-  	%3 = xetile.init_tile %b[%c0, %c0] : memref<32x32xf16> -> !xetile.tile<32x32xf16>
-    %4 = xetile.load_tile %3 : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    %5 = xetile.tile_mma %2, %4: vector<32x32xf16>, vector<32x32xf16> -> vector<32x32xf32>
-  	gpu.return
-  }
-
-  //CHECK: gpu.func @sg_tile_mma_b_transpose(%[[arg0:.*]]: memref<64x32xf16>, %[[arg1:.*]]: memref<64x32xf16>, %[[arg2:.*]]: memref<64x64xf32>)
-  gpu.func @sg_tile_mma_b_transpose(%a: memref<64x32xf16>, %b: memref<64x32xf16>, %c: memref<64x64xf32>) {
-    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}] : memref<64x32xf16> -> !xetile.tile<32x16xf16>
-    %0 = xetile.init_tile %a[0, 0] : memref<64x32xf16> -> !xetile.tile<64x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    %1 = xetile.load_tile %0 : !xetile.tile<64x32xf16> -> vector<64x32xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg1]][{{.*}}] : memref<64x32xf16> -> !xetile.tile<16x16xf16>
-    %2 = xetile.init_tile %b[0, 0] : memref<64x32xf16> -> !xetile.tile<64x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<16x16xf16> -> vector<16x16xf16>
-    %3 = xetile.load_tile %2 : !xetile.tile<64x32xf16> -> vector<64x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<16x16xf16> -> vector<16x16xf16>
-    %4 = xetile.transpose %3, [1, 0] : vector<64x32xf16> -> vector<32x64xf16>
-    //CHECK-COUNT-64: %{{.*}} = xetile.tile_mma {{.*}} : vector<8x16xf16>, vector<16x16xf16>{{.*}}-> vector<8x16xf32>
-    %5 = xetile.tile_mma %1, %4: vector<64x32xf16>, vector<32x64xf16> -> vector<64x64xf32>
-    //CHECK-COUNT-32: xetile.init_tile %[[arg2]][{{.*}}] : memref<64x64xf32> -> !xetile.tile<8x16xf32>
-    %6 = xetile.init_tile %c[0, 0] : memref<64x64xf32> -> !xetile.tile<64x64xf32>
-    //CHECK-COUNT-32: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    xetile.store_tile %5, %6: vector<64x64xf32>, !xetile.tile<64x64xf32>
-    gpu.return
-  }
-
-  // CHECK-LABEL: gpu.func @inner_reduction
-  // CHECK-SAME: (%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>)
-  gpu.func @inner_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-    //CHECK: %[[c15_i32:.*]] = arith.constant 15 : i32
-    //CHECK: %[[c14_i32:.*]] = arith.constant 14 : i32
-    //CHECK: %[[c13_i32:.*]] = arith.constant 13 : i32
-    //CHECK: %[[c12_i32:.*]] = arith.constant 12 : i32
-    //CHECK: %[[c11_i32:.*]] = arith.constant 11 : i32
-    //CHECK: %[[c10_i32:.*]] = arith.constant 10 : i32
-    //CHECK: %[[c9_i32:.*]] = arith.constant 9 : i32
-    //CHECK: %[[c8_i32:.*]] = arith.constant 8 : i32
-    //CHECK: %[[c7_i32:.*]] = arith.constant 7 : i32
-    //CHECK: %[[c6_i32:.*]] = arith.constant 6 : i32
-    //CHECK: %[[c5_i32:.*]] = arith.constant 5 : i32
-    //CHECK: %[[c4_i32:.*]] = arith.constant 4 : i32
-    //CHECK: %[[c3_i32:.*]] = arith.constant 3 : i32
-    //CHECK: %[[c2_i32:.*]] = arith.constant 2 : i32
-    //CHECK: %[[c1_i32:.*]] = arith.constant 1 : i32
-    //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r18:.*]] = math.exp %[[r2]] : vector<1x32xf16>
-    //CHECK: %[[r19:.*]] = math.exp %[[r3]] : vector<1x32xf16>
-    //CHECK: %[[r20:.*]] = math.exp %[[r4]] : vector<1x32xf16>
-    //CHECK: %[[r21:.*]] = math.exp %[[r5]] : vector<1x32xf16>
-    //CHECK: %[[r22:.*]] = math.exp %[[r6]] : vector<1x32xf16>
-    //CHECK: %[[r23:.*]] = math.exp %[[r7]] : vector<1x32xf16>
-    //CHECK: %[[r24:.*]] = math.exp %[[r8]] : vector<1x32xf16>
-    //CHECK: %[[r25:.*]] = math.exp %[[r9]] : vector<1x32xf16>
-    //CHECK: %[[r26:.*]] = math.exp %[[r10]] : vector<1x32xf16>
-    //CHECK: %[[r27:.*]] = math.exp %[[r11]] : vector<1x32xf16>
-    //CHECK: %[[r28:.*]] = math.exp %[[r12]] : vector<1x32xf16>
-    //CHECK: %[[r29:.*]] = math.exp %[[r13]] : vector<1x32xf16>
-    //CHECK: %[[r30:.*]] = math.exp %[[r14]] : vector<1x32xf16>
-    //CHECK: %[[r31:.*]] = math.exp %[[r15]] : vector<1x32xf16>
-    //CHECK: %[[r32:.*]] = math.exp %[[r16]] : vector<1x32xf16>
-    //CHECK: %[[r33:.*]] = math.exp %[[r17]] : vector<1x32xf16>
-    //CHECK: %[[r34:.*]] = vector.shape_cast %[[r18]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r35:.*]] = vector.shape_cast %[[r19]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r36:.*]] = vector.shape_cast %[[r20]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r37:.*]] = vector.shape_cast %[[r21]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r38:.*]] = vector.shape_cast %[[r22]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r39:.*]] = vector.shape_cast %[[r23]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r40:.*]] = vector.shape_cast %[[r24]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r41:.*]] = vector.shape_cast %[[r25]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r42:.*]] = vector.shape_cast %[[r26]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r43:.*]] = vector.shape_cast %[[r27]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r44:.*]] = vector.shape_cast %[[r28]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r45:.*]] = vector.shape_cast %[[r29]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r46:.*]] = vector.shape_cast %[[r30]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r47:.*]] = vector.shape_cast %[[r31]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r48:.*]] = vector.shape_cast %[[r32]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r49:.*]] = vector.shape_cast %[[r33]] : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r50:.*]] = vector.shuffle %[[r34]], %[[r35]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r51:.*]] = vector.shuffle %[[r34]], %[[r35]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r52:.*]] = arith.addf %[[r50]], %[[r51]] : vector<32xf16>
-    //CHECK: %[[r53:.*]] = vector.shuffle %[[r36]], %[[r37]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r54:.*]] = vector.shuffle %[[r36]], %[[r37]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r55:.*]] = arith.addf %[[r53]], %[[r54]] : vector<32xf16>
-    //CHECK: %[[r56:.*]] = vector.shuffle %[[r38]], %[[r39]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r57:.*]] = vector.shuffle %[[r38]], %[[r39]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r58:.*]] = arith.addf %[[r56]], %[[r57]] : vector<32xf16>
-    //CHECK: %[[r59:.*]] = vector.shuffle %[[r40]], %[[r41]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r60:.*]] = vector.shuffle %[[r40]], %[[r41]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r61:.*]] = arith.addf %[[r59]], %[[r60]] : vector<32xf16>
-    //CHECK: %[[r62:.*]] = vector.shuffle %[[r42]], %[[r43]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r63:.*]] = vector.shuffle %[[r42]], %[[r43]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r64:.*]] = arith.addf %[[r62]], %[[r63]] : vector<32xf16>
-    //CHECK: %[[r65:.*]] = vector.shuffle %[[r44]], %[[r45]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r66:.*]] = vector.shuffle %[[r44]], %[[r45]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r67:.*]] = arith.addf %[[r65]], %[[r66]] : vector<32xf16>
-    //CHECK: %[[r68:.*]] = vector.shuffle %[[r46]], %[[r47]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r69:.*]] = vector.shuffle %[[r46]], %[[r47]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r70:.*]] = arith.addf %[[r68]], %[[r69]] : vector<32xf16>
-    //CHECK: %[[r71:.*]] = vector.shuffle %[[r48]], %[[r49]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r72:.*]] = vector.shuffle %[[r48]], %[[r49]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r73:.*]] = arith.addf %[[r71]], %[[r72]] : vector<32xf16>
-    //CHECK: %[[r74:.*]] = vector.shuffle %[[r52]], %[[r55]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r75:.*]] = vector.shuffle %[[r52]], %[[r55]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r76:.*]] = arith.addf %[[r74]], %[[r75]] : vector<32xf16>
-    //CHECK: %[[r77:.*]] = vector.shuffle %[[r58]], %[[r61]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r78:.*]] = vector.shuffle %[[r58]], %[[r61]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r79:.*]] = arith.addf %[[r77]], %[[r78]] : vector<32xf16>
-    //CHECK: %[[r80:.*]] = vector.shuffle %[[r64]], %[[r67]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r81:.*]] = vector.shuffle %[[r64]], %[[r67]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r82:.*]] = arith.addf %[[r80]], %[[r81]] : vector<32xf16>
-    //CHECK: %[[r83:.*]] = vector.shuffle %[[r70]], %[[r73]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r84:.*]] = vector.shuffle %[[r70]], %[[r73]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r85:.*]] = arith.addf %[[r83]], %[[r84]] : vector<32xf16>
-    //CHECK: %[[r86:.*]] = vector.shuffle %[[r76]], %[[r79]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r87:.*]] = vector.shuffle %[[r76]], %[[r79]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r88:.*]] = arith.addf %[[r86]], %[[r87]] : vector<32xf16>
-    //CHECK: %[[r89:.*]] = vector.shuffle %[[r82]], %[[r85]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r90:.*]] = vector.shuffle %[[r82]], %[[r85]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r91:.*]] = arith.addf %[[r89]], %[[r90]] : vector<32xf16>
-    //CHECK: %[[r92:.*]] = vector.shuffle %[[r88]], %[[r91]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r93:.*]] = vector.shuffle %[[r88]], %[[r91]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r94:.*]] = arith.addf %[[r92]], %[[r93]] : vector<32xf16>
-    //CHECK: %[[r95:.*]] = vector.shuffle %[[r94]], %[[r94]] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r96:.*]] = vector.shuffle %[[r94]], %[[r94]] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r97:.*]] = arith.addf %[[r95]], %[[r96]] : vector<16xf16>
-    //CHECK: %[[r98:.*]] = vector.extractelement %[[r97]][%[[c0_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r99:.*]] = vector.splat %[[r98]] : vector<1x1xf16>
-    //CHECK: %[[r100:.*]] = vector.extractelement %[[r97]][%[[c1_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r101:.*]] = vector.splat %[[r100]] : vector<1x1xf16>
-    //CHECK: %[[r102:.*]] = vector.extractelement %[[r97]][%[[c2_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r103:.*]] = vector.splat %[[r102]] : vector<1x1xf16>
-    //CHECK: %[[r104:.*]] = vector.extractelement %[[r97]][%[[c3_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r105:.*]] = vector.splat %[[r104]] : vector<1x1xf16>
-    //CHECK: %[[r106:.*]] = vector.extractelement %[[r97]][%[[c4_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r107:.*]] = vector.splat %[[r106]] : vector<1x1xf16>
-    //CHECK: %[[r108:.*]] = vector.extractelement %[[r97]][%[[c5_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r109:.*]] = vector.splat %[[r108]] : vector<1x1xf16>
-    //CHECK: %[[r110:.*]] = vector.extractelement %[[r97]][%[[c6_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r111:.*]] = vector.splat %[[r110]] : vector<1x1xf16>
-    //CHECK: %[[r112:.*]] = vector.extractelement %[[r97]][%[[c7_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r113:.*]] = vector.splat %[[r112]] : vector<1x1xf16>
-    //CHECK: %[[r114:.*]] = vector.extractelement %[[r97]][%[[c8_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r115:.*]] = vector.splat %[[r114]] : vector<1x1xf16>
-    //CHECK: %[[r116:.*]] = vector.extractelement %[[r97]][%[[c9_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r117:.*]] = vector.splat %[[r116]] : vector<1x1xf16>
-    //CHECK: %[[r118:.*]] = vector.extractelement %[[r97]][%[[c10_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r119:.*]] = vector.splat %[[r118]] : vector<1x1xf16>
-    //CHECK: %[[r120:.*]] = vector.extractelement %[[r97]][%[[c11_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r121:.*]] = vector.splat %[[r120]] : vector<1x1xf16>
-    //CHECK: %[[r122:.*]] = vector.extractelement %[[r97]][%[[c12_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r123:.*]] = vector.splat %[[r122]] : vector<1x1xf16>
-    //CHECK: %[[r124:.*]] = vector.extractelement %[[r97]][%[[c13_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r125:.*]] = vector.splat %[[r124]] : vector<1x1xf16>
-    //CHECK: %[[r126:.*]] = vector.extractelement %[[r97]][%[[c14_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r127:.*]] = vector.splat %[[r126]] : vector<1x1xf16>
-    //CHECK: %[[r128:.*]] = vector.extractelement %[[r97]][%[[c15_i32]] : i32] : vector<16xf16>
-    //CHECK: %[[r129:.*]] = vector.splat %[[r128]] : vector<1x1xf16>
-    //CHECK: %[[r130:.*]] = vector.shuffle %[[r99]], %[[r101]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r131:.*]] = vector.shuffle %[[r103]], %[[r105]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r132:.*]] = vector.shuffle %[[r107]], %[[r109]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r133:.*]] = vector.shuffle %[[r111]], %[[r113]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r134:.*]] = vector.shuffle %[[r115]], %[[r117]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r135:.*]] = vector.shuffle %[[r119]], %[[r121]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r136:.*]] = vector.shuffle %[[r123]], %[[r125]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r137:.*]] = vector.shuffle %[[r127]], %[[r129]] [0, 1] : vector<1x1xf16>, vector<1x1xf16>
-    //CHECK: %[[r138:.*]] = vector.shuffle %[[r130]], %[[r131]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
-    //CHECK: %[[r139:.*]] = vector.shuffle %[[r132]], %[[r133]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
-    //CHECK: %[[r140:.*]] = vector.shuffle %[[r134]], %[[r135]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
-    //CHECK: %[[r141:.*]] = vector.shuffle %[[r136]], %[[r137]] [0, 1, 2, 3] : vector<2x1xf16>, vector<2x1xf16>
-    //CHECK: %[[r142:.*]] = vector.shuffle %[[r138]], %[[r139]] [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf16>, vector<4x1xf16>
-    //CHECK: %[[r143:.*]] = vector.shuffle %[[r140]], %[[r141]] [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x1xf16>, vector<4x1xf16>
-    //CHECK: %[[r144:.*]] = vector.shuffle %[[r142]], %[[r143]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x1xf16>, vector<8x1xf16>
-    //CHECK: %[[r145:.*]] = vector.shape_cast %[[r144]] : vector<16x1xf16> to vector<2x8xf16>
-    //CHECK: %[[r146:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
-    //CHECK: xetile.store_tile %[[r145]],  %[[r146]] : vector<2x8xf16>, !xetile.tile<2x8xf16>
-    %c0 = arith.constant 0 : index
-    %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-    %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-    %e = math.exp %v: vector<16x32xf16>
-    %r = xetile.reduction <add>, %e [1] : vector<16x32xf16> -> vector<16x1xf16>
-    %c = vector.shape_cast %r: vector<16x1xf16> to vector<2x8xf16>
-    %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<2x8xf16>
-    xetile.store_tile %c, %s : vector<2x8xf16>, !xetile.tile<2x8xf16>
-    gpu.return
-  }
-
-  //CHECK: gpu.func @outter_reduction(%[[arg0:.*]]: memref<128x256xf16>, %[[arg1:.*]]: memref<128x256xf16>) {
-  gpu.func @outter_reduction(%a: memref<128x256xf16>, %b: memref<128x256xf16>) {
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<16x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r18:.*]] = math.exp %[[r2:.*]] : vector<1x32xf16>
-    //CHECK: %[[r19:.*]] = math.exp %[[r3:.*]] : vector<1x32xf16>
-    //CHECK: %[[r20:.*]] = math.exp %[[r4:.*]] : vector<1x32xf16>
-    //CHECK: %[[r21:.*]] = math.exp %[[r5:.*]] : vector<1x32xf16>
-    //CHECK: %[[r22:.*]] = math.exp %[[r6:.*]] : vector<1x32xf16>
-    //CHECK: %[[r23:.*]] = math.exp %[[r7:.*]] : vector<1x32xf16>
-    //CHECK: %[[r24:.*]] = math.exp %[[r8:.*]] : vector<1x32xf16>
-    //CHECK: %[[r25:.*]] = math.exp %[[r9:.*]] : vector<1x32xf16>
-    //CHECK: %[[r26:.*]] = math.exp %[[r10:.*]] : vector<1x32xf16>
-    //CHECK: %[[r27:.*]] = math.exp %[[r11:.*]] : vector<1x32xf16>
-    //CHECK: %[[r28:.*]] = math.exp %[[r12:.*]] : vector<1x32xf16>
-    //CHECK: %[[r29:.*]] = math.exp %[[r13:.*]] : vector<1x32xf16>
-    //CHECK: %[[r30:.*]] = math.exp %[[r14:.*]] : vector<1x32xf16>
-    //CHECK: %[[r31:.*]] = math.exp %[[r15:.*]] : vector<1x32xf16>
-    //CHECK: %[[r32:.*]] = math.exp %[[r16:.*]] : vector<1x32xf16>
-    //CHECK: %[[r33:.*]] = math.exp %[[r17:.*]] : vector<1x32xf16>
-    //CHECK: %[[r34:.*]] = arith.addf %[[r18]], %[[r19]] : vector<1x32xf16>
-    //CHECK: %[[r35:.*]] = arith.addf %[[r34]], %[[r20]] : vector<1x32xf16>
-    //CHECK: %[[r36:.*]] = arith.addf %[[r35]], %[[r21]] : vector<1x32xf16>
-    //CHECK: %[[r37:.*]] = arith.addf %[[r36]], %[[r22]] : vector<1x32xf16>
-    //CHECK: %[[r38:.*]] = arith.addf %[[r37]], %[[r23]] : vector<1x32xf16>
-    //CHECK: %[[r39:.*]] = arith.addf %[[r38]], %[[r24]] : vector<1x32xf16>
-    //CHECK: %[[r40:.*]] = arith.addf %[[r39]], %[[r25]] : vector<1x32xf16>
-    //CHECK: %[[r41:.*]] = arith.addf %[[r40]], %[[r26]] : vector<1x32xf16>
-    //CHECK: %[[r42:.*]] = arith.addf %[[r41]], %[[r27]] : vector<1x32xf16>
-    //CHECK: %[[r43:.*]] = arith.addf %[[r42]], %[[r28]] : vector<1x32xf16>
-    //CHECK: %[[r44:.*]] = arith.addf %[[r43]], %[[r29]] : vector<1x32xf16>
-    //CHECK: %[[r45:.*]] = arith.addf %[[r44]], %[[r30]] : vector<1x32xf16>
-    //CHECK: %[[r46:.*]] = arith.addf %[[r45]], %[[r31]] : vector<1x32xf16>
-    //CHECK: %[[r47:.*]] = arith.addf %[[r46]], %[[r32]] : vector<1x32xf16>
-    //CHECK: %[[r48:.*]] = arith.addf %[[r47]], %[[r33]] : vector<1x32xf16>
-    //CHECK: %[[r49:.*]] = vector.shape_cast %[[r48]] : vector<1x32xf16> to vector<4x8xf16>
-    //CHECK: %[[r50:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
-    //CHECK: xetile.store_tile %[[r49]],  %[[r50]] : vector<4x8xf16>, !xetile.tile<4x8xf16>
-    %c0 = arith.constant 0 : index
-    %t = xetile.init_tile %a[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<16x32xf16>
-    %v = xetile.load_tile %t : !xetile.tile<16x32xf16> -> vector<16x32xf16>
-    %e = math.exp %v: vector<16x32xf16>
-    %r = xetile.reduction <add>, %e [0] : vector<16x32xf16> -> vector<1x32xf16>
-    %c = vector.shape_cast %r: vector<1x32xf16> to vector<4x8xf16>
-    %s = xetile.init_tile %b[%c0, %c0] : memref<128x256xf16> -> !xetile.tile<4x8xf16>
-    xetile.store_tile %c, %s : vector<4x8xf16>, !xetile.tile<4x8xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sg_gemm
-  //CHECK-SAME: (%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
-  gpu.func @sg_gemm(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
-
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c16]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r2:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r3:.*]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c16]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
-    %c0 = arith.constant 0 : index
-    %c32 = arith.constant 32 : index
-    %c128 = arith.constant 128 : index
-    %cst = arith.constant dense<0.0>: vector<32x32xf32>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
-  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r4:.*]]:12 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6:.*]] = %[[r2]], %[[arg7:.*]] = %[[r3]], %[[arg8:.*]] = %[[cst]], %[[arg9:.*]] = %[[cst]], %[[arg10:.*]] = %[[cst]], %[[arg11:.*]] = %[[cst]], %[[arg12:.*]] = %[[cst]], %[[arg13:.*]] = %[[cst]], %[[arg14:.*]] = %[[cst]], %[[arg15:.*]] = %[[cst]]) -> (!xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>) {
-    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
-        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      //CHECK: %[[r13:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-      //CHECK: %[[r14:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-      //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r18:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r19:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r20:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r21:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r22:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-      //CHECK: %[[r23:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-      //CHECK: %[[r24:.*]] = xetile.load_tile %[[arg7]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-      //CHECK: %[[r25:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r26:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r27:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r28:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-      //CHECK: %[[r29:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
-      //CHECK: %[[r30:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
-      //CHECK: %[[r31:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
-      //CHECK: %[[r32:.*]] = xetile.update_tile_offset %[[arg7]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
-      //CHECK: %[[r33:.*]] = xetile.tile_mma %[[r15]], %[[r25]], %[[arg8]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r34:.*]] = xetile.tile_mma %[[r19]], %[[r26]], %[[r33]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r35:.*]] = xetile.tile_mma %[[r15]], %[[r27]], %[[arg9]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r36:.*]] = xetile.tile_mma %[[r19]], %[[r28]], %[[r35]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r37:.*]] = xetile.tile_mma %[[r16]], %[[r25]], %[[arg10]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r38:.*]] = xetile.tile_mma %[[r20]], %[[r26]], %[[r37]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r39:.*]] = xetile.tile_mma %[[r16]], %[[r27]], %[[arg11]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r40:.*]] = xetile.tile_mma %[[r20]], %[[r28]], %[[r39]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r41:.*]] = xetile.tile_mma %[[r17]], %[[r25]], %[[arg12]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r42:.*]] = xetile.tile_mma %[[r21]], %[[r26]], %[[r41]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r43:.*]] = xetile.tile_mma %[[r17]], %[[r27]], %[[arg13]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r44:.*]] = xetile.tile_mma %[[r21]], %[[r28]], %[[r43]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r45:.*]] = xetile.tile_mma %[[r18]], %[[r25]], %[[arg14]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r46:.*]] = xetile.tile_mma %[[r22]], %[[r26]], %[[r45]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r47:.*]] = xetile.tile_mma %[[r18]], %[[r27]], %[[arg15]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      //CHECK: %[[r48:.*]] = xetile.tile_mma %[[r22]], %[[r28]], %[[r47]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]:  !xetile.tile<32x32xf16>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]:  !xetile.tile<32x32xf16>
-      %c_new_value = xetile.tile_mma %3, %4, %c_value:
-        vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-      //CHECK: scf.yield %[[r29]], %[[r30]], %[[r31]], %[[r32]], %[[r34]], %[[r36]], %[[r38]], %[[r40]], %[[r42]], %[[r44]], %[[r46]], %[[r48]] : !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
-    }
-
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r8:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r10:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-
-    //CHECK: xetile.store_tile %[[r4]]#4,  %[[r5]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#5,  %[[r6]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#6,  %[[r7]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#7,  %[[r8]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#8,  %[[r9]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#9,  %[[r10]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#10,  %[[r11]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#11,  %[[r12]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
-  	gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sg_gemm_with_preops_for_c
-  //CHECK-SAME: (%[[arg0:.*]]: memref<32x128xf16>, %[[arg1:.*]]: memref<128x32xf16>, %[[arg2:.*]]: memref<32x32xf32>)
-  gpu.func @sg_gemm_with_preops_for_c(%a: memref<32x128xf16>, %b: memref<128x32xf16>, %c: memref<32x32xf32>) {
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c128:.*]] = arith.constant 128 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<0.000000e+00> : vector<8x16xf32>
-    //CHECK: %[[r0]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r1]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c16]]] : memref<32x128xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r2]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c0]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r3]] = xetile.init_tile %[[arg1]][%[[c0]], %[[c16]]] : memref<128x32xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %[[r4]]:12 = scf.for %[[arg3:.*]] = %[[c0]] to %[[c128]] step %[[c32]] iter_args(%[[arg4:.*]] = %[[r0]], %[[arg5:.*]] = %[[r1]], %[[arg6:.*]] = %[[r2]], %[[arg7:.*]] = %[[r3]], %[[arg8:.*]] = %[[cst]], %[[arg9:.*]] = %[[cst]], %[[arg10:.*]] = %[[cst]], %[[arg11:.*]] = %[[cst]], %[[arg12:.*]] = %[[cst]], %[[arg13:.*]] = %[[cst]], %[[arg14:.*]] = %[[cst]], %[[arg15:.*]] = %[[cst]]) -> (!xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>) {
-    //CHECK:   %[[r13:.*]] = xetile.load_tile %[[arg4]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-    //CHECK:   %[[r14:.*]] = xetile.load_tile %[[arg5]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-    //CHECK:   %[[r15:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r16:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r17:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r18:.*]] = vector.extract_strided_slice %[[r13]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r19:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [0, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r20:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [8, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r21:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [16, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r22:.*]] = vector.extract_strided_slice %[[r14]] {offsets = [24, 0], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-    //CHECK:   %[[r23:.*]] = xetile.load_tile %[[arg6]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-    //CHECK:   %[[r24:.*]] = xetile.load_tile %[[arg7]] : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-    //CHECK:   %[[r25:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-    //CHECK:   %[[r26:.*]] = vector.extract_strided_slice %[[r23]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-    //CHECK:   %[[r27:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [0, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-    //CHECK:   %[[r28:.*]] = vector.extract_strided_slice %[[r24]] {offsets = [16, 0], sizes = [16, 16], strides = [1, 1]} : vector<32x16xf16> to vector<16x16xf16>
-    //CHECK:   %[[r29:.*]] = xetile.update_tile_offset %[[arg4]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
-    //CHECK:   %[[r30:.*]] = xetile.update_tile_offset %[[arg5]], [%[[c0]], %[[c32]]] : !xetile.tile<32x16xf16>
-    //CHECK:   %[[r31:.*]] = xetile.update_tile_offset %[[arg6]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
-    //CHECK:   %[[r32:.*]] = xetile.update_tile_offset %[[arg7]], [%[[c32]], %[[c0]]] : !xetile.tile<32x16xf16>
-    //CHECK:   %[[r33:.*]] = arith.addf %[[arg8]], %[[arg8]] : vector<8x16xf32>
-    //CHECK:   %[[r34:.*]] = arith.addf %[[arg9]], %[[arg9]] : vector<8x16xf32>
-    //CHECK:   %[[r35:.*]] = arith.addf %[[arg10]], %[[arg10]] : vector<8x16xf32>
-    //CHECK:   %[[r36:.*]] = arith.addf %[[arg11]], %[[arg11]] : vector<8x16xf32>
-    //CHECK:   %[[r37:.*]] = arith.addf %[[arg12]], %[[arg12]] : vector<8x16xf32>
-    //CHECK:   %[[r38:.*]] = arith.addf %[[arg13]], %[[arg13]] : vector<8x16xf32>
-    //CHECK:   %[[r39:.*]] = arith.addf %[[arg14]], %[[arg14]] : vector<8x16xf32>
-    //CHECK:   %[[r40:.*]] = arith.addf %[[arg15]], %[[arg15]] : vector<8x16xf32>
-    //CHECK:   %[[r41:.*]] = xetile.tile_mma %[[r15]], %[[r25]], %[[r33]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r42:.*]] = xetile.tile_mma %[[r19]], %[[r26]], %[[r41]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r43:.*]] = xetile.tile_mma %[[r15]], %[[r27]], %[[r34]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r44:.*]] = xetile.tile_mma %[[r19]], %[[r28]], %[[r43]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r45:.*]] = xetile.tile_mma %[[r16]], %[[r25]], %[[r35]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r46:.*]] = xetile.tile_mma %[[r20]], %[[r26]], %[[r45]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r47:.*]] = xetile.tile_mma %[[r16]], %[[r27]], %[[r36]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r48:.*]] = xetile.tile_mma %[[r20]], %[[r28]], %[[r47]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r49:.*]] = xetile.tile_mma %[[r17]], %[[r25]], %[[r37]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r50:.*]] = xetile.tile_mma %[[r21]], %[[r26]], %[[r49]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r51:.*]] = xetile.tile_mma %[[r17]], %[[r27]], %[[r38]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r52:.*]] = xetile.tile_mma %[[r21]], %[[r28]], %[[r51]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r53:.*]] = xetile.tile_mma %[[r18]], %[[r25]], %[[r39]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r54:.*]] = xetile.tile_mma %[[r22]], %[[r26]], %[[r53]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r55:.*]] = xetile.tile_mma %[[r18]], %[[r27]], %[[r40]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   %[[r56:.*]] = xetile.tile_mma %[[r22]], %[[r28]], %[[r55]] : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-    //CHECK:   scf.yield %[[r29]], %[[r30]], %[[r31]], %[[r32]], %[[r42]], %[[r44]], %[[r46]], %[[r48]], %[[r50]], %[[r52]], %[[r54]], %[[r56]] : !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>
-    //CHECK: }
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg2]][%[[c0]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r8:.*]] = xetile.init_tile %[[arg2]][%[[c8]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r9:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r10:.*]] = xetile.init_tile %[[arg2]][%[[c16]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r11:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c0]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %[[r12:.*]] = xetile.init_tile %[[arg2]][%[[c24]], %[[c16]]] : memref<32x32xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#4,  %[[r5]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#5,  %[[r6]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#6,  %[[r7]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#7,  %[[r8]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#8,  %[[r9]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#9,  %[[r10]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#10,  %[[r11]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    //CHECK: xetile.store_tile %[[r4]]#11,  %[[r12]] : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    %c0 = arith.constant 0 : index
-    %c32 = arith.constant 32 : index
-    %c128 = arith.constant 128 : index
-    %cst = arith.constant dense<0.0>: vector<32x32xf32>
-  	%1 = xetile.init_tile %a[%c0, %c0] : memref<32x128xf16> -> !xetile.tile<32x32xf16>
-  	%2 = xetile.init_tile %b[%c0, %c0] : memref<128x32xf16> -> !xetile.tile<32x32xf16>
-    %out:3 = scf.for %k = %c0 to %c128 step %c32 iter_args(%a_tile = %1, %b_tile = %2, %c_value = %cst)
-        -> (!xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>) {
-      %3 = xetile.load_tile %a_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-      %4 = xetile.load_tile %b_tile : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-      %a_next_tile = xetile.update_tile_offset %a_tile, [%c0, %c32]:  !xetile.tile<32x32xf16>
-      %b_next_tile = xetile.update_tile_offset %b_tile, [%c32, %c0]:  !xetile.tile<32x32xf16>
-      %5 = arith.addf %c_value, %c_value: vector<32x32xf32>
-      %c_new_value = xetile.tile_mma %3, %4, %5: vector<32x32xf16>, vector<32x32xf16>, vector<32x32xf32> -> vector<32x32xf32>
-      scf.yield %a_next_tile, %b_next_tile, %c_new_value : !xetile.tile<32x32xf16>, !xetile.tile<32x32xf16>, vector<32x32xf32>
-    }
-  	%c_tile = xetile.init_tile %c[%c0, %c0] : memref<32x32xf32> -> !xetile.tile<32x32xf32>
-    xetile.store_tile %out#2, %c_tile: vector<32x32xf32>, !xetile.tile<32x32xf32>
-  	gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_dim_0
-  //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_reduction_broadcast_dim_0(%a: memref<1024x1024xf16>) {
-
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-62: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    %3 = xetile.reduction <add>, %2 [0]: vector<32x64xf16> -> vector<1x64xf16>
-    %4 = xetile.broadcast %3 [0]: vector<1x64xf16> -> vector<32x64xf16>
-    %5 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    xetile.store_tile %4, %5: vector<32x64xf16>, !xetile.tile<32x64xf16>
-    gpu.return
-  }
-
-
-  //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_dim_1
-  //CHECK-SAME: (%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_reduction_broadcast_dim_1(%a: memref<1024x1024xf16>) {
-
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-    //CHECK: %{{.*}} = vector.shape_cast %{{.*}} : vector<1x32xf16> to vector<32xf16>
-
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[{{.*}} : i32] : vector<32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    %3 = xetile.reduction <add>, %2 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    %4 = xetile.broadcast %3 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    %5 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    xetile.store_tile %4, %5: vector<32x64xf16>, !xetile.tile<32x64xf16>
-    gpu.return
-  }
-
-
-  //CHECK-LABEL: gpu.func @sglevel_reduction_broadcast_transpose
-  //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_reduction_broadcast_transpose(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[c56:.*]] = arith.constant 56 : index
-    //CHECK: %[[c48:.*]] = arith.constant 48 : index
-    //CHECK: %[[c40:.*]] = arith.constant 40 : index
-    //CHECK: %[[c24:.*]] = arith.constant 24 : index
-    //CHECK: %[[c16:.*]] = arith.constant 16 : index
-    //CHECK: %[[c8:.*]] = arith.constant 8 : index
-    //CHECK: %[[c31_i32:.*]] = arith.constant 31 : i32
-    //CHECK: %[[c30_i32:.*]] = arith.constant 30 : i32
-    //CHECK: %[[c29_i32:.*]] = arith.constant 29 : i32
-    //CHECK: %[[c28_i32:.*]] = arith.constant 28 : i32
-    //CHECK: %[[c27_i32:.*]] = arith.constant 27 : i32
-    //CHECK: %[[c26_i32:.*]] = arith.constant 26 : i32
-    //CHECK: %[[c25_i32:.*]] = arith.constant 25 : i32
-    //CHECK: %[[c24_i32:.*]] = arith.constant 24 : i32
-    //CHECK: %[[c23_i32:.*]] = arith.constant 23 : i32
-    //CHECK: %[[c22_i32:.*]] = arith.constant 22 : i32
-    //CHECK: %[[c21_i32:.*]] = arith.constant 21 : i32
-    //CHECK: %[[c20_i32:.*]] = arith.constant 20 : i32
-    //CHECK: %[[c19_i32:.*]] = arith.constant 19 : i32
-    //CHECK: %[[c18_i32:.*]] = arith.constant 18 : i32
-    //CHECK: %[[c17_i32:.*]] = arith.constant 17 : i32
-    //CHECK: %[[c16_i32:.*]] = arith.constant 16 : i32
-    //CHECK: %[[c15_i32:.*]] = arith.constant 15 : i32
-    //CHECK: %[[c14_i32:.*]] = arith.constant 14 : i32
-    //CHECK: %[[c13_i32:.*]] = arith.constant 13 : i32
-    //CHECK: %[[c12_i32:.*]] = arith.constant 12 : i32
-    //CHECK: %[[c11_i32:.*]] = arith.constant 11 : i32
-    //CHECK: %[[c10_i32:.*]] = arith.constant 10 : i32
-    //CHECK: %[[c9_i32:.*]] = arith.constant 9 : i32
-    //CHECK: %[[c8_i32:.*]] = arith.constant 8 : i32
-    //CHECK: %[[c7_i32:.*]] = arith.constant 7 : i32
-    //CHECK: %[[c6_i32:.*]] = arith.constant 6 : i32
-    //CHECK: %[[c5_i32:.*]] = arith.constant 5 : i32
-    //CHECK: %[[c4_i32:.*]] = arith.constant 4 : i32
-    //CHECK: %[[c3_i32:.*]] = arith.constant 3 : i32
-    //CHECK: %[[c2_i32:.*]] = arith.constant 2 : i32
-    //CHECK: %[[c1_i32:.*]] = arith.constant 1 : i32
-    //CHECK: %[[c0_i32:.*]] = arith.constant 0 : i32
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK: %[[r4:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r5:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r6:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r7:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r8:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r9:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r10:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r11:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r12:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r13:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r14:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r15:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r16:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r17:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r18:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r19:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r20:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [16, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r21:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [17, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r22:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [18, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r23:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [19, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r24:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [20, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r25:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [21, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r26:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [22, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r27:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [23, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r28:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [24, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r29:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [25, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r30:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [26, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r31:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [27, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r32:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [28, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r33:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [29, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r34:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [30, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r35:.*]] = vector.extract_strided_slice %[[r2]] {offsets = [31, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r36:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r37:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r38:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r39:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r40:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [4, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r41:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [5, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r42:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [6, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r43:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [7, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r44:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [8, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r45:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [9, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r46:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [10, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r47:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [11, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r48:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [12, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r49:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [13, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r50:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [14, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r51:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [15, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r52:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [16, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r53:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [17, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r54:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [18, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r55:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [19, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r56:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [20, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r57:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [21, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r58:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [22, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r59:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [23, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r60:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [24, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r61:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [25, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r62:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [26, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r63:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [27, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r64:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [28, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r65:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [29, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r66:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [30, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r67:.*]] = vector.extract_strided_slice %[[r3]] {offsets = [31, 0], sizes = [1, 32], strides = [1, 1]} : vector<32x32xf16> to vector<1x32xf16>
-    //CHECK: %[[r68:.*]] = arith.addf %4, %36 : vector<1x32xf16>
-    //CHECK: %[[r69:.*]] = vector.shape_cast %68 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r70:.*]] = arith.addf %5, %37 : vector<1x32xf16>
-    //CHECK: %[[r71:.*]] = vector.shape_cast %70 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r72:.*]] = arith.addf %6, %38 : vector<1x32xf16>
-    //CHECK: %[[r73:.*]] = vector.shape_cast %72 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r74:.*]] = arith.addf %7, %39 : vector<1x32xf16>
-    //CHECK: %[[r75:.*]] = vector.shape_cast %74 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r76:.*]] = arith.addf %8, %40 : vector<1x32xf16>
-    //CHECK: %[[r77:.*]] = vector.shape_cast %76 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r78:.*]] = arith.addf %9, %41 : vector<1x32xf16>
-    //CHECK: %[[r79:.*]] = vector.shape_cast %78 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r80:.*]] = arith.addf %10, %42 : vector<1x32xf16>
-    //CHECK: %[[r81:.*]] = vector.shape_cast %80 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r82:.*]] = arith.addf %11, %43 : vector<1x32xf16>
-    //CHECK: %[[r83:.*]] = vector.shape_cast %82 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r84:.*]] = arith.addf %12, %44 : vector<1x32xf16>
-    //CHECK: %[[r85:.*]] = vector.shape_cast %84 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r86:.*]] = arith.addf %13, %45 : vector<1x32xf16>
-    //CHECK: %[[r87:.*]] = vector.shape_cast %86 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r88:.*]] = arith.addf %14, %46 : vector<1x32xf16>
-    //CHECK: %[[r89:.*]] = vector.shape_cast %88 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r90:.*]] = arith.addf %15, %47 : vector<1x32xf16>
-    //CHECK: %[[r91:.*]] = vector.shape_cast %90 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r92:.*]] = arith.addf %16, %48 : vector<1x32xf16>
-    //CHECK: %[[r93:.*]] = vector.shape_cast %92 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r94:.*]] = arith.addf %17, %49 : vector<1x32xf16>
-    //CHECK: %[[r95:.*]] = vector.shape_cast %94 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r96:.*]] = arith.addf %18, %50 : vector<1x32xf16>
-    //CHECK: %[[r97:.*]] = vector.shape_cast %96 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r98:.*]] = arith.addf %19, %51 : vector<1x32xf16>
-    //CHECK: %[[r99:.*]] = vector.shape_cast %98 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r100:.*]] = arith.addf %20, %52 : vector<1x32xf16>
-    //CHECK: %[[r101:.*]] = vector.shape_cast %100 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r102:.*]] = arith.addf %21, %53 : vector<1x32xf16>
-    //CHECK: %[[r103:.*]] = vector.shape_cast %102 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r104:.*]] = arith.addf %22, %54 : vector<1x32xf16>
-    //CHECK: %[[r105:.*]] = vector.shape_cast %104 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r106:.*]] = arith.addf %23, %55 : vector<1x32xf16>
-    //CHECK: %[[r107:.*]] = vector.shape_cast %106 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r108:.*]] = arith.addf %24, %56 : vector<1x32xf16>
-    //CHECK: %[[r109:.*]] = vector.shape_cast %108 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r110:.*]] = arith.addf %25, %57 : vector<1x32xf16>
-    //CHECK: %[[r111:.*]] = vector.shape_cast %110 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r112:.*]] = arith.addf %26, %58 : vector<1x32xf16>
-    //CHECK: %[[r113:.*]] = vector.shape_cast %112 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r114:.*]] = arith.addf %27, %59 : vector<1x32xf16>
-    //CHECK: %[[r115:.*]] = vector.shape_cast %114 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r116:.*]] = arith.addf %28, %60 : vector<1x32xf16>
-    //CHECK: %[[r117:.*]] = vector.shape_cast %116 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r118:.*]] = arith.addf %29, %61 : vector<1x32xf16>
-    //CHECK: %[[r119:.*]] = vector.shape_cast %118 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r120:.*]] = arith.addf %30, %62 : vector<1x32xf16>
-    //CHECK: %[[r121:.*]] = vector.shape_cast %120 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r122:.*]] = arith.addf %31, %63 : vector<1x32xf16>
-    //CHECK: %[[r123:.*]] = vector.shape_cast %122 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r124:.*]] = arith.addf %32, %64 : vector<1x32xf16>
-    //CHECK: %[[r125:.*]] = vector.shape_cast %124 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r126:.*]] = arith.addf %33, %65 : vector<1x32xf16>
-    //CHECK: %[[r127:.*]] = vector.shape_cast %126 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r128:.*]] = arith.addf %34, %66 : vector<1x32xf16>
-    //CHECK: %[[r129:.*]] = vector.shape_cast %128 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r130:.*]] = arith.addf %35, %67 : vector<1x32xf16>
-    //CHECK: %[[r131:.*]] = vector.shape_cast %130 : vector<1x32xf16> to vector<32xf16>
-    //CHECK: %[[r132:.*]] = vector.shuffle %[[r69]], %[[r71]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r133:.*]] = vector.shuffle %[[r69]], %[[r71]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r134:.*]] = arith.addf %132, %133 : vector<32xf16>
-    //CHECK: %[[r135:.*]] = vector.shuffle %[[r73]], %[[r75]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r136:.*]] = vector.shuffle %[[r73]], %[[r75]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r137:.*]] = arith.addf %135, %136 : vector<32xf16>
-    //CHECK: %[[r138:.*]] = vector.shuffle %[[r77]], %[[r79]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r139:.*]] = vector.shuffle %[[r77]], %[[r79]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r140:.*]] = arith.addf %138, %139 : vector<32xf16>
-    //CHECK: %[[r141:.*]] = vector.shuffle %[[r81]], %[[r83]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r142:.*]] = vector.shuffle %[[r81]], %[[r83]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r143:.*]] = arith.addf %141, %142 : vector<32xf16>
-    //CHECK: %[[r144:.*]] = vector.shuffle %[[r85]], %[[r87]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r145:.*]] = vector.shuffle %[[r85]], %[[r87]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r146:.*]] = arith.addf %144, %145 : vector<32xf16>
-    //CHECK: %[[r147:.*]] = vector.shuffle %[[r89]], %[[r91]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r148:.*]] = vector.shuffle %[[r89]], %[[r91]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r149:.*]] = arith.addf %147, %148 : vector<32xf16>
-    //CHECK: %[[r150:.*]] = vector.shuffle %[[r93]], %[[r95]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r151:.*]] = vector.shuffle %[[r93]], %[[r95]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r152:.*]] = arith.addf %150, %151 : vector<32xf16>
-    //CHECK: %[[r153:.*]] = vector.shuffle %[[r97]], %[[r99]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r154:.*]] = vector.shuffle %[[r97]], %[[r99]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r155:.*]] = arith.addf %153, %154 : vector<32xf16>
-    //CHECK: %[[r156:.*]] = vector.shuffle %[[r101]], %[[r103]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r157:.*]] = vector.shuffle %[[r101]], %[[r103]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r158:.*]] = arith.addf %156, %157 : vector<32xf16>
-    //CHECK: %[[r159:.*]] = vector.shuffle %[[r105]], %[[r107]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r160:.*]] = vector.shuffle %[[r105]], %[[r107]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r161:.*]] = arith.addf %159, %160 : vector<32xf16>
-    //CHECK: %[[r162:.*]] = vector.shuffle %[[r109]], %[[r111]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r163:.*]] = vector.shuffle %[[r109]], %[[r111]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r164:.*]] = arith.addf %162, %163 : vector<32xf16>
-    //CHECK: %[[r165:.*]] = vector.shuffle %[[r113]], %[[r115]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r166:.*]] = vector.shuffle %[[r113]], %[[r115]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r167:.*]] = arith.addf %165, %166 : vector<32xf16>
-    //CHECK: %[[r168:.*]] = vector.shuffle %[[r117]], %[[r119]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r169:.*]] = vector.shuffle %[[r117]], %[[r119]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r170:.*]] = arith.addf %168, %169 : vector<32xf16>
-    //CHECK: %[[r171:.*]] = vector.shuffle %[[r121]], %[[r123]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r172:.*]] = vector.shuffle %[[r121]], %[[r123]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r173:.*]] = arith.addf %171, %172 : vector<32xf16>
-    //CHECK: %[[r174:.*]] = vector.shuffle %[[r125]], %[[r127]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r175:.*]] = vector.shuffle %[[r125]], %[[r127]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r176:.*]] = arith.addf %174, %175 : vector<32xf16>
-    //CHECK: %[[r177:.*]] = vector.shuffle %[[r129]], %[[r131]] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r178:.*]] = vector.shuffle %[[r129]], %[[r131]] [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r179:.*]] = arith.addf %177, %178 : vector<32xf16>
-    //CHECK: %[[r180:.*]] = vector.shuffle %[[r134]], %[[r137]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r181:.*]] = vector.shuffle %[[r134]], %[[r137]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r182:.*]] = arith.addf %180, %181 : vector<32xf16>
-    //CHECK: %[[r183:.*]] = vector.shuffle %[[r140]], %[[r143]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r184:.*]] = vector.shuffle %[[r140]], %[[r143]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r185:.*]] = arith.addf %183, %184 : vector<32xf16>
-    //CHECK: %[[r186:.*]] = vector.shuffle %[[r146]], %[[r149]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r187:.*]] = vector.shuffle %[[r146]], %[[r149]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r188:.*]] = arith.addf %186, %187 : vector<32xf16>
-    //CHECK: %[[r189:.*]] = vector.shuffle %[[r152]], %[[r155]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r190:.*]] = vector.shuffle %[[r152]], %[[r155]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r191:.*]] = arith.addf %189, %190 : vector<32xf16>
-    //CHECK: %[[r192:.*]] = vector.shuffle %[[r158]], %[[r161]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r193:.*]] = vector.shuffle %[[r158]], %[[r161]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r194:.*]] = arith.addf %192, %193 : vector<32xf16>
-    //CHECK: %[[r195:.*]] = vector.shuffle %[[r164]], %[[r167]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r196:.*]] = vector.shuffle %[[r164]], %[[r167]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r197:.*]] = arith.addf %195, %196 : vector<32xf16>
-    //CHECK: %[[r198:.*]] = vector.shuffle %[[r170]], %[[r173]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r199:.*]] = vector.shuffle %[[r170]], %[[r173]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r200:.*]] = arith.addf %198, %199 : vector<32xf16>
-    //CHECK: %[[r201:.*]] = vector.shuffle %[[r176]], %[[r179]] [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r202:.*]] = vector.shuffle %[[r176]], %[[r179]] [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r203:.*]] = arith.addf %201, %202 : vector<32xf16>
-    //CHECK: %[[r204:.*]] = vector.shuffle %[[r182]], %[[r185]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r205:.*]] = vector.shuffle %[[r182]], %[[r185]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r206:.*]] = arith.addf %204, %205 : vector<32xf16>
-    //CHECK: %[[r207:.*]] = vector.shuffle %[[r188]], %[[r191]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r208:.*]] = vector.shuffle %[[r188]], %[[r191]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r209:.*]] = arith.addf %207, %208 : vector<32xf16>
-    //CHECK: %[[r210:.*]] = vector.shuffle %[[r194]], %[[r197]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r211:.*]] = vector.shuffle %[[r194]], %[[r197]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r212:.*]] = arith.addf %210, %211 : vector<32xf16>
-    //CHECK: %[[r213:.*]] = vector.shuffle %[[r200]], %[[r203]] [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r214:.*]] = vector.shuffle %[[r200]], %[[r203]] [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r215:.*]] = arith.addf %213, %214 : vector<32xf16>
-    //CHECK: %[[r216:.*]] = vector.shuffle %[[r206]], %[[r209]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r217:.*]] = vector.shuffle %[[r206]], %[[r209]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r218:.*]] = arith.addf %216, %217 : vector<32xf16>
-    //CHECK: %[[r219:.*]] = vector.shuffle %[[r212]], %[[r215]] [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r220:.*]] = vector.shuffle %[[r212]], %[[r215]] [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r221:.*]] = arith.addf %219, %220 : vector<32xf16>
-    //CHECK: %[[r222:.*]] = vector.shuffle %[[r218]], %[[r221]] [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r223:.*]] = vector.shuffle %[[r218]], %[[r221]] [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %[[r224:.*]] = arith.addf %222, %223 : vector<32xf16>
-
-    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x8xf16>
-
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<32x8xf16> -> vector<8x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    %3 = xetile.reduction <add>, %2 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    %4 = xetile.broadcast %3 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    %5 = xetile.transpose %4, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
-    %6 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
-    xetile.store_tile %5, %6: vector<64x32xf16>, !xetile.tile<64x32xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sglevel_softmax_dim_0
-  //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_softmax_dim_0(%a: memref<1024x1024xf16>) {
-
-    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-
-    //CHECK-COUNT-2: %{{.*}} = xetile.load_tile %{{.*}} : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x32xf16>
-    %3 = math.exp %2: vector<32x64xf16>
-
-    //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<8x32xf16> to vector<1x32xf16>
-    //CHECK-COUNT-62: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<1x32xf16>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    %4 = xetile.reduction <add>, %3 [0]: vector<32x64xf16> -> vector<1x64xf16>
-    %5 = xetile.broadcast %4 [0]: vector<1x64xf16> -> vector<32x64xf16>
-    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<8x32xf16>
-    %6 = arith.divf %3, %5: vector<32x64xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
-    gpu.return
-  }
-
-  //CHECK: (%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_softmax_dim_1(%a: memref<1024x1024xf16>) {
-    //CHECK: %[[c32:.*]] = arith.constant 32 : index
-    //CHECK: %[[c0:.*]] = arith.constant 0 : index
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c0]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][%[[c0]], %[[c32]]] : memref<1024x1024xf16> -> !xetile.tile<32x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.extract_strided_slice %[[r3]] {offsets = [{{.*}}], sizes = [8, 32], strides = [1, 1]} : vector<32x32xf16> to vector<8x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x32xf16>
-    //CHECK-COUNT-64: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [1, 32], strides = [1, 1]} : vector<8x32xf16> to vector<1x32xf16>
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23, 32, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 51, 52, 53, 54, 55] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31, 40, 41, 42, 43, 44, 45, 46, 47, 56, 57, 58, 59, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27, 32, 33, 34, 35, 40, 41, 42, 43, 48, 49, 50, 51, 56, 57, 58, 59] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31, 36, 37, 38, 39, 44, 45, 46, 47, 52, 53, 54, 55, 60, 61, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32, 33, 36, 37, 40, 41, 44, 45, 48, 49, 52, 53, 56, 57, 60, 61] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 42, 43, 46, 47, 50, 51, 54, 55, 58, 59, 62, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63] : vector<32xf16>, vector<32xf16>
-    //CHECK: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<32xf16>
-
-    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<8x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    %3 = math.exp %2: vector<32x64xf16>
-    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    %6 = arith.divf %3, %5: vector<32x64xf16>
-    %7 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    xetile.store_tile %6, %7: vector<32x64xf16>, !xetile.tile<32x64xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sglevel_softmax_transpose
-  //CHECK-SAME(%[[arg0:.*]]: memref<1024x1024xf16>)
-  gpu.func @sglevel_softmax_transpose(%a: memref<1024x1024xf16>) {
-
-
-    //CHECK-COUNT-32: %{{.*}} = vector.extractelement %{{.*}}[%{{.*}} : i32] : vector<32xf16>
-    //CHECK-COUNT-32: %{{.*}} = vector.splat %{{.*}} : vector<1x8xf16>
-
-    //CHECK-COUNT-16: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x8xf16>, vector<1x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x8xf16>, vector<2x8xf16>
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x8xf16>, vector<4x8xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] : vector<8x8xf16>, vector<8x8xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] : vector<16x8xf16>, vector<16x8xf16>
-
-    //CHECK-COUNT-8: %{{.*}} = arith.divf %{{.*}}, %{{.*}} : vector<32x8xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<32x8xf16> -> vector<8x32xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<1024x1024xf16> -> !xetile.tile<8x32xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    %1 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<32x64xf16>
-    %2 = xetile.load_tile %1: !xetile.tile<32x64xf16> -> vector<32x64xf16>
-    %3 = math.exp %2: vector<32x64xf16>
-    %4 = xetile.reduction <add>, %3 [1]: vector<32x64xf16> -> vector<32x1xf16>
-    %5 = xetile.broadcast %4 [1]: vector<32x1xf16> -> vector<32x64xf16>
-    %6 = arith.divf %3, %5: vector<32x64xf16>
-    %7 = xetile.transpose %6, [1, 0]: vector<32x64xf16> -> vector<64x32xf16>
-    %8 = xetile.init_tile %a[0, 0] : memref<1024x1024xf16> -> !xetile.tile<64x32xf16>
-    xetile.store_tile %7, %8: vector<64x32xf16>, !xetile.tile<64x32xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sglevel_unregular_gemm
-  //CHECK-SAME: %[[arg0:.*]]: memref<16384x12288xf16>, %[[arg1:.*]]: memref<1536x12288xf16>, %[[arg2:.*]]: memref<16384x1536xf32>
-  gpu.func @sglevel_unregular_gemm(%arg0: memref<16384x12288xf16>, %arg1: memref<1536x12288xf16>, %arg2: memref<16384x1536xf32>) attributes {gemm_tiles_b = 1 : i64, gemm_tiles_x = dense<[8, 2, 4, 8]> : vector<4xi64>, gemm_tiles_y = dense<[1, 1, 8, 4]> : vector<4xi64>, physical_nd_range = dense<[8, 32]> : vector<2xi64>, region_partition = 0 : i64, region_size = 32 : i64, syn.fusion_successful, syn.tensor_signature = (tensor<16384x12288xf16>, tensor<1536x12288xf16>) -> tensor<16384x1536xf32>, synFusionGenOps = 6 : i64, synFusionRequiredBeamSize = 1 : i64, synFusionTotalCost = 1007562515.4 : f64} {
-    %c64 = arith.constant 64 : index
-    %cst = arith.constant dense<0.000000e+00> : vector<32x64xf32>
-    %c0 = arith.constant 0 : index
-    %c1024 = arith.constant 1024 : index
-    %c256 = arith.constant 256 : index
-    %c2048 = arith.constant 2048 : index
-    %c2 = arith.constant 2 : index
-    %c12288 = arith.constant 12288 : index
-    %c8 = arith.constant 8 : index
-    %c32 = arith.constant 32 : index
-    %c4 = arith.constant 4 : index
-    %c1 = arith.constant 1 : index
-    %block_id_x = gpu.block_id  x
-    %block_id_y = gpu.block_id  y
-    %0 = arith.divsi %block_id_y, %c8 : index
-    %1 = arith.remsi %block_id_y, %c8 : index
-    %2 = arith.muli %1, %c256 : index
-    %3 = arith.muli %block_id_x, %c2048 : index
-    %4 = arith.muli %0, %c256 : index
-    %5 = arith.addi %3, %4 : index
-    %6 = gpu.subgroup_id : index
-    %7 = index.floordivs %6, %c4
-    %8 = index.remu %6, %c4
-    %9 = index.remu %7, %c8
-    %10 = index.mul %9, %c32
-    %11 = index.add %5, %10
-    %12 = index.remu %8, %c4
-    %13 = index.mul %12, %c64
-    %14 = index.add %2, %13
-
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-    //CHECK-COUNT-4: %{{.*}} = xetile.init_tile %[[arg2]][%{{.*}}, %{{.*}}] : memref<16384x1536xf32> -> !xetile.tile<8x16xf32>
-
-    %15 = xetile.init_tile %arg2[%11, %14] : memref<16384x1536xf32> -> !xetile.tile<32x64xf32>
-    %16 = index.remu %8, %c1
-    %17 = index.mul %16, %c32
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<16384x12288xf16> -> !xetile.tile<32x16xf16>
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg0]][%{{.*}}, %{{.*}}] : memref<16384x12288xf16> -> !xetile.tile<32x16xf16>
-    %18 = xetile.init_tile %arg0[%11, %17] : memref<16384x12288xf16> -> !xetile.tile<32x32xf16>
-    %19 = index.floordivs %6, %c8
-    %20 = index.remu %6, %c8
-    %21 = index.remu %19, %c4
-    %22 = index.mul %21, %c64
-    %23 = index.add %2, %22
-    %24 = index.remu %20, %c1
-    %25 = index.mul %24, %c32
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
-    //CHECK: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
-    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
-    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
-    //CHECK-COUNT-2: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<1536x12288xf16> -> !xetile.tile<16x16xf16>
-    %26 = xetile.init_tile %arg1[%23, %25] : memref<1536x12288xf16> -> !xetile.tile<64x32xf16>
-    %27:2 = scf.for %arg15 = %c0 to %c2 step %c1 iter_args(%arg16 = %15, %arg17 = %18) -> (!xetile.tile<32x64xf32>, !xetile.tile<32x32xf16>) {
-      //CHECK-COUNT-2: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
-      %28 = xetile.update_tile_offset %arg17, [%c1024,  %c0] :  !xetile.tile<32x32xf16>
-      //CHECK-COUNT-16: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<8x16xf32>
-      %29 = xetile.update_tile_offset %arg16, [%c1024,  %c0] : !xetile.tile<32x64xf32>
-      //CHECK: %{{.*}}:26 = scf.for %[[arg22:.*]] = %{{.*}} to %{{.*}} step %{{.*}} iter_args({{.*}}) -> (vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, vector<8x16xf32>, !xetile.tile<32x16xf16>, !xetile.tile<32x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>, !xetile.tile<16x16xf16>) {
-      %30:3 = scf.for %arg18 = %c0 to %c12288 step %c32 iter_args(%arg19 = %cst, %arg20 = %arg17, %arg21 = %26) -> (vector<32x64xf32>, !xetile.tile<32x32xf16>, !xetile.tile<64x32xf16>) {
-        //CHECK-COUNT-8: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<16x16xf16>
-        %32 = xetile.update_tile_offset %arg21, [%c0,  %c32] : !xetile.tile<64x32xf16>
-        //CHECK-COUNT-2: %{{.*}} = xetile.update_tile_offset %{{.*}}, [%{{.*}}, %{{.*}}] : !xetile.tile<32x16xf16>
-        %33 = xetile.update_tile_offset %arg20, [%c0,  %c32] :  !xetile.tile<32x32xf16>
-        //CHECK-COUNT-2: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<32x16xf16> -> vector<32x16xf16>
-        //CHECK-COUNT-8: %{{.*}} = vector.extract_strided_slice %{{.*}} {offsets = [{{.*}}], sizes = [8, 16], strides = [1, 1]} : vector<32x16xf16> to vector<8x16xf16>
-        %34 = xetile.load_tile %arg20 {padding = 0.000000e+00 : f32}  : !xetile.tile<32x32xf16> -> vector<32x32xf16>
-        //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<8x16xf16>
-        %35 = math.exp %34 : vector<32x32xf16>
-        //CHECK-COUNT-8: %{{.*}} = xetile.load_tile %{{.*}} {padding = 0.000000e+00 : f32} : !xetile.tile<16x16xf16> -> vector<16x16xf16>
-        %36 = xetile.load_tile %arg21 {padding = 0.000000e+00 : f32}  : !xetile.tile<64x32xf16> -> vector<64x32xf16>
-        //CHECK-COUNT-8: %{{.*}} = xetile.transpose %{{.*}}, [1, 0] : vector<16x16xf16> -> vector<16x16xf16>
-        %37 = xetile.transpose %36, [1, 0] : vector<64x32xf16> -> vector<32x64xf16>
-        //CHECK-COUNT-8: %{{.*}} = math.exp %{{.*}} : vector<16x16xf16>
-        %38 = math.exp %37 : vector<32x64xf16>
-        //CHECK: xegpu.compile_hint
-        xegpu.compile_hint
-        //CHECK-COUNT-32: %{{.*}} = xetile.tile_mma %{{.*}}, %{{.*}}, %{{.*}} : vector<8x16xf16>, vector<16x16xf16>, vector<8x16xf32> -> vector<8x16xf32>
-        %39 = xetile.tile_mma %35, %38, %cst : vector<32x32xf16>, vector<32x64xf16>, vector<32x64xf32> -> vector<32x64xf32>
-        //CHECK: xegpu.compile_hint
-        xegpu.compile_hint
-        //CHECK-COUNT-16: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : vector<8x16xf32>
-        %40 = arith.addf %arg19, %39 : vector<32x64xf32>
-        scf.yield %40, %33, %32 : vector<32x64xf32>, !xetile.tile<32x32xf16>, !xetile.tile<64x32xf16>
-      }
-      //CHECK-COUNT-16: %{{.*}} = math.exp %{{.*}} : vector<8x16xf32>
-      %31 = math.exp %30#0 : vector<32x64xf32>
-      //CHECK-COUNT-16: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
-      xetile.store_tile %31,  %arg16 : vector<32x64xf32>, !xetile.tile<32x64xf32>
-      scf.yield %29, %28 : !xetile.tile<32x64xf32>, !xetile.tile<32x32xf16>
-    }
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sglevel_transpose_broadcast_dim_0
-  //CHECK-SAME(%[[arg0:.*]]: memref<384x1xf32>, %[[arg1:.*]]: memref<256x384xf32>)
-  gpu.func @sglevel_transpose_broadcast_dim_0(%arg0: memref<384x1xf32>, %arg1: memref<256x384xf32>) {
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][{{.*}}] : memref<384x1xf32> -> !xetile.tile<16x1xf32>
-    //CHECK: %[[r1:.*]] = xetile.init_tile %[[arg0]][{{.*}}] : memref<384x1xf32> -> !xetile.tile<16x1xf32>
-    %1 = xetile.init_tile %arg0[0, 0] : memref<384x1xf32> -> !xetile.tile<32x1xf32>
-    //CHECK: %[[r2:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32} : !xetile.tile<16x1xf32> -> vector<16x1xf32>
-    //CHECK: %[[r3:.*]] = xetile.load_tile %[[r1]] {padding = 0.000000e+00 : f32} : !xetile.tile<16x1xf32> -> vector<16x1xf32>
-    %2 = xetile.load_tile %1 {padding = 0.000000e+00 : f32} : !xetile.tile<32x1xf32> -> vector<32x1xf32>
-    //CHECK: %[[r4:.*]] = xetile.transpose %[[r2]], [1, 0] : vector<16x1xf32> -> vector<1x16xf32>
-    //CHECK: %[[r5:.*]] = xetile.transpose %[[r3]], [1, 0] : vector<16x1xf32> -> vector<1x16xf32>
-    %3 = xetile.transpose %2, [1, 0] : vector<32x1xf32> -> vector<1x32xf32>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x16xf32>, vector<1x16xf32>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x16xf32>, vector<2x16xf32>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x16xf32>, vector<4x16xf32>
-    %4 = xetile.broadcast %3 [0] : vector<1x32xf32> -> vector<64x32xf32>
-
-    //CHECK-COUNT-16: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<256x384xf32> -> !xetile.tile<8x16xf32>
-    %5 = xetile.init_tile %arg1[0, 0] : memref<256x384xf32> -> !xetile.tile<64x32xf32>
-    //CHECK-COUNT-16: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x16xf32>, !xetile.tile<8x16xf32>
-    xetile.store_tile %4, %5 : vector<64x32xf32>, !xetile.tile<64x32xf32>
-    gpu.return
-  }
-
-  gpu.func @sglevel_transpose_broadcast_dim_1(%arg0: memref<1x384xf16>, %arg1: memref<384x256xf16>) {
-
-    //CHECK: %[[r0:.*]] = xetile.init_tile %[[arg0]][0, 0] : memref<1x384xf16> -> !xetile.tile<1x32xf16>
-    //CHECK: %[[r1:.*]] = xetile.load_tile %[[r0]] {padding = 0.000000e+00 : f32} : !xetile.tile<1x32xf16> -> vector<1x32xf16>
-    //CHECK: %[[r2:.*]] = xetile.transpose %[[r1]], [1, 0] : vector<1x32xf16> -> vector<32x1xf16>
-    %1 = xetile.init_tile %arg0[0, 0] : memref<1x384xf16> -> !xetile.tile<1x32xf16>
-    %2 = xetile.load_tile %1 {padding = 0.000000e+00 : f32} : !xetile.tile<1x32xf16> -> vector<1x32xf16>
-    %3 = xetile.transpose %2, [1, 0] : vector<1x32xf16> -> vector<32x1xf16>
-
-    //CHECK-COUNT-32: %{{.*}} = vector.extract_strided_slice %[[r2]] {offsets = [{{.*}}, 0], sizes = [1, 1], strides = [1, 1]} : vector<32x1xf16> to vector<1x1xf16>
-
-    //CHECK: %{{.*}} = vector.extract %{{.*}}[0, 0] : f16 from vector<1x1xf16>
-    //CHECK: %{{.*}} = vector.splat %{{.*}} : vector<1x32xf16>
-
-    //CHECK-COUNT-4: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1] : vector<1x32xf16>, vector<1x32xf16>
-    //CHECK-COUNT-2: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3] : vector<2x32xf16>, vector<2x32xf16>
-    //CHECK: %{{.*}} = vector.shuffle %{{.*}}, %{{.*}} [0, 1, 2, 3, 4, 5, 6, 7] : vector<4x32xf16>, vector<4x32xf16>
-    %4 = xetile.broadcast %3 [1] : vector<32x1xf16> -> vector<32x64xf16>
-    //CHECK-COUNT-8: %{{.*}} = xetile.init_tile %[[arg1]][%{{.*}}, %{{.*}}] : memref<384x256xf16> -> !xetile.tile<8x32xf16>
-    %5 = xetile.init_tile %arg1[0, 0] : memref<384x256xf16> -> !xetile.tile<32x64xf16>
-    //CHECK-COUNT-8: xetile.store_tile %{{.*}},  %{{.*}} : vector<8x32xf16>, !xetile.tile<8x32xf16>
-    xetile.store_tile %4, %5 : vector<32x64xf16>, !xetile.tile<32x64xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sg_loadgather
-  //CHECK-SAME: %[[arg0:.*]]: memref<1024xf16>, %[[arg1:.*]]: vector<4x32xindex>
-  gpu.func @sg_loadgather(%a: memref<1024xf16>, %indices: vector<4x32xindex>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<1x32xi1>
-    //CHECK: %[[r0:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r1:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]], %[[r1]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]], %[[r2]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg0]], %[[r3]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r8:.*]] = xetile.load %[[r4]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
-    //CHECK: %[[r9:.*]] = xetile.load %[[r5]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
-    //CHECK: %[[r10:.*]] = xetile.load %[[r6]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
-    //CHECK: %[[r11:.*]] = xetile.load %[[r7]], %[[cst]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf16>
-    %mask = arith.constant dense<1> : vector<4x32xi1>
-    %1 = xetile.init_tile %a, %indices : memref<1024xf16>, vector<4x32xindex> -> !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>
-    %2 = xetile.load %1, %mask : !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>, vector<4x32xi1> -> vector<4x32xf16>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @sg_storescatter
-  //CHECK-SAME: %[[arg0:.*]]: memref<1024xf16>, %[[arg1:.*]]: vector<4x32xindex>
-  gpu.func @sg_storescatter(%a: memref<1024xf16>, %indices: vector<4x32xindex>) {
-    //CHECK: %[[cst:.*]] = arith.constant dense<4.200000e+01> : vector<1x32xf16>
-    //CHECK: %[[cst_0:.*]] = arith.constant dense<true> : vector<1x32xi1>
-    //CHECK: %[[cst_1:.*]] = arith.constant dense<1> : vector<1x32xindex>
-    //CHECK: %[[r0:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [0, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r1:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [1, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [2, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[arg1]] {offsets = [3, 0], sizes = [1, 32], strides = [1, 1]} : vector<4x32xindex> to vector<1x32xindex>
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[arg0]], %[[r0]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[arg0]], %[[r1]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r6:.*]] = xetile.init_tile %[[arg0]], %[[r2]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r7:.*]] = xetile.init_tile %[[arg0]], %[[r3]] : memref<1024xf16>, vector<1x32xindex> -> !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>
-    //CHECK: xetile.store %[[cst]], %[[r4]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r5]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r6]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r7]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: %[[r8:.*]] = xetile.update_tile_offset %[[r4]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
-    //CHECK: %[[r9:.*]] = xetile.update_tile_offset %[[r5]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
-    //CHECK: %[[r10:.*]] = xetile.update_tile_offset %[[r6]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
-    //CHECK: %[[r11:.*]] = xetile.update_tile_offset %[[r7]], %[[cst_1]] : !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xindex>
-    //CHECK: xetile.store %[[cst]], %[[r8]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r9]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r10]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    //CHECK: xetile.store %[[cst]], %[[r11]], %[[cst_0]] : vector<1x32xf16>, !xetile.tile<1x32xf16, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    %offsets = arith.constant dense<1> : vector<4x32xindex>
-    %mask = arith.constant dense<1> : vector<4x32xi1>
-    %data = arith.constant dense<42.0> : vector<4x32xf16>
-    %tile = xetile.init_tile %a, %indices : memref<1024xf16>, vector<4x32xindex> -> !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>
-    xetile.store %data, %tile, %mask : vector<4x32xf16>, !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>, vector<4x32xi1>
-    %next = xetile.update_tile_offset %tile, %offsets : !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>, vector<4x32xindex>
-    xetile.store %data, %next, %mask : vector<4x32xf16>, !xetile.tile<4x32xf16, #xetile.tile_attr<scattered = true>>, vector<4x32xi1>
-    gpu.return
-  }
-
-  //CHECK-LABEL: gpu.func @add_kernel
-  //CHECK-SAME: %[[arg0:.*]]: memref<*xf32>, %[[arg1:.*]]: memref<*xf32>, %[[arg2:.*]]: memref<*xf32>
-  gpu.func @add_kernel(%arg0: memref<*xf32>, %arg1: memref<*xf32>, %arg2: memref<*xf32>) {
-
-    //CHECK: %[[c1024:.*]] = arith.constant 1024 : index
-    //CHECK: %[[cst:.*]] = arith.constant dense<true> : vector<1x16xi1>
-    //CHECK: %[[cast:.*]] = memref.cast %[[arg0]] : memref<*xf32> to memref<?xf32>
-    //CHECK: %[[cast_0:.*]] = memref.cast %[[arg1]] : memref<*xf32> to memref<?xf32>
-    //CHECK: %[[cast_1:.*]] = memref.cast %[[arg2]] : memref<*xf32> to memref<?xf32>
-    //CHECK: %[[block_id_x:.*]] = gpu.block_id  x
-    //CHECK: %[[r0:.*]] = arith.muli %[[block_id_x]], %[[c1024]] : index
-    //CHECK: %[[r1:.*]] = vector.splat %[[r0]] : vector<1x32xindex>
-    //CHECK: %[[r2:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 0], sizes = [1, 16], strides = [1, 1]} : vector<1x32xindex> to vector<1x16xindex>
-    //CHECK: %[[r3:.*]] = vector.extract_strided_slice %[[r1]] {offsets = [0, 16], sizes = [1, 16], strides = [1, 1]} : vector<1x32xindex> to vector<1x16xindex>
-    //CHECK: %[[r4:.*]] = xetile.init_tile %[[cast]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r5:.*]] = xetile.init_tile %[[cast]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r6:.*]] = xetile.load %[[r4]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
-    //CHECK: %[[r7:.*]] = xetile.load %[[r5]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
-    //CHECK: %[[r8:.*]] = xetile.init_tile %[[cast_0]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r9:.*]] = xetile.init_tile %[[cast_0]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r10:.*]] = xetile.load %[[r8]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
-    //CHECK: %[[r11:.*]] = xetile.load %[[r9]], %[[cst]] : !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1> -> vector<1x16xf32>
-    //CHECK: %[[r12:.*]] = arith.addf %[[r6]], %[[r10]] : vector<1x16xf32>
-    //CHECK: %[[r13:.*]] = arith.addf %[[r7]], %[[r11]] : vector<1x16xf32>
-    //CHECK: %[[r14:.*]] = xetile.init_tile %[[cast_1]], %[[r2]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: %[[r15:.*]] = xetile.init_tile %[[cast_1]], %[[r3]] : memref<?xf32>, vector<1x16xindex> -> !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>
-    //CHECK: xetile.store %[[r12]], %[[r14]], %[[cst]] : vector<1x16xf32>, !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1>
-    //CHECK: xetile.store %[[r13]], %[[r15]], %[[cst]] : vector<1x16xf32>, !xetile.tile<1x16xf32, #xetile.tile_attr<scattered = true>>, vector<1x16xi1>
-
-    %cst = arith.constant dense<true> : vector<1x32xi1>
-    %c1024 = arith.constant 1024 : index
-    %cast = memref.cast %arg0 : memref<*xf32> to memref<?xf32>
-    %cast_0 = memref.cast %arg1 : memref<*xf32> to memref<?xf32>
-    %cast_1 = memref.cast %arg2 : memref<*xf32> to memref<?xf32>
-    %block_id_x = gpu.block_id  x
-    %0 = arith.muli %block_id_x, %c1024 : index
-    %1 = vector.splat %0 : vector<1x32xindex>
-    %2 = xetile.init_tile %cast, %1 : memref<?xf32>, vector<1x32xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>
-    %3 = xetile.load %2, %cst : !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf32>
-    %4 = xetile.init_tile %cast_0, %1 : memref<?xf32>, vector<1x32xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>
-    %5 = xetile.load %4, %cst : !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>, vector<1x32xi1> -> vector<1x32xf32>
-    %6 = arith.addf %3, %5 : vector<1x32xf32>
-    %7 = xetile.init_tile %cast_1, %1 : memref<?xf32>, vector<1x32xindex> -> !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>
-    xetile.store %6, %7, %cst : vector<1x32xf32>, !xetile.tile<1x32xf32, #xetile.tile_attr<scattered = true>>, vector<1x32xi1>
-    gpu.return
-  }
-}
diff --git a/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp b/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
index e0335abc6..9cd8594f6 100644
--- a/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
+++ b/test/Integration/Dialect/XeTile/xetile-to-func-vc.pp
@@ -2,7 +2,7 @@
     cse
     gpu.module(xetile-init-duplicate
         xetile-canonicalization
-        xetile-blocking{enable-2d-transform=true}
+        xetile-blocking
 	cse
         convert-xetile-to-xegpu
 	cse
diff --git a/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp b/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
index 27352d9bc..9037120f3 100644
--- a/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
+++ b/test/Integration/Dialect/XeTile/xetile-wg-to-func-vc.pp
@@ -4,7 +4,7 @@
         cse
         xetile-init-duplicate
         xetile-canonicalization
-        xetile-blocking{enable-2d-transform=true}
+        xetile-blocking
         canonicalize
         convert-xetile-to-xegpu
         cse