[llvm-branch-commits] [llvm] [Matrix] Introduce LoadInfo/StoreInfo to add tiling with remainder support (PR #211444)
Jon Roelofs via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Jul 23 08:47:13 PDT 2026
https://github.com/jroelofs updated https://github.com/llvm/llvm-project/pull/211444
>From f66306a1c52005c00a79c83ecc08b438073d957f Mon Sep 17 00:00:00 2001
From: Francis Visoiu Mistrih <francisvm at apple.com>
Date: Thu, 2 Jul 2026 17:16:21 -0700
Subject: [PATCH 1/2] [Matrix] Introduce LoadInfo/StoreInfo to add tiling with
remainder support
---
.../Scalar/LowerMatrixIntrinsics.cpp | 951 ++-
.../alias-check-remark.ll | 17 +
.../double-transpose-asserts-shape.ll | 163 +
.../multiply-fused-loops.ll | 73 +-
.../LowerMatrixIntrinsics/no-tiling-remark.ll | 6436 +++++++++++++++++
5 files changed, 7515 insertions(+), 125 deletions(-)
create mode 100644 llvm/test/Transforms/LowerMatrixIntrinsics/alias-check-remark.ll
create mode 100644 llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
create mode 100644 llvm/test/Transforms/LowerMatrixIntrinsics/no-tiling-remark.ll
diff --git a/llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp b/llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp
index b8eb5d3f94984..8200ce1a4acce 100644
--- a/llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp
+++ b/llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp
@@ -117,6 +117,14 @@ static cl::opt<unsigned>
LoopMinTilesCount("fuse-matrix-loop-min-tiles-count", cl::init(4),
cl::desc("The minimum number of computed tiles required "
"to make loop generation profitable."));
+static cl::opt<bool> EnablePushingToMemForTiling(
+ "matrix-enable-pushing-to-mem-for-tiling", cl::init(true), cl::Hidden,
+ cl::desc("Push operands of large matrix multiplies into memory in order to "
+ "satisfy the requirements for tiling."));
+
+// Frame pointers are unsupported currently, so disable dynamic allocas.
+static cl::opt<bool> AllocaInEntryBlock("matrix-alloca-in-entry-block",
+ cl::init(false));
static cl::opt<unsigned> SplitMatmulRemainderOverThreshold(
"matrix-split-matmul-remainder-over-threshold", cl::Hidden,
@@ -282,6 +290,233 @@ raw_ostream &operator<<(raw_ostream &OS, ShapeInfo SI) {
} // namespace
+// Returns true if \p V is a matrix load.
+static bool isAnyLoad(Value *V) {
+ if (isa<LoadInst>(V))
+ return true;
+ if (match(V, m_Intrinsic<Intrinsic::matrix_column_major_load>()))
+ return true;
+ return false;
+}
+
+// Information about the way a matrix is loaded. Used to analyze the operands
+// of a matrix multiply and help with lowering different types of lowering
+// sequences.
+// This can represent:
+// * a regular matrix load
+// * matrix.column.major.load intrinsics
+class LoadInfo {
+public:
+ LoadInfo(Instruction *Load, Instruction *Transpose = nullptr)
+ : Load(Load), Ptr(Load->getOperand(0)), Transpose(Transpose) {
+ assert(isAnyLoad(Load) &&
+ "Only loads and matrix.column.major.loads are supported.");
+ }
+
+ Instruction *getLoad() { return Load; }
+ Value *getPointerOperand() const { return Ptr; }
+ unsigned getPointerAddressSpace() const {
+ return getPointerOperand()->getType()->getPointerAddressSpace();
+ }
+ MaybeAlign getAlign() const {
+ if (auto *LI = dyn_cast<LoadInst>(Load))
+ return LI->getAlign();
+ return cast<CallInst>(Load)->getParamAlign(0);
+ }
+
+ bool isVolatile() const {
+ if (auto *LI = dyn_cast<LoadInst>(Load))
+ return LI->isVolatile();
+ return cast<ConstantInt>(cast<CallInst>(Load)->getArgOperand(2))->isOne();
+ }
+
+ void setNonAliasingPtr(Value *NonAliasingPtr) {
+ if (NonAliasingPtr != getPointerOperand())
+ Ptr = NonAliasingPtr;
+ }
+
+ Value *getRealStride(unsigned ShapeStride, IRBuilder<> &Builder) const {
+ if (isa<LoadInst>(Load))
+ return asIndex(Builder, ShapeStride);
+ // It's a column.major load otherwise. If it's a constant, use the index
+ // type, otherwise just return the dynamic value.
+ Value *Stride = Load->getOperand(1);
+ if (auto *CI = dyn_cast<ConstantInt>(Stride))
+ return asIndex(Builder, CI->getZExtValue());
+ return Stride;
+ }
+
+ MemoryLocation getMemLoc(const DataLayout &DL) const {
+ AAMDNodes AATags = Load->getAAMetadata();
+ MemoryLocation LoadLoc(
+ getPointerOperand(),
+ LocationSize::precise(DL.getTypeStoreSize(Load->getType())), AATags);
+ return LoadLoc;
+ }
+
+ bool isTransposed() const { return Transpose != nullptr; }
+ Instruction *getTranspose() { return Transpose; }
+
+private:
+ Instruction *Load = nullptr;
+ Value *Ptr = nullptr;
+ Instruction *Transpose = nullptr;
+};
+
+/// Information about the way a matrix is stored.
+/// This can represent:
+/// * a regular store: store(matmul)
+/// * an accumulating store: store(add(load, matmul))
+class StoreInfo {
+public:
+ /// Create a regular store.
+ StoreInfo(Instruction *Store) : Store(Store) {}
+ /// Create an accumulating store.
+ StoreInfo(Instruction *Store, Instruction *BinOp, LoadInfo LI)
+ : Store(Store), BinOp(BinOp), LI(LI) {}
+
+ /// Returns true when the accumulating operation is an add, false if it's a
+ /// sub.
+ bool isAdd() const {
+ switch (BinOp->getOpcode()) {
+ case Instruction::Add:
+ case Instruction::FAdd:
+ return true;
+ case Instruction::Sub:
+ case Instruction::FSub:
+ return false;
+ default:
+ llvm_unreachable(
+ "Only add and sub operations are supported with a store.");
+ }
+ }
+
+ /// Returns true if this is an accumulating store.
+ bool isAccumulating() const { return BinOp && LI; }
+
+ /// Returns the value used by the store as a pointer.
+ Value *getPointerOperand() const {
+ Value *PointerOperand = Store->getOperand(1);
+ if (LI) {
+ assert(!isAccumulating() ||
+ PointerOperand->stripPointerCasts() ==
+ LI->getPointerOperand()->stripPointerCasts() &&
+ "Accumulating store has different load and store pointers.");
+ }
+ return PointerOperand;
+ }
+
+ Value *getRealStride(unsigned ShapeStride, IRBuilder<> &Builder) const {
+ if (isa<StoreInst>(Store))
+ return asIndex(Builder, ShapeStride);
+ // It's a column.major store otherwise. If it's a constant, use the index
+ // type, otherwise just return the dynamic value.
+ Value *Stride = Store->getOperand(2);
+ if (auto *CI = dyn_cast<ConstantInt>(Stride))
+ return asIndex(Builder, CI->getZExtValue());
+ return Stride;
+ }
+
+ MemoryLocation getMemLoc(const DataLayout &DL) const {
+ Value *ValueOperand = Store->getOperand(0);
+ AAMDNodes AATags = Store->getAAMetadata();
+ MemoryLocation StoreLoc(
+ getPointerOperand(),
+ LocationSize::precise(DL.getTypeStoreSize(ValueOperand->getType())),
+ AATags);
+ return StoreLoc;
+ }
+
+ Instruction *getStore() { return Store; }
+ Instruction *getBinOp() { return BinOp; }
+ std::optional<LoadInfo> getLoadInfo() { return LI; }
+
+ MaybeAlign getAlign() const {
+ if (auto *SI = dyn_cast<StoreInst>(Store))
+ return SI->getAlign();
+ return cast<CallInst>(Store)->getParamAlign(1);
+ }
+
+ bool isVolatile() const {
+ if (auto *SI = dyn_cast<StoreInst>(Store))
+ return SI->isVolatile();
+ return cast<ConstantInt>(cast<CallInst>(Store)->getArgOperand(3))->isOne();
+ }
+
+private:
+ /// The final store instruction. Can be either a `store` or a
+ /// `matrix.column.major.store`.
+ Instruction *Store = nullptr;
+ /// The accumulating binop part of the accumulating sequence: can be either
+ /// an add or a sub.
+ Instruction *BinOp = nullptr;
+ /// The load part of the accumulating sequence.
+ std::optional<LoadInfo> LI;
+};
+
+static bool isAnyStore(Instruction *MaybeStore) {
+ if (isa<StoreInst>(MaybeStore))
+ return true;
+ if (match(MaybeStore, m_Intrinsic<Intrinsic::matrix_column_major_store>()))
+ return true;
+ return false;
+}
+
+// Starting from \p MatMul, analyze how its result is stored.
+// Returns a StoreInfo object:
+// * None: the matrix is not directly stored (or stored in an unrecognized way).
+// * StoreInfo::isAccumulating() == false: regular store: store(MatMul)
+// * StoreInfo::isAccumulating() == true: accumulating store:
+// store(fadd(load(PTR), MATMUL), PTR)
+static std::optional<StoreInfo> analyzeStore(CallInst *MatMul,
+ unsigned ShapeStride) {
+ assert(MatMul->hasOneUse() && "Expected matmul with single use");
+ Instruction *MaybeStore = dyn_cast<Instruction>(*MatMul->user_begin());
+ if (!MaybeStore)
+ return std::nullopt;
+
+ if (isAnyStore(MaybeStore))
+ return StoreInfo(MaybeStore);
+
+ return std::nullopt;
+}
+
+static std::optional<LoadInfo> analyzeLoadOperand(Value *Operand) {
+ if (isAnyLoad(Operand))
+ return LoadInfo(cast<Instruction>(Operand));
+
+ Value *Ptr = nullptr;
+ Instruction *Load = nullptr;
+ Instruction *Transpose = nullptr;
+
+ if (match(Operand,
+ m_CombineAnd(
+ m_Intrinsic<Intrinsic::matrix_transpose>(m_CombineAnd(
+ m_CombineOr(
+ m_Load(m_Value(Ptr)),
+ m_Intrinsic<Intrinsic::matrix_column_major_load>()),
+ m_Instruction(Load))),
+ m_Instruction(Transpose))))
+ return LoadInfo(Load, Transpose);
+
+ return std::nullopt;
+}
+
+static std::optional<std::pair<LoadInfo, LoadInfo>>
+analyzeLoadOperands(CallInst *MatMul) {
+ assert(MatMul->hasOneUse() && "Expected matmul with single use");
+ Value *Op0 = MatMul->getOperand(0);
+ Value *Op1 = MatMul->getOperand(1);
+ std::optional<LoadInfo> MaybeOp0 = analyzeLoadOperand(Op0);
+ std::optional<LoadInfo> MaybeOp1 = analyzeLoadOperand(Op1);
+
+ // Return only if both operands are valid.
+ if (MaybeOp0 && MaybeOp1)
+ return std::make_pair(*MaybeOp0, *MaybeOp1);
+
+ return std::nullopt;
+}
+
static bool isShapePreserving(Value *V) {
Instruction *I = dyn_cast<Instruction>(V);
if (!I)
@@ -1216,6 +1451,90 @@ class LowerMatrixIntrinsics {
/// Perform inst-combine-like transformations on matrix operations.
/// Note that this doesn't update the ShapeInfo and relies on it being called
/// before shape propagation.
+ /// Push V to the stack, read it back and change the original users to use the
+ /// load. This is used to push inputs and output of a matmul to the stack in
+ /// order to satisfy the requirements for the tiling loops.
+ void pushToStackForMatmul(Value *V, Instruction *Before, bool IsInput) {
+ IRBuilder<> Builder(Before);
+ if (IsInput) {
+ Value *TA;
+ while (match(V, m_Intrinsic<Intrinsic::matrix_transpose>(m_Value(TA)))) {
+ Builder.SetInsertPoint(cast<Instruction>(V));
+ V = TA;
+ }
+ }
+
+ IRBuilder<>::InsertPoint IP;
+ if (AllocaInEntryBlock) {
+ IP = Builder.saveIP();
+ Builder.SetInsertPoint(Builder.GetInsertBlock()
+ ->getParent()
+ ->getEntryBlock()
+ .getFirstNonPHIIt());
+ }
+ Value *Alloca =
+ Builder.CreateAlloca(V->getType(), nullptr, "fused_matmul_op_stack");
+ if (AllocaInEntryBlock)
+ Builder.restoreIP(IP);
+
+ if (auto *I = dyn_cast<Instruction>(V)) {
+ unsigned StoreSize = DL.getTypeStoreSize(V->getType());
+ if (ORE) {
+ ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+ "large-matmul-stored-to-stack", I)
+ << "Store and re-load of the value of size "
+ << ore::NV("StoreSize", StoreSize)
+ << " is required to facilitate tiling");
+ emitRemarksForInlineChain(*I, *ORE);
+ }
+ }
+
+ StoreInst *Store = Builder.CreateStore(V, Alloca);
+ LoadInst *Load = Builder.CreateLoad(V->getType(), Alloca);
+ V->replaceUsesWithIf(Load, [&](Use &U) { return U.getUser() != Store; });
+ }
+
+ /// Try to transform a matmul with multiple uses to a matmul with a single
+ /// use. If at least one of the uses is a store, try to make it the unique use
+ /// of the matmul to facilitate tiling loop creation. Once that is done,
+ /// this inserts a load from the stored matrix to be used by the rest of the
+ /// uses.
+ /// Returns whether it succeeded at transforming the matmul.
+ bool makeMatMulOneUse(Value *MatMul) {
+ assert(!MatMul->hasOneUse() && "Expecting matmul with multiple uses.");
+
+ // Look for at least one store instruction in the list of uses.
+ auto Found = llvm::find_if(
+ MatMul->uses(), [&](Use &U) { return isa<StoreInst>(U.getUser()); });
+ // If there is no store, there's nothing to be done.
+ if (Found == MatMul->uses().end())
+ return false;
+
+ auto *Store = cast<StoreInst>(Found->getUser());
+ // If the store doesn't dominate all the other uses, we can't rely on
+ // reloading from that memory location, so we need to give up.
+ // FIXME: We can try to improve this by hoisting the store as close as
+ // possible to the MatMul.
+ if (llvm::any_of(MatMul->uses(), [&](Use &U) {
+ if (auto *Inst = dyn_cast<Instruction>(U.getUser()))
+ if (Store != Inst && (!DT || !DT->dominates(Store, Inst)))
+ return true;
+ return false;
+ }))
+ return false;
+
+ // Now, insert a load right after the store, and make all the uses use it
+ // instead of the matmul directly.
+ auto AfterStore = std::next(Store->getIterator());
+ IRBuilder<> Builder(&*AfterStore);
+ LoadInst *Load = Builder.CreateLoad(Store->getValueOperand()->getType(),
+ Store->getPointerOperand());
+ // Replace every use except the original store.
+ MatMul->replaceUsesWithIf(Load,
+ [&](Use &U) { return U.getUser() != Store; });
+ return true;
+ }
+
void combineMatrixOps() {
// Only do this for column major.
if (MatrixLayout != MatrixLayoutTy::ColumnMajor)
@@ -1241,6 +1560,30 @@ class LowerMatrixIntrinsics {
Next = It;
continue;
}
+
+ TileInfo TI(R->getZExtValue(), M->getZExtValue(), C->getZExtValue(),
+ TileSizeRows, TileSizeInner, TileSizeColumns, I.getType());
+ bool FacilitateTilingLoops = EnablePushingToMemForTiling &&
+ TileUseLoops && isTilingLoopProfitable(TI);
+
+ if (FacilitateTilingLoops) {
+ if (!analyzeLoadOperand(A))
+ pushToStackForMatmul(A, &I, true);
+ if (!analyzeLoadOperand(B))
+ pushToStackForMatmul(B, &I, true);
+
+ if (!I.hasOneUse() && !makeMatMulOneUse(&I)) {
+ LLVM_DEBUG(dbgs()
+ << "Could not simplify matmul with multiple uses\n");
+ }
+
+ if (!I.hasOneUse() ||
+ !analyzeStore(cast<CallInst>(&I),
+ ShapeInfo(R->getZExtValue(), C->getZExtValue())
+ .getStride())) {
+ pushToStackForMatmul(&I, I.getNextNode(), false);
+ }
+ }
}
}
}
@@ -1615,6 +1958,21 @@ class LowerMatrixIntrinsics {
{Inst->getArgOperand(3), Inst->getArgOperand(4)}, Builder);
}
+ /// Loads a sub-matrix with shape \p ResultShape from a \p MatrixShape matrix,
+ /// starting at \p LoadInfo's pointer at offset [I][J].
+ MatrixTy loadMatrix(class LoadInfo LoadInfo, ShapeInfo MatrixShape, Value *I,
+ Value *J, ShapeInfo ResultShape, Type *EltTy,
+ IRBuilder<> &Builder) {
+ Value *Stride = LoadInfo.getRealStride(MatrixShape.getStride(), Builder);
+ Value *Offset = Builder.CreateAdd(Builder.CreateMul(J, Stride), I);
+ Value *MatrixPtr = LoadInfo.getPointerOperand();
+ Value *TileStart = Builder.CreateInBoundsGEP(EltTy, MatrixPtr, Offset);
+ auto *TileTy = FixedVectorType::get(EltTy, ResultShape.NumRows *
+ ResultShape.NumColumns);
+ return loadMatrix(TileTy, TileStart, LoadInfo.getAlign(), Stride,
+ LoadInfo.isVolatile(), ResultShape, Builder);
+ }
+
/// Stores a sub-matrix \p StoreVal into the \p R x \p C matrix starting at \p
/// MatrixPtr[I][J].
void storeMatrix(const MatrixTy &StoreVal, Value *MatrixPtr,
@@ -1656,6 +2014,63 @@ class LowerMatrixIntrinsics {
StoreVal.getNumVectors());
}
+ /// Stores a sub-matrix \p StoreVal into the matrix at \p StoreInfo's pointer,
+ /// starting at \p MatrixShape[I][J].
+ void storeMatrix(const MatrixTy &StoreVal, class StoreInfo SI,
+ ShapeInfo MatrixShape, Value *I, Value *J, Type *EltTy,
+ IRBuilder<> &Builder) {
+ Value *MatrixPtr = SI.getPointerOperand();
+ Value *Stride = SI.getRealStride(MatrixShape.getStride(), Builder);
+ Value *Offset = Builder.CreateAdd(Builder.CreateMul(J, Stride), I);
+
+ Value *TileStart = Builder.CreateInBoundsGEP(EltTy, MatrixPtr, Offset);
+ auto *TileTy = FixedVectorType::get(EltTy, StoreVal.getNumRows() *
+ StoreVal.getNumColumns());
+ storeMatrix(TileTy, StoreVal, TileStart, Stride, SI, Builder);
+ }
+
+ /// Store matrix \p StoreVal, accumulating into existing memory if \p SI is
+ /// an accumulating store.
+ MatrixTy storeMatrix(Type *Ty, MatrixTy StoreVal, Value *Ptr, Value *Stride,
+ class StoreInfo SI, IRBuilder<> &Builder) {
+ auto *VType = cast<FixedVectorType>(Ty);
+ auto *EltType = VType->getElementType();
+ Value *EltPtr = Ptr;
+ for (auto Vec : enumerate(StoreVal.vectors())) {
+ Value *GEP = computeVectorAddr(
+ EltPtr,
+ Builder.getIntN(Stride->getType()->getScalarSizeInBits(),
+ Vec.index()),
+ Stride, StoreVal.getStride(), VType->getElementType(), Builder);
+ Value *V = Vec.value();
+ if (SI.isAccumulating()) {
+ Value *Load = Builder.CreateLoad(V->getType(), GEP, "load.accumulator");
+ if (SI.isAdd()) {
+ if (EltType->isFloatingPointTy())
+ V = Builder.CreateFAdd(Load, V, "accumulate");
+ else
+ V = Builder.CreateAdd(Load, V, "accumulate");
+ } else {
+ if (EltType->isFloatingPointTy())
+ V = Builder.CreateFSub(Load, V, "accumulate");
+ else
+ V = Builder.CreateSub(Load, V, "accumulate");
+ }
+ }
+ Builder.CreateAlignedStore(V, GEP,
+ getAlignForIndex(Vec.index(), Stride,
+ VType->getElementType(),
+ SI.getAlign()),
+ SI.isVolatile());
+ }
+ return MatrixTy()
+ .addNumStores(getNumOps(StoreVal.getVectorTy()) *
+ StoreVal.getNumVectors())
+ .addNumComputeOps(SI.isAccumulating()
+ ? StoreVal.getNumVectors() * /*load + add*/ 2
+ : 0);
+ }
+
/// Lower a store instruction with shape information.
MatrixTy LowerStore(Instruction *Inst, Value *Matrix, Value *Ptr,
MaybeAlign A, Value *Stride, bool IsVolatile,
@@ -2014,6 +2429,19 @@ class LowerMatrixIntrinsics {
assert(A.isColumnMajor() == B.isColumnMajor() &&
Result.isColumnMajor() == A.isColumnMajor() &&
"operands must agree on matrix layout");
+
+ if (!IsTiled && R * C * M > 100) {
+ Instruction &I = *Builder.GetInsertPoint();
+ assert(match(&I, m_Intrinsic<Intrinsic::matrix_multiply>()));
+ if (ORE) {
+ ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+ "large-matmul-without-tiling", &I)
+ << "Not tiling for matmul with FLOPS "
+ << ore::NV("FLOPS", R * M * C));
+ emitRemarksForInlineChain(I, *ORE);
+ }
+ }
+
unsigned NumComputeOps = 0;
Builder.setFastMathFlags(FMF);
@@ -2076,31 +2504,108 @@ class LowerMatrixIntrinsics {
Result.addNumComputeOps(NumComputeOps);
}
- /// Ensure that the memory in \p Load does not alias \p Store by potentially
+ /// Compute \p Result = \p A^t * \p B using a dot product through
+ /// vector_reduce_fadd(fmul(col(A), col(B))).
+ void emitMatrixMultiplyTN(MatrixTy &Result, const MatrixTy &A,
+ const MatrixTy &B, IRBuilder<> &Builder,
+ bool isTiled) {
+ auto *EltType = Result.getElementType();
+ unsigned VF = std::max<unsigned>(
+ TTI.getRegisterBitWidth(TargetTransformInfo::RGK_FixedWidthVector)
+ .getFixedValue() /
+ EltType->getPrimitiveSizeInBits().getFixedValue(),
+ 1U);
+
+ unsigned Rows = Result.getNumRows();
+ unsigned Cols = Result.getNumColumns();
+ unsigned Inner = B.getNumRows();
+
+ assert(A.isColumnMajor());
+
+ if (!isTiled && Rows * Cols * Inner > 100) {
+ Instruction &I = *Builder.GetInsertPoint();
+ assert(match(&I, m_Intrinsic<Intrinsic::matrix_multiply>()));
+ if (ORE) {
+ ORE->emit(
+ OptimizationRemarkMissed(DEBUG_TYPE, "matmul TN without tiling", &I)
+ << "Not tiling for TN matmul with FLOPS "
+ << ore::NV("FLOPS", Rows * Inner * Cols));
+ emitRemarksForInlineChain(I, *ORE);
+ }
+ }
+
+ // Extract a column from A and a column from B, compute the dot product (of
+ // dimension VF) and accumulate the result into the result column one by
+ // one.
+ for (unsigned C = 0; C < Cols; ++C) {
+ Value *InitialResultColumn = Result.getColumn(C);
+ Value *ResultColumn = InitialResultColumn;
+ for (unsigned R = 0; R < Rows; ++R) {
+ // Accumulate the dot products of the inner loop.
+ Value *InnerAccumulator = nullptr;
+ for (unsigned M = 0; M < Inner; M += VF) {
+ // The vectorization size for the iteration. This allows for the
+ // last iteration to use a narrower vector size if needed.
+ unsigned IterVF = std::min(VF, Inner - M);
+ Value *AVect = A.extractVector(M, R, IterVF, Builder);
+ Value *BVect = B.extractVector(M, C, IterVF, Builder);
+ Value *FMul = Builder.CreateFMul(AVect, BVect);
+ auto *ZeroAccumulator = Constant::getNullValue(EltType);
+ auto *Reduce = Builder.CreateFAddReduce(ZeroAccumulator, FMul);
+ cast<Instruction>(Reduce)->setFast(true);
+ Result.addNumComputeOps(1);
+ // Start the accumulation, or accumulate in the existing value.
+ InnerAccumulator = InnerAccumulator
+ ? Builder.CreateFAdd(InnerAccumulator, Reduce)
+ : Reduce;
+ }
+ // Insert the computed matrix element into the result column.
+ ResultColumn =
+ Builder.CreateInsertElement(ResultColumn, InnerAccumulator, R);
+ }
+ // Finally, set the result column.
+ if (isTiled)
+ ResultColumn = Builder.CreateFAdd(ResultColumn, InitialResultColumn);
+ Result.setVector(C, ResultColumn);
+ }
+ }
+
+ /// Ensure that the memory in \p LI does not alias \p SI by potentially
/// copying it to a new location. This new or otherwise the original location
/// is returned.
std::pair<Value *, AllocaInst *>
- getNonAliasingPointer(LoadInst *Load, StoreInst *Store, CallInst *MatMul) {
- MemoryLocation StoreLoc = MemoryLocation::get(Store);
- MemoryLocation LoadLoc = MemoryLocation::get(Load);
+ getNonAliasingPointer(class LoadInfo LoadInf, class StoreInfo StoreInf,
+ CallInst *MatMul, unsigned MatMulOpNumber) {
+ MemoryLocation StoreLoc = StoreInf.getMemLoc(DL);
+ LoadInst *Load = cast<LoadInst>(LoadInf.getLoad());
+ MemoryLocation LoadLoc = LoadInf.getMemLoc(DL);
// If we can statically determine noalias we're good.
if (AA->isNoAlias(LoadLoc, StoreLoc))
- return {Load->getPointerOperand(), nullptr};
+ return {LoadInf.getPointerOperand(), nullptr};
+
+ if (ORE) {
+ ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE, "alias-check", Load)
+ << "Adding run-time alias check between load operand #"
+ << ore::NV("LoadOpNumber", MatMulOpNumber)
+ << " of a matrix multiply and the store of the result");
+ emitRemarksForInlineChain(*Load, *ORE);
+ }
// If the pointers are in different address spaces, we cannot compare them
// at runtime. Conservatively copy the load operand to a new buffer.
IRBuilder<> AllocaBuilder(&Func.getEntryBlock().front());
- if (Load->getPointerAddressSpace() != Store->getPointerAddressSpace()) {
+ if (LoadInf.getPointerAddressSpace() !=
+ StoreInf.getPointerOperand()->getType()->getPointerAddressSpace()) {
auto *VT = cast<FixedVectorType>(Load->getType());
auto *ArrayTy =
ArrayType::get(VT->getElementType(), VT->getNumElements());
AllocaInst *Alloca =
- AllocaBuilder.CreateAlloca(ArrayTy, Load->getPointerAddressSpace());
+ AllocaBuilder.CreateAlloca(ArrayTy, LoadInf.getPointerAddressSpace());
IRBuilder<> Builder(MatMul);
Builder.CreateLifetimeStart(Alloca);
Builder.CreateMemCpy(Alloca, Alloca->getAlign(),
- Load->getPointerOperand(), Load->getAlign(),
+ LoadInf.getPointerOperand(), LoadInf.getAlign(),
LoadLoc.Size.getValue());
return {Alloca, Alloca};
}
@@ -2133,13 +2638,13 @@ class LowerMatrixIntrinsics {
IRBuilder<> Builder(MatMul);
Check0->getTerminator()->eraseFromParent();
Builder.SetInsertPoint(Check0);
- Type *AddrTy = DL.getAddressType(Store->getPointerOperand()->getType());
- Value *StoreBegin = Store->getPointerOperand();
+ Type *AddrTy = DL.getAddressType(StoreInf.getPointerOperand()->getType());
+ Value *StoreBegin = StoreInf.getPointerOperand();
Value *StoreEnd = Builder.CreatePtrAdd(
StoreBegin, ConstantInt::get(AddrTy, StoreLoc.Size.getValue()),
"store.end",
GEPNoWrapFlags::inBounds() | GEPNoWrapFlags::noUnsignedWrap());
- Value *LoadBegin = Load->getPointerOperand();
+ Value *LoadBegin = LoadInf.getPointerOperand();
CondBrInst *BR1 = Builder.CreateCondBr(
Builder.CreateICmpULT(LoadBegin, StoreEnd), Check1, Fusion);
setExplicitlyUnknownBranchWeightsIfProfiled(*BR1, DEBUG_TYPE);
@@ -2155,7 +2660,7 @@ class LowerMatrixIntrinsics {
// requirements for large vector types.
auto *ArrayTy = ArrayType::get(VT->getElementType(), VT->getNumElements());
AllocaInst *Alloca =
- AllocaBuilder.CreateAlloca(ArrayTy, Load->getPointerAddressSpace());
+ AllocaBuilder.CreateAlloca(ArrayTy, LoadInf.getPointerAddressSpace());
Builder.CreateLifetimeStart(Alloca);
Value *LoadEnd = Builder.CreatePtrAdd(
@@ -2168,12 +2673,13 @@ class LowerMatrixIntrinsics {
// Copy load operand to new alloca.
Builder.SetInsertPoint(Copy, Copy->begin());
- Builder.CreateMemCpy(Alloca, Alloca->getAlign(), Load->getPointerOperand(),
- Load->getAlign(), LoadLoc.Size.getValue());
+ Builder.CreateMemCpy(Alloca, Alloca->getAlign(),
+ LoadInf.getPointerOperand(), LoadInf.getAlign(),
+ LoadLoc.Size.getValue());
Builder.SetInsertPoint(Fusion, Fusion->begin());
- PHINode *PHI = Builder.CreatePHI(Load->getPointerOperandType(), 3);
- PHI->addIncoming(Load->getPointerOperand(), Check0);
- PHI->addIncoming(Load->getPointerOperand(), Check1);
+ PHINode *PHI = Builder.CreatePHI(LoadInf.getPointerOperand()->getType(), 3);
+ PHI->addIncoming(LoadInf.getPointerOperand(), Check0);
+ PHI->addIncoming(LoadInf.getPointerOperand(), Check1);
PHI->addIncoming(Alloca, Copy);
// Adjust DT.
@@ -2258,8 +2764,99 @@ class LowerMatrixIntrinsics {
return Res;
}
- void createTiledLoops(CallInst *MatMul, Value *LPtr, ShapeInfo LShape,
- Value *RPtr, ShapeInfo RShape, StoreInst *Store) {
+ void createKLoop(class LoadInfo LoadInfoL, ShapeInfo LShape,
+ class LoadInfo LoadInfoR, ShapeInfo RShape,
+ class StoreInfo StoreInf, Value *Row, Value *Column,
+ Value *K, Type *EltType, unsigned TileNumRows,
+ unsigned TileNumInner, unsigned TileNumColumns,
+ BasicBlock *LoopHeader, BasicBlock *LoopEntry,
+ BasicBlock *LoopExit, FastMathFlags FMF,
+ IRBuilder<> &Builder) {
+ BasicBlock *LoopBody = LoopHeader->getSingleSuccessor();
+ BasicBlock *LoopLatch = LoopBody->getSingleSuccessor();
+ ShapeInfo ResultShape{LShape.NumRows, RShape.NumColumns};
+ unsigned NumInner = LShape.NumColumns;
+ ShapeInfo ResultTileShape{TileNumRows, TileNumColumns};
+
+ Type *TileColumnVecTy =
+ FixedVectorType::get(EltType, ResultTileShape.NumRows);
+ MatrixTy TileResult;
+ // Create PHI nodes for the result columns to accumulate across iterations
+ // and insert them in the loop header.
+ Builder.SetInsertPoint(LoopHeader->getTerminator());
+ SmallVector<PHINode *, 4> ColumnPhis;
+ for (unsigned I = 0; I < ResultTileShape.NumColumns; I++) {
+ auto *Phi =
+ Builder.CreatePHI(TileColumnVecTy, 2, "result.vec." + Twine(I));
+ // Result vectors start out as zeroes we FMA into.
+ Phi->addIncoming(ConstantAggregateZero::get(TileColumnVecTy), LoopEntry);
+ TileResult.addVector(Phi);
+ ColumnPhis.push_back(Phi);
+ }
+
+ Builder.SetInsertPoint(LoopBody->getTerminator());
+ ShapeInfo LTileShape{std::min(TileNumRows, LShape.NumRows),
+ std::min(TileNumInner, LShape.NumColumns)};
+ ShapeInfo RTileShape{std::min(TileNumInner, RShape.NumRows),
+ std::min(TileNumColumns, RShape.NumColumns)};
+
+ if (LoadInfoL.isTransposed()) {
+ MatrixTy L = loadMatrix(LoadInfoL, LShape.t(), K, Row, LTileShape.t(),
+ EltType, Builder);
+ MatrixTy R = loadMatrix(LoadInfoR, RShape, K, Column, RTileShape, EltType,
+ Builder);
+ emitMatrixMultiplyTN(TileResult, L, R, Builder, /*isTiled=*/true);
+ } else {
+ MatrixTy L =
+ loadMatrix(LoadInfoL, LShape, Row, K, LTileShape, EltType, Builder);
+ MatrixTy R = loadMatrix(LoadInfoR, RShape, K, Column, RTileShape, EltType,
+ Builder);
+ emitMatrixMultiply(TileResult, L, R, Builder,
+ /*isTiled=*/true, /*IsScalarMatrixTransposed=*/false,
+ FMF);
+ }
+
+ for (unsigned I = 0; I < TileResult.getNumVectors(); I++)
+ ColumnPhis[I]->addIncoming(TileResult.getVector(I), LoopLatch);
+
+ // Store result after the inner loop is done.
+ Builder.SetInsertPoint(&*LoopExit->getFirstInsertionPt());
+
+ // Handle the K remainder inline, right before the store.
+ if (unsigned RemainderInner = NumInner % TileNumInner) {
+ Value *RemK = asIndex(Builder, NumInner - RemainderInner);
+ ShapeInfo LRemShape{ResultTileShape.NumRows, RemainderInner};
+ ShapeInfo RRemShape{RemainderInner, ResultTileShape.NumColumns};
+ if (LoadInfoL.isTransposed()) {
+ MatrixTy L = loadMatrix(LoadInfoL, LShape.t(), RemK, Row, LRemShape.t(),
+ EltType, Builder);
+ MatrixTy R = loadMatrix(LoadInfoR, RShape, RemK, Column, RRemShape,
+ EltType, Builder);
+ emitMatrixMultiplyTN(TileResult, L, R, Builder, /*isTiled=*/true);
+ } else {
+ MatrixTy L = loadMatrix(LoadInfoL, LShape, Row, RemK, LRemShape,
+ EltType, Builder);
+ MatrixTy R = loadMatrix(LoadInfoR, RShape, RemK, Column, RRemShape,
+ EltType, Builder);
+ emitMatrixMultiply(TileResult, L, R, Builder,
+ /*isTiled=*/true,
+ /*IsScalarMatrixTransposed=*/false, FMF);
+ }
+ }
+
+ storeMatrix(TileResult, StoreInf, ResultShape, Row, Column, EltType,
+ Builder);
+ }
+
+ /// Given a matrix multiply \p MatMul and a store of its result \p StoreInf,
+ /// generate a loop nest that computes the result.
+ ///
+ /// Note: this is only supported for column-major for now.
+ void createTiledLoops(CallInst *MatMul, class LoadInfo LoadInfoL,
+ ShapeInfo LShape, class LoadInfo LoadInfoR,
+ ShapeInfo RShape, class StoreInfo StoreInf) {
+ assert(MatrixLayout == MatrixLayoutTy::ColumnMajor &&
+ "Tiling only supported for column-major matrixes at the moment!");
auto *EltType = cast<FixedVectorType>(MatMul->getType())->getElementType();
// Create the main tiling loop nest.
@@ -2271,56 +2868,69 @@ class LowerMatrixIntrinsics {
BasicBlock *End =
SplitBlock(InsertI->getParent(), InsertI, DT, LI, nullptr, "continue");
IRBuilder<> Builder(MatMul);
- BasicBlock *InnerBody = TI.CreateTiledLoops(Start, End, Builder, DTU, *LI);
-
- Type *TileVecTy =
- FixedVectorType::get(MatMul->getType()->getScalarType(), TileSizeRows);
- MatrixTy TileResult;
- // Insert in the inner loop header.
- Builder.SetInsertPoint(TI.KLoop.Header->getTerminator());
- // Create PHI nodes for the result columns to accumulate across iterations.
- SmallVector<PHINode *, 4> ColumnPhis;
- for (unsigned I = 0; I < TileSizeColumns; I++) {
- auto *Phi = Builder.CreatePHI(TileVecTy, 2, "result.vec." + Twine(I));
- Phi->addIncoming(ConstantAggregateZero::get(TileVecTy),
- TI.RowLoop.Header->getSingleSuccessor());
- TileResult.addVector(Phi);
- ColumnPhis.push_back(Phi);
+ TI.CreateTiledLoopsWithRemainder(Start, End, Builder, DTU, *LI);
+
+ BasicBlock *ColumnLoopBody = TI.ColumnLoop.Header->getSingleSuccessor();
+ createKLoop(LoadInfoL, LShape, LoadInfoR, RShape, StoreInf,
+ TI.RowLoop.Index, TI.ColumnLoop.Index, TI.KLoop.Index, EltType,
+ TI.TileNumRows, TI.TileNumInner, TI.TileNumColumns,
+ TI.KLoop.Header, ColumnLoopBody, TI.ColumnLoop.Latch,
+ getFastMathFlags(MatMul), Builder);
+
+ if (unsigned RemainderColumns = TI.NumColumns % TI.TileNumColumns) {
+ Value *CurrentColumn = asIndex(Builder, TI.NumColumns - RemainderColumns);
+ createKLoop(LoadInfoL, LShape, LoadInfoR, RShape, StoreInf,
+ TI.RowLoop.Index, CurrentColumn,
+ TI.RemainderColumnsKLoop.Index, EltType, TI.TileNumRows,
+ TI.TileNumInner, RemainderColumns,
+ TI.RemainderColumnsKLoop.Header, TI.ColumnLoop.Latch,
+ TI.RowLoop.Latch, getFastMathFlags(MatMul), Builder);
+ }
+
+ if (unsigned RemainderRows = TI.NumRows % TI.TileNumRows) {
+ Value *Row = asIndex(Builder, TI.NumRows - RemainderRows);
+ BasicBlock *RemainderRowsColumnLoopBody =
+ TI.RemainderRowsColumnLoop.Header->getSingleSuccessor();
+ createKLoop(LoadInfoL, LShape, LoadInfoR, RShape, StoreInf, Row,
+ TI.RemainderRowsColumnLoop.Index, TI.RemainderRowsKLoop.Index,
+ EltType, RemainderRows, TI.TileNumInner, TI.TileNumColumns,
+ TI.RemainderRowsKLoop.Header, RemainderRowsColumnLoopBody,
+ TI.RemainderRowsColumnLoop.Latch, getFastMathFlags(MatMul),
+ Builder);
+
+ if (unsigned RemainderColumns = TI.NumColumns % TI.TileNumColumns) {
+ Value *Column = asIndex(Builder, TI.NumColumns - RemainderColumns);
+ createKLoop(LoadInfoL, LShape, LoadInfoR, RShape, StoreInf, Row, Column,
+ TI.RemainderRowsRemainderColumnsKLoop.Index, EltType,
+ RemainderRows, TI.TileNumInner, RemainderColumns,
+ TI.RemainderRowsRemainderColumnsKLoop.Header,
+ TI.RemainderRowsColumnLoop.Latch, End,
+ getFastMathFlags(MatMul), Builder);
+ }
}
- // Insert in the inner loop body, which computes
- // Res += Load(CurrentRow, K) * Load(K, CurrentColumn)
- Builder.SetInsertPoint(InnerBody->getTerminator());
- // Load tiles of the operands.
- MatrixTy A =
- loadMatrix(LPtr, {}, false, LShape, TI.RowLoop.Index, TI.KLoop.Index,
- {TileSizeRows, TileSizeInner}, EltType, Builder);
- MatrixTy B =
- loadMatrix(RPtr, {}, false, RShape, TI.KLoop.Index, TI.ColumnLoop.Index,
- {TileSizeInner, TileSizeColumns}, EltType, Builder);
- emitMatrixMultiply(TileResult, A, B, Builder, true, false,
- getFastMathFlags(MatMul));
- // Store result after the inner loop is done.
- Builder.SetInsertPoint(TI.RowLoop.Latch->getTerminator());
- storeMatrix(TileResult, Store->getPointerOperand(), Store->getAlign(),
- Store->isVolatile(), {LShape.NumRows, RShape.NumColumns},
- TI.RowLoop.Index, TI.ColumnLoop.Index, EltType, Builder);
-
- for (unsigned I = 0; I < TileResult.getNumVectors(); I++)
- ColumnPhis[I]->addIncoming(TileResult.getVector(I), TI.KLoop.Latch);
-
- // Force unrolling of a few iterations of the inner loop, to make sure there
- // is enough work per iteration.
+ // Mark all loops as already unrolled — the remainder handling is explicit
+ // and the backend should not attempt to re-unroll.
// FIXME: The unroller should make this decision directly instead, but
// currently the cost-model is not up to the task.
- unsigned InnerLoopUnrollCount =
- std::min(10u, LShape.NumColumns / TileSizeInner);
- addStringMetadataToLoop(LI->getLoopFor(TI.KLoop.Header),
- "llvm.loop.unroll.count", InnerLoopUnrollCount);
+ auto NoUnroll = [&](BasicBlock *Header) {
+ if (!Header)
+ return;
+ auto *Loop = LI->getLoopFor(Header);
+ if (Loop)
+ Loop->setLoopAlreadyUnrolled();
+ };
+ NoUnroll(TI.KLoop.Header);
+ NoUnroll(TI.ColumnLoop.Header);
+ NoUnroll(TI.RowLoop.Header);
+ NoUnroll(TI.RemainderColumnsKLoop.Header);
+ NoUnroll(TI.RemainderRowsKLoop.Header);
+ NoUnroll(TI.RemainderRowsColumnLoop.Header);
+ NoUnroll(TI.RemainderRowsRemainderColumnsKLoop.Header);
}
- void emitSIMDTiling(CallInst *MatMul, LoadInst *LoadOp0, LoadInst *LoadOp1,
- StoreInst *Store,
+ void emitSIMDTiling(CallInst *MatMul, class LoadInfo LoadInfoL,
+ class LoadInfo LoadInfoR, class StoreInfo StoreInf,
SmallPtrSetImpl<Instruction *> &FusedInsts) {
assert(MatrixLayout == MatrixLayoutTy::ColumnMajor &&
"Tiling only supported for column-major matrixes at the moment!");
@@ -2335,15 +2945,19 @@ class LowerMatrixIntrinsics {
const unsigned M = LShape.NumColumns;
auto *EltType = cast<FixedVectorType>(MatMul->getType())->getElementType();
- auto [APtr, AAlloca] = getNonAliasingPointer(LoadOp0, Store, MatMul);
- auto [BPtr, BAlloca] = getNonAliasingPointer(LoadOp1, Store, MatMul);
- Value *CPtr = Store->getPointerOperand();
+ auto [LPtr, AAlloca] =
+ getNonAliasingPointer(LoadInfoL, StoreInf, MatMul, 0);
+ LoadInfoL.setNonAliasingPtr(LPtr);
+ auto [RPtr, BAlloca] =
+ getNonAliasingPointer(LoadInfoR, StoreInf, MatMul, 1);
+ LoadInfoR.setNonAliasingPtr(RPtr);
+ Instruction *Store = StoreInf.getStore();
TileInfo TI(LShape.NumRows, RShape.NumColumns, LShape.NumColumns,
TileSizeRows, TileSizeInner, TileSizeColumns, EltType);
if (TileUseLoops && isTilingLoopProfitable(TI))
- createTiledLoops(MatMul, APtr, LShape, BPtr, RShape, Store);
+ createTiledLoops(MatMul, LoadInfoL, LShape, LoadInfoR, RShape, StoreInf);
else {
IRBuilder<> Builder(Store);
for (unsigned J = 0; J < C; J += TileSizeColumns)
@@ -2354,19 +2968,29 @@ class LowerMatrixIntrinsics {
for (unsigned K = 0; K < M; K += TileSizeInner) {
const unsigned TileM = std::min(M - K, unsigned(TileSizeInner));
- MatrixTy A =
- loadMatrix(APtr, LoadOp0->getAlign(), LoadOp0->isVolatile(),
- LShape, getIndex(APtr, I), getIndex(APtr, K),
- {TileR, TileM}, EltType, Builder);
- MatrixTy B =
- loadMatrix(BPtr, LoadOp1->getAlign(), LoadOp1->isVolatile(),
- RShape, getIndex(BPtr, K), getIndex(BPtr, J),
- {TileM, TileC}, EltType, Builder);
- emitMatrixMultiply(Res, A, B, Builder, true, false,
- getFastMathFlags(MatMul));
+ if (LoadInfoL.isTransposed()) {
+ MatrixTy A = loadMatrix(LoadInfoL, LShape.t(), getIndex(LPtr, K),
+ getIndex(LPtr, I), {TileM, TileR},
+ EltType, Builder);
+ MatrixTy B = loadMatrix(LoadInfoR, RShape, getIndex(RPtr, K),
+ getIndex(RPtr, J), {TileM, TileC},
+ EltType, Builder);
+ emitMatrixMultiplyTN(Res, A, B, Builder, /*isTiled=*/true);
+ } else {
+ MatrixTy A = loadMatrix(LoadInfoL, LShape, getIndex(LPtr, I),
+ getIndex(LPtr, K), {TileR, TileM},
+ EltType, Builder);
+ MatrixTy B = loadMatrix(LoadInfoR, RShape, getIndex(RPtr, K),
+ getIndex(RPtr, J), {TileM, TileC},
+ EltType, Builder);
+ emitMatrixMultiply(Res, A, B, Builder, /*isTiled=*/true,
+ /*IsScalarMatrixTransposed=*/false,
+ getFastMathFlags(MatMul));
+ }
}
- storeMatrix(Res, CPtr, Store->getAlign(), Store->isVolatile(), {R, M},
- getIndex(CPtr, I), getIndex(CPtr, J), EltType, Builder);
+ storeMatrix(
+ Res, StoreInf, {R, M}, getIndex(StoreInf.getPointerOperand(), I),
+ getIndex(StoreInf.getPointerOperand(), J), EltType, Builder);
}
}
@@ -2383,14 +3007,34 @@ class LowerMatrixIntrinsics {
FusedInsts.insert(Store);
FusedInsts.insert(MatMul);
eraseFromParentAndRemoveFromShapeMap(Store);
+ if (StoreInf.getBinOp() && StoreInf.getBinOp()->hasNUses(0)) {
+ FusedInsts.insert(StoreInf.getBinOp());
+ StoreInf.getBinOp()->eraseFromParent();
+ }
+ std::optional<class LoadInfo> MaybeLoadInfo = StoreInf.getLoadInfo();
+ if (MaybeLoadInfo && MaybeLoadInfo->getLoad()->hasNUses(0)) {
+ FusedInsts.insert(MaybeLoadInfo->getLoad());
+ MaybeLoadInfo->getLoad()->eraseFromParent();
+ }
eraseFromParentAndRemoveFromShapeMap(MatMul);
- if (LoadOp0->use_empty()) {
- FusedInsts.insert(LoadOp0);
- eraseFromParentAndRemoveFromShapeMap(LoadOp0);
+ Instruction *LTranspose = LoadInfoL.getTranspose();
+ if (LTranspose && LTranspose->hasNUses(0)) {
+ FusedInsts.insert(LTranspose);
+ LTranspose->eraseFromParent();
+ }
+ if (LoadInfoL.getLoad()->hasNUses(0)) {
+ FusedInsts.insert(LoadInfoL.getLoad());
+ LoadInfoL.getLoad()->eraseFromParent();
+ }
+ Instruction *RTranspose = LoadInfoR.getTranspose();
+ if (RTranspose && RTranspose->hasNUses(0)) {
+ FusedInsts.insert(RTranspose);
+ RTranspose->eraseFromParent();
}
- if (LoadOp1 != LoadOp0 && LoadOp1->use_empty()) {
- FusedInsts.insert(LoadOp1);
- eraseFromParentAndRemoveFromShapeMap(LoadOp1);
+ if (LoadInfoR.getLoad() != LoadInfoL.getLoad() &&
+ LoadInfoR.getLoad()->hasNUses(0)) {
+ FusedInsts.insert(LoadInfoR.getLoad());
+ eraseFromParentAndRemoveFromShapeMap(LoadInfoR.getLoad());
}
}
@@ -2456,9 +3100,134 @@ class LowerMatrixIntrinsics {
return;
}
- if (!MatMul->hasOneUse() || MatrixLayout != MatrixLayoutTy::ColumnMajor)
+ if (!MatMul->hasOneUse()) {
+ // Emit a remark for large matmuls that can't be tiled due to multiple
+ // uses.
+ ShapeInfo LShape(MatMul->getArgOperand(2), MatMul->getArgOperand(3));
+ ShapeInfo RShape(MatMul->getArgOperand(3), MatMul->getArgOperand(4));
+ const unsigned R = LShape.NumRows;
+ const unsigned M = LShape.NumColumns;
+ const unsigned C = RShape.NumColumns;
+ if (R * M * C > 100 && ORE) {
+ ORE->emit(
+ OptimizationRemarkMissed(DEBUG_TYPE, "no-tiling-multiple-uses",
+ MatMul)
+ << "Not tiling because the matrix multiply has multiple uses, "
+ "FLOPS="
+ << ore::NV("FLOPS", R * M * C));
+ emitRemarksForInlineChain(*MatMul, *ORE);
+ }
return;
+ }
+
+ if (MatrixLayout != MatrixLayoutTy::ColumnMajor)
+ return;
+
+ {
+ ShapeInfo LShape(MatMul->getArgOperand(2), MatMul->getArgOperand(3));
+ ShapeInfo RShape(MatMul->getArgOperand(3), MatMul->getArgOperand(4));
+ const unsigned R = LShape.NumRows;
+ const unsigned M = LShape.NumColumns;
+ const unsigned C = RShape.NumColumns;
+ auto *EltType =
+ cast<FixedVectorType>(MatMul->getType())->getElementType();
+
+ auto Operands = analyzeLoadOperands(MatMul);
+ if (Operands) {
+ auto StoreInf = analyzeStore(MatMul, ShapeInfo(R, C).getStride());
+ if (!StoreInf) {
+ if (R * M * C > 100 && ORE) {
+ ORE->emit(
+ OptimizationRemarkMissed(DEBUG_TYPE, "no-tiling-unknown-store",
+ MatMul)
+ << "Not tiling because the matrix multiply has an unknown "
+ "store, FLOPS="
+ << ore::NV("FLOPS", R * M * C));
+ emitRemarksForInlineChain(*MatMul, *ORE);
+ }
+ // Fall through to the legacy path.
+ } else if (R > TileSizeRows || M > TileSizeRows ||
+ C > TileSizeColumns) {
+ // The matrix is larger than one tile — use the LoadInfo path.
+ TileInfo TI(R, C, M, TileSizeRows, TileSizeInner, TileSizeColumns,
+ EltType);
+
+ // The store address must dominate the MatMul instruction.
+ SetVector<Value *> WL;
+ WL.insert(StoreInf->getPointerOperand());
+ SmallVector<Instruction *> ToHoist;
+ for (unsigned I = 0; I != WL.size(); ++I) {
+ Value *Current = WL[I];
+ auto *CurrI = dyn_cast<Instruction>(Current);
+ if (!CurrI)
+ continue;
+ if (isa<PHINode>(CurrI))
+ return;
+ if (DT->dominates(CurrI, MatMul))
+ continue;
+ if (CurrI->mayHaveSideEffects() || CurrI->mayReadFromMemory())
+ return;
+ ToHoist.push_back(CurrI);
+ WL.insert_range(CurrI->operands());
+ }
+ sort(ToHoist, [this](Instruction *A, Instruction *B) {
+ return DT->dominates(A, B);
+ });
+ for (Instruction *I : ToHoist)
+ I->moveBefore(MatMul->getIterator());
+
+ // Handle lifetime.end markers between the loads and store.
+ MemoryLocation Load0Loc = Operands->first.getMemLoc(DL);
+ MemoryLocation Load1Loc = Operands->second.getMemLoc(DL);
+ BasicBlock *StoreParent = StoreInf->getStore()->getParent();
+ bool FusableOpsInSameBlock =
+ Operands->first.getLoad()->getParent() == StoreParent &&
+ Operands->second.getLoad()->getParent() == StoreParent;
+ for (unsigned Idx = 0; Idx != LifetimeEnds.size();) {
+ IntrinsicInst *End = LifetimeEnds[Idx];
+ llvm::scope_exit Inc([&Idx]() { Idx++; });
+ if (DT->dominates(End, Operands->first.getLoad()) &&
+ DT->dominates(End, Operands->second.getLoad()))
+ continue;
+ if (DT->dominates(StoreInf->getStore(), End))
+ continue;
+ if (FusableOpsInSameBlock && End->getParent() != StoreParent)
+ continue;
+ MemoryLocation EndLoc =
+ MemoryLocation::getForArgument(End, 0, nullptr);
+ if (!EndLoc.Ptr)
+ continue;
+ if (AA->isNoAlias(Load0Loc, EndLoc) &&
+ AA->isNoAlias(Load1Loc, EndLoc))
+ continue;
+ if (End->getParent() == StoreParent) {
+ End->moveAfter(StoreInf->getStore());
+ continue;
+ }
+ ToRemove.push_back(End);
+ std::swap(LifetimeEnds[Idx], LifetimeEnds.back());
+ LifetimeEnds.pop_back();
+ Inc.release();
+ }
+
+ emitSIMDTiling(MatMul, Operands->first, Operands->second, *StoreInf,
+ FusedInsts);
+ return;
+ }
+ } else {
+ if (R * M * C > 100 && ORE) {
+ ORE->emit(
+ OptimizationRemarkMissed(DEBUG_TYPE, "no-tiling-unknown-load",
+ MatMul)
+ << "Not tiling because the matrix multiply has unknown loads, "
+ "FLOPS="
+ << ore::NV("FLOPS", R * M * C));
+ emitRemarksForInlineChain(*MatMul, *ORE);
+ }
+ }
+ }
+ // Legacy path: lower {ld, ld} -> matmul -> st chains directly.
// Lower {ld, ld} -> matmul -> st chains. No need to call finalizeLowering
// since the single store user will be lowered as part of this.
auto *LoadOp0 = dyn_cast<LoadInst>(A);
@@ -2540,7 +3309,8 @@ class LowerMatrixIntrinsics {
Inc.release();
}
- emitSIMDTiling(MatMul, LoadOp0, LoadOp1, Store, FusedInsts);
+ emitSIMDTiling(MatMul, LoadInfo(LoadOp0), LoadInfo(LoadOp1),
+ StoreInfo(Store), FusedInsts);
return;
}
}
@@ -2955,9 +3725,10 @@ class LowerMatrixIntrinsics {
for (Value *S : SI->second) {
if (S == Leaf)
continue;
- DebugLoc DL = cast<Instruction>(S)->getDebugLoc();
- write("shared with remark at line " + std::to_string(DL.getLine()) +
- " column " + std::to_string(DL.getCol()) + " (");
+ if (DebugLoc DbgLoc = cast<Instruction>(S)->getDebugLoc())
+ write("shared with remark at line " +
+ std::to_string(DbgLoc.getLine()) + " column " +
+ std::to_string(DbgLoc.getCol()) + " (");
}
ExprShared = SI->second.size() > 1;
}
diff --git a/llvm/test/Transforms/LowerMatrixIntrinsics/alias-check-remark.ll b/llvm/test/Transforms/LowerMatrixIntrinsics/alias-check-remark.ll
new file mode 100644
index 0000000000000..f46fdd58f11c5
--- /dev/null
+++ b/llvm/test/Transforms/LowerMatrixIntrinsics/alias-check-remark.ll
@@ -0,0 +1,17 @@
+; RUN: opt -passes=lower-matrix-intrinsics -aa-pipeline=basic-aa -pass-remarks-missed=lower-matrix-intrinsics %s -o /dev/null 2>&1 | FileCheck %s
+
+; CHECK: Adding run-time alias check between load operand #1 of a matrix multiply and the store of the result
+; CHECK-NOT: Adding run-time alias check between load operand
+
+define void @multiply(ptr noalias %A, ptr %B, ptr %C) {
+entry:
+ %a = load <64 x double>, ptr %A, align 16
+ %b = load <64 x double>, ptr %B, align 16
+
+ %c = call <64 x double> @llvm.matrix.multiply(<64 x double> %a, <64 x double> %b, i32 8, i32 8, i32 8)
+
+ store <64 x double> %c, ptr %C, align 16
+ ret void
+}
+
+declare <64 x double> @llvm.matrix.multiply(<64 x double>, <64 x double>, i32, i32, i32)
diff --git a/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll b/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
new file mode 100644
index 0000000000000..b368e6801dcc5
--- /dev/null
+++ b/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
@@ -0,0 +1,163 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -passes='lower-matrix-intrinsics' -matrix-allow-contract=false -S < %s | FileCheck %s
+
+; The double transposes assert the shape (no other instruction carry shape
+; information). With this we can lower the flattened <9 x double> loads and
+; stores as 3 vectors of <3 x double>. I.e. there should be no longer any
+; <9 x double> load or store below.
+
+define void @test_jskew_right(ptr %Rv, ptr %R, ptr %v) {
+; CHECK-LABEL: @test_jskew_right(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VV:%.*]] = load <3 x double>, ptr [[V:%.*]], align 8
+; CHECK-NEXT: [[COL_LOAD:%.*]] = load <3 x double>, ptr [[R:%.*]], align 8
+; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds double, ptr [[R]], i64 3
+; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <3 x double>, ptr [[VEC_GEP]], align 8
+; CHECK-NEXT: [[VEC_GEP2:%.*]] = getelementptr inbounds double, ptr [[R]], i64 6
+; CHECK-NEXT: [[COL_LOAD3:%.*]] = load <3 x double>, ptr [[VEC_GEP2]], align 8
+; CHECK-NEXT: [[TMP0:%.*]] = shufflevector <3 x double> [[COL_LOAD]], <3 x double> [[COL_LOAD1]], <6 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <3 x double> [[COL_LOAD3]], <3 x double> poison, <6 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <6 x double> [[TMP0]], <6 x double> [[TMP1]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8>
+; CHECK-NEXT: [[SPLAT_SPLAT_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 2, i32 2, i32 2>
+; CHECK-NEXT: [[T3:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[MUL_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT_I]], [[T3]]
+; CHECK-NEXT: [[SPLAT_SPLAT8_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 1, i32 1, i32 1>
+; CHECK-NEXT: [[T4:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 6, i32 7, i32 8>
+; CHECK-NEXT: [[MUL10_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT8_I]], [[T4]]
+; CHECK-NEXT: [[SUB_I:%.*]] = fsub <3 x double> [[MUL_I]], [[MUL10_I]]
+; CHECK-NEXT: [[T5:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[SPLAT_SPLAT13_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> zeroinitializer
+; CHECK-NEXT: [[MUL15_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT13_I]], [[T4]]
+; CHECK-NEXT: [[T6:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 0, i32 1, i32 2>
+; CHECK-NEXT: [[MUL20_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT_I]], [[T6]]
+; CHECK-NEXT: [[SUB21_I:%.*]] = fsub <3 x double> [[MUL15_I]], [[MUL20_I]]
+; CHECK-NEXT: [[T7:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T8:%.*]] = shufflevector <9 x double> [[T5]], <9 x double> [[T7]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[MUL26_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT8_I]], [[T6]]
+; CHECK-NEXT: [[MUL31_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT13_I]], [[T3]]
+; CHECK-NEXT: [[SUB32_I:%.*]] = fsub <3 x double> [[MUL26_I]], [[MUL31_I]]
+; CHECK-NEXT: [[T9:%.*]] = shufflevector <3 x double> [[SUB32_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T10:%.*]] = shufflevector <9 x double> [[T8]], <9 x double> [[T9]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
+; CHECK-NEXT: [[SPLIT:%.*]] = shufflevector <9 x double> [[T10]], <9 x double> poison, <3 x i32> <i32 0, i32 1, i32 2>
+; CHECK-NEXT: [[SPLIT4:%.*]] = shufflevector <9 x double> [[T10]], <9 x double> poison, <3 x i32> <i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[SPLIT5:%.*]] = shufflevector <9 x double> [[T10]], <9 x double> poison, <3 x i32> <i32 6, i32 7, i32 8>
+; CHECK-NEXT: store <3 x double> [[SPLIT]], ptr [[RV:%.*]], align 8
+; CHECK-NEXT: [[VEC_GEP6:%.*]] = getelementptr inbounds double, ptr [[RV]], i64 3
+; CHECK-NEXT: store <3 x double> [[SPLIT4]], ptr [[VEC_GEP6]], align 8
+; CHECK-NEXT: [[VEC_GEP7:%.*]] = getelementptr inbounds double, ptr [[RV]], i64 6
+; CHECK-NEXT: store <3 x double> [[SPLIT5]], ptr [[VEC_GEP7]], align 8
+; CHECK-NEXT: ret void
+;
+entry:
+ %vv = load <3 x double>, ptr %v, align 8
+ %RR = load <9 x double>, ptr %R, align 8
+ %t1 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %RR, i32 3, i32 3)
+ %t2 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t1, i32 3, i32 3)
+ %splat.splat.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 2, i32 2, i32 2>
+ %t3 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 3, i32 4, i32 5>
+ %mul.i = fmul <3 x double> %splat.splat.i, %t3
+ %splat.splat8.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 1, i32 1, i32 1>
+ %t4 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 6, i32 7, i32 8>
+ %mul10.i = fmul <3 x double> %splat.splat8.i, %t4
+ %sub.i = fsub <3 x double> %mul.i, %mul10.i
+ %t5 = shufflevector <3 x double> %sub.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %splat.splat13.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> zeroinitializer
+ %mul15.i = fmul <3 x double> %splat.splat13.i, %t4
+ %t6 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 0, i32 1, i32 2>
+ %mul20.i = fmul <3 x double> %splat.splat.i, %t6
+ %sub21.i = fsub <3 x double> %mul15.i, %mul20.i
+ %t7 = shufflevector <3 x double> %sub21.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t8 = shufflevector <9 x double> %t5, <9 x double> %t7, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 undef, i32 undef, i32 undef>
+ %mul26.i = fmul <3 x double> %splat.splat8.i, %t6
+ %mul31.i = fmul <3 x double> %splat.splat13.i, %t3
+ %sub32.i = fsub <3 x double> %mul26.i, %mul31.i
+ %t9 = shufflevector <3 x double> %sub32.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t10 = shufflevector <9 x double> %t8, <9 x double> %t9, <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
+ %t11 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t10, i32 3, i32 3)
+ %t12 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t11, i32 3, i32 3)
+ store <9 x double> %t12, ptr %Rv, align 8
+ ret void
+}
+
+define void @test_jskew_left(ptr %vmR, ptr %R, ptr %v) {
+; CHECK-LABEL: @test_jskew_left(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[COL_LOAD:%.*]] = load <3 x double>, ptr [[R:%.*]], align 8
+; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds double, ptr [[R]], i64 3
+; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <3 x double>, ptr [[VEC_GEP]], align 8
+; CHECK-NEXT: [[VEC_GEP2:%.*]] = getelementptr inbounds double, ptr [[R]], i64 6
+; CHECK-NEXT: [[COL_LOAD3:%.*]] = load <3 x double>, ptr [[VEC_GEP2]], align 8
+; CHECK-NEXT: [[TMP0:%.*]] = fneg <3 x double> [[COL_LOAD]]
+; CHECK-NEXT: [[TMP1:%.*]] = fneg <3 x double> [[COL_LOAD1]]
+; CHECK-NEXT: [[TMP2:%.*]] = fneg <3 x double> [[COL_LOAD3]]
+; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <3 x double> [[TMP0]], <3 x double> [[TMP1]], <6 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[TMP4:%.*]] = shufflevector <3 x double> [[TMP2]], <3 x double> poison, <6 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP5:%.*]] = shufflevector <6 x double> [[TMP3]], <6 x double> [[TMP4]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8>
+; CHECK-NEXT: [[VV:%.*]] = load <3 x double>, ptr [[V:%.*]], align 8
+; CHECK-NEXT: [[T4:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+; CHECK-NEXT: [[T5:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+; CHECK-NEXT: [[MUL_I:%.*]] = fmul <3 x double> [[T4]], [[T5]]
+; CHECK-NEXT: [[T6:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+; CHECK-NEXT: [[T7:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+; CHECK-NEXT: [[MUL7_I:%.*]] = fmul <3 x double> [[T6]], [[T7]]
+; CHECK-NEXT: [[SUB_I:%.*]] = fsub <3 x double> [[MUL_I]], [[MUL7_I]]
+; CHECK-NEXT: [[T8:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T9:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 5, i32 3, i32 4>
+; CHECK-NEXT: [[MUL10_I:%.*]] = fmul <3 x double> [[T4]], [[T9]]
+; CHECK-NEXT: [[T10:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 4, i32 5, i32 3>
+; CHECK-NEXT: [[MUL13_I:%.*]] = fmul <3 x double> [[T6]], [[T10]]
+; CHECK-NEXT: [[SUB14_I:%.*]] = fsub <3 x double> [[MUL10_I]], [[MUL13_I]]
+; CHECK-NEXT: [[T11:%.*]] = shufflevector <3 x double> [[SUB14_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T12:%.*]] = shufflevector <9 x double> [[T8]], <9 x double> [[T11]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T13:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[MUL17_I:%.*]] = fmul <3 x double> [[T4]], [[T13]]
+; CHECK-NEXT: [[T14:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 7, i32 8, i32 6>
+; CHECK-NEXT: [[MUL20_I:%.*]] = fmul <3 x double> [[T6]], [[T14]]
+; CHECK-NEXT: [[SUB21_I:%.*]] = fsub <3 x double> [[MUL17_I]], [[MUL20_I]]
+; CHECK-NEXT: [[T15:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T16:%.*]] = shufflevector <9 x double> [[T12]], <9 x double> [[T15]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
+; CHECK-NEXT: [[SPLIT:%.*]] = shufflevector <9 x double> [[T16]], <9 x double> poison, <3 x i32> <i32 0, i32 1, i32 2>
+; CHECK-NEXT: [[SPLIT4:%.*]] = shufflevector <9 x double> [[T16]], <9 x double> poison, <3 x i32> <i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[SPLIT5:%.*]] = shufflevector <9 x double> [[T16]], <9 x double> poison, <3 x i32> <i32 6, i32 7, i32 8>
+; CHECK-NEXT: store <3 x double> [[SPLIT]], ptr [[VMR:%.*]], align 8
+; CHECK-NEXT: [[VEC_GEP6:%.*]] = getelementptr inbounds double, ptr [[VMR]], i64 3
+; CHECK-NEXT: store <3 x double> [[SPLIT4]], ptr [[VEC_GEP6]], align 8
+; CHECK-NEXT: [[VEC_GEP7:%.*]] = getelementptr inbounds double, ptr [[VMR]], i64 6
+; CHECK-NEXT: store <3 x double> [[SPLIT5]], ptr [[VEC_GEP7]], align 8
+; CHECK-NEXT: ret void
+;
+entry:
+ %RR = load <9 x double>, ptr %R, align 8
+ %t1 = fneg <9 x double> %RR
+ %vv = load <3 x double>, ptr %v, align 8
+ %t2 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t1, i32 3, i32 3)
+ %t3 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t2, i32 3, i32 3)
+ %t4 = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+ %t5 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+ %mul.i = fmul <3 x double> %t4, %t5
+ %t6 = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+ %t7 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+ %mul7.i = fmul <3 x double> %t6, %t7
+ %sub.i = fsub <3 x double> %mul.i, %mul7.i
+ %t8 = shufflevector <3 x double> %sub.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t9 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 5, i32 3, i32 4>
+ %mul10.i = fmul <3 x double> %t4, %t9
+ %t10 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 4, i32 5, i32 3>
+ %mul13.i = fmul <3 x double> %t6, %t10
+ %sub14.i = fsub <3 x double> %mul10.i, %mul13.i
+ %t11 = shufflevector <3 x double> %sub14.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t12 = shufflevector <9 x double> %t8, <9 x double> %t11, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 undef, i32 undef, i32 undef>
+ %t13 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 8, i32 6, i32 7>
+ %mul17.i = fmul <3 x double> %t4, %t13
+ %t14 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 7, i32 8, i32 6>
+ %mul20.i = fmul <3 x double> %t6, %t14
+ %sub21.i = fsub <3 x double> %mul17.i, %mul20.i
+ %t15 = shufflevector <3 x double> %sub21.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t16 = shufflevector <9 x double> %t12, <9 x double> %t15, <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
+ %t17 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t16, i32 3, i32 3)
+ %t18 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t17, i32 3, i32 3)
+ store <9 x double> %t18, ptr %vmR, align 8
+ ret void
+}
+
+declare <9 x double> @llvm.matrix.transpose.v9f64(<9 x double>, i32 immarg, i32 immarg) #1
diff --git a/llvm/test/Transforms/LowerMatrixIntrinsics/multiply-fused-loops.ll b/llvm/test/Transforms/LowerMatrixIntrinsics/multiply-fused-loops.ll
index 0813588d48079..89a89d0f413e6 100644
--- a/llvm/test/Transforms/LowerMatrixIntrinsics/multiply-fused-loops.ll
+++ b/llvm/test/Transforms/LowerMatrixIntrinsics/multiply-fused-loops.ll
@@ -10,15 +10,15 @@ define void @multiply_noalias_4x4(ptr noalias %A, ptr noalias %B, ptr noalias %C
; CHECK-LABEL: @multiply_noalias_4x4(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[COLS_HEADER:%.*]]
-; CHECK: cols.header:
+; CHECK: rows.header:
; CHECK-NEXT: [[COLS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[COLS_STEP:%.*]], [[COLS_LATCH:%.*]] ]
; CHECK-NEXT: br label [[COLS_BODY:%.*]]
-; CHECK: cols.body:
+; CHECK: rows.body:
; CHECK-NEXT: br label [[ROWS_HEADER:%.*]]
-; CHECK: rows.header:
+; CHECK: cols.header:
; CHECK-NEXT: [[ROWS_IV:%.*]] = phi i64 [ 0, [[COLS_BODY]] ], [ [[ROWS_STEP:%.*]], [[ROWS_LATCH:%.*]] ]
; CHECK-NEXT: br label [[ROWS_BODY:%.*]]
-; CHECK: rows.body:
+; CHECK: cols.body:
; CHECK-NEXT: br label [[INNER_HEADER:%.*]]
; CHECK: k.header:
; CHECK-NEXT: [[INNER_IV:%.*]] = phi i64 [ 0, [[ROWS_BODY]] ], [ [[INNER_STEP:%.*]], [[INNER_LATCH:%.*]] ]
@@ -28,11 +28,11 @@ define void @multiply_noalias_4x4(ptr noalias %A, ptr noalias %B, ptr noalias %C
; CHECK: k.body:
; CHECK-NEXT: [[DOTIDX:%.*]] = shl i64 [[INNER_IV]], 5
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 [[DOTIDX]]
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [8 x i8], ptr [[TMP0]], i64 [[ROWS_IV]]
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [8 x i8], ptr [[TMP0]], i64 [[COLS_IV]]
; CHECK-NEXT: [[COL_LOAD:%.*]] = load <2 x double>, ptr [[TMP1]], align 8
; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP1]], i64 32
; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <2 x double>, ptr [[VEC_GEP]], align 8
-; CHECK-NEXT: [[DOTIDX17:%.*]] = shl i64 [[COLS_IV]], 5
+; CHECK-NEXT: [[DOTIDX17:%.*]] = shl i64 [[ROWS_IV]], 5
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[B:%.*]], i64 [[DOTIDX17]]
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr [8 x i8], ptr [[TMP2]], i64 [[INNER_IV]]
; CHECK-NEXT: [[COL_LOAD2:%.*]] = load <2 x double>, ptr [[TMP3]], align 8
@@ -51,20 +51,20 @@ define void @multiply_noalias_4x4(ptr noalias %A, ptr noalias %B, ptr noalias %C
; CHECK-NEXT: [[INNER_STEP]] = add i64 [[INNER_IV]], 2
; CHECK-NEXT: [[INNER_COND_NOT:%.*]] = icmp eq i64 [[INNER_STEP]], 4
; CHECK-NEXT: br i1 [[INNER_COND_NOT]], label [[ROWS_LATCH]], label [[INNER_HEADER]], !prof [[PROF0:![0-9]+]], !llvm.loop [[LOOP1:![0-9]+]]
-; CHECK: rows.latch:
-; CHECK-NEXT: [[ROWS_STEP]] = add i64 [[ROWS_IV]], 2
-; CHECK-NEXT: [[ROWS_COND_NOT:%.*]] = icmp eq i64 [[ROWS_STEP]], 4
-; CHECK-NEXT: [[DOTIDX18:%.*]] = shl i64 [[COLS_IV]], 5
+; CHECK: cols.latch:
+; CHECK-NEXT: [[DOTIDX18:%.*]] = shl i64 [[ROWS_IV]], 5
; CHECK-NEXT: [[TMP8:%.*]] = getelementptr i8, ptr [[C:%.*]], i64 [[DOTIDX18]]
-; CHECK-NEXT: [[TMP9:%.*]] = getelementptr [8 x i8], ptr [[TMP8]], i64 [[ROWS_IV]]
+; CHECK-NEXT: [[TMP9:%.*]] = getelementptr [8 x i8], ptr [[TMP8]], i64 [[COLS_IV]]
; CHECK-NEXT: store <2 x double> [[TMP5]], ptr [[TMP9]], align 8
; CHECK-NEXT: [[VEC_GEP16:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP9]], i64 32
; CHECK-NEXT: store <2 x double> [[TMP7]], ptr [[VEC_GEP16]], align 8
-; CHECK-NEXT: br i1 [[ROWS_COND_NOT]], label [[COLS_LATCH]], label [[ROWS_HEADER]], !prof [[PROF0]]
-; CHECK: cols.latch:
+; CHECK-NEXT: [[ROWS_STEP]] = add i64 [[ROWS_IV]], 2
+; CHECK-NEXT: [[COLS_COND_NOT1:%.*]] = icmp eq i64 [[ROWS_STEP]], 4
+; CHECK-NEXT: br i1 [[COLS_COND_NOT1]], label [[COLS_LATCH]], label [[ROWS_HEADER]], !prof [[PROF0]], !llvm.loop [[LOOP3:![0-9]+]]
+; CHECK: rows.latch:
; CHECK-NEXT: [[COLS_STEP]] = add i64 [[COLS_IV]], 2
; CHECK-NEXT: [[COLS_COND_NOT:%.*]] = icmp eq i64 [[COLS_STEP]], 4
-; CHECK-NEXT: br i1 [[COLS_COND_NOT]], label [[CONTINUE:%.*]], label [[COLS_HEADER]], !prof [[PROF0]]
+; CHECK-NEXT: br i1 [[COLS_COND_NOT]], label [[CONTINUE:%.*]], label [[COLS_HEADER]], !prof [[PROF0]], !llvm.loop [[LOOP4:![0-9]+]]
; CHECK: continue:
; CHECK-NEXT: ret void
;
@@ -150,15 +150,15 @@ define void @multiply_noalias_4x2_2x8(ptr noalias %A, ptr noalias %B, ptr noalia
; CHECK-LABEL: @multiply_noalias_4x2_2x8(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[COLS_HEADER:%.*]]
-; CHECK: cols.header:
+; CHECK: rows.header:
; CHECK-NEXT: [[COLS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[COLS_STEP:%.*]], [[COLS_LATCH:%.*]] ]
; CHECK-NEXT: br label [[COLS_BODY:%.*]]
-; CHECK: cols.body:
+; CHECK: rows.body:
; CHECK-NEXT: br label [[ROWS_HEADER:%.*]]
-; CHECK: rows.header:
+; CHECK: cols.header:
; CHECK-NEXT: [[ROWS_IV:%.*]] = phi i64 [ 0, [[COLS_BODY]] ], [ [[ROWS_STEP:%.*]], [[ROWS_LATCH:%.*]] ]
; CHECK-NEXT: br label [[ROWS_BODY:%.*]]
-; CHECK: rows.body:
+; CHECK: cols.body:
; CHECK-NEXT: br label [[INNER_HEADER:%.*]]
; CHECK: k.header:
; CHECK-NEXT: [[INNER_IV:%.*]] = phi i64 [ 0, [[ROWS_BODY]] ], [ [[INNER_STEP:%.*]], [[INNER_LATCH:%.*]] ]
@@ -168,11 +168,11 @@ define void @multiply_noalias_4x2_2x8(ptr noalias %A, ptr noalias %B, ptr noalia
; CHECK: k.body:
; CHECK-NEXT: [[DOTIDX:%.*]] = shl i64 [[INNER_IV]], 5
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr i8, ptr [[A:%.*]], i64 [[DOTIDX]]
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [8 x i8], ptr [[TMP0]], i64 [[ROWS_IV]]
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [8 x i8], ptr [[TMP0]], i64 [[COLS_IV]]
; CHECK-NEXT: [[COL_LOAD:%.*]] = load <2 x i64>, ptr [[TMP1]], align 8
; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP1]], i64 32
; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <2 x i64>, ptr [[VEC_GEP]], align 8
-; CHECK-NEXT: [[DOTIDX17:%.*]] = shl i64 [[COLS_IV]], 4
+; CHECK-NEXT: [[DOTIDX17:%.*]] = shl i64 [[ROWS_IV]], 4
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[B:%.*]], i64 [[DOTIDX17]]
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr [8 x i8], ptr [[TMP2]], i64 [[INNER_IV]]
; CHECK-NEXT: [[COL_LOAD2:%.*]] = load <2 x i64>, ptr [[TMP3]], align 8
@@ -194,21 +194,21 @@ define void @multiply_noalias_4x2_2x8(ptr noalias %A, ptr noalias %B, ptr noalia
; CHECK: k.latch:
; CHECK-NEXT: [[INNER_STEP]] = add i64 [[INNER_IV]], 2
; CHECK-NEXT: [[INNER_COND_NOT:%.*]] = icmp eq i64 [[INNER_IV]], 0
-; CHECK-NEXT: br i1 [[INNER_COND_NOT]], label [[ROWS_LATCH]], label [[INNER_HEADER]], !prof [[PROF3:![0-9]+]], !llvm.loop [[LOOP4:![0-9]+]]
-; CHECK: rows.latch:
-; CHECK-NEXT: [[ROWS_STEP]] = add i64 [[ROWS_IV]], 2
-; CHECK-NEXT: [[ROWS_COND_NOT:%.*]] = icmp eq i64 [[ROWS_STEP]], 4
-; CHECK-NEXT: [[DOTIDX18:%.*]] = shl i64 [[COLS_IV]], 5
+; CHECK-NEXT: br i1 [[INNER_COND_NOT]], label [[ROWS_LATCH]], label [[INNER_HEADER]], !prof [[PROF5:![0-9]+]], !llvm.loop [[LOOP6:![0-9]+]]
+; CHECK: cols.latch:
+; CHECK-NEXT: [[DOTIDX18:%.*]] = shl i64 [[ROWS_IV]], 5
; CHECK-NEXT: [[TMP12:%.*]] = getelementptr i8, ptr [[C:%.*]], i64 [[DOTIDX18]]
-; CHECK-NEXT: [[TMP13:%.*]] = getelementptr [8 x i8], ptr [[TMP12]], i64 [[ROWS_IV]]
+; CHECK-NEXT: [[TMP13:%.*]] = getelementptr [8 x i8], ptr [[TMP12]], i64 [[COLS_IV]]
; CHECK-NEXT: store <2 x i64> [[TMP7]], ptr [[TMP13]], align 8
; CHECK-NEXT: [[VEC_GEP16:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP13]], i64 32
; CHECK-NEXT: store <2 x i64> [[TMP11]], ptr [[VEC_GEP16]], align 8
-; CHECK-NEXT: br i1 [[ROWS_COND_NOT]], label [[COLS_LATCH]], label [[ROWS_HEADER]], !prof [[PROF0]]
-; CHECK: cols.latch:
+; CHECK-NEXT: [[ROWS_STEP]] = add i64 [[ROWS_IV]], 2
+; CHECK-NEXT: [[COLS_COND_NOT:%.*]] = icmp eq i64 [[ROWS_STEP]], 8
+; CHECK-NEXT: br i1 [[COLS_COND_NOT]], label [[COLS_LATCH]], label [[ROWS_HEADER]], !prof [[PROF7:![0-9]+]], !llvm.loop [[LOOP8:![0-9]+]]
+; CHECK: rows.latch:
; CHECK-NEXT: [[COLS_STEP]] = add i64 [[COLS_IV]], 2
-; CHECK-NEXT: [[COLS_COND_NOT:%.*]] = icmp eq i64 [[COLS_STEP]], 8
-; CHECK-NEXT: br i1 [[COLS_COND_NOT]], label [[CONTINUE:%.*]], label [[COLS_HEADER]], !prof [[PROF6:![0-9]+]]
+; CHECK-NEXT: [[ROWS_COND_NOT:%.*]] = icmp eq i64 [[COLS_STEP]], 4
+; CHECK-NEXT: br i1 [[ROWS_COND_NOT]], label [[CONTINUE:%.*]], label [[COLS_HEADER]], !prof [[PROF0]], !llvm.loop [[LOOP9:![0-9]+]]
; CHECK: continue:
; CHECK-NEXT: ret void
;
@@ -301,9 +301,12 @@ declare <4 x float> @llvm.matrix.multiply.v4f32.v4f32.v4f32(<4 x float>, <4 x fl
;.
; CHECK: [[PROF0]] = !{!"branch_weights", i32 1, i32 2}
; CHECK: [[LOOP1]] = distinct !{[[LOOP1]], [[META2:![0-9]+]]}
-; CHECK: [[META2]] = !{!"llvm.loop.unroll.count", i32 2}
-; CHECK: [[PROF3]] = !{!"branch_weights", i32 1, i32 1}
-; CHECK: [[LOOP4]] = distinct !{[[LOOP4]], [[META5:![0-9]+]]}
-; CHECK: [[META5]] = !{!"llvm.loop.unroll.count", i32 1}
-; CHECK: [[PROF6]] = !{!"branch_weights", i32 1, i32 4}
+; CHECK: [[META2]] = !{!"llvm.loop.unroll.disable"}
+; CHECK: [[LOOP3]] = distinct !{[[LOOP3]], [[META2]]}
+; CHECK: [[LOOP4]] = distinct !{[[LOOP4]], [[META2]]}
+; CHECK: [[PROF5]] = !{!"branch_weights", i32 1, i32 1}
+; CHECK: [[LOOP6]] = distinct !{[[LOOP6]], [[META2]]}
+; CHECK: [[PROF7]] = !{!"branch_weights", i32 1, i32 4}
+; CHECK: [[LOOP8]] = distinct !{[[LOOP8]], [[META2]]}
+; CHECK: [[LOOP9]] = distinct !{[[LOOP9]], [[META2]]}
;.
diff --git a/llvm/test/Transforms/LowerMatrixIntrinsics/no-tiling-remark.ll b/llvm/test/Transforms/LowerMatrixIntrinsics/no-tiling-remark.ll
new file mode 100644
index 0000000000000..1b16199f04590
--- /dev/null
+++ b/llvm/test/Transforms/LowerMatrixIntrinsics/no-tiling-remark.ll
@@ -0,0 +1,6436 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -passes=lower-matrix-intrinsics -aa-pipeline=basic-aa -S < %s | FileCheck %s
+; RUN: opt -passes=lower-matrix-intrinsics -aa-pipeline=basic-aa -matrix-enable-pushing-to-mem-for-tiling=false -pass-remarks-missed=lower-matrix-intrinsics %s -o /dev/null 2>&1 | FileCheck -check-prefix=DISABLED-REMARKS %s
+
+; DISABLED-REMARKS: Not tiling for matmul with FLOPS
+; DISABLED-REMARKS: Not tiling for matmul with FLOPS
+
+define void @multiply(<64 x float> * noalias %A, <64 x float> * noalias %B, <64 x float>* noalias %C) {
+; CHECK-LABEL: @multiply(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[COL_LOAD:%.*]] = load <8 x float>, ptr [[A:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds float, ptr [[A]], i64 8
+; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <8 x float>, ptr [[VEC_GEP]], align 16
+; CHECK-NEXT: [[VEC_GEP2:%.*]] = getelementptr inbounds float, ptr [[A]], i64 16
+; CHECK-NEXT: [[COL_LOAD3:%.*]] = load <8 x float>, ptr [[VEC_GEP2]], align 16
+; CHECK-NEXT: [[VEC_GEP4:%.*]] = getelementptr inbounds float, ptr [[A]], i64 24
+; CHECK-NEXT: [[COL_LOAD5:%.*]] = load <8 x float>, ptr [[VEC_GEP4]], align 16
+; CHECK-NEXT: [[VEC_GEP6:%.*]] = getelementptr inbounds float, ptr [[A]], i64 32
+; CHECK-NEXT: [[COL_LOAD7:%.*]] = load <8 x float>, ptr [[VEC_GEP6]], align 16
+; CHECK-NEXT: [[VEC_GEP8:%.*]] = getelementptr inbounds float, ptr [[A]], i64 40
+; CHECK-NEXT: [[COL_LOAD9:%.*]] = load <8 x float>, ptr [[VEC_GEP8]], align 16
+; CHECK-NEXT: [[VEC_GEP10:%.*]] = getelementptr inbounds float, ptr [[A]], i64 48
+; CHECK-NEXT: [[COL_LOAD11:%.*]] = load <8 x float>, ptr [[VEC_GEP10]], align 16
+; CHECK-NEXT: [[VEC_GEP12:%.*]] = getelementptr inbounds float, ptr [[A]], i64 56
+; CHECK-NEXT: [[COL_LOAD13:%.*]] = load <8 x float>, ptr [[VEC_GEP12]], align 16
+; CHECK-NEXT: [[COL_LOAD14:%.*]] = load <8 x float>, ptr [[B:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP15:%.*]] = getelementptr inbounds float, ptr [[B]], i64 8
+; CHECK-NEXT: [[COL_LOAD16:%.*]] = load <8 x float>, ptr [[VEC_GEP15]], align 16
+; CHECK-NEXT: [[VEC_GEP17:%.*]] = getelementptr inbounds float, ptr [[B]], i64 16
+; CHECK-NEXT: [[COL_LOAD18:%.*]] = load <8 x float>, ptr [[VEC_GEP17]], align 16
+; CHECK-NEXT: [[VEC_GEP19:%.*]] = getelementptr inbounds float, ptr [[B]], i64 24
+; CHECK-NEXT: [[COL_LOAD20:%.*]] = load <8 x float>, ptr [[VEC_GEP19]], align 16
+; CHECK-NEXT: [[VEC_GEP21:%.*]] = getelementptr inbounds float, ptr [[B]], i64 32
+; CHECK-NEXT: [[COL_LOAD22:%.*]] = load <8 x float>, ptr [[VEC_GEP21]], align 16
+; CHECK-NEXT: [[VEC_GEP23:%.*]] = getelementptr inbounds float, ptr [[B]], i64 40
+; CHECK-NEXT: [[COL_LOAD24:%.*]] = load <8 x float>, ptr [[VEC_GEP23]], align 16
+; CHECK-NEXT: [[VEC_GEP25:%.*]] = getelementptr inbounds float, ptr [[B]], i64 48
+; CHECK-NEXT: [[COL_LOAD26:%.*]] = load <8 x float>, ptr [[VEC_GEP25]], align 16
+; CHECK-NEXT: [[VEC_GEP27:%.*]] = getelementptr inbounds float, ptr [[B]], i64 56
+; CHECK-NEXT: [[COL_LOAD28:%.*]] = load <8 x float>, ptr [[VEC_GEP27]], align 16
+; CHECK-NEXT: [[TMP0:%.*]] = fneg <8 x float> [[COL_LOAD14]]
+; CHECK-NEXT: [[TMP1:%.*]] = fneg <8 x float> [[COL_LOAD16]]
+; CHECK-NEXT: [[TMP2:%.*]] = fneg <8 x float> [[COL_LOAD18]]
+; CHECK-NEXT: [[TMP3:%.*]] = fneg <8 x float> [[COL_LOAD20]]
+; CHECK-NEXT: [[TMP4:%.*]] = fneg <8 x float> [[COL_LOAD22]]
+; CHECK-NEXT: [[TMP5:%.*]] = fneg <8 x float> [[COL_LOAD24]]
+; CHECK-NEXT: [[TMP6:%.*]] = fneg <8 x float> [[COL_LOAD26]]
+; CHECK-NEXT: [[TMP7:%.*]] = fneg <8 x float> [[COL_LOAD28]]
+; CHECK-NEXT: [[BLOCK:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP8:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT:%.*]] = insertelement <1 x float> poison, float [[TMP8]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP9:%.*]] = fmul <1 x float> [[BLOCK]], [[SPLAT_SPLAT]]
+; CHECK-NEXT: [[BLOCK29:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP10:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT30:%.*]] = insertelement <1 x float> poison, float [[TMP10]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT31:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT30]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP11:%.*]] = fmul <1 x float> [[BLOCK29]], [[SPLAT_SPLAT31]]
+; CHECK-NEXT: [[TMP13:%.*]] = fadd <1 x float> [[TMP9]], [[TMP11]]
+; CHECK-NEXT: [[BLOCK32:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP12:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT33:%.*]] = insertelement <1 x float> poison, float [[TMP12]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT34:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT33]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP19:%.*]] = fmul <1 x float> [[BLOCK32]], [[SPLAT_SPLAT34]]
+; CHECK-NEXT: [[TMP15:%.*]] = fadd <1 x float> [[TMP13]], [[TMP19]]
+; CHECK-NEXT: [[BLOCK35:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP14:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT36:%.*]] = insertelement <1 x float> poison, float [[TMP14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT37:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT36]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP17:%.*]] = fmul <1 x float> [[BLOCK35]], [[SPLAT_SPLAT37]]
+; CHECK-NEXT: [[TMP31:%.*]] = fadd <1 x float> [[TMP15]], [[TMP17]]
+; CHECK-NEXT: [[BLOCK38:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP16:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT39:%.*]] = insertelement <1 x float> poison, float [[TMP16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT40:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT39]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP33:%.*]] = fmul <1 x float> [[BLOCK38]], [[SPLAT_SPLAT40]]
+; CHECK-NEXT: [[TMP21:%.*]] = fadd <1 x float> [[TMP31]], [[TMP33]]
+; CHECK-NEXT: [[BLOCK41:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP18:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT42:%.*]] = insertelement <1 x float> poison, float [[TMP18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT43:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT42]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP35:%.*]] = fmul <1 x float> [[BLOCK41]], [[SPLAT_SPLAT43]]
+; CHECK-NEXT: [[TMP47:%.*]] = fadd <1 x float> [[TMP21]], [[TMP35]]
+; CHECK-NEXT: [[BLOCK44:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP20:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT45:%.*]] = insertelement <1 x float> poison, float [[TMP20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT46:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT45]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP53:%.*]] = fmul <1 x float> [[BLOCK44]], [[SPLAT_SPLAT46]]
+; CHECK-NEXT: [[TMP27:%.*]] = fadd <1 x float> [[TMP47]], [[TMP53]]
+; CHECK-NEXT: [[BLOCK47:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP22:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT48:%.*]] = insertelement <1 x float> poison, float [[TMP22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT49:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT48]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP29:%.*]] = fmul <1 x float> [[BLOCK47]], [[SPLAT_SPLAT49]]
+; CHECK-NEXT: [[TMP23:%.*]] = fadd <1 x float> [[TMP27]], [[TMP29]]
+; CHECK-NEXT: [[TMP24:%.*]] = shufflevector <1 x float> [[TMP23]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP25:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP24]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK50:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP26:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT51:%.*]] = insertelement <1 x float> poison, float [[TMP26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT52:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT51]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP55:%.*]] = fmul <1 x float> [[BLOCK50]], [[SPLAT_SPLAT52]]
+; CHECK-NEXT: [[BLOCK53:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP28:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT54:%.*]] = insertelement <1 x float> poison, float [[TMP28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT55:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT54]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP57:%.*]] = fmul <1 x float> [[BLOCK53]], [[SPLAT_SPLAT55]]
+; CHECK-NEXT: [[TMP37:%.*]] = fadd <1 x float> [[TMP55]], [[TMP57]]
+; CHECK-NEXT: [[BLOCK56:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP30:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT57:%.*]] = insertelement <1 x float> poison, float [[TMP30]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT58:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT57]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP39:%.*]] = fmul <1 x float> [[BLOCK56]], [[SPLAT_SPLAT58]]
+; CHECK-NEXT: [[TMP63:%.*]] = fadd <1 x float> [[TMP37]], [[TMP39]]
+; CHECK-NEXT: [[BLOCK59:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP32:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT60:%.*]] = insertelement <1 x float> poison, float [[TMP32]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT61:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT60]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP69:%.*]] = fmul <1 x float> [[BLOCK59]], [[SPLAT_SPLAT61]]
+; CHECK-NEXT: [[TMP75:%.*]] = fadd <1 x float> [[TMP63]], [[TMP69]]
+; CHECK-NEXT: [[BLOCK62:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP34:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT63:%.*]] = insertelement <1 x float> poison, float [[TMP34]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT64:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT63]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP45:%.*]] = fmul <1 x float> [[BLOCK62]], [[SPLAT_SPLAT64]]
+; CHECK-NEXT: [[TMP81:%.*]] = fadd <1 x float> [[TMP75]], [[TMP45]]
+; CHECK-NEXT: [[BLOCK65:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP36:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT66:%.*]] = insertelement <1 x float> poison, float [[TMP36]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT67:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT66]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP83:%.*]] = fmul <1 x float> [[BLOCK65]], [[SPLAT_SPLAT67]]
+; CHECK-NEXT: [[TMP49:%.*]] = fadd <1 x float> [[TMP81]], [[TMP83]]
+; CHECK-NEXT: [[BLOCK68:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP38:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT69:%.*]] = insertelement <1 x float> poison, float [[TMP38]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT70:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT69]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP51:%.*]] = fmul <1 x float> [[BLOCK68]], [[SPLAT_SPLAT70]]
+; CHECK-NEXT: [[TMP85:%.*]] = fadd <1 x float> [[TMP49]], [[TMP51]]
+; CHECK-NEXT: [[BLOCK71:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP40:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT72:%.*]] = insertelement <1 x float> poison, float [[TMP40]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT73:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT72]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP91:%.*]] = fmul <1 x float> [[BLOCK71]], [[SPLAT_SPLAT73]]
+; CHECK-NEXT: [[TMP41:%.*]] = fadd <1 x float> [[TMP85]], [[TMP91]]
+; CHECK-NEXT: [[TMP42:%.*]] = shufflevector <1 x float> [[TMP41]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP43:%.*]] = shufflevector <8 x float> [[TMP25]], <8 x float> [[TMP42]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK74:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP44:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT75:%.*]] = insertelement <1 x float> poison, float [[TMP44]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT76:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT75]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP103:%.*]] = fmul <1 x float> [[BLOCK74]], [[SPLAT_SPLAT76]]
+; CHECK-NEXT: [[BLOCK77:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP46:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT78:%.*]] = insertelement <1 x float> poison, float [[TMP46]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT79:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT78]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP105:%.*]] = fmul <1 x float> [[BLOCK77]], [[SPLAT_SPLAT79]]
+; CHECK-NEXT: [[TMP107:%.*]] = fadd <1 x float> [[TMP103]], [[TMP105]]
+; CHECK-NEXT: [[BLOCK80:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP48:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT81:%.*]] = insertelement <1 x float> poison, float [[TMP48]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT82:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT81]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP119:%.*]] = fmul <1 x float> [[BLOCK80]], [[SPLAT_SPLAT82]]
+; CHECK-NEXT: [[TMP65:%.*]] = fadd <1 x float> [[TMP107]], [[TMP119]]
+; CHECK-NEXT: [[BLOCK83:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP50:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT84:%.*]] = insertelement <1 x float> poison, float [[TMP50]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT85:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT84]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP67:%.*]] = fmul <1 x float> [[BLOCK83]], [[SPLAT_SPLAT85]]
+; CHECK-NEXT: [[TMP125:%.*]] = fadd <1 x float> [[TMP65]], [[TMP67]]
+; CHECK-NEXT: [[BLOCK86:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP52:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT87:%.*]] = insertelement <1 x float> poison, float [[TMP52]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT88:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT87]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP135:%.*]] = fmul <1 x float> [[BLOCK86]], [[SPLAT_SPLAT88]]
+; CHECK-NEXT: [[TMP71:%.*]] = fadd <1 x float> [[TMP125]], [[TMP135]]
+; CHECK-NEXT: [[BLOCK89:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP54:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT90:%.*]] = insertelement <1 x float> poison, float [[TMP54]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT91:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT90]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP73:%.*]] = fmul <1 x float> [[BLOCK89]], [[SPLAT_SPLAT91]]
+; CHECK-NEXT: [[TMP141:%.*]] = fadd <1 x float> [[TMP71]], [[TMP73]]
+; CHECK-NEXT: [[BLOCK92:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP56:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT93:%.*]] = insertelement <1 x float> poison, float [[TMP56]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT94:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT93]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP147:%.*]] = fmul <1 x float> [[BLOCK92]], [[SPLAT_SPLAT94]]
+; CHECK-NEXT: [[TMP153:%.*]] = fadd <1 x float> [[TMP141]], [[TMP147]]
+; CHECK-NEXT: [[BLOCK95:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP58:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT96:%.*]] = insertelement <1 x float> poison, float [[TMP58]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT97:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT96]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP155:%.*]] = fmul <1 x float> [[BLOCK95]], [[SPLAT_SPLAT97]]
+; CHECK-NEXT: [[TMP59:%.*]] = fadd <1 x float> [[TMP153]], [[TMP155]]
+; CHECK-NEXT: [[TMP60:%.*]] = shufflevector <1 x float> [[TMP59]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP61:%.*]] = shufflevector <8 x float> [[TMP43]], <8 x float> [[TMP60]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK98:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP62:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT99:%.*]] = insertelement <1 x float> poison, float [[TMP62]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT100:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT99]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP157:%.*]] = fmul <1 x float> [[BLOCK98]], [[SPLAT_SPLAT100]]
+; CHECK-NEXT: [[BLOCK101:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP64:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT102:%.*]] = insertelement <1 x float> poison, float [[TMP64]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT103:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT102]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP163:%.*]] = fmul <1 x float> [[BLOCK101]], [[SPLAT_SPLAT103]]
+; CHECK-NEXT: [[TMP87:%.*]] = fadd <1 x float> [[TMP157]], [[TMP163]]
+; CHECK-NEXT: [[BLOCK104:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP66:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT105:%.*]] = insertelement <1 x float> poison, float [[TMP66]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT106:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT105]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP89:%.*]] = fmul <1 x float> [[BLOCK104]], [[SPLAT_SPLAT106]]
+; CHECK-NEXT: [[TMP175:%.*]] = fadd <1 x float> [[TMP87]], [[TMP89]]
+; CHECK-NEXT: [[BLOCK107:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP68:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT108:%.*]] = insertelement <1 x float> poison, float [[TMP68]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT109:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT108]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP181:%.*]] = fmul <1 x float> [[BLOCK107]], [[SPLAT_SPLAT109]]
+; CHECK-NEXT: [[TMP93:%.*]] = fadd <1 x float> [[TMP175]], [[TMP181]]
+; CHECK-NEXT: [[BLOCK110:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP70:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT111:%.*]] = insertelement <1 x float> poison, float [[TMP70]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT112:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT111]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP183:%.*]] = fmul <1 x float> [[BLOCK110]], [[SPLAT_SPLAT112]]
+; CHECK-NEXT: [[TMP191:%.*]] = fadd <1 x float> [[TMP93]], [[TMP183]]
+; CHECK-NEXT: [[BLOCK113:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP72:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT114:%.*]] = insertelement <1 x float> poison, float [[TMP72]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT115:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT114]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP197:%.*]] = fmul <1 x float> [[BLOCK113]], [[SPLAT_SPLAT115]]
+; CHECK-NEXT: [[TMP99:%.*]] = fadd <1 x float> [[TMP191]], [[TMP197]]
+; CHECK-NEXT: [[BLOCK116:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP74:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT117:%.*]] = insertelement <1 x float> poison, float [[TMP74]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT118:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT117]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP101:%.*]] = fmul <1 x float> [[BLOCK116]], [[SPLAT_SPLAT118]]
+; CHECK-NEXT: [[TMP207:%.*]] = fadd <1 x float> [[TMP99]], [[TMP101]]
+; CHECK-NEXT: [[BLOCK119:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP76:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT120:%.*]] = insertelement <1 x float> poison, float [[TMP76]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT121:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT120]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP213:%.*]] = fmul <1 x float> [[BLOCK119]], [[SPLAT_SPLAT121]]
+; CHECK-NEXT: [[TMP77:%.*]] = fadd <1 x float> [[TMP207]], [[TMP213]]
+; CHECK-NEXT: [[TMP78:%.*]] = shufflevector <1 x float> [[TMP77]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP79:%.*]] = shufflevector <8 x float> [[TMP61]], <8 x float> [[TMP78]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK122:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP80:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT123:%.*]] = insertelement <1 x float> poison, float [[TMP80]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT124:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT123]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP109:%.*]] = fmul <1 x float> [[BLOCK122]], [[SPLAT_SPLAT124]]
+; CHECK-NEXT: [[BLOCK125:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP82:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT126:%.*]] = insertelement <1 x float> poison, float [[TMP82]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT127:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT126]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP111:%.*]] = fmul <1 x float> [[BLOCK125]], [[SPLAT_SPLAT127]]
+; CHECK-NEXT: [[TMP219:%.*]] = fadd <1 x float> [[TMP109]], [[TMP111]]
+; CHECK-NEXT: [[BLOCK128:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP84:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT129:%.*]] = insertelement <1 x float> poison, float [[TMP84]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT130:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT129]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP225:%.*]] = fmul <1 x float> [[BLOCK128]], [[SPLAT_SPLAT130]]
+; CHECK-NEXT: [[TMP231:%.*]] = fadd <1 x float> [[TMP219]], [[TMP225]]
+; CHECK-NEXT: [[BLOCK131:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP86:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT132:%.*]] = insertelement <1 x float> poison, float [[TMP86]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT133:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT132]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP117:%.*]] = fmul <1 x float> [[BLOCK131]], [[SPLAT_SPLAT133]]
+; CHECK-NEXT: [[TMP233:%.*]] = fadd <1 x float> [[TMP231]], [[TMP117]]
+; CHECK-NEXT: [[BLOCK134:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP88:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT135:%.*]] = insertelement <1 x float> poison, float [[TMP88]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT136:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT135]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP235:%.*]] = fmul <1 x float> [[BLOCK134]], [[SPLAT_SPLAT136]]
+; CHECK-NEXT: [[TMP121:%.*]] = fadd <1 x float> [[TMP233]], [[TMP235]]
+; CHECK-NEXT: [[BLOCK137:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP90:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT138:%.*]] = insertelement <1 x float> poison, float [[TMP90]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT139:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT138]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP123:%.*]] = fmul <1 x float> [[BLOCK137]], [[SPLAT_SPLAT139]]
+; CHECK-NEXT: [[TMP247:%.*]] = fadd <1 x float> [[TMP121]], [[TMP123]]
+; CHECK-NEXT: [[BLOCK140:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP92:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT141:%.*]] = insertelement <1 x float> poison, float [[TMP92]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT142:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT141]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP253:%.*]] = fmul <1 x float> [[BLOCK140]], [[SPLAT_SPLAT142]]
+; CHECK-NEXT: [[TMP127:%.*]] = fadd <1 x float> [[TMP247]], [[TMP253]]
+; CHECK-NEXT: [[BLOCK143:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP94:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT144:%.*]] = insertelement <1 x float> poison, float [[TMP94]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT145:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT144]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP129:%.*]] = fmul <1 x float> [[BLOCK143]], [[SPLAT_SPLAT145]]
+; CHECK-NEXT: [[TMP95:%.*]] = fadd <1 x float> [[TMP127]], [[TMP129]]
+; CHECK-NEXT: [[TMP96:%.*]] = shufflevector <1 x float> [[TMP95]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP97:%.*]] = shufflevector <8 x float> [[TMP79]], <8 x float> [[TMP96]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK146:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP98:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT147:%.*]] = insertelement <1 x float> poison, float [[TMP98]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT148:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT147]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP255:%.*]] = fmul <1 x float> [[BLOCK146]], [[SPLAT_SPLAT148]]
+; CHECK-NEXT: [[BLOCK149:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP100:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT150:%.*]] = insertelement <1 x float> poison, float [[TMP100]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT151:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT150]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP263:%.*]] = fmul <1 x float> [[BLOCK149]], [[SPLAT_SPLAT151]]
+; CHECK-NEXT: [[TMP137:%.*]] = fadd <1 x float> [[TMP255]], [[TMP263]]
+; CHECK-NEXT: [[BLOCK152:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP102:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT153:%.*]] = insertelement <1 x float> poison, float [[TMP102]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT154:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT153]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP139:%.*]] = fmul <1 x float> [[BLOCK152]], [[SPLAT_SPLAT154]]
+; CHECK-NEXT: [[TMP269:%.*]] = fadd <1 x float> [[TMP137]], [[TMP139]]
+; CHECK-NEXT: [[BLOCK155:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP104:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT156:%.*]] = insertelement <1 x float> poison, float [[TMP104]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT157:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT156]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP281:%.*]] = fmul <1 x float> [[BLOCK155]], [[SPLAT_SPLAT157]]
+; CHECK-NEXT: [[TMP143:%.*]] = fadd <1 x float> [[TMP269]], [[TMP281]]
+; CHECK-NEXT: [[BLOCK158:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP106:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT159:%.*]] = insertelement <1 x float> poison, float [[TMP106]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT160:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT159]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP145:%.*]] = fmul <1 x float> [[BLOCK158]], [[SPLAT_SPLAT160]]
+; CHECK-NEXT: [[TMP283:%.*]] = fadd <1 x float> [[TMP143]], [[TMP145]]
+; CHECK-NEXT: [[BLOCK161:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP108:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT162:%.*]] = insertelement <1 x float> poison, float [[TMP108]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT163:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT162]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP285:%.*]] = fmul <1 x float> [[BLOCK161]], [[SPLAT_SPLAT163]]
+; CHECK-NEXT: [[TMP291:%.*]] = fadd <1 x float> [[TMP283]], [[TMP285]]
+; CHECK-NEXT: [[BLOCK164:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP110:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT165:%.*]] = insertelement <1 x float> poison, float [[TMP110]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT166:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT165]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP297:%.*]] = fmul <1 x float> [[BLOCK164]], [[SPLAT_SPLAT166]]
+; CHECK-NEXT: [[TMP303:%.*]] = fadd <1 x float> [[TMP291]], [[TMP297]]
+; CHECK-NEXT: [[BLOCK167:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP112:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT168:%.*]] = insertelement <1 x float> poison, float [[TMP112]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT169:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT168]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP305:%.*]] = fmul <1 x float> [[BLOCK167]], [[SPLAT_SPLAT169]]
+; CHECK-NEXT: [[TMP113:%.*]] = fadd <1 x float> [[TMP303]], [[TMP305]]
+; CHECK-NEXT: [[TMP114:%.*]] = shufflevector <1 x float> [[TMP113]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP115:%.*]] = shufflevector <8 x float> [[TMP97]], <8 x float> [[TMP114]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK170:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP116:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT171:%.*]] = insertelement <1 x float> poison, float [[TMP116]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT172:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT171]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP159:%.*]] = fmul <1 x float> [[BLOCK170]], [[SPLAT_SPLAT172]]
+; CHECK-NEXT: [[BLOCK173:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP118:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT174:%.*]] = insertelement <1 x float> poison, float [[TMP118]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT175:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT174]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP161:%.*]] = fmul <1 x float> [[BLOCK173]], [[SPLAT_SPLAT175]]
+; CHECK-NEXT: [[TMP307:%.*]] = fadd <1 x float> [[TMP159]], [[TMP161]]
+; CHECK-NEXT: [[BLOCK176:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP120:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT177:%.*]] = insertelement <1 x float> poison, float [[TMP120]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT178:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT177]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP319:%.*]] = fmul <1 x float> [[BLOCK176]], [[SPLAT_SPLAT178]]
+; CHECK-NEXT: [[TMP165:%.*]] = fadd <1 x float> [[TMP307]], [[TMP319]]
+; CHECK-NEXT: [[BLOCK179:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP122:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT180:%.*]] = insertelement <1 x float> poison, float [[TMP122]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT181:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT180]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP325:%.*]] = fmul <1 x float> [[BLOCK179]], [[SPLAT_SPLAT181]]
+; CHECK-NEXT: [[TMP333:%.*]] = fadd <1 x float> [[TMP165]], [[TMP325]]
+; CHECK-NEXT: [[BLOCK182:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP124:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT183:%.*]] = insertelement <1 x float> poison, float [[TMP124]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT184:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT183]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP335:%.*]] = fmul <1 x float> [[BLOCK182]], [[SPLAT_SPLAT184]]
+; CHECK-NEXT: [[TMP171:%.*]] = fadd <1 x float> [[TMP333]], [[TMP335]]
+; CHECK-NEXT: [[BLOCK185:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP126:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT186:%.*]] = insertelement <1 x float> poison, float [[TMP126]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT187:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT186]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP173:%.*]] = fmul <1 x float> [[BLOCK185]], [[SPLAT_SPLAT187]]
+; CHECK-NEXT: [[TMP341:%.*]] = fadd <1 x float> [[TMP171]], [[TMP173]]
+; CHECK-NEXT: [[BLOCK188:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP128:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT189:%.*]] = insertelement <1 x float> poison, float [[TMP128]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT190:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT189]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP353:%.*]] = fmul <1 x float> [[BLOCK188]], [[SPLAT_SPLAT190]]
+; CHECK-NEXT: [[TMP177:%.*]] = fadd <1 x float> [[TMP341]], [[TMP353]]
+; CHECK-NEXT: [[BLOCK191:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP130:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT192:%.*]] = insertelement <1 x float> poison, float [[TMP130]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT193:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT192]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP179:%.*]] = fmul <1 x float> [[BLOCK191]], [[SPLAT_SPLAT193]]
+; CHECK-NEXT: [[TMP131:%.*]] = fadd <1 x float> [[TMP177]], [[TMP179]]
+; CHECK-NEXT: [[TMP132:%.*]] = shufflevector <1 x float> [[TMP131]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP133:%.*]] = shufflevector <8 x float> [[TMP115]], <8 x float> [[TMP132]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK194:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP134:%.*]] = extractelement <8 x float> [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT195:%.*]] = insertelement <1 x float> poison, float [[TMP134]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT196:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT195]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP355:%.*]] = fmul <1 x float> [[BLOCK194]], [[SPLAT_SPLAT196]]
+; CHECK-NEXT: [[BLOCK197:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP136:%.*]] = extractelement <8 x float> [[TMP0]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT198:%.*]] = insertelement <1 x float> poison, float [[TMP136]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT199:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT198]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP357:%.*]] = fmul <1 x float> [[BLOCK197]], [[SPLAT_SPLAT199]]
+; CHECK-NEXT: [[TMP363:%.*]] = fadd <1 x float> [[TMP355]], [[TMP357]]
+; CHECK-NEXT: [[BLOCK200:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP138:%.*]] = extractelement <8 x float> [[TMP0]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT201:%.*]] = insertelement <1 x float> poison, float [[TMP138]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT202:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT201]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP189:%.*]] = fmul <1 x float> [[BLOCK200]], [[SPLAT_SPLAT202]]
+; CHECK-NEXT: [[TMP369:%.*]] = fadd <1 x float> [[TMP363]], [[TMP189]]
+; CHECK-NEXT: [[BLOCK203:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP140:%.*]] = extractelement <8 x float> [[TMP0]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT204:%.*]] = insertelement <1 x float> poison, float [[TMP140]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT205:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT204]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP375:%.*]] = fmul <1 x float> [[BLOCK203]], [[SPLAT_SPLAT205]]
+; CHECK-NEXT: [[TMP193:%.*]] = fadd <1 x float> [[TMP369]], [[TMP375]]
+; CHECK-NEXT: [[BLOCK206:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP142:%.*]] = extractelement <8 x float> [[TMP0]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT207:%.*]] = insertelement <1 x float> poison, float [[TMP142]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT208:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT207]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP195:%.*]] = fmul <1 x float> [[BLOCK206]], [[SPLAT_SPLAT208]]
+; CHECK-NEXT: [[TMP381:%.*]] = fadd <1 x float> [[TMP193]], [[TMP195]]
+; CHECK-NEXT: [[BLOCK209:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP144:%.*]] = extractelement <8 x float> [[TMP0]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT210:%.*]] = insertelement <1 x float> poison, float [[TMP144]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT211:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT210]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP391:%.*]] = fmul <1 x float> [[BLOCK209]], [[SPLAT_SPLAT211]]
+; CHECK-NEXT: [[TMP199:%.*]] = fadd <1 x float> [[TMP381]], [[TMP391]]
+; CHECK-NEXT: [[BLOCK212:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP146:%.*]] = extractelement <8 x float> [[TMP0]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT213:%.*]] = insertelement <1 x float> poison, float [[TMP146]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT214:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT213]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP201:%.*]] = fmul <1 x float> [[BLOCK212]], [[SPLAT_SPLAT214]]
+; CHECK-NEXT: [[TMP397:%.*]] = fadd <1 x float> [[TMP199]], [[TMP201]]
+; CHECK-NEXT: [[BLOCK215:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP148:%.*]] = extractelement <8 x float> [[TMP0]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT216:%.*]] = insertelement <1 x float> poison, float [[TMP148]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT217:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT216]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP405:%.*]] = fmul <1 x float> [[BLOCK215]], [[SPLAT_SPLAT217]]
+; CHECK-NEXT: [[TMP149:%.*]] = fadd <1 x float> [[TMP397]], [[TMP405]]
+; CHECK-NEXT: [[TMP150:%.*]] = shufflevector <1 x float> [[TMP149]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP151:%.*]] = shufflevector <8 x float> [[TMP133]], <8 x float> [[TMP150]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK218:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP152:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT219:%.*]] = insertelement <1 x float> poison, float [[TMP152]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT220:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT219]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP209:%.*]] = fmul <1 x float> [[BLOCK218]], [[SPLAT_SPLAT220]]
+; CHECK-NEXT: [[BLOCK221:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP154:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT222:%.*]] = insertelement <1 x float> poison, float [[TMP154]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT223:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT222]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP211:%.*]] = fmul <1 x float> [[BLOCK221]], [[SPLAT_SPLAT223]]
+; CHECK-NEXT: [[TMP407:%.*]] = fadd <1 x float> [[TMP209]], [[TMP211]]
+; CHECK-NEXT: [[BLOCK224:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP156:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT225:%.*]] = insertelement <1 x float> poison, float [[TMP156]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT226:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT225]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP413:%.*]] = fmul <1 x float> [[BLOCK224]], [[SPLAT_SPLAT226]]
+; CHECK-NEXT: [[TMP215:%.*]] = fadd <1 x float> [[TMP407]], [[TMP413]]
+; CHECK-NEXT: [[BLOCK227:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP158:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT228:%.*]] = insertelement <1 x float> poison, float [[TMP158]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT229:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT228]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP217:%.*]] = fmul <1 x float> [[BLOCK227]], [[SPLAT_SPLAT229]]
+; CHECK-NEXT: [[TMP425:%.*]] = fadd <1 x float> [[TMP215]], [[TMP217]]
+; CHECK-NEXT: [[BLOCK230:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP160:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT231:%.*]] = insertelement <1 x float> poison, float [[TMP160]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT232:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT231]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP431:%.*]] = fmul <1 x float> [[BLOCK230]], [[SPLAT_SPLAT232]]
+; CHECK-NEXT: [[TMP433:%.*]] = fadd <1 x float> [[TMP425]], [[TMP431]]
+; CHECK-NEXT: [[BLOCK233:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP162:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT234:%.*]] = insertelement <1 x float> poison, float [[TMP162]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT235:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT234]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP435:%.*]] = fmul <1 x float> [[BLOCK233]], [[SPLAT_SPLAT235]]
+; CHECK-NEXT: [[TMP441:%.*]] = fadd <1 x float> [[TMP433]], [[TMP435]]
+; CHECK-NEXT: [[BLOCK236:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP164:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT237:%.*]] = insertelement <1 x float> poison, float [[TMP164]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT238:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT237]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP447:%.*]] = fmul <1 x float> [[BLOCK236]], [[SPLAT_SPLAT238]]
+; CHECK-NEXT: [[TMP227:%.*]] = fadd <1 x float> [[TMP441]], [[TMP447]]
+; CHECK-NEXT: [[BLOCK239:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP166:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT240:%.*]] = insertelement <1 x float> poison, float [[TMP166]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT241:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT240]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP229:%.*]] = fmul <1 x float> [[BLOCK239]], [[SPLAT_SPLAT241]]
+; CHECK-NEXT: [[TMP167:%.*]] = fadd <1 x float> [[TMP227]], [[TMP229]]
+; CHECK-NEXT: [[TMP168:%.*]] = shufflevector <1 x float> [[TMP167]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP169:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP168]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK242:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP170:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT243:%.*]] = insertelement <1 x float> poison, float [[TMP170]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT244:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT243]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP453:%.*]] = fmul <1 x float> [[BLOCK242]], [[SPLAT_SPLAT244]]
+; CHECK-NEXT: [[BLOCK245:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP172:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT246:%.*]] = insertelement <1 x float> poison, float [[TMP172]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT247:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT246]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP463:%.*]] = fmul <1 x float> [[BLOCK245]], [[SPLAT_SPLAT247]]
+; CHECK-NEXT: [[TMP237:%.*]] = fadd <1 x float> [[TMP453]], [[TMP463]]
+; CHECK-NEXT: [[BLOCK248:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP174:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT249:%.*]] = insertelement <1 x float> poison, float [[TMP174]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT250:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT249]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP469:%.*]] = fmul <1 x float> [[BLOCK248]], [[SPLAT_SPLAT250]]
+; CHECK-NEXT: [[TMP481:%.*]] = fadd <1 x float> [[TMP237]], [[TMP469]]
+; CHECK-NEXT: [[BLOCK251:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP176:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT252:%.*]] = insertelement <1 x float> poison, float [[TMP176]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT253:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT252]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP483:%.*]] = fmul <1 x float> [[BLOCK251]], [[SPLAT_SPLAT253]]
+; CHECK-NEXT: [[TMP243:%.*]] = fadd <1 x float> [[TMP481]], [[TMP483]]
+; CHECK-NEXT: [[BLOCK254:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP178:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT255:%.*]] = insertelement <1 x float> poison, float [[TMP178]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT256:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT255]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP245:%.*]] = fmul <1 x float> [[BLOCK254]], [[SPLAT_SPLAT256]]
+; CHECK-NEXT: [[TMP485:%.*]] = fadd <1 x float> [[TMP243]], [[TMP245]]
+; CHECK-NEXT: [[BLOCK257:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP180:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT258:%.*]] = insertelement <1 x float> poison, float [[TMP180]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT259:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT258]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP497:%.*]] = fmul <1 x float> [[BLOCK257]], [[SPLAT_SPLAT259]]
+; CHECK-NEXT: [[TMP249:%.*]] = fadd <1 x float> [[TMP485]], [[TMP497]]
+; CHECK-NEXT: [[BLOCK260:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP182:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT261:%.*]] = insertelement <1 x float> poison, float [[TMP182]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT262:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT261]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP251:%.*]] = fmul <1 x float> [[BLOCK260]], [[SPLAT_SPLAT262]]
+; CHECK-NEXT: [[TMP503:%.*]] = fadd <1 x float> [[TMP249]], [[TMP251]]
+; CHECK-NEXT: [[BLOCK263:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP184:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT264:%.*]] = insertelement <1 x float> poison, float [[TMP184]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT265:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT264]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP505:%.*]] = fmul <1 x float> [[BLOCK263]], [[SPLAT_SPLAT265]]
+; CHECK-NEXT: [[TMP185:%.*]] = fadd <1 x float> [[TMP503]], [[TMP505]]
+; CHECK-NEXT: [[TMP186:%.*]] = shufflevector <1 x float> [[TMP185]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP187:%.*]] = shufflevector <8 x float> [[TMP169]], <8 x float> [[TMP186]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK266:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP188:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT267:%.*]] = insertelement <1 x float> poison, float [[TMP188]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT268:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT267]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP507:%.*]] = fmul <1 x float> [[BLOCK266]], [[SPLAT_SPLAT268]]
+; CHECK-NEXT: [[BLOCK269:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP190:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT270:%.*]] = insertelement <1 x float> poison, float [[TMP190]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT271:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT270]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP261:%.*]] = fmul <1 x float> [[BLOCK269]], [[SPLAT_SPLAT271]]
+; CHECK-NEXT: [[TMP513:%.*]] = fadd <1 x float> [[TMP507]], [[TMP261]]
+; CHECK-NEXT: [[BLOCK272:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP192:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT273:%.*]] = insertelement <1 x float> poison, float [[TMP192]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT274:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT273]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP519:%.*]] = fmul <1 x float> [[BLOCK272]], [[SPLAT_SPLAT274]]
+; CHECK-NEXT: [[TMP265:%.*]] = fadd <1 x float> [[TMP513]], [[TMP519]]
+; CHECK-NEXT: [[BLOCK275:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP194:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT276:%.*]] = insertelement <1 x float> poison, float [[TMP194]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT277:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT276]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP267:%.*]] = fmul <1 x float> [[BLOCK275]], [[SPLAT_SPLAT277]]
+; CHECK-NEXT: [[TMP525:%.*]] = fadd <1 x float> [[TMP265]], [[TMP267]]
+; CHECK-NEXT: [[BLOCK278:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP196:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT279:%.*]] = insertelement <1 x float> poison, float [[TMP196]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT280:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT279]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP531:%.*]] = fmul <1 x float> [[BLOCK278]], [[SPLAT_SPLAT280]]
+; CHECK-NEXT: [[TMP271:%.*]] = fadd <1 x float> [[TMP525]], [[TMP531]]
+; CHECK-NEXT: [[BLOCK281:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP198:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT282:%.*]] = insertelement <1 x float> poison, float [[TMP198]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT283:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT282]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP273:%.*]] = fmul <1 x float> [[BLOCK281]], [[SPLAT_SPLAT283]]
+; CHECK-NEXT: [[TMP533:%.*]] = fadd <1 x float> [[TMP271]], [[TMP273]]
+; CHECK-NEXT: [[BLOCK284:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP200:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT285:%.*]] = insertelement <1 x float> poison, float [[TMP200]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT286:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT285]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP535:%.*]] = fmul <1 x float> [[BLOCK284]], [[SPLAT_SPLAT286]]
+; CHECK-NEXT: [[TMP541:%.*]] = fadd <1 x float> [[TMP533]], [[TMP535]]
+; CHECK-NEXT: [[BLOCK287:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP202:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT288:%.*]] = insertelement <1 x float> poison, float [[TMP202]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT289:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT288]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP279:%.*]] = fmul <1 x float> [[BLOCK287]], [[SPLAT_SPLAT289]]
+; CHECK-NEXT: [[TMP203:%.*]] = fadd <1 x float> [[TMP541]], [[TMP279]]
+; CHECK-NEXT: [[TMP204:%.*]] = shufflevector <1 x float> [[TMP203]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP205:%.*]] = shufflevector <8 x float> [[TMP187]], <8 x float> [[TMP204]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK290:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP206:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT291:%.*]] = insertelement <1 x float> poison, float [[TMP206]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT292:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT291]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP553:%.*]] = fmul <1 x float> [[BLOCK290]], [[SPLAT_SPLAT292]]
+; CHECK-NEXT: [[BLOCK293:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP208:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT294:%.*]] = insertelement <1 x float> poison, float [[TMP208]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT295:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT294]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP555:%.*]] = fmul <1 x float> [[BLOCK293]], [[SPLAT_SPLAT295]]
+; CHECK-NEXT: [[TMP287:%.*]] = fadd <1 x float> [[TMP553]], [[TMP555]]
+; CHECK-NEXT: [[BLOCK296:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP210:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT297:%.*]] = insertelement <1 x float> poison, float [[TMP210]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT298:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT297]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP289:%.*]] = fmul <1 x float> [[BLOCK296]], [[SPLAT_SPLAT298]]
+; CHECK-NEXT: [[TMP557:%.*]] = fadd <1 x float> [[TMP287]], [[TMP289]]
+; CHECK-NEXT: [[BLOCK299:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP212:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT300:%.*]] = insertelement <1 x float> poison, float [[TMP212]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT301:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT300]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP569:%.*]] = fmul <1 x float> [[BLOCK299]], [[SPLAT_SPLAT301]]
+; CHECK-NEXT: [[TMP575:%.*]] = fadd <1 x float> [[TMP557]], [[TMP569]]
+; CHECK-NEXT: [[BLOCK302:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP214:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT303:%.*]] = insertelement <1 x float> poison, float [[TMP214]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT304:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT303]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP585:%.*]] = fmul <1 x float> [[BLOCK302]], [[SPLAT_SPLAT304]]
+; CHECK-NEXT: [[TMP591:%.*]] = fadd <1 x float> [[TMP575]], [[TMP585]]
+; CHECK-NEXT: [[BLOCK305:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP216:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT306:%.*]] = insertelement <1 x float> poison, float [[TMP216]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT307:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT306]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP597:%.*]] = fmul <1 x float> [[BLOCK305]], [[SPLAT_SPLAT307]]
+; CHECK-NEXT: [[TMP299:%.*]] = fadd <1 x float> [[TMP591]], [[TMP597]]
+; CHECK-NEXT: [[BLOCK308:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP218:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT309:%.*]] = insertelement <1 x float> poison, float [[TMP218]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT310:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT309]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP301:%.*]] = fmul <1 x float> [[BLOCK308]], [[SPLAT_SPLAT310]]
+; CHECK-NEXT: [[TMP603:%.*]] = fadd <1 x float> [[TMP299]], [[TMP301]]
+; CHECK-NEXT: [[BLOCK311:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP220:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT312:%.*]] = insertelement <1 x float> poison, float [[TMP220]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT313:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT312]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP605:%.*]] = fmul <1 x float> [[BLOCK311]], [[SPLAT_SPLAT313]]
+; CHECK-NEXT: [[TMP221:%.*]] = fadd <1 x float> [[TMP603]], [[TMP605]]
+; CHECK-NEXT: [[TMP222:%.*]] = shufflevector <1 x float> [[TMP221]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP223:%.*]] = shufflevector <8 x float> [[TMP205]], <8 x float> [[TMP222]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK314:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP224:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT315:%.*]] = insertelement <1 x float> poison, float [[TMP224]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT316:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT315]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP309:%.*]] = fmul <1 x float> [[BLOCK314]], [[SPLAT_SPLAT316]]
+; CHECK-NEXT: [[BLOCK317:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP226:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT318:%.*]] = insertelement <1 x float> poison, float [[TMP226]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT319:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT318]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP607:%.*]] = fmul <1 x float> [[BLOCK317]], [[SPLAT_SPLAT319]]
+; CHECK-NEXT: [[TMP613:%.*]] = fadd <1 x float> [[TMP309]], [[TMP607]]
+; CHECK-NEXT: [[BLOCK320:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP228:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT321:%.*]] = insertelement <1 x float> poison, float [[TMP228]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT322:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT321]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP625:%.*]] = fmul <1 x float> [[BLOCK320]], [[SPLAT_SPLAT322]]
+; CHECK-NEXT: [[TMP315:%.*]] = fadd <1 x float> [[TMP613]], [[TMP625]]
+; CHECK-NEXT: [[BLOCK323:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP230:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT324:%.*]] = insertelement <1 x float> poison, float [[TMP230]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT325:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT324]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP317:%.*]] = fmul <1 x float> [[BLOCK323]], [[SPLAT_SPLAT325]]
+; CHECK-NEXT: [[TMP631:%.*]] = fadd <1 x float> [[TMP315]], [[TMP317]]
+; CHECK-NEXT: [[BLOCK326:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP232:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT327:%.*]] = insertelement <1 x float> poison, float [[TMP232]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT328:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT327]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP633:%.*]] = fmul <1 x float> [[BLOCK326]], [[SPLAT_SPLAT328]]
+; CHECK-NEXT: [[TMP321:%.*]] = fadd <1 x float> [[TMP631]], [[TMP633]]
+; CHECK-NEXT: [[BLOCK329:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP234:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT330:%.*]] = insertelement <1 x float> poison, float [[TMP234]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT331:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT330]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP323:%.*]] = fmul <1 x float> [[BLOCK329]], [[SPLAT_SPLAT331]]
+; CHECK-NEXT: [[TMP641:%.*]] = fadd <1 x float> [[TMP321]], [[TMP323]]
+; CHECK-NEXT: [[BLOCK332:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP236:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT333:%.*]] = insertelement <1 x float> poison, float [[TMP236]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT334:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT333]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP647:%.*]] = fmul <1 x float> [[BLOCK332]], [[SPLAT_SPLAT334]]
+; CHECK-NEXT: [[TMP327:%.*]] = fadd <1 x float> [[TMP641]], [[TMP647]]
+; CHECK-NEXT: [[BLOCK335:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP238:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT336:%.*]] = insertelement <1 x float> poison, float [[TMP238]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT337:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT336]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP657:%.*]] = fmul <1 x float> [[BLOCK335]], [[SPLAT_SPLAT337]]
+; CHECK-NEXT: [[TMP239:%.*]] = fadd <1 x float> [[TMP327]], [[TMP657]]
+; CHECK-NEXT: [[TMP240:%.*]] = shufflevector <1 x float> [[TMP239]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP241:%.*]] = shufflevector <8 x float> [[TMP223]], <8 x float> [[TMP240]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK338:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP242:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT339:%.*]] = insertelement <1 x float> poison, float [[TMP242]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT340:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT339]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP663:%.*]] = fmul <1 x float> [[BLOCK338]], [[SPLAT_SPLAT340]]
+; CHECK-NEXT: [[BLOCK341:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP244:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT342:%.*]] = insertelement <1 x float> poison, float [[TMP244]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT343:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT342]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP669:%.*]] = fmul <1 x float> [[BLOCK341]], [[SPLAT_SPLAT343]]
+; CHECK-NEXT: [[TMP337:%.*]] = fadd <1 x float> [[TMP663]], [[TMP669]]
+; CHECK-NEXT: [[BLOCK344:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP246:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT345:%.*]] = insertelement <1 x float> poison, float [[TMP246]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT346:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT345]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP339:%.*]] = fmul <1 x float> [[BLOCK344]], [[SPLAT_SPLAT346]]
+; CHECK-NEXT: [[TMP675:%.*]] = fadd <1 x float> [[TMP337]], [[TMP339]]
+; CHECK-NEXT: [[BLOCK347:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP248:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT348:%.*]] = insertelement <1 x float> poison, float [[TMP248]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT349:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT348]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP681:%.*]] = fmul <1 x float> [[BLOCK347]], [[SPLAT_SPLAT349]]
+; CHECK-NEXT: [[TMP343:%.*]] = fadd <1 x float> [[TMP675]], [[TMP681]]
+; CHECK-NEXT: [[BLOCK350:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP250:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT351:%.*]] = insertelement <1 x float> poison, float [[TMP250]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT352:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT351]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP345:%.*]] = fmul <1 x float> [[BLOCK350]], [[SPLAT_SPLAT352]]
+; CHECK-NEXT: [[TMP683:%.*]] = fadd <1 x float> [[TMP343]], [[TMP345]]
+; CHECK-NEXT: [[BLOCK353:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP252:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT354:%.*]] = insertelement <1 x float> poison, float [[TMP252]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT355:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT354]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP685:%.*]] = fmul <1 x float> [[BLOCK353]], [[SPLAT_SPLAT355]]
+; CHECK-NEXT: [[TMP697:%.*]] = fadd <1 x float> [[TMP683]], [[TMP685]]
+; CHECK-NEXT: [[BLOCK356:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP254:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT357:%.*]] = insertelement <1 x float> poison, float [[TMP254]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT358:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT357]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP351:%.*]] = fmul <1 x float> [[BLOCK356]], [[SPLAT_SPLAT358]]
+; CHECK-NEXT: [[TMP703:%.*]] = fadd <1 x float> [[TMP697]], [[TMP351]]
+; CHECK-NEXT: [[BLOCK359:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP256:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT360:%.*]] = insertelement <1 x float> poison, float [[TMP256]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT361:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT360]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP705:%.*]] = fmul <1 x float> [[BLOCK359]], [[SPLAT_SPLAT361]]
+; CHECK-NEXT: [[TMP257:%.*]] = fadd <1 x float> [[TMP703]], [[TMP705]]
+; CHECK-NEXT: [[TMP258:%.*]] = shufflevector <1 x float> [[TMP257]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP259:%.*]] = shufflevector <8 x float> [[TMP241]], <8 x float> [[TMP258]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK362:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP260:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT363:%.*]] = insertelement <1 x float> poison, float [[TMP260]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT364:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT363]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP359:%.*]] = fmul <1 x float> [[BLOCK362]], [[SPLAT_SPLAT364]]
+; CHECK-NEXT: [[BLOCK365:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP262:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT366:%.*]] = insertelement <1 x float> poison, float [[TMP262]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT367:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT366]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP361:%.*]] = fmul <1 x float> [[BLOCK365]], [[SPLAT_SPLAT367]]
+; CHECK-NEXT: [[TMP713:%.*]] = fadd <1 x float> [[TMP359]], [[TMP361]]
+; CHECK-NEXT: [[BLOCK368:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP264:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT369:%.*]] = insertelement <1 x float> poison, float [[TMP264]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT370:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT369]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP719:%.*]] = fmul <1 x float> [[BLOCK368]], [[SPLAT_SPLAT370]]
+; CHECK-NEXT: [[TMP731:%.*]] = fadd <1 x float> [[TMP713]], [[TMP719]]
+; CHECK-NEXT: [[BLOCK371:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP266:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT372:%.*]] = insertelement <1 x float> poison, float [[TMP266]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT373:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT372]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP733:%.*]] = fmul <1 x float> [[BLOCK371]], [[SPLAT_SPLAT373]]
+; CHECK-NEXT: [[TMP735:%.*]] = fadd <1 x float> [[TMP731]], [[TMP733]]
+; CHECK-NEXT: [[BLOCK374:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP268:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT375:%.*]] = insertelement <1 x float> poison, float [[TMP268]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT376:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT375]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP741:%.*]] = fmul <1 x float> [[BLOCK374]], [[SPLAT_SPLAT376]]
+; CHECK-NEXT: [[TMP371:%.*]] = fadd <1 x float> [[TMP735]], [[TMP741]]
+; CHECK-NEXT: [[BLOCK377:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP270:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT378:%.*]] = insertelement <1 x float> poison, float [[TMP270]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT379:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT378]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP373:%.*]] = fmul <1 x float> [[BLOCK377]], [[SPLAT_SPLAT379]]
+; CHECK-NEXT: [[TMP747:%.*]] = fadd <1 x float> [[TMP371]], [[TMP373]]
+; CHECK-NEXT: [[BLOCK380:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP272:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT381:%.*]] = insertelement <1 x float> poison, float [[TMP272]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT382:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT381]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP753:%.*]] = fmul <1 x float> [[BLOCK380]], [[SPLAT_SPLAT382]]
+; CHECK-NEXT: [[TMP377:%.*]] = fadd <1 x float> [[TMP747]], [[TMP753]]
+; CHECK-NEXT: [[BLOCK383:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP274:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT384:%.*]] = insertelement <1 x float> poison, float [[TMP274]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT385:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT384]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP379:%.*]] = fmul <1 x float> [[BLOCK383]], [[SPLAT_SPLAT385]]
+; CHECK-NEXT: [[TMP275:%.*]] = fadd <1 x float> [[TMP377]], [[TMP379]]
+; CHECK-NEXT: [[TMP276:%.*]] = shufflevector <1 x float> [[TMP275]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP277:%.*]] = shufflevector <8 x float> [[TMP259]], <8 x float> [[TMP276]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK386:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP278:%.*]] = extractelement <8 x float> [[TMP1]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT387:%.*]] = insertelement <1 x float> poison, float [[TMP278]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT388:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT387]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP755:%.*]] = fmul <1 x float> [[BLOCK386]], [[SPLAT_SPLAT388]]
+; CHECK-NEXT: [[BLOCK389:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP280:%.*]] = extractelement <8 x float> [[TMP1]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT390:%.*]] = insertelement <1 x float> poison, float [[TMP280]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT391:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT390]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP757:%.*]] = fmul <1 x float> [[BLOCK389]], [[SPLAT_SPLAT391]]
+; CHECK-NEXT: [[TMP387:%.*]] = fadd <1 x float> [[TMP755]], [[TMP757]]
+; CHECK-NEXT: [[BLOCK392:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP282:%.*]] = extractelement <8 x float> [[TMP1]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT393:%.*]] = insertelement <1 x float> poison, float [[TMP282]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT394:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT393]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP389:%.*]] = fmul <1 x float> [[BLOCK392]], [[SPLAT_SPLAT394]]
+; CHECK-NEXT: [[TMP769:%.*]] = fadd <1 x float> [[TMP387]], [[TMP389]]
+; CHECK-NEXT: [[BLOCK395:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP284:%.*]] = extractelement <8 x float> [[TMP1]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT396:%.*]] = insertelement <1 x float> poison, float [[TMP284]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT397:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT396]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP775:%.*]] = fmul <1 x float> [[BLOCK395]], [[SPLAT_SPLAT397]]
+; CHECK-NEXT: [[TMP393:%.*]] = fadd <1 x float> [[TMP769]], [[TMP775]]
+; CHECK-NEXT: [[BLOCK398:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP286:%.*]] = extractelement <8 x float> [[TMP1]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT399:%.*]] = insertelement <1 x float> poison, float [[TMP286]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT400:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT399]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP395:%.*]] = fmul <1 x float> [[BLOCK398]], [[SPLAT_SPLAT400]]
+; CHECK-NEXT: [[TMP783:%.*]] = fadd <1 x float> [[TMP393]], [[TMP395]]
+; CHECK-NEXT: [[BLOCK401:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP288:%.*]] = extractelement <8 x float> [[TMP1]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT402:%.*]] = insertelement <1 x float> poison, float [[TMP288]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT403:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT402]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP785:%.*]] = fmul <1 x float> [[BLOCK401]], [[SPLAT_SPLAT403]]
+; CHECK-NEXT: [[TMP399:%.*]] = fadd <1 x float> [[TMP783]], [[TMP785]]
+; CHECK-NEXT: [[BLOCK404:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP290:%.*]] = extractelement <8 x float> [[TMP1]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT405:%.*]] = insertelement <1 x float> poison, float [[TMP290]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT406:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT405]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP791:%.*]] = fmul <1 x float> [[BLOCK404]], [[SPLAT_SPLAT406]]
+; CHECK-NEXT: [[TMP803:%.*]] = fadd <1 x float> [[TMP399]], [[TMP791]]
+; CHECK-NEXT: [[BLOCK407:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP292:%.*]] = extractelement <8 x float> [[TMP1]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT408:%.*]] = insertelement <1 x float> poison, float [[TMP292]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT409:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT408]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP805:%.*]] = fmul <1 x float> [[BLOCK407]], [[SPLAT_SPLAT409]]
+; CHECK-NEXT: [[TMP293:%.*]] = fadd <1 x float> [[TMP803]], [[TMP805]]
+; CHECK-NEXT: [[TMP294:%.*]] = shufflevector <1 x float> [[TMP293]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP295:%.*]] = shufflevector <8 x float> [[TMP277]], <8 x float> [[TMP294]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK410:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP296:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT411:%.*]] = insertelement <1 x float> poison, float [[TMP296]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT412:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT411]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP409:%.*]] = fmul <1 x float> [[BLOCK410]], [[SPLAT_SPLAT412]]
+; CHECK-NEXT: [[BLOCK413:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP298:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT414:%.*]] = insertelement <1 x float> poison, float [[TMP298]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT415:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT414]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP411:%.*]] = fmul <1 x float> [[BLOCK413]], [[SPLAT_SPLAT415]]
+; CHECK-NEXT: [[TMP807:%.*]] = fadd <1 x float> [[TMP409]], [[TMP411]]
+; CHECK-NEXT: [[BLOCK416:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP300:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT417:%.*]] = insertelement <1 x float> poison, float [[TMP300]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT418:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT417]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP813:%.*]] = fmul <1 x float> [[BLOCK416]], [[SPLAT_SPLAT418]]
+; CHECK-NEXT: [[TMP415:%.*]] = fadd <1 x float> [[TMP807]], [[TMP813]]
+; CHECK-NEXT: [[BLOCK419:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP302:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT420:%.*]] = insertelement <1 x float> poison, float [[TMP302]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT421:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT420]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP417:%.*]] = fmul <1 x float> [[BLOCK419]], [[SPLAT_SPLAT421]]
+; CHECK-NEXT: [[TMP819:%.*]] = fadd <1 x float> [[TMP415]], [[TMP417]]
+; CHECK-NEXT: [[BLOCK422:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP304:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT423:%.*]] = insertelement <1 x float> poison, float [[TMP304]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT424:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT423]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP825:%.*]] = fmul <1 x float> [[BLOCK422]], [[SPLAT_SPLAT424]]
+; CHECK-NEXT: [[TMP831:%.*]] = fadd <1 x float> [[TMP819]], [[TMP825]]
+; CHECK-NEXT: [[BLOCK425:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP306:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT426:%.*]] = insertelement <1 x float> poison, float [[TMP306]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT427:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT426]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP423:%.*]] = fmul <1 x float> [[BLOCK425]], [[SPLAT_SPLAT427]]
+; CHECK-NEXT: [[TMP841:%.*]] = fadd <1 x float> [[TMP831]], [[TMP423]]
+; CHECK-NEXT: [[BLOCK428:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP308:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT429:%.*]] = insertelement <1 x float> poison, float [[TMP308]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT430:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT429]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP847:%.*]] = fmul <1 x float> [[BLOCK428]], [[SPLAT_SPLAT430]]
+; CHECK-NEXT: [[TMP427:%.*]] = fadd <1 x float> [[TMP841]], [[TMP847]]
+; CHECK-NEXT: [[BLOCK431:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP310:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT432:%.*]] = insertelement <1 x float> poison, float [[TMP310]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT433:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT432]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP429:%.*]] = fmul <1 x float> [[BLOCK431]], [[SPLAT_SPLAT433]]
+; CHECK-NEXT: [[TMP311:%.*]] = fadd <1 x float> [[TMP427]], [[TMP429]]
+; CHECK-NEXT: [[TMP312:%.*]] = shufflevector <1 x float> [[TMP311]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP313:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP312]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK434:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP314:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT435:%.*]] = insertelement <1 x float> poison, float [[TMP314]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT436:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT435]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP855:%.*]] = fmul <1 x float> [[BLOCK434]], [[SPLAT_SPLAT436]]
+; CHECK-NEXT: [[BLOCK437:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP316:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT438:%.*]] = insertelement <1 x float> poison, float [[TMP316]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT439:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT438]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP857:%.*]] = fmul <1 x float> [[BLOCK437]], [[SPLAT_SPLAT439]]
+; CHECK-NEXT: [[TMP863:%.*]] = fadd <1 x float> [[TMP855]], [[TMP857]]
+; CHECK-NEXT: [[BLOCK440:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP318:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT441:%.*]] = insertelement <1 x float> poison, float [[TMP318]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT442:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT441]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP875:%.*]] = fmul <1 x float> [[BLOCK440]], [[SPLAT_SPLAT442]]
+; CHECK-NEXT: [[TMP881:%.*]] = fadd <1 x float> [[TMP863]], [[TMP875]]
+; CHECK-NEXT: [[BLOCK443:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP320:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT444:%.*]] = insertelement <1 x float> poison, float [[TMP320]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT445:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT444]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP883:%.*]] = fmul <1 x float> [[BLOCK443]], [[SPLAT_SPLAT445]]
+; CHECK-NEXT: [[TMP443:%.*]] = fadd <1 x float> [[TMP881]], [[TMP883]]
+; CHECK-NEXT: [[BLOCK446:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP322:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT447:%.*]] = insertelement <1 x float> poison, float [[TMP322]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT448:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT447]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP445:%.*]] = fmul <1 x float> [[BLOCK446]], [[SPLAT_SPLAT448]]
+; CHECK-NEXT: [[TMP885:%.*]] = fadd <1 x float> [[TMP443]], [[TMP445]]
+; CHECK-NEXT: [[BLOCK449:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP324:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT450:%.*]] = insertelement <1 x float> poison, float [[TMP324]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT451:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT450]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP891:%.*]] = fmul <1 x float> [[BLOCK449]], [[SPLAT_SPLAT451]]
+; CHECK-NEXT: [[TMP449:%.*]] = fadd <1 x float> [[TMP885]], [[TMP891]]
+; CHECK-NEXT: [[BLOCK452:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP326:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT453:%.*]] = insertelement <1 x float> poison, float [[TMP326]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT454:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT453]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP451:%.*]] = fmul <1 x float> [[BLOCK452]], [[SPLAT_SPLAT454]]
+; CHECK-NEXT: [[TMP897:%.*]] = fadd <1 x float> [[TMP449]], [[TMP451]]
+; CHECK-NEXT: [[BLOCK455:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP328:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT456:%.*]] = insertelement <1 x float> poison, float [[TMP328]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT457:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT456]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP903:%.*]] = fmul <1 x float> [[BLOCK455]], [[SPLAT_SPLAT457]]
+; CHECK-NEXT: [[TMP329:%.*]] = fadd <1 x float> [[TMP897]], [[TMP903]]
+; CHECK-NEXT: [[TMP330:%.*]] = shufflevector <1 x float> [[TMP329]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP331:%.*]] = shufflevector <8 x float> [[TMP313]], <8 x float> [[TMP330]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK458:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP332:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT459:%.*]] = insertelement <1 x float> poison, float [[TMP332]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT460:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT459]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP459:%.*]] = fmul <1 x float> [[BLOCK458]], [[SPLAT_SPLAT460]]
+; CHECK-NEXT: [[BLOCK461:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP334:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT462:%.*]] = insertelement <1 x float> poison, float [[TMP334]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT463:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT462]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP461:%.*]] = fmul <1 x float> [[BLOCK461]], [[SPLAT_SPLAT463]]
+; CHECK-NEXT: [[TMP913:%.*]] = fadd <1 x float> [[TMP459]], [[TMP461]]
+; CHECK-NEXT: [[BLOCK464:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP336:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT465:%.*]] = insertelement <1 x float> poison, float [[TMP336]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT466:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT465]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP919:%.*]] = fmul <1 x float> [[BLOCK464]], [[SPLAT_SPLAT466]]
+; CHECK-NEXT: [[TMP465:%.*]] = fadd <1 x float> [[TMP913]], [[TMP919]]
+; CHECK-NEXT: [[BLOCK467:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP338:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT468:%.*]] = insertelement <1 x float> poison, float [[TMP338]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT469:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT468]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP467:%.*]] = fmul <1 x float> [[BLOCK467]], [[SPLAT_SPLAT469]]
+; CHECK-NEXT: [[TMP931:%.*]] = fadd <1 x float> [[TMP465]], [[TMP467]]
+; CHECK-NEXT: [[BLOCK470:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP340:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT471:%.*]] = insertelement <1 x float> poison, float [[TMP340]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT472:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT471]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP933:%.*]] = fmul <1 x float> [[BLOCK470]], [[SPLAT_SPLAT472]]
+; CHECK-NEXT: [[TMP471:%.*]] = fadd <1 x float> [[TMP931]], [[TMP933]]
+; CHECK-NEXT: [[BLOCK473:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP342:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT474:%.*]] = insertelement <1 x float> poison, float [[TMP342]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT475:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT474]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP935:%.*]] = fmul <1 x float> [[BLOCK473]], [[SPLAT_SPLAT475]]
+; CHECK-NEXT: [[TMP947:%.*]] = fadd <1 x float> [[TMP471]], [[TMP935]]
+; CHECK-NEXT: [[BLOCK476:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP344:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT477:%.*]] = insertelement <1 x float> poison, float [[TMP344]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT478:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT477]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP953:%.*]] = fmul <1 x float> [[BLOCK476]], [[SPLAT_SPLAT478]]
+; CHECK-NEXT: [[TMP477:%.*]] = fadd <1 x float> [[TMP947]], [[TMP953]]
+; CHECK-NEXT: [[BLOCK479:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP346:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT480:%.*]] = insertelement <1 x float> poison, float [[TMP346]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT481:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT480]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP479:%.*]] = fmul <1 x float> [[BLOCK479]], [[SPLAT_SPLAT481]]
+; CHECK-NEXT: [[TMP347:%.*]] = fadd <1 x float> [[TMP477]], [[TMP479]]
+; CHECK-NEXT: [[TMP348:%.*]] = shufflevector <1 x float> [[TMP347]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP349:%.*]] = shufflevector <8 x float> [[TMP331]], <8 x float> [[TMP348]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK482:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP350:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT483:%.*]] = insertelement <1 x float> poison, float [[TMP350]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT484:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT483]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP955:%.*]] = fmul <1 x float> [[BLOCK482]], [[SPLAT_SPLAT484]]
+; CHECK-NEXT: [[BLOCK485:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP352:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT486:%.*]] = insertelement <1 x float> poison, float [[TMP352]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT487:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT486]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP957:%.*]] = fmul <1 x float> [[BLOCK485]], [[SPLAT_SPLAT487]]
+; CHECK-NEXT: [[TMP487:%.*]] = fadd <1 x float> [[TMP955]], [[TMP957]]
+; CHECK-NEXT: [[BLOCK488:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP354:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT489:%.*]] = insertelement <1 x float> poison, float [[TMP354]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT490:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT489]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP489:%.*]] = fmul <1 x float> [[BLOCK488]], [[SPLAT_SPLAT490]]
+; CHECK-NEXT: [[TMP963:%.*]] = fadd <1 x float> [[TMP487]], [[TMP489]]
+; CHECK-NEXT: [[BLOCK491:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP356:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT492:%.*]] = insertelement <1 x float> poison, float [[TMP356]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT493:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT492]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP969:%.*]] = fmul <1 x float> [[BLOCK491]], [[SPLAT_SPLAT493]]
+; CHECK-NEXT: [[TMP975:%.*]] = fadd <1 x float> [[TMP963]], [[TMP969]]
+; CHECK-NEXT: [[BLOCK494:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP358:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT495:%.*]] = insertelement <1 x float> poison, float [[TMP358]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT496:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT495]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP495:%.*]] = fmul <1 x float> [[BLOCK494]], [[SPLAT_SPLAT496]]
+; CHECK-NEXT: [[TMP981:%.*]] = fadd <1 x float> [[TMP975]], [[TMP495]]
+; CHECK-NEXT: [[BLOCK497:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP360:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT498:%.*]] = insertelement <1 x float> poison, float [[TMP360]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT499:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT498]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP983:%.*]] = fmul <1 x float> [[BLOCK497]], [[SPLAT_SPLAT499]]
+; CHECK-NEXT: [[TMP499:%.*]] = fadd <1 x float> [[TMP981]], [[TMP983]]
+; CHECK-NEXT: [[BLOCK500:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP362:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT501:%.*]] = insertelement <1 x float> poison, float [[TMP362]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT502:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT501]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP501:%.*]] = fmul <1 x float> [[BLOCK500]], [[SPLAT_SPLAT502]]
+; CHECK-NEXT: [[TMP985:%.*]] = fadd <1 x float> [[TMP499]], [[TMP501]]
+; CHECK-NEXT: [[BLOCK503:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP364:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT504:%.*]] = insertelement <1 x float> poison, float [[TMP364]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT505:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT504]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP991:%.*]] = fmul <1 x float> [[BLOCK503]], [[SPLAT_SPLAT505]]
+; CHECK-NEXT: [[TMP365:%.*]] = fadd <1 x float> [[TMP985]], [[TMP991]]
+; CHECK-NEXT: [[TMP366:%.*]] = shufflevector <1 x float> [[TMP365]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP367:%.*]] = shufflevector <8 x float> [[TMP349]], <8 x float> [[TMP366]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK506:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP368:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT507:%.*]] = insertelement <1 x float> poison, float [[TMP368]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT508:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT507]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1003:%.*]] = fmul <1 x float> [[BLOCK506]], [[SPLAT_SPLAT508]]
+; CHECK-NEXT: [[BLOCK509:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP370:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT510:%.*]] = insertelement <1 x float> poison, float [[TMP370]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT511:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT510]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1005:%.*]] = fmul <1 x float> [[BLOCK509]], [[SPLAT_SPLAT511]]
+; CHECK-NEXT: [[TMP1007:%.*]] = fadd <1 x float> [[TMP1003]], [[TMP1005]]
+; CHECK-NEXT: [[BLOCK512:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP372:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT513:%.*]] = insertelement <1 x float> poison, float [[TMP372]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT514:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT513]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1019:%.*]] = fmul <1 x float> [[BLOCK512]], [[SPLAT_SPLAT514]]
+; CHECK-NEXT: [[TMP515:%.*]] = fadd <1 x float> [[TMP1007]], [[TMP1019]]
+; CHECK-NEXT: [[BLOCK515:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP374:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT516:%.*]] = insertelement <1 x float> poison, float [[TMP374]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT517:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT516]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP517:%.*]] = fmul <1 x float> [[BLOCK515]], [[SPLAT_SPLAT517]]
+; CHECK-NEXT: [[TMP1025:%.*]] = fadd <1 x float> [[TMP515]], [[TMP517]]
+; CHECK-NEXT: [[BLOCK518:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP376:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT519:%.*]] = insertelement <1 x float> poison, float [[TMP376]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT520:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT519]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1035:%.*]] = fmul <1 x float> [[BLOCK518]], [[SPLAT_SPLAT520]]
+; CHECK-NEXT: [[TMP521:%.*]] = fadd <1 x float> [[TMP1025]], [[TMP1035]]
+; CHECK-NEXT: [[BLOCK521:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP378:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT522:%.*]] = insertelement <1 x float> poison, float [[TMP378]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT523:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT522]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP523:%.*]] = fmul <1 x float> [[BLOCK521]], [[SPLAT_SPLAT523]]
+; CHECK-NEXT: [[TMP1041:%.*]] = fadd <1 x float> [[TMP521]], [[TMP523]]
+; CHECK-NEXT: [[BLOCK524:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP380:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT525:%.*]] = insertelement <1 x float> poison, float [[TMP380]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT526:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT525]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1047:%.*]] = fmul <1 x float> [[BLOCK524]], [[SPLAT_SPLAT526]]
+; CHECK-NEXT: [[TMP1053:%.*]] = fadd <1 x float> [[TMP1041]], [[TMP1047]]
+; CHECK-NEXT: [[BLOCK527:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP382:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT528:%.*]] = insertelement <1 x float> poison, float [[TMP382]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT529:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT528]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1055:%.*]] = fmul <1 x float> [[BLOCK527]], [[SPLAT_SPLAT529]]
+; CHECK-NEXT: [[TMP383:%.*]] = fadd <1 x float> [[TMP1053]], [[TMP1055]]
+; CHECK-NEXT: [[TMP384:%.*]] = shufflevector <1 x float> [[TMP383]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP385:%.*]] = shufflevector <8 x float> [[TMP367]], <8 x float> [[TMP384]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK530:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP386:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT531:%.*]] = insertelement <1 x float> poison, float [[TMP386]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT532:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT531]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1057:%.*]] = fmul <1 x float> [[BLOCK530]], [[SPLAT_SPLAT532]]
+; CHECK-NEXT: [[BLOCK533:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP388:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT534:%.*]] = insertelement <1 x float> poison, float [[TMP388]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT535:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT534]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1063:%.*]] = fmul <1 x float> [[BLOCK533]], [[SPLAT_SPLAT535]]
+; CHECK-NEXT: [[TMP537:%.*]] = fadd <1 x float> [[TMP1057]], [[TMP1063]]
+; CHECK-NEXT: [[BLOCK536:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP390:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT537:%.*]] = insertelement <1 x float> poison, float [[TMP390]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT538:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT537]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP539:%.*]] = fmul <1 x float> [[BLOCK536]], [[SPLAT_SPLAT538]]
+; CHECK-NEXT: [[TMP1075:%.*]] = fadd <1 x float> [[TMP537]], [[TMP539]]
+; CHECK-NEXT: [[BLOCK539:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP392:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT540:%.*]] = insertelement <1 x float> poison, float [[TMP392]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT541:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT540]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1081:%.*]] = fmul <1 x float> [[BLOCK539]], [[SPLAT_SPLAT541]]
+; CHECK-NEXT: [[TMP543:%.*]] = fadd <1 x float> [[TMP1075]], [[TMP1081]]
+; CHECK-NEXT: [[BLOCK542:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP394:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT543:%.*]] = insertelement <1 x float> poison, float [[TMP394]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT544:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT543]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1083:%.*]] = fmul <1 x float> [[BLOCK542]], [[SPLAT_SPLAT544]]
+; CHECK-NEXT: [[TMP1091:%.*]] = fadd <1 x float> [[TMP543]], [[TMP1083]]
+; CHECK-NEXT: [[BLOCK545:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP396:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT546:%.*]] = insertelement <1 x float> poison, float [[TMP396]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT547:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT546]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1097:%.*]] = fmul <1 x float> [[BLOCK545]], [[SPLAT_SPLAT547]]
+; CHECK-NEXT: [[TMP549:%.*]] = fadd <1 x float> [[TMP1091]], [[TMP1097]]
+; CHECK-NEXT: [[BLOCK548:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP398:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT549:%.*]] = insertelement <1 x float> poison, float [[TMP398]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT550:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT549]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP551:%.*]] = fmul <1 x float> [[BLOCK548]], [[SPLAT_SPLAT550]]
+; CHECK-NEXT: [[TMP1107:%.*]] = fadd <1 x float> [[TMP549]], [[TMP551]]
+; CHECK-NEXT: [[BLOCK551:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP400:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT552:%.*]] = insertelement <1 x float> poison, float [[TMP400]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT553:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT552]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1113:%.*]] = fmul <1 x float> [[BLOCK551]], [[SPLAT_SPLAT553]]
+; CHECK-NEXT: [[TMP401:%.*]] = fadd <1 x float> [[TMP1107]], [[TMP1113]]
+; CHECK-NEXT: [[TMP402:%.*]] = shufflevector <1 x float> [[TMP401]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP403:%.*]] = shufflevector <8 x float> [[TMP385]], <8 x float> [[TMP402]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK554:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP404:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT555:%.*]] = insertelement <1 x float> poison, float [[TMP404]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT556:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT555]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP559:%.*]] = fmul <1 x float> [[BLOCK554]], [[SPLAT_SPLAT556]]
+; CHECK-NEXT: [[BLOCK557:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP406:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT558:%.*]] = insertelement <1 x float> poison, float [[TMP406]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT559:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT558]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP561:%.*]] = fmul <1 x float> [[BLOCK557]], [[SPLAT_SPLAT559]]
+; CHECK-NEXT: [[TMP1119:%.*]] = fadd <1 x float> [[TMP559]], [[TMP561]]
+; CHECK-NEXT: [[BLOCK560:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP408:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT561:%.*]] = insertelement <1 x float> poison, float [[TMP408]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT562:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT561]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1125:%.*]] = fmul <1 x float> [[BLOCK560]], [[SPLAT_SPLAT562]]
+; CHECK-NEXT: [[TMP1131:%.*]] = fadd <1 x float> [[TMP1119]], [[TMP1125]]
+; CHECK-NEXT: [[BLOCK563:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP410:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT564:%.*]] = insertelement <1 x float> poison, float [[TMP410]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT565:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT564]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP567:%.*]] = fmul <1 x float> [[BLOCK563]], [[SPLAT_SPLAT565]]
+; CHECK-NEXT: [[TMP1133:%.*]] = fadd <1 x float> [[TMP1131]], [[TMP567]]
+; CHECK-NEXT: [[BLOCK566:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP412:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT567:%.*]] = insertelement <1 x float> poison, float [[TMP412]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT568:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT567]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1135:%.*]] = fmul <1 x float> [[BLOCK566]], [[SPLAT_SPLAT568]]
+; CHECK-NEXT: [[TMP571:%.*]] = fadd <1 x float> [[TMP1133]], [[TMP1135]]
+; CHECK-NEXT: [[BLOCK569:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP414:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT570:%.*]] = insertelement <1 x float> poison, float [[TMP414]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT571:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT570]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP573:%.*]] = fmul <1 x float> [[BLOCK569]], [[SPLAT_SPLAT571]]
+; CHECK-NEXT: [[TMP1147:%.*]] = fadd <1 x float> [[TMP571]], [[TMP573]]
+; CHECK-NEXT: [[BLOCK572:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP416:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT573:%.*]] = insertelement <1 x float> poison, float [[TMP416]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT574:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT573]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1153:%.*]] = fmul <1 x float> [[BLOCK572]], [[SPLAT_SPLAT574]]
+; CHECK-NEXT: [[TMP577:%.*]] = fadd <1 x float> [[TMP1147]], [[TMP1153]]
+; CHECK-NEXT: [[BLOCK575:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP418:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT576:%.*]] = insertelement <1 x float> poison, float [[TMP418]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT577:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT576]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP579:%.*]] = fmul <1 x float> [[BLOCK575]], [[SPLAT_SPLAT577]]
+; CHECK-NEXT: [[TMP419:%.*]] = fadd <1 x float> [[TMP577]], [[TMP579]]
+; CHECK-NEXT: [[TMP420:%.*]] = shufflevector <1 x float> [[TMP419]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP421:%.*]] = shufflevector <8 x float> [[TMP403]], <8 x float> [[TMP420]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK578:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP422:%.*]] = extractelement <8 x float> [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT579:%.*]] = insertelement <1 x float> poison, float [[TMP422]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT580:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT579]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1155:%.*]] = fmul <1 x float> [[BLOCK578]], [[SPLAT_SPLAT580]]
+; CHECK-NEXT: [[BLOCK581:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP424:%.*]] = extractelement <8 x float> [[TMP2]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT582:%.*]] = insertelement <1 x float> poison, float [[TMP424]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT583:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT582]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1160:%.*]] = fmul <1 x float> [[BLOCK581]], [[SPLAT_SPLAT583]]
+; CHECK-NEXT: [[TMP587:%.*]] = fadd <1 x float> [[TMP1155]], [[TMP1160]]
+; CHECK-NEXT: [[BLOCK584:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP426:%.*]] = extractelement <8 x float> [[TMP2]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT585:%.*]] = insertelement <1 x float> poison, float [[TMP426]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT586:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT585]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP589:%.*]] = fmul <1 x float> [[BLOCK584]], [[SPLAT_SPLAT586]]
+; CHECK-NEXT: [[TMP1163:%.*]] = fadd <1 x float> [[TMP587]], [[TMP589]]
+; CHECK-NEXT: [[BLOCK587:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP428:%.*]] = extractelement <8 x float> [[TMP2]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT588:%.*]] = insertelement <1 x float> poison, float [[TMP428]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT589:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT588]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1166:%.*]] = fmul <1 x float> [[BLOCK587]], [[SPLAT_SPLAT589]]
+; CHECK-NEXT: [[TMP593:%.*]] = fadd <1 x float> [[TMP1163]], [[TMP1166]]
+; CHECK-NEXT: [[BLOCK590:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP430:%.*]] = extractelement <8 x float> [[TMP2]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT591:%.*]] = insertelement <1 x float> poison, float [[TMP430]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT592:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT591]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP595:%.*]] = fmul <1 x float> [[BLOCK590]], [[SPLAT_SPLAT592]]
+; CHECK-NEXT: [[TMP1169:%.*]] = fadd <1 x float> [[TMP593]], [[TMP595]]
+; CHECK-NEXT: [[BLOCK593:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP432:%.*]] = extractelement <8 x float> [[TMP2]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT594:%.*]] = insertelement <1 x float> poison, float [[TMP432]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT595:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT594]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1172:%.*]] = fmul <1 x float> [[BLOCK593]], [[SPLAT_SPLAT595]]
+; CHECK-NEXT: [[TMP1175:%.*]] = fadd <1 x float> [[TMP1169]], [[TMP1172]]
+; CHECK-NEXT: [[BLOCK596:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP434:%.*]] = extractelement <8 x float> [[TMP2]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT597:%.*]] = insertelement <1 x float> poison, float [[TMP434]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT598:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT597]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1178:%.*]] = fmul <1 x float> [[BLOCK596]], [[SPLAT_SPLAT598]]
+; CHECK-NEXT: [[TMP1180:%.*]] = fadd <1 x float> [[TMP1175]], [[TMP1178]]
+; CHECK-NEXT: [[BLOCK599:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP436:%.*]] = extractelement <8 x float> [[TMP2]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT600:%.*]] = insertelement <1 x float> poison, float [[TMP436]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT601:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT600]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1181:%.*]] = fmul <1 x float> [[BLOCK599]], [[SPLAT_SPLAT601]]
+; CHECK-NEXT: [[TMP437:%.*]] = fadd <1 x float> [[TMP1180]], [[TMP1181]]
+; CHECK-NEXT: [[TMP438:%.*]] = shufflevector <1 x float> [[TMP437]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP439:%.*]] = shufflevector <8 x float> [[TMP421]], <8 x float> [[TMP438]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK602:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP440:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT603:%.*]] = insertelement <1 x float> poison, float [[TMP440]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT604:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT603]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP609:%.*]] = fmul <1 x float> [[BLOCK602]], [[SPLAT_SPLAT604]]
+; CHECK-NEXT: [[BLOCK605:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP442:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT606:%.*]] = insertelement <1 x float> poison, float [[TMP442]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT607:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT606]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP611:%.*]] = fmul <1 x float> [[BLOCK605]], [[SPLAT_SPLAT607]]
+; CHECK-NEXT: [[TMP1182:%.*]] = fadd <1 x float> [[TMP609]], [[TMP611]]
+; CHECK-NEXT: [[BLOCK608:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP444:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT609:%.*]] = insertelement <1 x float> poison, float [[TMP444]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT610:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT609]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1183:%.*]] = fmul <1 x float> [[BLOCK608]], [[SPLAT_SPLAT610]]
+; CHECK-NEXT: [[TMP615:%.*]] = fadd <1 x float> [[TMP1182]], [[TMP1183]]
+; CHECK-NEXT: [[BLOCK611:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP446:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT612:%.*]] = insertelement <1 x float> poison, float [[TMP446]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT613:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT612]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1185:%.*]] = fmul <1 x float> [[BLOCK611]], [[SPLAT_SPLAT613]]
+; CHECK-NEXT: [[TMP1188:%.*]] = fadd <1 x float> [[TMP615]], [[TMP1185]]
+; CHECK-NEXT: [[BLOCK614:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP448:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT615:%.*]] = insertelement <1 x float> poison, float [[TMP448]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT616:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT615]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1191:%.*]] = fmul <1 x float> [[BLOCK614]], [[SPLAT_SPLAT616]]
+; CHECK-NEXT: [[TMP621:%.*]] = fadd <1 x float> [[TMP1188]], [[TMP1191]]
+; CHECK-NEXT: [[BLOCK617:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP450:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT618:%.*]] = insertelement <1 x float> poison, float [[TMP450]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT619:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT618]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP623:%.*]] = fmul <1 x float> [[BLOCK617]], [[SPLAT_SPLAT619]]
+; CHECK-NEXT: [[TMP1194:%.*]] = fadd <1 x float> [[TMP621]], [[TMP623]]
+; CHECK-NEXT: [[BLOCK620:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP452:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT621:%.*]] = insertelement <1 x float> poison, float [[TMP452]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT622:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT621]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1197:%.*]] = fmul <1 x float> [[BLOCK620]], [[SPLAT_SPLAT622]]
+; CHECK-NEXT: [[TMP627:%.*]] = fadd <1 x float> [[TMP1194]], [[TMP1197]]
+; CHECK-NEXT: [[BLOCK623:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP454:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT624:%.*]] = insertelement <1 x float> poison, float [[TMP454]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT625:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT624]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP629:%.*]] = fmul <1 x float> [[BLOCK623]], [[SPLAT_SPLAT625]]
+; CHECK-NEXT: [[TMP455:%.*]] = fadd <1 x float> [[TMP627]], [[TMP629]]
+; CHECK-NEXT: [[TMP456:%.*]] = shufflevector <1 x float> [[TMP455]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP457:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP456]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK626:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP458:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT627:%.*]] = insertelement <1 x float> poison, float [[TMP458]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT628:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT627]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1200:%.*]] = fmul <1 x float> [[BLOCK626]], [[SPLAT_SPLAT628]]
+; CHECK-NEXT: [[BLOCK629:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP460:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT630:%.*]] = insertelement <1 x float> poison, float [[TMP460]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT631:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT630]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1203:%.*]] = fmul <1 x float> [[BLOCK629]], [[SPLAT_SPLAT631]]
+; CHECK-NEXT: [[TMP1205:%.*]] = fadd <1 x float> [[TMP1200]], [[TMP1203]]
+; CHECK-NEXT: [[BLOCK632:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP462:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT633:%.*]] = insertelement <1 x float> poison, float [[TMP462]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT634:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT633]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP639:%.*]] = fmul <1 x float> [[BLOCK632]], [[SPLAT_SPLAT634]]
+; CHECK-NEXT: [[TMP1206:%.*]] = fadd <1 x float> [[TMP1205]], [[TMP639]]
+; CHECK-NEXT: [[BLOCK635:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP464:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT636:%.*]] = insertelement <1 x float> poison, float [[TMP464]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT637:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT636]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1207:%.*]] = fmul <1 x float> [[BLOCK635]], [[SPLAT_SPLAT637]]
+; CHECK-NEXT: [[TMP643:%.*]] = fadd <1 x float> [[TMP1206]], [[TMP1207]]
+; CHECK-NEXT: [[BLOCK638:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP466:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT639:%.*]] = insertelement <1 x float> poison, float [[TMP466]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT640:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT639]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP645:%.*]] = fmul <1 x float> [[BLOCK638]], [[SPLAT_SPLAT640]]
+; CHECK-NEXT: [[TMP1208:%.*]] = fadd <1 x float> [[TMP643]], [[TMP645]]
+; CHECK-NEXT: [[BLOCK641:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP468:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT642:%.*]] = insertelement <1 x float> poison, float [[TMP468]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT643:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT642]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1210:%.*]] = fmul <1 x float> [[BLOCK641]], [[SPLAT_SPLAT643]]
+; CHECK-NEXT: [[TMP649:%.*]] = fadd <1 x float> [[TMP1208]], [[TMP1210]]
+; CHECK-NEXT: [[BLOCK644:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP470:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT645:%.*]] = insertelement <1 x float> poison, float [[TMP470]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT646:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT645]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP651:%.*]] = fmul <1 x float> [[BLOCK644]], [[SPLAT_SPLAT646]]
+; CHECK-NEXT: [[TMP1213:%.*]] = fadd <1 x float> [[TMP649]], [[TMP651]]
+; CHECK-NEXT: [[BLOCK647:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP472:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT648:%.*]] = insertelement <1 x float> poison, float [[TMP472]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT649:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT648]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1216:%.*]] = fmul <1 x float> [[BLOCK647]], [[SPLAT_SPLAT649]]
+; CHECK-NEXT: [[TMP473:%.*]] = fadd <1 x float> [[TMP1213]], [[TMP1216]]
+; CHECK-NEXT: [[TMP474:%.*]] = shufflevector <1 x float> [[TMP473]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP475:%.*]] = shufflevector <8 x float> [[TMP457]], <8 x float> [[TMP474]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK650:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP476:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT651:%.*]] = insertelement <1 x float> poison, float [[TMP476]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT652:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT651]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP659:%.*]] = fmul <1 x float> [[BLOCK650]], [[SPLAT_SPLAT652]]
+; CHECK-NEXT: [[BLOCK653:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP478:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT654:%.*]] = insertelement <1 x float> poison, float [[TMP478]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT655:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT654]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP661:%.*]] = fmul <1 x float> [[BLOCK653]], [[SPLAT_SPLAT655]]
+; CHECK-NEXT: [[TMP1219:%.*]] = fadd <1 x float> [[TMP659]], [[TMP661]]
+; CHECK-NEXT: [[BLOCK656:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP480:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT657:%.*]] = insertelement <1 x float> poison, float [[TMP480]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT658:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT657]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1222:%.*]] = fmul <1 x float> [[BLOCK656]], [[SPLAT_SPLAT658]]
+; CHECK-NEXT: [[TMP665:%.*]] = fadd <1 x float> [[TMP1219]], [[TMP1222]]
+; CHECK-NEXT: [[BLOCK659:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP482:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT660:%.*]] = insertelement <1 x float> poison, float [[TMP482]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT661:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT660]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP667:%.*]] = fmul <1 x float> [[BLOCK659]], [[SPLAT_SPLAT661]]
+; CHECK-NEXT: [[TMP1225:%.*]] = fadd <1 x float> [[TMP665]], [[TMP667]]
+; CHECK-NEXT: [[BLOCK662:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP484:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT663:%.*]] = insertelement <1 x float> poison, float [[TMP484]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT664:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT663]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1228:%.*]] = fmul <1 x float> [[BLOCK662]], [[SPLAT_SPLAT664]]
+; CHECK-NEXT: [[TMP1230:%.*]] = fadd <1 x float> [[TMP1225]], [[TMP1228]]
+; CHECK-NEXT: [[BLOCK665:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP486:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT666:%.*]] = insertelement <1 x float> poison, float [[TMP486]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT667:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT666]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1231:%.*]] = fmul <1 x float> [[BLOCK665]], [[SPLAT_SPLAT667]]
+; CHECK-NEXT: [[TMP1232:%.*]] = fadd <1 x float> [[TMP1230]], [[TMP1231]]
+; CHECK-NEXT: [[BLOCK668:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP488:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT669:%.*]] = insertelement <1 x float> poison, float [[TMP488]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT670:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT669]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1233:%.*]] = fmul <1 x float> [[BLOCK668]], [[SPLAT_SPLAT670]]
+; CHECK-NEXT: [[TMP677:%.*]] = fadd <1 x float> [[TMP1232]], [[TMP1233]]
+; CHECK-NEXT: [[BLOCK671:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP490:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT672:%.*]] = insertelement <1 x float> poison, float [[TMP490]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT673:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT672]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP679:%.*]] = fmul <1 x float> [[BLOCK671]], [[SPLAT_SPLAT673]]
+; CHECK-NEXT: [[TMP491:%.*]] = fadd <1 x float> [[TMP677]], [[TMP679]]
+; CHECK-NEXT: [[TMP492:%.*]] = shufflevector <1 x float> [[TMP491]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP493:%.*]] = shufflevector <8 x float> [[TMP475]], <8 x float> [[TMP492]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK674:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP494:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT675:%.*]] = insertelement <1 x float> poison, float [[TMP494]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT676:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT675]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1235:%.*]] = fmul <1 x float> [[BLOCK674]], [[SPLAT_SPLAT676]]
+; CHECK-NEXT: [[BLOCK677:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP496:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT678:%.*]] = insertelement <1 x float> poison, float [[TMP496]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT679:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT678]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1238:%.*]] = fmul <1 x float> [[BLOCK677]], [[SPLAT_SPLAT679]]
+; CHECK-NEXT: [[TMP687:%.*]] = fadd <1 x float> [[TMP1235]], [[TMP1238]]
+; CHECK-NEXT: [[BLOCK680:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP498:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT681:%.*]] = insertelement <1 x float> poison, float [[TMP498]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT682:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT681]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1241:%.*]] = fmul <1 x float> [[BLOCK680]], [[SPLAT_SPLAT682]]
+; CHECK-NEXT: [[TMP1244:%.*]] = fadd <1 x float> [[TMP687]], [[TMP1241]]
+; CHECK-NEXT: [[BLOCK683:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP500:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT684:%.*]] = insertelement <1 x float> poison, float [[TMP500]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT685:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT684]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1247:%.*]] = fmul <1 x float> [[BLOCK683]], [[SPLAT_SPLAT685]]
+; CHECK-NEXT: [[TMP693:%.*]] = fadd <1 x float> [[TMP1244]], [[TMP1247]]
+; CHECK-NEXT: [[BLOCK686:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP502:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT687:%.*]] = insertelement <1 x float> poison, float [[TMP502]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT688:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT687]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP695:%.*]] = fmul <1 x float> [[BLOCK686]], [[SPLAT_SPLAT688]]
+; CHECK-NEXT: [[TMP1250:%.*]] = fadd <1 x float> [[TMP693]], [[TMP695]]
+; CHECK-NEXT: [[BLOCK689:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP504:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT690:%.*]] = insertelement <1 x float> poison, float [[TMP504]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT691:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT690]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1253:%.*]] = fmul <1 x float> [[BLOCK689]], [[SPLAT_SPLAT691]]
+; CHECK-NEXT: [[TMP699:%.*]] = fadd <1 x float> [[TMP1250]], [[TMP1253]]
+; CHECK-NEXT: [[BLOCK692:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP506:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT693:%.*]] = insertelement <1 x float> poison, float [[TMP506]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT694:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT693]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP701:%.*]] = fmul <1 x float> [[BLOCK692]], [[SPLAT_SPLAT694]]
+; CHECK-NEXT: [[TMP1255:%.*]] = fadd <1 x float> [[TMP699]], [[TMP701]]
+; CHECK-NEXT: [[BLOCK695:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP508:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT696:%.*]] = insertelement <1 x float> poison, float [[TMP508]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT697:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT696]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1256:%.*]] = fmul <1 x float> [[BLOCK695]], [[SPLAT_SPLAT697]]
+; CHECK-NEXT: [[TMP509:%.*]] = fadd <1 x float> [[TMP1255]], [[TMP1256]]
+; CHECK-NEXT: [[TMP510:%.*]] = shufflevector <1 x float> [[TMP509]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP511:%.*]] = shufflevector <8 x float> [[TMP493]], <8 x float> [[TMP510]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK698:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP512:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT699:%.*]] = insertelement <1 x float> poison, float [[TMP512]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT700:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT699]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1257:%.*]] = fmul <1 x float> [[BLOCK698]], [[SPLAT_SPLAT700]]
+; CHECK-NEXT: [[BLOCK701:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP514:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT702:%.*]] = insertelement <1 x float> poison, float [[TMP514]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT703:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT702]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP711:%.*]] = fmul <1 x float> [[BLOCK701]], [[SPLAT_SPLAT703]]
+; CHECK-NEXT: [[TMP1258:%.*]] = fadd <1 x float> [[TMP1257]], [[TMP711]]
+; CHECK-NEXT: [[BLOCK704:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP516:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT705:%.*]] = insertelement <1 x float> poison, float [[TMP516]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT706:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT705]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1260:%.*]] = fmul <1 x float> [[BLOCK704]], [[SPLAT_SPLAT706]]
+; CHECK-NEXT: [[TMP715:%.*]] = fadd <1 x float> [[TMP1258]], [[TMP1260]]
+; CHECK-NEXT: [[BLOCK707:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP518:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT708:%.*]] = insertelement <1 x float> poison, float [[TMP518]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT709:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT708]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP717:%.*]] = fmul <1 x float> [[BLOCK707]], [[SPLAT_SPLAT709]]
+; CHECK-NEXT: [[TMP1263:%.*]] = fadd <1 x float> [[TMP715]], [[TMP717]]
+; CHECK-NEXT: [[BLOCK710:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP520:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT711:%.*]] = insertelement <1 x float> poison, float [[TMP520]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT712:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT711]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1266:%.*]] = fmul <1 x float> [[BLOCK710]], [[SPLAT_SPLAT712]]
+; CHECK-NEXT: [[TMP721:%.*]] = fadd <1 x float> [[TMP1263]], [[TMP1266]]
+; CHECK-NEXT: [[BLOCK713:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP522:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT714:%.*]] = insertelement <1 x float> poison, float [[TMP522]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT715:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT714]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP723:%.*]] = fmul <1 x float> [[BLOCK713]], [[SPLAT_SPLAT715]]
+; CHECK-NEXT: [[TMP1269:%.*]] = fadd <1 x float> [[TMP721]], [[TMP723]]
+; CHECK-NEXT: [[BLOCK716:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP524:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT717:%.*]] = insertelement <1 x float> poison, float [[TMP524]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT718:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT717]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1272:%.*]] = fmul <1 x float> [[BLOCK716]], [[SPLAT_SPLAT718]]
+; CHECK-NEXT: [[TMP1275:%.*]] = fadd <1 x float> [[TMP1269]], [[TMP1272]]
+; CHECK-NEXT: [[BLOCK719:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP526:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT720:%.*]] = insertelement <1 x float> poison, float [[TMP526]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT721:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT720]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP729:%.*]] = fmul <1 x float> [[BLOCK719]], [[SPLAT_SPLAT721]]
+; CHECK-NEXT: [[TMP527:%.*]] = fadd <1 x float> [[TMP1275]], [[TMP729]]
+; CHECK-NEXT: [[TMP528:%.*]] = shufflevector <1 x float> [[TMP527]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP529:%.*]] = shufflevector <8 x float> [[TMP511]], <8 x float> [[TMP528]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK722:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP530:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT723:%.*]] = insertelement <1 x float> poison, float [[TMP530]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT724:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT723]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1278:%.*]] = fmul <1 x float> [[BLOCK722]], [[SPLAT_SPLAT724]]
+; CHECK-NEXT: [[BLOCK725:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP532:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT726:%.*]] = insertelement <1 x float> poison, float [[TMP532]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT727:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT726]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1280:%.*]] = fmul <1 x float> [[BLOCK725]], [[SPLAT_SPLAT727]]
+; CHECK-NEXT: [[TMP737:%.*]] = fadd <1 x float> [[TMP1278]], [[TMP1280]]
+; CHECK-NEXT: [[BLOCK728:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP534:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT729:%.*]] = insertelement <1 x float> poison, float [[TMP534]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT730:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT729]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP739:%.*]] = fmul <1 x float> [[BLOCK728]], [[SPLAT_SPLAT730]]
+; CHECK-NEXT: [[TMP1281:%.*]] = fadd <1 x float> [[TMP737]], [[TMP739]]
+; CHECK-NEXT: [[BLOCK731:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP536:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT732:%.*]] = insertelement <1 x float> poison, float [[TMP536]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT733:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT732]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1282:%.*]] = fmul <1 x float> [[BLOCK731]], [[SPLAT_SPLAT733]]
+; CHECK-NEXT: [[TMP1283:%.*]] = fadd <1 x float> [[TMP1281]], [[TMP1282]]
+; CHECK-NEXT: [[BLOCK734:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP538:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT735:%.*]] = insertelement <1 x float> poison, float [[TMP538]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT736:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT735]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1285:%.*]] = fmul <1 x float> [[BLOCK734]], [[SPLAT_SPLAT736]]
+; CHECK-NEXT: [[TMP1288:%.*]] = fadd <1 x float> [[TMP1283]], [[TMP1285]]
+; CHECK-NEXT: [[BLOCK737:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP540:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT738:%.*]] = insertelement <1 x float> poison, float [[TMP540]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT739:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT738]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1291:%.*]] = fmul <1 x float> [[BLOCK737]], [[SPLAT_SPLAT739]]
+; CHECK-NEXT: [[TMP749:%.*]] = fadd <1 x float> [[TMP1288]], [[TMP1291]]
+; CHECK-NEXT: [[BLOCK740:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP542:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT741:%.*]] = insertelement <1 x float> poison, float [[TMP542]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT742:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT741]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP751:%.*]] = fmul <1 x float> [[BLOCK740]], [[SPLAT_SPLAT742]]
+; CHECK-NEXT: [[TMP1294:%.*]] = fadd <1 x float> [[TMP749]], [[TMP751]]
+; CHECK-NEXT: [[BLOCK743:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP544:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT744:%.*]] = insertelement <1 x float> poison, float [[TMP544]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT745:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT744]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1297:%.*]] = fmul <1 x float> [[BLOCK743]], [[SPLAT_SPLAT745]]
+; CHECK-NEXT: [[TMP545:%.*]] = fadd <1 x float> [[TMP1294]], [[TMP1297]]
+; CHECK-NEXT: [[TMP546:%.*]] = shufflevector <1 x float> [[TMP545]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP547:%.*]] = shufflevector <8 x float> [[TMP529]], <8 x float> [[TMP546]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK746:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP548:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT747:%.*]] = insertelement <1 x float> poison, float [[TMP548]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT748:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT747]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP759:%.*]] = fmul <1 x float> [[BLOCK746]], [[SPLAT_SPLAT748]]
+; CHECK-NEXT: [[BLOCK749:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP550:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT750:%.*]] = insertelement <1 x float> poison, float [[TMP550]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT751:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT750]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1300:%.*]] = fmul <1 x float> [[BLOCK749]], [[SPLAT_SPLAT751]]
+; CHECK-NEXT: [[TMP1303:%.*]] = fadd <1 x float> [[TMP759]], [[TMP1300]]
+; CHECK-NEXT: [[BLOCK752:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP552:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT753:%.*]] = insertelement <1 x float> poison, float [[TMP552]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT754:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT753]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1305:%.*]] = fmul <1 x float> [[BLOCK752]], [[SPLAT_SPLAT754]]
+; CHECK-NEXT: [[TMP765:%.*]] = fadd <1 x float> [[TMP1303]], [[TMP1305]]
+; CHECK-NEXT: [[BLOCK755:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP554:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT756:%.*]] = insertelement <1 x float> poison, float [[TMP554]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT757:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT756]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP767:%.*]] = fmul <1 x float> [[BLOCK755]], [[SPLAT_SPLAT757]]
+; CHECK-NEXT: [[TMP1306:%.*]] = fadd <1 x float> [[TMP765]], [[TMP767]]
+; CHECK-NEXT: [[BLOCK758:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP556:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT759:%.*]] = insertelement <1 x float> poison, float [[TMP556]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT760:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT759]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1307:%.*]] = fmul <1 x float> [[BLOCK758]], [[SPLAT_SPLAT760]]
+; CHECK-NEXT: [[TMP771:%.*]] = fadd <1 x float> [[TMP1306]], [[TMP1307]]
+; CHECK-NEXT: [[BLOCK761:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP558:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT762:%.*]] = insertelement <1 x float> poison, float [[TMP558]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT763:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT762]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP773:%.*]] = fmul <1 x float> [[BLOCK761]], [[SPLAT_SPLAT763]]
+; CHECK-NEXT: [[TMP1308:%.*]] = fadd <1 x float> [[TMP771]], [[TMP773]]
+; CHECK-NEXT: [[BLOCK764:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP560:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT765:%.*]] = insertelement <1 x float> poison, float [[TMP560]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT766:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT765]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1310:%.*]] = fmul <1 x float> [[BLOCK764]], [[SPLAT_SPLAT766]]
+; CHECK-NEXT: [[TMP777:%.*]] = fadd <1 x float> [[TMP1308]], [[TMP1310]]
+; CHECK-NEXT: [[BLOCK767:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP562:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT768:%.*]] = insertelement <1 x float> poison, float [[TMP562]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT769:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT768]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1313:%.*]] = fmul <1 x float> [[BLOCK767]], [[SPLAT_SPLAT769]]
+; CHECK-NEXT: [[TMP563:%.*]] = fadd <1 x float> [[TMP777]], [[TMP1313]]
+; CHECK-NEXT: [[TMP564:%.*]] = shufflevector <1 x float> [[TMP563]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP565:%.*]] = shufflevector <8 x float> [[TMP547]], <8 x float> [[TMP564]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK770:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP566:%.*]] = extractelement <8 x float> [[TMP3]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT771:%.*]] = insertelement <1 x float> poison, float [[TMP566]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT772:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT771]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1316:%.*]] = fmul <1 x float> [[BLOCK770]], [[SPLAT_SPLAT772]]
+; CHECK-NEXT: [[BLOCK773:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP568:%.*]] = extractelement <8 x float> [[TMP3]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT774:%.*]] = insertelement <1 x float> poison, float [[TMP568]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT775:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT774]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1319:%.*]] = fmul <1 x float> [[BLOCK773]], [[SPLAT_SPLAT775]]
+; CHECK-NEXT: [[TMP787:%.*]] = fadd <1 x float> [[TMP1316]], [[TMP1319]]
+; CHECK-NEXT: [[BLOCK776:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP570:%.*]] = extractelement <8 x float> [[TMP3]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT777:%.*]] = insertelement <1 x float> poison, float [[TMP570]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT778:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT777]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP789:%.*]] = fmul <1 x float> [[BLOCK776]], [[SPLAT_SPLAT778]]
+; CHECK-NEXT: [[TMP1322:%.*]] = fadd <1 x float> [[TMP787]], [[TMP789]]
+; CHECK-NEXT: [[BLOCK779:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP572:%.*]] = extractelement <8 x float> [[TMP3]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT780:%.*]] = insertelement <1 x float> poison, float [[TMP572]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT781:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT780]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1325:%.*]] = fmul <1 x float> [[BLOCK779]], [[SPLAT_SPLAT781]]
+; CHECK-NEXT: [[TMP793:%.*]] = fadd <1 x float> [[TMP1322]], [[TMP1325]]
+; CHECK-NEXT: [[BLOCK782:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP574:%.*]] = extractelement <8 x float> [[TMP3]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT783:%.*]] = insertelement <1 x float> poison, float [[TMP574]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT784:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT783]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP795:%.*]] = fmul <1 x float> [[BLOCK782]], [[SPLAT_SPLAT784]]
+; CHECK-NEXT: [[TMP1328:%.*]] = fadd <1 x float> [[TMP793]], [[TMP795]]
+; CHECK-NEXT: [[BLOCK785:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP576:%.*]] = extractelement <8 x float> [[TMP3]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT786:%.*]] = insertelement <1 x float> poison, float [[TMP576]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT787:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT786]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1330:%.*]] = fmul <1 x float> [[BLOCK785]], [[SPLAT_SPLAT787]]
+; CHECK-NEXT: [[TMP1331:%.*]] = fadd <1 x float> [[TMP1328]], [[TMP1330]]
+; CHECK-NEXT: [[BLOCK788:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP578:%.*]] = extractelement <8 x float> [[TMP3]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT789:%.*]] = insertelement <1 x float> poison, float [[TMP578]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT790:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT789]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP801:%.*]] = fmul <1 x float> [[BLOCK788]], [[SPLAT_SPLAT790]]
+; CHECK-NEXT: [[TMP1332:%.*]] = fadd <1 x float> [[TMP1331]], [[TMP801]]
+; CHECK-NEXT: [[BLOCK791:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP580:%.*]] = extractelement <8 x float> [[TMP3]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT792:%.*]] = insertelement <1 x float> poison, float [[TMP580]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT793:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT792]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1333:%.*]] = fmul <1 x float> [[BLOCK791]], [[SPLAT_SPLAT793]]
+; CHECK-NEXT: [[TMP581:%.*]] = fadd <1 x float> [[TMP1332]], [[TMP1333]]
+; CHECK-NEXT: [[TMP582:%.*]] = shufflevector <1 x float> [[TMP581]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP583:%.*]] = shufflevector <8 x float> [[TMP565]], <8 x float> [[TMP582]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK794:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP584:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT795:%.*]] = insertelement <1 x float> poison, float [[TMP584]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT796:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT795]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP809:%.*]] = fmul <1 x float> [[BLOCK794]], [[SPLAT_SPLAT796]]
+; CHECK-NEXT: [[BLOCK797:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP586:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT798:%.*]] = insertelement <1 x float> poison, float [[TMP586]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT799:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT798]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP811:%.*]] = fmul <1 x float> [[BLOCK797]], [[SPLAT_SPLAT799]]
+; CHECK-NEXT: [[TMP1335:%.*]] = fadd <1 x float> [[TMP809]], [[TMP811]]
+; CHECK-NEXT: [[BLOCK800:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP588:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT801:%.*]] = insertelement <1 x float> poison, float [[TMP588]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT802:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT801]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1338:%.*]] = fmul <1 x float> [[BLOCK800]], [[SPLAT_SPLAT802]]
+; CHECK-NEXT: [[TMP1341:%.*]] = fadd <1 x float> [[TMP1335]], [[TMP1338]]
+; CHECK-NEXT: [[BLOCK803:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP590:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT804:%.*]] = insertelement <1 x float> poison, float [[TMP590]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT805:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT804]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1344:%.*]] = fmul <1 x float> [[BLOCK803]], [[SPLAT_SPLAT805]]
+; CHECK-NEXT: [[TMP1347:%.*]] = fadd <1 x float> [[TMP1341]], [[TMP1344]]
+; CHECK-NEXT: [[BLOCK806:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP592:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT807:%.*]] = insertelement <1 x float> poison, float [[TMP592]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT808:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT807]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1350:%.*]] = fmul <1 x float> [[BLOCK806]], [[SPLAT_SPLAT808]]
+; CHECK-NEXT: [[TMP821:%.*]] = fadd <1 x float> [[TMP1347]], [[TMP1350]]
+; CHECK-NEXT: [[BLOCK809:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP594:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT810:%.*]] = insertelement <1 x float> poison, float [[TMP594]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT811:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT810]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP823:%.*]] = fmul <1 x float> [[BLOCK809]], [[SPLAT_SPLAT811]]
+; CHECK-NEXT: [[TMP1353:%.*]] = fadd <1 x float> [[TMP821]], [[TMP823]]
+; CHECK-NEXT: [[BLOCK812:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP596:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT813:%.*]] = insertelement <1 x float> poison, float [[TMP596]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT814:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT813]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1355:%.*]] = fmul <1 x float> [[BLOCK812]], [[SPLAT_SPLAT814]]
+; CHECK-NEXT: [[TMP827:%.*]] = fadd <1 x float> [[TMP1353]], [[TMP1355]]
+; CHECK-NEXT: [[BLOCK815:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP598:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT816:%.*]] = insertelement <1 x float> poison, float [[TMP598]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT817:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT816]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP829:%.*]] = fmul <1 x float> [[BLOCK815]], [[SPLAT_SPLAT817]]
+; CHECK-NEXT: [[TMP599:%.*]] = fadd <1 x float> [[TMP827]], [[TMP829]]
+; CHECK-NEXT: [[TMP600:%.*]] = shufflevector <1 x float> [[TMP599]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP601:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP600]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK818:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP602:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT819:%.*]] = insertelement <1 x float> poison, float [[TMP602]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT820:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT819]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1356:%.*]] = fmul <1 x float> [[BLOCK818]], [[SPLAT_SPLAT820]]
+; CHECK-NEXT: [[BLOCK821:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP604:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT822:%.*]] = insertelement <1 x float> poison, float [[TMP604]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT823:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT822]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1357:%.*]] = fmul <1 x float> [[BLOCK821]], [[SPLAT_SPLAT823]]
+; CHECK-NEXT: [[TMP837:%.*]] = fadd <1 x float> [[TMP1356]], [[TMP1357]]
+; CHECK-NEXT: [[BLOCK824:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP606:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT825:%.*]] = insertelement <1 x float> poison, float [[TMP606]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT826:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT825]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP839:%.*]] = fmul <1 x float> [[BLOCK824]], [[SPLAT_SPLAT826]]
+; CHECK-NEXT: [[TMP1358:%.*]] = fadd <1 x float> [[TMP837]], [[TMP839]]
+; CHECK-NEXT: [[BLOCK827:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP608:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT828:%.*]] = insertelement <1 x float> poison, float [[TMP608]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT829:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT828]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1360:%.*]] = fmul <1 x float> [[BLOCK827]], [[SPLAT_SPLAT829]]
+; CHECK-NEXT: [[TMP843:%.*]] = fadd <1 x float> [[TMP1358]], [[TMP1360]]
+; CHECK-NEXT: [[BLOCK830:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP610:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT831:%.*]] = insertelement <1 x float> poison, float [[TMP610]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT832:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT831]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP845:%.*]] = fmul <1 x float> [[BLOCK830]], [[SPLAT_SPLAT832]]
+; CHECK-NEXT: [[TMP1363:%.*]] = fadd <1 x float> [[TMP843]], [[TMP845]]
+; CHECK-NEXT: [[BLOCK833:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP612:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT834:%.*]] = insertelement <1 x float> poison, float [[TMP612]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT835:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT834]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1366:%.*]] = fmul <1 x float> [[BLOCK833]], [[SPLAT_SPLAT835]]
+; CHECK-NEXT: [[TMP849:%.*]] = fadd <1 x float> [[TMP1363]], [[TMP1366]]
+; CHECK-NEXT: [[BLOCK836:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP614:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT837:%.*]] = insertelement <1 x float> poison, float [[TMP614]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT838:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT837]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1369:%.*]] = fmul <1 x float> [[BLOCK836]], [[SPLAT_SPLAT838]]
+; CHECK-NEXT: [[TMP1372:%.*]] = fadd <1 x float> [[TMP849]], [[TMP1369]]
+; CHECK-NEXT: [[BLOCK839:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP616:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT840:%.*]] = insertelement <1 x float> poison, float [[TMP616]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT841:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT840]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1375:%.*]] = fmul <1 x float> [[BLOCK839]], [[SPLAT_SPLAT841]]
+; CHECK-NEXT: [[TMP617:%.*]] = fadd <1 x float> [[TMP1372]], [[TMP1375]]
+; CHECK-NEXT: [[TMP618:%.*]] = shufflevector <1 x float> [[TMP617]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP619:%.*]] = shufflevector <8 x float> [[TMP601]], <8 x float> [[TMP618]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK842:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP620:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT843:%.*]] = insertelement <1 x float> poison, float [[TMP620]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT844:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT843]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP859:%.*]] = fmul <1 x float> [[BLOCK842]], [[SPLAT_SPLAT844]]
+; CHECK-NEXT: [[BLOCK845:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP622:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT846:%.*]] = insertelement <1 x float> poison, float [[TMP622]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT847:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT846]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP861:%.*]] = fmul <1 x float> [[BLOCK845]], [[SPLAT_SPLAT847]]
+; CHECK-NEXT: [[TMP1378:%.*]] = fadd <1 x float> [[TMP859]], [[TMP861]]
+; CHECK-NEXT: [[BLOCK848:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP624:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT849:%.*]] = insertelement <1 x float> poison, float [[TMP624]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT850:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT849]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1380:%.*]] = fmul <1 x float> [[BLOCK848]], [[SPLAT_SPLAT850]]
+; CHECK-NEXT: [[TMP865:%.*]] = fadd <1 x float> [[TMP1378]], [[TMP1380]]
+; CHECK-NEXT: [[BLOCK851:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP626:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT852:%.*]] = insertelement <1 x float> poison, float [[TMP626]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT853:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT852]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP867:%.*]] = fmul <1 x float> [[BLOCK851]], [[SPLAT_SPLAT853]]
+; CHECK-NEXT: [[TMP1381:%.*]] = fadd <1 x float> [[TMP865]], [[TMP867]]
+; CHECK-NEXT: [[BLOCK854:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP628:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT855:%.*]] = insertelement <1 x float> poison, float [[TMP628]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT856:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT855]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1382:%.*]] = fmul <1 x float> [[BLOCK854]], [[SPLAT_SPLAT856]]
+; CHECK-NEXT: [[TMP1383:%.*]] = fadd <1 x float> [[TMP1381]], [[TMP1382]]
+; CHECK-NEXT: [[BLOCK857:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP630:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT858:%.*]] = insertelement <1 x float> poison, float [[TMP630]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT859:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT858]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP873:%.*]] = fmul <1 x float> [[BLOCK857]], [[SPLAT_SPLAT859]]
+; CHECK-NEXT: [[TMP1385:%.*]] = fadd <1 x float> [[TMP1383]], [[TMP873]]
+; CHECK-NEXT: [[BLOCK860:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP632:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT861:%.*]] = insertelement <1 x float> poison, float [[TMP632]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT862:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT861]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1388:%.*]] = fmul <1 x float> [[BLOCK860]], [[SPLAT_SPLAT862]]
+; CHECK-NEXT: [[TMP877:%.*]] = fadd <1 x float> [[TMP1385]], [[TMP1388]]
+; CHECK-NEXT: [[BLOCK863:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP634:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT864:%.*]] = insertelement <1 x float> poison, float [[TMP634]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT865:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT864]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP879:%.*]] = fmul <1 x float> [[BLOCK863]], [[SPLAT_SPLAT865]]
+; CHECK-NEXT: [[TMP635:%.*]] = fadd <1 x float> [[TMP877]], [[TMP879]]
+; CHECK-NEXT: [[TMP636:%.*]] = shufflevector <1 x float> [[TMP635]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP637:%.*]] = shufflevector <8 x float> [[TMP619]], <8 x float> [[TMP636]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK866:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP638:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT867:%.*]] = insertelement <1 x float> poison, float [[TMP638]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT868:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT867]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1391:%.*]] = fmul <1 x float> [[BLOCK866]], [[SPLAT_SPLAT868]]
+; CHECK-NEXT: [[BLOCK869:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP640:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT870:%.*]] = insertelement <1 x float> poison, float [[TMP640]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT871:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT870]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1394:%.*]] = fmul <1 x float> [[BLOCK869]], [[SPLAT_SPLAT871]]
+; CHECK-NEXT: [[TMP1397:%.*]] = fadd <1 x float> [[TMP1391]], [[TMP1394]]
+; CHECK-NEXT: [[BLOCK872:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP642:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT873:%.*]] = insertelement <1 x float> poison, float [[TMP642]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT874:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT873]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1400:%.*]] = fmul <1 x float> [[BLOCK872]], [[SPLAT_SPLAT874]]
+; CHECK-NEXT: [[TMP1403:%.*]] = fadd <1 x float> [[TMP1397]], [[TMP1400]]
+; CHECK-NEXT: [[BLOCK875:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP644:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT876:%.*]] = insertelement <1 x float> poison, float [[TMP644]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT877:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT876]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1405:%.*]] = fmul <1 x float> [[BLOCK875]], [[SPLAT_SPLAT877]]
+; CHECK-NEXT: [[TMP893:%.*]] = fadd <1 x float> [[TMP1403]], [[TMP1405]]
+; CHECK-NEXT: [[BLOCK878:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP646:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT879:%.*]] = insertelement <1 x float> poison, float [[TMP646]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT880:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT879]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP895:%.*]] = fmul <1 x float> [[BLOCK878]], [[SPLAT_SPLAT880]]
+; CHECK-NEXT: [[TMP1406:%.*]] = fadd <1 x float> [[TMP893]], [[TMP895]]
+; CHECK-NEXT: [[BLOCK881:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP648:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT882:%.*]] = insertelement <1 x float> poison, float [[TMP648]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT883:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT882]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1407:%.*]] = fmul <1 x float> [[BLOCK881]], [[SPLAT_SPLAT883]]
+; CHECK-NEXT: [[TMP899:%.*]] = fadd <1 x float> [[TMP1406]], [[TMP1407]]
+; CHECK-NEXT: [[BLOCK884:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP650:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT885:%.*]] = insertelement <1 x float> poison, float [[TMP650]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT886:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT885]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP901:%.*]] = fmul <1 x float> [[BLOCK884]], [[SPLAT_SPLAT886]]
+; CHECK-NEXT: [[TMP1408:%.*]] = fadd <1 x float> [[TMP899]], [[TMP901]]
+; CHECK-NEXT: [[BLOCK887:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP652:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT888:%.*]] = insertelement <1 x float> poison, float [[TMP652]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT889:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT888]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1410:%.*]] = fmul <1 x float> [[BLOCK887]], [[SPLAT_SPLAT889]]
+; CHECK-NEXT: [[TMP653:%.*]] = fadd <1 x float> [[TMP1408]], [[TMP1410]]
+; CHECK-NEXT: [[TMP654:%.*]] = shufflevector <1 x float> [[TMP653]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP655:%.*]] = shufflevector <8 x float> [[TMP637]], <8 x float> [[TMP654]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK890:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP656:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT891:%.*]] = insertelement <1 x float> poison, float [[TMP656]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT892:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT891]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP909:%.*]] = fmul <1 x float> [[BLOCK890]], [[SPLAT_SPLAT892]]
+; CHECK-NEXT: [[BLOCK893:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP658:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT894:%.*]] = insertelement <1 x float> poison, float [[TMP658]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT895:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT894]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP911:%.*]] = fmul <1 x float> [[BLOCK893]], [[SPLAT_SPLAT895]]
+; CHECK-NEXT: [[TMP1413:%.*]] = fadd <1 x float> [[TMP909]], [[TMP911]]
+; CHECK-NEXT: [[BLOCK896:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP660:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT897:%.*]] = insertelement <1 x float> poison, float [[TMP660]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT898:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT897]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1416:%.*]] = fmul <1 x float> [[BLOCK896]], [[SPLAT_SPLAT898]]
+; CHECK-NEXT: [[TMP915:%.*]] = fadd <1 x float> [[TMP1413]], [[TMP1416]]
+; CHECK-NEXT: [[BLOCK899:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP662:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT900:%.*]] = insertelement <1 x float> poison, float [[TMP662]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT901:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT900]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP917:%.*]] = fmul <1 x float> [[BLOCK899]], [[SPLAT_SPLAT901]]
+; CHECK-NEXT: [[TMP1419:%.*]] = fadd <1 x float> [[TMP915]], [[TMP917]]
+; CHECK-NEXT: [[BLOCK902:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP664:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT903:%.*]] = insertelement <1 x float> poison, float [[TMP664]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT904:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT903]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1422:%.*]] = fmul <1 x float> [[BLOCK902]], [[SPLAT_SPLAT904]]
+; CHECK-NEXT: [[TMP921:%.*]] = fadd <1 x float> [[TMP1419]], [[TMP1422]]
+; CHECK-NEXT: [[BLOCK905:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP666:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT906:%.*]] = insertelement <1 x float> poison, float [[TMP666]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT907:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT906]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1425:%.*]] = fmul <1 x float> [[BLOCK905]], [[SPLAT_SPLAT907]]
+; CHECK-NEXT: [[TMP1428:%.*]] = fadd <1 x float> [[TMP921]], [[TMP1425]]
+; CHECK-NEXT: [[BLOCK908:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP668:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT909:%.*]] = insertelement <1 x float> poison, float [[TMP668]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT910:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT909]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1430:%.*]] = fmul <1 x float> [[BLOCK908]], [[SPLAT_SPLAT910]]
+; CHECK-NEXT: [[TMP927:%.*]] = fadd <1 x float> [[TMP1428]], [[TMP1430]]
+; CHECK-NEXT: [[BLOCK911:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP670:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT912:%.*]] = insertelement <1 x float> poison, float [[TMP670]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT913:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT912]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP929:%.*]] = fmul <1 x float> [[BLOCK911]], [[SPLAT_SPLAT913]]
+; CHECK-NEXT: [[TMP671:%.*]] = fadd <1 x float> [[TMP927]], [[TMP929]]
+; CHECK-NEXT: [[TMP672:%.*]] = shufflevector <1 x float> [[TMP671]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP673:%.*]] = shufflevector <8 x float> [[TMP655]], <8 x float> [[TMP672]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK914:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP674:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT915:%.*]] = insertelement <1 x float> poison, float [[TMP674]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT916:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT915]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1431:%.*]] = fmul <1 x float> [[BLOCK914]], [[SPLAT_SPLAT916]]
+; CHECK-NEXT: [[BLOCK917:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP676:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT918:%.*]] = insertelement <1 x float> poison, float [[TMP676]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT919:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT918]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1432:%.*]] = fmul <1 x float> [[BLOCK917]], [[SPLAT_SPLAT919]]
+; CHECK-NEXT: [[TMP937:%.*]] = fadd <1 x float> [[TMP1431]], [[TMP1432]]
+; CHECK-NEXT: [[BLOCK920:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP678:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT921:%.*]] = insertelement <1 x float> poison, float [[TMP678]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT922:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT921]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP939:%.*]] = fmul <1 x float> [[BLOCK920]], [[SPLAT_SPLAT922]]
+; CHECK-NEXT: [[TMP1433:%.*]] = fadd <1 x float> [[TMP937]], [[TMP939]]
+; CHECK-NEXT: [[BLOCK923:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP680:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT924:%.*]] = insertelement <1 x float> poison, float [[TMP680]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT925:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT924]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1435:%.*]] = fmul <1 x float> [[BLOCK923]], [[SPLAT_SPLAT925]]
+; CHECK-NEXT: [[TMP1438:%.*]] = fadd <1 x float> [[TMP1433]], [[TMP1435]]
+; CHECK-NEXT: [[BLOCK926:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP682:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT927:%.*]] = insertelement <1 x float> poison, float [[TMP682]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT928:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT927]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP945:%.*]] = fmul <1 x float> [[BLOCK926]], [[SPLAT_SPLAT928]]
+; CHECK-NEXT: [[TMP1441:%.*]] = fadd <1 x float> [[TMP1438]], [[TMP945]]
+; CHECK-NEXT: [[BLOCK929:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP684:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT930:%.*]] = insertelement <1 x float> poison, float [[TMP684]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT931:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT930]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1444:%.*]] = fmul <1 x float> [[BLOCK929]], [[SPLAT_SPLAT931]]
+; CHECK-NEXT: [[TMP949:%.*]] = fadd <1 x float> [[TMP1441]], [[TMP1444]]
+; CHECK-NEXT: [[BLOCK932:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP686:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT933:%.*]] = insertelement <1 x float> poison, float [[TMP686]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT934:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT933]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP951:%.*]] = fmul <1 x float> [[BLOCK932]], [[SPLAT_SPLAT934]]
+; CHECK-NEXT: [[TMP1447:%.*]] = fadd <1 x float> [[TMP949]], [[TMP951]]
+; CHECK-NEXT: [[BLOCK935:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP688:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT936:%.*]] = insertelement <1 x float> poison, float [[TMP688]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT937:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT936]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1450:%.*]] = fmul <1 x float> [[BLOCK935]], [[SPLAT_SPLAT937]]
+; CHECK-NEXT: [[TMP689:%.*]] = fadd <1 x float> [[TMP1447]], [[TMP1450]]
+; CHECK-NEXT: [[TMP690:%.*]] = shufflevector <1 x float> [[TMP689]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP691:%.*]] = shufflevector <8 x float> [[TMP673]], <8 x float> [[TMP690]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK938:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP692:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT939:%.*]] = insertelement <1 x float> poison, float [[TMP692]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT940:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT939]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1453:%.*]] = fmul <1 x float> [[BLOCK938]], [[SPLAT_SPLAT940]]
+; CHECK-NEXT: [[BLOCK941:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP694:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT942:%.*]] = insertelement <1 x float> poison, float [[TMP694]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT943:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT942]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1455:%.*]] = fmul <1 x float> [[BLOCK941]], [[SPLAT_SPLAT943]]
+; CHECK-NEXT: [[TMP1456:%.*]] = fadd <1 x float> [[TMP1453]], [[TMP1455]]
+; CHECK-NEXT: [[BLOCK944:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP696:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT945:%.*]] = insertelement <1 x float> poison, float [[TMP696]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT946:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT945]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1457:%.*]] = fmul <1 x float> [[BLOCK944]], [[SPLAT_SPLAT946]]
+; CHECK-NEXT: [[TMP965:%.*]] = fadd <1 x float> [[TMP1456]], [[TMP1457]]
+; CHECK-NEXT: [[BLOCK947:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP698:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT948:%.*]] = insertelement <1 x float> poison, float [[TMP698]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT949:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT948]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP967:%.*]] = fmul <1 x float> [[BLOCK947]], [[SPLAT_SPLAT949]]
+; CHECK-NEXT: [[TMP1458:%.*]] = fadd <1 x float> [[TMP965]], [[TMP967]]
+; CHECK-NEXT: [[BLOCK950:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP700:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT951:%.*]] = insertelement <1 x float> poison, float [[TMP700]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT952:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT951]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1460:%.*]] = fmul <1 x float> [[BLOCK950]], [[SPLAT_SPLAT952]]
+; CHECK-NEXT: [[TMP971:%.*]] = fadd <1 x float> [[TMP1458]], [[TMP1460]]
+; CHECK-NEXT: [[BLOCK953:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP702:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT954:%.*]] = insertelement <1 x float> poison, float [[TMP702]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT955:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT954]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP973:%.*]] = fmul <1 x float> [[BLOCK953]], [[SPLAT_SPLAT955]]
+; CHECK-NEXT: [[TMP1463:%.*]] = fadd <1 x float> [[TMP971]], [[TMP973]]
+; CHECK-NEXT: [[BLOCK956:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP704:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT957:%.*]] = insertelement <1 x float> poison, float [[TMP704]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT958:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT957]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1466:%.*]] = fmul <1 x float> [[BLOCK956]], [[SPLAT_SPLAT958]]
+; CHECK-NEXT: [[TMP1469:%.*]] = fadd <1 x float> [[TMP1463]], [[TMP1466]]
+; CHECK-NEXT: [[BLOCK959:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP706:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT960:%.*]] = insertelement <1 x float> poison, float [[TMP706]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT961:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT960]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1472:%.*]] = fmul <1 x float> [[BLOCK959]], [[SPLAT_SPLAT961]]
+; CHECK-NEXT: [[TMP707:%.*]] = fadd <1 x float> [[TMP1469]], [[TMP1472]]
+; CHECK-NEXT: [[TMP708:%.*]] = shufflevector <1 x float> [[TMP707]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP709:%.*]] = shufflevector <8 x float> [[TMP691]], <8 x float> [[TMP708]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK962:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP710:%.*]] = extractelement <8 x float> [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT963:%.*]] = insertelement <1 x float> poison, float [[TMP710]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT964:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT963]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1475:%.*]] = fmul <1 x float> [[BLOCK962]], [[SPLAT_SPLAT964]]
+; CHECK-NEXT: [[BLOCK965:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP712:%.*]] = extractelement <8 x float> [[TMP4]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT966:%.*]] = insertelement <1 x float> poison, float [[TMP712]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT967:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT966]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1478:%.*]] = fmul <1 x float> [[BLOCK965]], [[SPLAT_SPLAT967]]
+; CHECK-NEXT: [[TMP987:%.*]] = fadd <1 x float> [[TMP1475]], [[TMP1478]]
+; CHECK-NEXT: [[BLOCK968:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP714:%.*]] = extractelement <8 x float> [[TMP4]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT969:%.*]] = insertelement <1 x float> poison, float [[TMP714]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT970:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT969]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP989:%.*]] = fmul <1 x float> [[BLOCK968]], [[SPLAT_SPLAT970]]
+; CHECK-NEXT: [[TMP1480:%.*]] = fadd <1 x float> [[TMP987]], [[TMP989]]
+; CHECK-NEXT: [[BLOCK971:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP716:%.*]] = extractelement <8 x float> [[TMP4]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT972:%.*]] = insertelement <1 x float> poison, float [[TMP716]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT973:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT972]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1481:%.*]] = fmul <1 x float> [[BLOCK971]], [[SPLAT_SPLAT973]]
+; CHECK-NEXT: [[TMP993:%.*]] = fadd <1 x float> [[TMP1480]], [[TMP1481]]
+; CHECK-NEXT: [[BLOCK974:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP718:%.*]] = extractelement <8 x float> [[TMP4]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT975:%.*]] = insertelement <1 x float> poison, float [[TMP718]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT976:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT975]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1482:%.*]] = fmul <1 x float> [[BLOCK974]], [[SPLAT_SPLAT976]]
+; CHECK-NEXT: [[TMP1483:%.*]] = fadd <1 x float> [[TMP993]], [[TMP1482]]
+; CHECK-NEXT: [[BLOCK977:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP720:%.*]] = extractelement <8 x float> [[TMP4]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT978:%.*]] = insertelement <1 x float> poison, float [[TMP720]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT979:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT978]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1485:%.*]] = fmul <1 x float> [[BLOCK977]], [[SPLAT_SPLAT979]]
+; CHECK-NEXT: [[TMP999:%.*]] = fadd <1 x float> [[TMP1483]], [[TMP1485]]
+; CHECK-NEXT: [[BLOCK980:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP722:%.*]] = extractelement <8 x float> [[TMP4]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT981:%.*]] = insertelement <1 x float> poison, float [[TMP722]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT982:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT981]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1001:%.*]] = fmul <1 x float> [[BLOCK980]], [[SPLAT_SPLAT982]]
+; CHECK-NEXT: [[TMP1488:%.*]] = fadd <1 x float> [[TMP999]], [[TMP1001]]
+; CHECK-NEXT: [[BLOCK983:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP724:%.*]] = extractelement <8 x float> [[TMP4]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT984:%.*]] = insertelement <1 x float> poison, float [[TMP724]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT985:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT984]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1491:%.*]] = fmul <1 x float> [[BLOCK983]], [[SPLAT_SPLAT985]]
+; CHECK-NEXT: [[TMP725:%.*]] = fadd <1 x float> [[TMP1488]], [[TMP1491]]
+; CHECK-NEXT: [[TMP726:%.*]] = shufflevector <1 x float> [[TMP725]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP727:%.*]] = shufflevector <8 x float> [[TMP709]], <8 x float> [[TMP726]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK986:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP728:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT987:%.*]] = insertelement <1 x float> poison, float [[TMP728]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT988:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT987]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1009:%.*]] = fmul <1 x float> [[BLOCK986]], [[SPLAT_SPLAT988]]
+; CHECK-NEXT: [[BLOCK989:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP730:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT990:%.*]] = insertelement <1 x float> poison, float [[TMP730]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT991:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT990]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1011:%.*]] = fmul <1 x float> [[BLOCK989]], [[SPLAT_SPLAT991]]
+; CHECK-NEXT: [[TMP1494:%.*]] = fadd <1 x float> [[TMP1009]], [[TMP1011]]
+; CHECK-NEXT: [[BLOCK992:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP732:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT993:%.*]] = insertelement <1 x float> poison, float [[TMP732]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT994:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT993]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1497:%.*]] = fmul <1 x float> [[BLOCK992]], [[SPLAT_SPLAT994]]
+; CHECK-NEXT: [[TMP1500:%.*]] = fadd <1 x float> [[TMP1494]], [[TMP1497]]
+; CHECK-NEXT: [[BLOCK995:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP734:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT996:%.*]] = insertelement <1 x float> poison, float [[TMP734]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT997:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT996]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1017:%.*]] = fmul <1 x float> [[BLOCK995]], [[SPLAT_SPLAT997]]
+; CHECK-NEXT: [[TMP1503:%.*]] = fadd <1 x float> [[TMP1500]], [[TMP1017]]
+; CHECK-NEXT: [[BLOCK998:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP736:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT999:%.*]] = insertelement <1 x float> poison, float [[TMP736]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1000:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT999]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1505:%.*]] = fmul <1 x float> [[BLOCK998]], [[SPLAT_SPLAT1000]]
+; CHECK-NEXT: [[TMP1021:%.*]] = fadd <1 x float> [[TMP1503]], [[TMP1505]]
+; CHECK-NEXT: [[BLOCK1001:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP738:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1002:%.*]] = insertelement <1 x float> poison, float [[TMP738]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1003:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1002]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1023:%.*]] = fmul <1 x float> [[BLOCK1001]], [[SPLAT_SPLAT1003]]
+; CHECK-NEXT: [[TMP1506:%.*]] = fadd <1 x float> [[TMP1021]], [[TMP1023]]
+; CHECK-NEXT: [[BLOCK1004:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP740:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1005:%.*]] = insertelement <1 x float> poison, float [[TMP740]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1006:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1005]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1507:%.*]] = fmul <1 x float> [[BLOCK1004]], [[SPLAT_SPLAT1006]]
+; CHECK-NEXT: [[TMP1027:%.*]] = fadd <1 x float> [[TMP1506]], [[TMP1507]]
+; CHECK-NEXT: [[BLOCK1007:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP742:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1008:%.*]] = insertelement <1 x float> poison, float [[TMP742]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1009:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1008]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1029:%.*]] = fmul <1 x float> [[BLOCK1007]], [[SPLAT_SPLAT1009]]
+; CHECK-NEXT: [[TMP743:%.*]] = fadd <1 x float> [[TMP1027]], [[TMP1029]]
+; CHECK-NEXT: [[TMP744:%.*]] = shufflevector <1 x float> [[TMP743]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP745:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP744]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1010:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP746:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1011:%.*]] = insertelement <1 x float> poison, float [[TMP746]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1012:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1011]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1508:%.*]] = fmul <1 x float> [[BLOCK1010]], [[SPLAT_SPLAT1012]]
+; CHECK-NEXT: [[BLOCK1013:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP748:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1014:%.*]] = insertelement <1 x float> poison, float [[TMP748]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1015:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1014]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1510:%.*]] = fmul <1 x float> [[BLOCK1013]], [[SPLAT_SPLAT1015]]
+; CHECK-NEXT: [[TMP1037:%.*]] = fadd <1 x float> [[TMP1508]], [[TMP1510]]
+; CHECK-NEXT: [[BLOCK1016:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP750:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1017:%.*]] = insertelement <1 x float> poison, float [[TMP750]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1018:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1017]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1039:%.*]] = fmul <1 x float> [[BLOCK1016]], [[SPLAT_SPLAT1018]]
+; CHECK-NEXT: [[TMP1513:%.*]] = fadd <1 x float> [[TMP1037]], [[TMP1039]]
+; CHECK-NEXT: [[BLOCK1019:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP752:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1020:%.*]] = insertelement <1 x float> poison, float [[TMP752]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1021:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1020]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1516:%.*]] = fmul <1 x float> [[BLOCK1019]], [[SPLAT_SPLAT1021]]
+; CHECK-NEXT: [[TMP1043:%.*]] = fadd <1 x float> [[TMP1513]], [[TMP1516]]
+; CHECK-NEXT: [[BLOCK1022:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP754:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1023:%.*]] = insertelement <1 x float> poison, float [[TMP754]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1024:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1023]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1045:%.*]] = fmul <1 x float> [[BLOCK1022]], [[SPLAT_SPLAT1024]]
+; CHECK-NEXT: [[TMP1519:%.*]] = fadd <1 x float> [[TMP1043]], [[TMP1045]]
+; CHECK-NEXT: [[BLOCK1025:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP756:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1026:%.*]] = insertelement <1 x float> poison, float [[TMP756]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1027:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1026]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1522:%.*]] = fmul <1 x float> [[BLOCK1025]], [[SPLAT_SPLAT1027]]
+; CHECK-NEXT: [[TMP1525:%.*]] = fadd <1 x float> [[TMP1519]], [[TMP1522]]
+; CHECK-NEXT: [[BLOCK1028:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP758:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1029:%.*]] = insertelement <1 x float> poison, float [[TMP758]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1030:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1029]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1528:%.*]] = fmul <1 x float> [[BLOCK1028]], [[SPLAT_SPLAT1030]]
+; CHECK-NEXT: [[TMP1530:%.*]] = fadd <1 x float> [[TMP1525]], [[TMP1528]]
+; CHECK-NEXT: [[BLOCK1031:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP760:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1032:%.*]] = insertelement <1 x float> poison, float [[TMP760]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1033:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1032]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1531:%.*]] = fmul <1 x float> [[BLOCK1031]], [[SPLAT_SPLAT1033]]
+; CHECK-NEXT: [[TMP761:%.*]] = fadd <1 x float> [[TMP1530]], [[TMP1531]]
+; CHECK-NEXT: [[TMP762:%.*]] = shufflevector <1 x float> [[TMP761]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP763:%.*]] = shufflevector <8 x float> [[TMP745]], <8 x float> [[TMP762]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1034:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP764:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1035:%.*]] = insertelement <1 x float> poison, float [[TMP764]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1036:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1035]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1059:%.*]] = fmul <1 x float> [[BLOCK1034]], [[SPLAT_SPLAT1036]]
+; CHECK-NEXT: [[BLOCK1037:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP766:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1038:%.*]] = insertelement <1 x float> poison, float [[TMP766]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1039:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1038]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1061:%.*]] = fmul <1 x float> [[BLOCK1037]], [[SPLAT_SPLAT1039]]
+; CHECK-NEXT: [[TMP1532:%.*]] = fadd <1 x float> [[TMP1059]], [[TMP1061]]
+; CHECK-NEXT: [[BLOCK1040:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP768:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1041:%.*]] = insertelement <1 x float> poison, float [[TMP768]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1042:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1041]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1533:%.*]] = fmul <1 x float> [[BLOCK1040]], [[SPLAT_SPLAT1042]]
+; CHECK-NEXT: [[TMP1065:%.*]] = fadd <1 x float> [[TMP1532]], [[TMP1533]]
+; CHECK-NEXT: [[BLOCK1043:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP770:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1044:%.*]] = insertelement <1 x float> poison, float [[TMP770]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1045:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1044]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1535:%.*]] = fmul <1 x float> [[BLOCK1043]], [[SPLAT_SPLAT1045]]
+; CHECK-NEXT: [[TMP1538:%.*]] = fadd <1 x float> [[TMP1065]], [[TMP1535]]
+; CHECK-NEXT: [[BLOCK1046:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP772:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1047:%.*]] = insertelement <1 x float> poison, float [[TMP772]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1048:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1047]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1541:%.*]] = fmul <1 x float> [[BLOCK1046]], [[SPLAT_SPLAT1048]]
+; CHECK-NEXT: [[TMP1071:%.*]] = fadd <1 x float> [[TMP1538]], [[TMP1541]]
+; CHECK-NEXT: [[BLOCK1049:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP774:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1050:%.*]] = insertelement <1 x float> poison, float [[TMP774]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1051:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1050]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1073:%.*]] = fmul <1 x float> [[BLOCK1049]], [[SPLAT_SPLAT1051]]
+; CHECK-NEXT: [[TMP1544:%.*]] = fadd <1 x float> [[TMP1071]], [[TMP1073]]
+; CHECK-NEXT: [[BLOCK1052:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP776:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1053:%.*]] = insertelement <1 x float> poison, float [[TMP776]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1054:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1053]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1547:%.*]] = fmul <1 x float> [[BLOCK1052]], [[SPLAT_SPLAT1054]]
+; CHECK-NEXT: [[TMP1077:%.*]] = fadd <1 x float> [[TMP1544]], [[TMP1547]]
+; CHECK-NEXT: [[BLOCK1055:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP778:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1056:%.*]] = insertelement <1 x float> poison, float [[TMP778]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1057:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1056]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1079:%.*]] = fmul <1 x float> [[BLOCK1055]], [[SPLAT_SPLAT1057]]
+; CHECK-NEXT: [[TMP779:%.*]] = fadd <1 x float> [[TMP1077]], [[TMP1079]]
+; CHECK-NEXT: [[TMP780:%.*]] = shufflevector <1 x float> [[TMP779]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP781:%.*]] = shufflevector <8 x float> [[TMP763]], <8 x float> [[TMP780]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1058:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP782:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1059:%.*]] = insertelement <1 x float> poison, float [[TMP782]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1060:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1059]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1550:%.*]] = fmul <1 x float> [[BLOCK1058]], [[SPLAT_SPLAT1060]]
+; CHECK-NEXT: [[BLOCK1061:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP784:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1062:%.*]] = insertelement <1 x float> poison, float [[TMP784]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1063:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1062]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1553:%.*]] = fmul <1 x float> [[BLOCK1061]], [[SPLAT_SPLAT1063]]
+; CHECK-NEXT: [[TMP1555:%.*]] = fadd <1 x float> [[TMP1550]], [[TMP1553]]
+; CHECK-NEXT: [[BLOCK1064:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP786:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1065:%.*]] = insertelement <1 x float> poison, float [[TMP786]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1066:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1065]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1089:%.*]] = fmul <1 x float> [[BLOCK1064]], [[SPLAT_SPLAT1066]]
+; CHECK-NEXT: [[TMP1556:%.*]] = fadd <1 x float> [[TMP1555]], [[TMP1089]]
+; CHECK-NEXT: [[BLOCK1067:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP788:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1068:%.*]] = insertelement <1 x float> poison, float [[TMP788]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1069:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1068]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1557:%.*]] = fmul <1 x float> [[BLOCK1067]], [[SPLAT_SPLAT1069]]
+; CHECK-NEXT: [[TMP1093:%.*]] = fadd <1 x float> [[TMP1556]], [[TMP1557]]
+; CHECK-NEXT: [[BLOCK1070:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP790:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1071:%.*]] = insertelement <1 x float> poison, float [[TMP790]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1072:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1071]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1095:%.*]] = fmul <1 x float> [[BLOCK1070]], [[SPLAT_SPLAT1072]]
+; CHECK-NEXT: [[TMP1558:%.*]] = fadd <1 x float> [[TMP1093]], [[TMP1095]]
+; CHECK-NEXT: [[BLOCK1073:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP792:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1074:%.*]] = insertelement <1 x float> poison, float [[TMP792]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1075:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1074]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1560:%.*]] = fmul <1 x float> [[BLOCK1073]], [[SPLAT_SPLAT1075]]
+; CHECK-NEXT: [[TMP1099:%.*]] = fadd <1 x float> [[TMP1558]], [[TMP1560]]
+; CHECK-NEXT: [[BLOCK1076:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP794:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1077:%.*]] = insertelement <1 x float> poison, float [[TMP794]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1078:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1077]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1101:%.*]] = fmul <1 x float> [[BLOCK1076]], [[SPLAT_SPLAT1078]]
+; CHECK-NEXT: [[TMP1563:%.*]] = fadd <1 x float> [[TMP1099]], [[TMP1101]]
+; CHECK-NEXT: [[BLOCK1079:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP796:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1080:%.*]] = insertelement <1 x float> poison, float [[TMP796]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1081:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1080]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1566:%.*]] = fmul <1 x float> [[BLOCK1079]], [[SPLAT_SPLAT1081]]
+; CHECK-NEXT: [[TMP797:%.*]] = fadd <1 x float> [[TMP1563]], [[TMP1566]]
+; CHECK-NEXT: [[TMP798:%.*]] = shufflevector <1 x float> [[TMP797]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP799:%.*]] = shufflevector <8 x float> [[TMP781]], <8 x float> [[TMP798]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1082:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP800:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1083:%.*]] = insertelement <1 x float> poison, float [[TMP800]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1084:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1083]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1109:%.*]] = fmul <1 x float> [[BLOCK1082]], [[SPLAT_SPLAT1084]]
+; CHECK-NEXT: [[BLOCK1085:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP802:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1086:%.*]] = insertelement <1 x float> poison, float [[TMP802]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1087:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1086]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1111:%.*]] = fmul <1 x float> [[BLOCK1085]], [[SPLAT_SPLAT1087]]
+; CHECK-NEXT: [[TMP1569:%.*]] = fadd <1 x float> [[TMP1109]], [[TMP1111]]
+; CHECK-NEXT: [[BLOCK1088:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP804:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1089:%.*]] = insertelement <1 x float> poison, float [[TMP804]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1090:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1089]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1572:%.*]] = fmul <1 x float> [[BLOCK1088]], [[SPLAT_SPLAT1090]]
+; CHECK-NEXT: [[TMP1115:%.*]] = fadd <1 x float> [[TMP1569]], [[TMP1572]]
+; CHECK-NEXT: [[BLOCK1091:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP806:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1092:%.*]] = insertelement <1 x float> poison, float [[TMP806]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1093:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1092]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1117:%.*]] = fmul <1 x float> [[BLOCK1091]], [[SPLAT_SPLAT1093]]
+; CHECK-NEXT: [[TMP1575:%.*]] = fadd <1 x float> [[TMP1115]], [[TMP1117]]
+; CHECK-NEXT: [[BLOCK1094:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP808:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1095:%.*]] = insertelement <1 x float> poison, float [[TMP808]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1096:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1095]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1578:%.*]] = fmul <1 x float> [[BLOCK1094]], [[SPLAT_SPLAT1096]]
+; CHECK-NEXT: [[TMP1580:%.*]] = fadd <1 x float> [[TMP1575]], [[TMP1578]]
+; CHECK-NEXT: [[BLOCK1097:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP810:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1098:%.*]] = insertelement <1 x float> poison, float [[TMP810]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1099:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1098]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1581:%.*]] = fmul <1 x float> [[BLOCK1097]], [[SPLAT_SPLAT1099]]
+; CHECK-NEXT: [[TMP1582:%.*]] = fadd <1 x float> [[TMP1580]], [[TMP1581]]
+; CHECK-NEXT: [[BLOCK1100:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP812:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1101:%.*]] = insertelement <1 x float> poison, float [[TMP812]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1102:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1101]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1583:%.*]] = fmul <1 x float> [[BLOCK1100]], [[SPLAT_SPLAT1102]]
+; CHECK-NEXT: [[TMP1127:%.*]] = fadd <1 x float> [[TMP1582]], [[TMP1583]]
+; CHECK-NEXT: [[BLOCK1103:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP814:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1104:%.*]] = insertelement <1 x float> poison, float [[TMP814]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1105:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1104]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1129:%.*]] = fmul <1 x float> [[BLOCK1103]], [[SPLAT_SPLAT1105]]
+; CHECK-NEXT: [[TMP815:%.*]] = fadd <1 x float> [[TMP1127]], [[TMP1129]]
+; CHECK-NEXT: [[TMP816:%.*]] = shufflevector <1 x float> [[TMP815]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP817:%.*]] = shufflevector <8 x float> [[TMP799]], <8 x float> [[TMP816]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1106:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP818:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1107:%.*]] = insertelement <1 x float> poison, float [[TMP818]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1108:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1107]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1585:%.*]] = fmul <1 x float> [[BLOCK1106]], [[SPLAT_SPLAT1108]]
+; CHECK-NEXT: [[BLOCK1109:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP820:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1110:%.*]] = insertelement <1 x float> poison, float [[TMP820]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1111:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1110]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1588:%.*]] = fmul <1 x float> [[BLOCK1109]], [[SPLAT_SPLAT1111]]
+; CHECK-NEXT: [[TMP1137:%.*]] = fadd <1 x float> [[TMP1585]], [[TMP1588]]
+; CHECK-NEXT: [[BLOCK1112:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP822:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1113:%.*]] = insertelement <1 x float> poison, float [[TMP822]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1114:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1113]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1591:%.*]] = fmul <1 x float> [[BLOCK1112]], [[SPLAT_SPLAT1114]]
+; CHECK-NEXT: [[TMP1594:%.*]] = fadd <1 x float> [[TMP1137]], [[TMP1591]]
+; CHECK-NEXT: [[BLOCK1115:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP824:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1116:%.*]] = insertelement <1 x float> poison, float [[TMP824]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1117:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1116]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1597:%.*]] = fmul <1 x float> [[BLOCK1115]], [[SPLAT_SPLAT1117]]
+; CHECK-NEXT: [[TMP1143:%.*]] = fadd <1 x float> [[TMP1594]], [[TMP1597]]
+; CHECK-NEXT: [[BLOCK1118:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP826:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1119:%.*]] = insertelement <1 x float> poison, float [[TMP826]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1120:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1119]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1145:%.*]] = fmul <1 x float> [[BLOCK1118]], [[SPLAT_SPLAT1120]]
+; CHECK-NEXT: [[TMP1600:%.*]] = fadd <1 x float> [[TMP1143]], [[TMP1145]]
+; CHECK-NEXT: [[BLOCK1121:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP828:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1122:%.*]] = insertelement <1 x float> poison, float [[TMP828]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1123:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1122]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1603:%.*]] = fmul <1 x float> [[BLOCK1121]], [[SPLAT_SPLAT1123]]
+; CHECK-NEXT: [[TMP1149:%.*]] = fadd <1 x float> [[TMP1600]], [[TMP1603]]
+; CHECK-NEXT: [[BLOCK1124:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP830:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1125:%.*]] = insertelement <1 x float> poison, float [[TMP830]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1126:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1125]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1151:%.*]] = fmul <1 x float> [[BLOCK1124]], [[SPLAT_SPLAT1126]]
+; CHECK-NEXT: [[TMP1605:%.*]] = fadd <1 x float> [[TMP1149]], [[TMP1151]]
+; CHECK-NEXT: [[BLOCK1127:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP832:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1128:%.*]] = insertelement <1 x float> poison, float [[TMP832]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1129:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1128]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1606:%.*]] = fmul <1 x float> [[BLOCK1127]], [[SPLAT_SPLAT1129]]
+; CHECK-NEXT: [[TMP833:%.*]] = fadd <1 x float> [[TMP1605]], [[TMP1606]]
+; CHECK-NEXT: [[TMP834:%.*]] = shufflevector <1 x float> [[TMP833]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP835:%.*]] = shufflevector <8 x float> [[TMP817]], <8 x float> [[TMP834]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1130:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP836:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1131:%.*]] = insertelement <1 x float> poison, float [[TMP836]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1132:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1131]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1607:%.*]] = fmul <1 x float> [[BLOCK1130]], [[SPLAT_SPLAT1132]]
+; CHECK-NEXT: [[BLOCK1133:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP838:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1134:%.*]] = insertelement <1 x float> poison, float [[TMP838]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1135:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1134]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1161:%.*]] = fmul <1 x float> [[BLOCK1133]], [[SPLAT_SPLAT1135]]
+; CHECK-NEXT: [[TMP1162:%.*]] = fadd <1 x float> [[TMP1607]], [[TMP1161]]
+; CHECK-NEXT: [[BLOCK1136:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP840:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1137:%.*]] = insertelement <1 x float> poison, float [[TMP840]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1138:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1137]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1164:%.*]] = fmul <1 x float> [[BLOCK1136]], [[SPLAT_SPLAT1138]]
+; CHECK-NEXT: [[TMP1165:%.*]] = fadd <1 x float> [[TMP1162]], [[TMP1164]]
+; CHECK-NEXT: [[BLOCK1139:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP842:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1140:%.*]] = insertelement <1 x float> poison, float [[TMP842]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1141:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1140]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1167:%.*]] = fmul <1 x float> [[BLOCK1139]], [[SPLAT_SPLAT1141]]
+; CHECK-NEXT: [[TMP1168:%.*]] = fadd <1 x float> [[TMP1165]], [[TMP1167]]
+; CHECK-NEXT: [[BLOCK1142:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP844:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1143:%.*]] = insertelement <1 x float> poison, float [[TMP844]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1144:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1143]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1170:%.*]] = fmul <1 x float> [[BLOCK1142]], [[SPLAT_SPLAT1144]]
+; CHECK-NEXT: [[TMP1171:%.*]] = fadd <1 x float> [[TMP1168]], [[TMP1170]]
+; CHECK-NEXT: [[BLOCK1145:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP846:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1146:%.*]] = insertelement <1 x float> poison, float [[TMP846]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1147:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1146]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1173:%.*]] = fmul <1 x float> [[BLOCK1145]], [[SPLAT_SPLAT1147]]
+; CHECK-NEXT: [[TMP1174:%.*]] = fadd <1 x float> [[TMP1171]], [[TMP1173]]
+; CHECK-NEXT: [[BLOCK1148:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP848:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1149:%.*]] = insertelement <1 x float> poison, float [[TMP848]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1150:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1149]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1176:%.*]] = fmul <1 x float> [[BLOCK1148]], [[SPLAT_SPLAT1150]]
+; CHECK-NEXT: [[TMP1177:%.*]] = fadd <1 x float> [[TMP1174]], [[TMP1176]]
+; CHECK-NEXT: [[BLOCK1151:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP850:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1152:%.*]] = insertelement <1 x float> poison, float [[TMP850]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1153:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1152]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1179:%.*]] = fmul <1 x float> [[BLOCK1151]], [[SPLAT_SPLAT1153]]
+; CHECK-NEXT: [[TMP851:%.*]] = fadd <1 x float> [[TMP1177]], [[TMP1179]]
+; CHECK-NEXT: [[TMP852:%.*]] = shufflevector <1 x float> [[TMP851]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP853:%.*]] = shufflevector <8 x float> [[TMP835]], <8 x float> [[TMP852]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1154:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP854:%.*]] = extractelement <8 x float> [[TMP5]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1155:%.*]] = insertelement <1 x float> poison, float [[TMP854]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1156:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1155]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1184:%.*]] = fmul <1 x float> [[BLOCK1154]], [[SPLAT_SPLAT1156]]
+; CHECK-NEXT: [[BLOCK1157:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP856:%.*]] = extractelement <8 x float> [[TMP5]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1158:%.*]] = insertelement <1 x float> poison, float [[TMP856]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1159:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1158]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1186:%.*]] = fmul <1 x float> [[BLOCK1157]], [[SPLAT_SPLAT1159]]
+; CHECK-NEXT: [[TMP1187:%.*]] = fadd <1 x float> [[TMP1184]], [[TMP1186]]
+; CHECK-NEXT: [[BLOCK1160:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP858:%.*]] = extractelement <8 x float> [[TMP5]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1161:%.*]] = insertelement <1 x float> poison, float [[TMP858]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1162:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1161]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1189:%.*]] = fmul <1 x float> [[BLOCK1160]], [[SPLAT_SPLAT1162]]
+; CHECK-NEXT: [[TMP1190:%.*]] = fadd <1 x float> [[TMP1187]], [[TMP1189]]
+; CHECK-NEXT: [[BLOCK1163:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP860:%.*]] = extractelement <8 x float> [[TMP5]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1164:%.*]] = insertelement <1 x float> poison, float [[TMP860]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1165:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1164]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1192:%.*]] = fmul <1 x float> [[BLOCK1163]], [[SPLAT_SPLAT1165]]
+; CHECK-NEXT: [[TMP1193:%.*]] = fadd <1 x float> [[TMP1190]], [[TMP1192]]
+; CHECK-NEXT: [[BLOCK1166:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP862:%.*]] = extractelement <8 x float> [[TMP5]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1167:%.*]] = insertelement <1 x float> poison, float [[TMP862]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1168:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1167]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1195:%.*]] = fmul <1 x float> [[BLOCK1166]], [[SPLAT_SPLAT1168]]
+; CHECK-NEXT: [[TMP1196:%.*]] = fadd <1 x float> [[TMP1193]], [[TMP1195]]
+; CHECK-NEXT: [[BLOCK1169:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP864:%.*]] = extractelement <8 x float> [[TMP5]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1170:%.*]] = insertelement <1 x float> poison, float [[TMP864]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1171:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1170]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1198:%.*]] = fmul <1 x float> [[BLOCK1169]], [[SPLAT_SPLAT1171]]
+; CHECK-NEXT: [[TMP1199:%.*]] = fadd <1 x float> [[TMP1196]], [[TMP1198]]
+; CHECK-NEXT: [[BLOCK1172:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP866:%.*]] = extractelement <8 x float> [[TMP5]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1173:%.*]] = insertelement <1 x float> poison, float [[TMP866]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1174:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1173]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1201:%.*]] = fmul <1 x float> [[BLOCK1172]], [[SPLAT_SPLAT1174]]
+; CHECK-NEXT: [[TMP1202:%.*]] = fadd <1 x float> [[TMP1199]], [[TMP1201]]
+; CHECK-NEXT: [[BLOCK1175:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP868:%.*]] = extractelement <8 x float> [[TMP5]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1176:%.*]] = insertelement <1 x float> poison, float [[TMP868]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1177:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1176]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1204:%.*]] = fmul <1 x float> [[BLOCK1175]], [[SPLAT_SPLAT1177]]
+; CHECK-NEXT: [[TMP869:%.*]] = fadd <1 x float> [[TMP1202]], [[TMP1204]]
+; CHECK-NEXT: [[TMP870:%.*]] = shufflevector <1 x float> [[TMP869]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP871:%.*]] = shufflevector <8 x float> [[TMP853]], <8 x float> [[TMP870]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK1178:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP872:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1179:%.*]] = insertelement <1 x float> poison, float [[TMP872]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1180:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1179]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1209:%.*]] = fmul <1 x float> [[BLOCK1178]], [[SPLAT_SPLAT1180]]
+; CHECK-NEXT: [[BLOCK1181:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP874:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1182:%.*]] = insertelement <1 x float> poison, float [[TMP874]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1183:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1182]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1211:%.*]] = fmul <1 x float> [[BLOCK1181]], [[SPLAT_SPLAT1183]]
+; CHECK-NEXT: [[TMP1212:%.*]] = fadd <1 x float> [[TMP1209]], [[TMP1211]]
+; CHECK-NEXT: [[BLOCK1184:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP876:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1185:%.*]] = insertelement <1 x float> poison, float [[TMP876]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1186:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1185]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1214:%.*]] = fmul <1 x float> [[BLOCK1184]], [[SPLAT_SPLAT1186]]
+; CHECK-NEXT: [[TMP1215:%.*]] = fadd <1 x float> [[TMP1212]], [[TMP1214]]
+; CHECK-NEXT: [[BLOCK1187:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP878:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1188:%.*]] = insertelement <1 x float> poison, float [[TMP878]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1189:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1188]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1217:%.*]] = fmul <1 x float> [[BLOCK1187]], [[SPLAT_SPLAT1189]]
+; CHECK-NEXT: [[TMP1218:%.*]] = fadd <1 x float> [[TMP1215]], [[TMP1217]]
+; CHECK-NEXT: [[BLOCK1190:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP880:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1191:%.*]] = insertelement <1 x float> poison, float [[TMP880]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1192:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1191]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1220:%.*]] = fmul <1 x float> [[BLOCK1190]], [[SPLAT_SPLAT1192]]
+; CHECK-NEXT: [[TMP1221:%.*]] = fadd <1 x float> [[TMP1218]], [[TMP1220]]
+; CHECK-NEXT: [[BLOCK1193:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP882:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1194:%.*]] = insertelement <1 x float> poison, float [[TMP882]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1195:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1194]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1223:%.*]] = fmul <1 x float> [[BLOCK1193]], [[SPLAT_SPLAT1195]]
+; CHECK-NEXT: [[TMP1224:%.*]] = fadd <1 x float> [[TMP1221]], [[TMP1223]]
+; CHECK-NEXT: [[BLOCK1196:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP884:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1197:%.*]] = insertelement <1 x float> poison, float [[TMP884]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1198:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1197]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1226:%.*]] = fmul <1 x float> [[BLOCK1196]], [[SPLAT_SPLAT1198]]
+; CHECK-NEXT: [[TMP1227:%.*]] = fadd <1 x float> [[TMP1224]], [[TMP1226]]
+; CHECK-NEXT: [[BLOCK1199:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP886:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1200:%.*]] = insertelement <1 x float> poison, float [[TMP886]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1201:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1200]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1229:%.*]] = fmul <1 x float> [[BLOCK1199]], [[SPLAT_SPLAT1201]]
+; CHECK-NEXT: [[TMP887:%.*]] = fadd <1 x float> [[TMP1227]], [[TMP1229]]
+; CHECK-NEXT: [[TMP888:%.*]] = shufflevector <1 x float> [[TMP887]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP889:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP888]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1202:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP890:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1203:%.*]] = insertelement <1 x float> poison, float [[TMP890]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1204:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1203]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1234:%.*]] = fmul <1 x float> [[BLOCK1202]], [[SPLAT_SPLAT1204]]
+; CHECK-NEXT: [[BLOCK1205:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP892:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1206:%.*]] = insertelement <1 x float> poison, float [[TMP892]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1207:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1206]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1236:%.*]] = fmul <1 x float> [[BLOCK1205]], [[SPLAT_SPLAT1207]]
+; CHECK-NEXT: [[TMP1237:%.*]] = fadd <1 x float> [[TMP1234]], [[TMP1236]]
+; CHECK-NEXT: [[BLOCK1208:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP894:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1209:%.*]] = insertelement <1 x float> poison, float [[TMP894]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1210:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1209]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1239:%.*]] = fmul <1 x float> [[BLOCK1208]], [[SPLAT_SPLAT1210]]
+; CHECK-NEXT: [[TMP1240:%.*]] = fadd <1 x float> [[TMP1237]], [[TMP1239]]
+; CHECK-NEXT: [[BLOCK1211:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP896:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1212:%.*]] = insertelement <1 x float> poison, float [[TMP896]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1213:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1212]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1242:%.*]] = fmul <1 x float> [[BLOCK1211]], [[SPLAT_SPLAT1213]]
+; CHECK-NEXT: [[TMP1243:%.*]] = fadd <1 x float> [[TMP1240]], [[TMP1242]]
+; CHECK-NEXT: [[BLOCK1214:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP898:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1215:%.*]] = insertelement <1 x float> poison, float [[TMP898]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1216:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1215]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1245:%.*]] = fmul <1 x float> [[BLOCK1214]], [[SPLAT_SPLAT1216]]
+; CHECK-NEXT: [[TMP1246:%.*]] = fadd <1 x float> [[TMP1243]], [[TMP1245]]
+; CHECK-NEXT: [[BLOCK1217:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP900:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1218:%.*]] = insertelement <1 x float> poison, float [[TMP900]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1219:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1218]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1248:%.*]] = fmul <1 x float> [[BLOCK1217]], [[SPLAT_SPLAT1219]]
+; CHECK-NEXT: [[TMP1249:%.*]] = fadd <1 x float> [[TMP1246]], [[TMP1248]]
+; CHECK-NEXT: [[BLOCK1220:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP902:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1221:%.*]] = insertelement <1 x float> poison, float [[TMP902]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1222:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1221]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1251:%.*]] = fmul <1 x float> [[BLOCK1220]], [[SPLAT_SPLAT1222]]
+; CHECK-NEXT: [[TMP1252:%.*]] = fadd <1 x float> [[TMP1249]], [[TMP1251]]
+; CHECK-NEXT: [[BLOCK1223:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP904:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1224:%.*]] = insertelement <1 x float> poison, float [[TMP904]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1225:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1224]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1254:%.*]] = fmul <1 x float> [[BLOCK1223]], [[SPLAT_SPLAT1225]]
+; CHECK-NEXT: [[TMP905:%.*]] = fadd <1 x float> [[TMP1252]], [[TMP1254]]
+; CHECK-NEXT: [[TMP906:%.*]] = shufflevector <1 x float> [[TMP905]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP907:%.*]] = shufflevector <8 x float> [[TMP889]], <8 x float> [[TMP906]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1226:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP908:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1227:%.*]] = insertelement <1 x float> poison, float [[TMP908]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1228:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1227]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1259:%.*]] = fmul <1 x float> [[BLOCK1226]], [[SPLAT_SPLAT1228]]
+; CHECK-NEXT: [[BLOCK1229:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP910:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1230:%.*]] = insertelement <1 x float> poison, float [[TMP910]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1231:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1230]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1261:%.*]] = fmul <1 x float> [[BLOCK1229]], [[SPLAT_SPLAT1231]]
+; CHECK-NEXT: [[TMP1262:%.*]] = fadd <1 x float> [[TMP1259]], [[TMP1261]]
+; CHECK-NEXT: [[BLOCK1232:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP912:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1233:%.*]] = insertelement <1 x float> poison, float [[TMP912]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1234:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1233]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1264:%.*]] = fmul <1 x float> [[BLOCK1232]], [[SPLAT_SPLAT1234]]
+; CHECK-NEXT: [[TMP1265:%.*]] = fadd <1 x float> [[TMP1262]], [[TMP1264]]
+; CHECK-NEXT: [[BLOCK1235:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP914:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1236:%.*]] = insertelement <1 x float> poison, float [[TMP914]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1237:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1236]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1267:%.*]] = fmul <1 x float> [[BLOCK1235]], [[SPLAT_SPLAT1237]]
+; CHECK-NEXT: [[TMP1268:%.*]] = fadd <1 x float> [[TMP1265]], [[TMP1267]]
+; CHECK-NEXT: [[BLOCK1238:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP916:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1239:%.*]] = insertelement <1 x float> poison, float [[TMP916]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1240:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1239]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1270:%.*]] = fmul <1 x float> [[BLOCK1238]], [[SPLAT_SPLAT1240]]
+; CHECK-NEXT: [[TMP1271:%.*]] = fadd <1 x float> [[TMP1268]], [[TMP1270]]
+; CHECK-NEXT: [[BLOCK1241:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP918:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1242:%.*]] = insertelement <1 x float> poison, float [[TMP918]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1243:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1242]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1273:%.*]] = fmul <1 x float> [[BLOCK1241]], [[SPLAT_SPLAT1243]]
+; CHECK-NEXT: [[TMP1274:%.*]] = fadd <1 x float> [[TMP1271]], [[TMP1273]]
+; CHECK-NEXT: [[BLOCK1244:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP920:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1245:%.*]] = insertelement <1 x float> poison, float [[TMP920]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1246:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1245]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1276:%.*]] = fmul <1 x float> [[BLOCK1244]], [[SPLAT_SPLAT1246]]
+; CHECK-NEXT: [[TMP1277:%.*]] = fadd <1 x float> [[TMP1274]], [[TMP1276]]
+; CHECK-NEXT: [[BLOCK1247:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP922:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1248:%.*]] = insertelement <1 x float> poison, float [[TMP922]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1249:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1248]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1279:%.*]] = fmul <1 x float> [[BLOCK1247]], [[SPLAT_SPLAT1249]]
+; CHECK-NEXT: [[TMP923:%.*]] = fadd <1 x float> [[TMP1277]], [[TMP1279]]
+; CHECK-NEXT: [[TMP924:%.*]] = shufflevector <1 x float> [[TMP923]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP925:%.*]] = shufflevector <8 x float> [[TMP907]], <8 x float> [[TMP924]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1250:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP926:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1251:%.*]] = insertelement <1 x float> poison, float [[TMP926]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1252:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1251]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1284:%.*]] = fmul <1 x float> [[BLOCK1250]], [[SPLAT_SPLAT1252]]
+; CHECK-NEXT: [[BLOCK1253:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP928:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1254:%.*]] = insertelement <1 x float> poison, float [[TMP928]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1255:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1254]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1286:%.*]] = fmul <1 x float> [[BLOCK1253]], [[SPLAT_SPLAT1255]]
+; CHECK-NEXT: [[TMP1287:%.*]] = fadd <1 x float> [[TMP1284]], [[TMP1286]]
+; CHECK-NEXT: [[BLOCK1256:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP930:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1257:%.*]] = insertelement <1 x float> poison, float [[TMP930]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1258:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1257]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1289:%.*]] = fmul <1 x float> [[BLOCK1256]], [[SPLAT_SPLAT1258]]
+; CHECK-NEXT: [[TMP1290:%.*]] = fadd <1 x float> [[TMP1287]], [[TMP1289]]
+; CHECK-NEXT: [[BLOCK1259:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP932:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1260:%.*]] = insertelement <1 x float> poison, float [[TMP932]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1261:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1260]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1292:%.*]] = fmul <1 x float> [[BLOCK1259]], [[SPLAT_SPLAT1261]]
+; CHECK-NEXT: [[TMP1293:%.*]] = fadd <1 x float> [[TMP1290]], [[TMP1292]]
+; CHECK-NEXT: [[BLOCK1262:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP934:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1263:%.*]] = insertelement <1 x float> poison, float [[TMP934]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1264:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1263]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1295:%.*]] = fmul <1 x float> [[BLOCK1262]], [[SPLAT_SPLAT1264]]
+; CHECK-NEXT: [[TMP1296:%.*]] = fadd <1 x float> [[TMP1293]], [[TMP1295]]
+; CHECK-NEXT: [[BLOCK1265:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP936:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1266:%.*]] = insertelement <1 x float> poison, float [[TMP936]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1267:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1266]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1298:%.*]] = fmul <1 x float> [[BLOCK1265]], [[SPLAT_SPLAT1267]]
+; CHECK-NEXT: [[TMP1299:%.*]] = fadd <1 x float> [[TMP1296]], [[TMP1298]]
+; CHECK-NEXT: [[BLOCK1268:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP938:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1269:%.*]] = insertelement <1 x float> poison, float [[TMP938]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1270:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1269]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1301:%.*]] = fmul <1 x float> [[BLOCK1268]], [[SPLAT_SPLAT1270]]
+; CHECK-NEXT: [[TMP1302:%.*]] = fadd <1 x float> [[TMP1299]], [[TMP1301]]
+; CHECK-NEXT: [[BLOCK1271:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP940:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1272:%.*]] = insertelement <1 x float> poison, float [[TMP940]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1273:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1272]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1304:%.*]] = fmul <1 x float> [[BLOCK1271]], [[SPLAT_SPLAT1273]]
+; CHECK-NEXT: [[TMP941:%.*]] = fadd <1 x float> [[TMP1302]], [[TMP1304]]
+; CHECK-NEXT: [[TMP942:%.*]] = shufflevector <1 x float> [[TMP941]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP943:%.*]] = shufflevector <8 x float> [[TMP925]], <8 x float> [[TMP942]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1274:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP944:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1275:%.*]] = insertelement <1 x float> poison, float [[TMP944]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1276:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1275]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1309:%.*]] = fmul <1 x float> [[BLOCK1274]], [[SPLAT_SPLAT1276]]
+; CHECK-NEXT: [[BLOCK1277:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP946:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1278:%.*]] = insertelement <1 x float> poison, float [[TMP946]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1279:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1278]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1311:%.*]] = fmul <1 x float> [[BLOCK1277]], [[SPLAT_SPLAT1279]]
+; CHECK-NEXT: [[TMP1312:%.*]] = fadd <1 x float> [[TMP1309]], [[TMP1311]]
+; CHECK-NEXT: [[BLOCK1280:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP948:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1281:%.*]] = insertelement <1 x float> poison, float [[TMP948]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1282:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1281]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1314:%.*]] = fmul <1 x float> [[BLOCK1280]], [[SPLAT_SPLAT1282]]
+; CHECK-NEXT: [[TMP1315:%.*]] = fadd <1 x float> [[TMP1312]], [[TMP1314]]
+; CHECK-NEXT: [[BLOCK1283:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP950:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1284:%.*]] = insertelement <1 x float> poison, float [[TMP950]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1285:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1284]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1317:%.*]] = fmul <1 x float> [[BLOCK1283]], [[SPLAT_SPLAT1285]]
+; CHECK-NEXT: [[TMP1318:%.*]] = fadd <1 x float> [[TMP1315]], [[TMP1317]]
+; CHECK-NEXT: [[BLOCK1286:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP952:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1287:%.*]] = insertelement <1 x float> poison, float [[TMP952]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1288:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1287]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1320:%.*]] = fmul <1 x float> [[BLOCK1286]], [[SPLAT_SPLAT1288]]
+; CHECK-NEXT: [[TMP1321:%.*]] = fadd <1 x float> [[TMP1318]], [[TMP1320]]
+; CHECK-NEXT: [[BLOCK1289:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP954:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1290:%.*]] = insertelement <1 x float> poison, float [[TMP954]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1291:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1290]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1323:%.*]] = fmul <1 x float> [[BLOCK1289]], [[SPLAT_SPLAT1291]]
+; CHECK-NEXT: [[TMP1324:%.*]] = fadd <1 x float> [[TMP1321]], [[TMP1323]]
+; CHECK-NEXT: [[BLOCK1292:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP956:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1293:%.*]] = insertelement <1 x float> poison, float [[TMP956]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1294:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1293]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1326:%.*]] = fmul <1 x float> [[BLOCK1292]], [[SPLAT_SPLAT1294]]
+; CHECK-NEXT: [[TMP1327:%.*]] = fadd <1 x float> [[TMP1324]], [[TMP1326]]
+; CHECK-NEXT: [[BLOCK1295:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP958:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1296:%.*]] = insertelement <1 x float> poison, float [[TMP958]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1297:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1296]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1329:%.*]] = fmul <1 x float> [[BLOCK1295]], [[SPLAT_SPLAT1297]]
+; CHECK-NEXT: [[TMP959:%.*]] = fadd <1 x float> [[TMP1327]], [[TMP1329]]
+; CHECK-NEXT: [[TMP960:%.*]] = shufflevector <1 x float> [[TMP959]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP961:%.*]] = shufflevector <8 x float> [[TMP943]], <8 x float> [[TMP960]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1298:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP962:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1299:%.*]] = insertelement <1 x float> poison, float [[TMP962]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1300:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1299]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1334:%.*]] = fmul <1 x float> [[BLOCK1298]], [[SPLAT_SPLAT1300]]
+; CHECK-NEXT: [[BLOCK1301:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP964:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1302:%.*]] = insertelement <1 x float> poison, float [[TMP964]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1303:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1302]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1336:%.*]] = fmul <1 x float> [[BLOCK1301]], [[SPLAT_SPLAT1303]]
+; CHECK-NEXT: [[TMP1337:%.*]] = fadd <1 x float> [[TMP1334]], [[TMP1336]]
+; CHECK-NEXT: [[BLOCK1304:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP966:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1305:%.*]] = insertelement <1 x float> poison, float [[TMP966]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1306:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1305]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1339:%.*]] = fmul <1 x float> [[BLOCK1304]], [[SPLAT_SPLAT1306]]
+; CHECK-NEXT: [[TMP1340:%.*]] = fadd <1 x float> [[TMP1337]], [[TMP1339]]
+; CHECK-NEXT: [[BLOCK1307:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP968:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1308:%.*]] = insertelement <1 x float> poison, float [[TMP968]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1309:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1308]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1342:%.*]] = fmul <1 x float> [[BLOCK1307]], [[SPLAT_SPLAT1309]]
+; CHECK-NEXT: [[TMP1343:%.*]] = fadd <1 x float> [[TMP1340]], [[TMP1342]]
+; CHECK-NEXT: [[BLOCK1310:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP970:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1311:%.*]] = insertelement <1 x float> poison, float [[TMP970]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1312:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1311]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1345:%.*]] = fmul <1 x float> [[BLOCK1310]], [[SPLAT_SPLAT1312]]
+; CHECK-NEXT: [[TMP1346:%.*]] = fadd <1 x float> [[TMP1343]], [[TMP1345]]
+; CHECK-NEXT: [[BLOCK1313:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP972:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1314:%.*]] = insertelement <1 x float> poison, float [[TMP972]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1315:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1314]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1348:%.*]] = fmul <1 x float> [[BLOCK1313]], [[SPLAT_SPLAT1315]]
+; CHECK-NEXT: [[TMP1349:%.*]] = fadd <1 x float> [[TMP1346]], [[TMP1348]]
+; CHECK-NEXT: [[BLOCK1316:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP974:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1317:%.*]] = insertelement <1 x float> poison, float [[TMP974]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1318:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1317]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1351:%.*]] = fmul <1 x float> [[BLOCK1316]], [[SPLAT_SPLAT1318]]
+; CHECK-NEXT: [[TMP1352:%.*]] = fadd <1 x float> [[TMP1349]], [[TMP1351]]
+; CHECK-NEXT: [[BLOCK1319:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP976:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1320:%.*]] = insertelement <1 x float> poison, float [[TMP976]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1321:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1320]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1354:%.*]] = fmul <1 x float> [[BLOCK1319]], [[SPLAT_SPLAT1321]]
+; CHECK-NEXT: [[TMP977:%.*]] = fadd <1 x float> [[TMP1352]], [[TMP1354]]
+; CHECK-NEXT: [[TMP978:%.*]] = shufflevector <1 x float> [[TMP977]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP979:%.*]] = shufflevector <8 x float> [[TMP961]], <8 x float> [[TMP978]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1322:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP980:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1323:%.*]] = insertelement <1 x float> poison, float [[TMP980]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1324:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1323]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1359:%.*]] = fmul <1 x float> [[BLOCK1322]], [[SPLAT_SPLAT1324]]
+; CHECK-NEXT: [[BLOCK1325:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP982:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1326:%.*]] = insertelement <1 x float> poison, float [[TMP982]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1327:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1326]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1361:%.*]] = fmul <1 x float> [[BLOCK1325]], [[SPLAT_SPLAT1327]]
+; CHECK-NEXT: [[TMP1362:%.*]] = fadd <1 x float> [[TMP1359]], [[TMP1361]]
+; CHECK-NEXT: [[BLOCK1328:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP984:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1329:%.*]] = insertelement <1 x float> poison, float [[TMP984]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1330:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1329]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1364:%.*]] = fmul <1 x float> [[BLOCK1328]], [[SPLAT_SPLAT1330]]
+; CHECK-NEXT: [[TMP1365:%.*]] = fadd <1 x float> [[TMP1362]], [[TMP1364]]
+; CHECK-NEXT: [[BLOCK1331:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP986:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1332:%.*]] = insertelement <1 x float> poison, float [[TMP986]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1333:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1332]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1367:%.*]] = fmul <1 x float> [[BLOCK1331]], [[SPLAT_SPLAT1333]]
+; CHECK-NEXT: [[TMP1368:%.*]] = fadd <1 x float> [[TMP1365]], [[TMP1367]]
+; CHECK-NEXT: [[BLOCK1334:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP988:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1335:%.*]] = insertelement <1 x float> poison, float [[TMP988]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1336:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1335]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1370:%.*]] = fmul <1 x float> [[BLOCK1334]], [[SPLAT_SPLAT1336]]
+; CHECK-NEXT: [[TMP1371:%.*]] = fadd <1 x float> [[TMP1368]], [[TMP1370]]
+; CHECK-NEXT: [[BLOCK1337:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP990:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1338:%.*]] = insertelement <1 x float> poison, float [[TMP990]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1339:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1338]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1373:%.*]] = fmul <1 x float> [[BLOCK1337]], [[SPLAT_SPLAT1339]]
+; CHECK-NEXT: [[TMP1374:%.*]] = fadd <1 x float> [[TMP1371]], [[TMP1373]]
+; CHECK-NEXT: [[BLOCK1340:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP992:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1341:%.*]] = insertelement <1 x float> poison, float [[TMP992]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1342:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1341]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1376:%.*]] = fmul <1 x float> [[BLOCK1340]], [[SPLAT_SPLAT1342]]
+; CHECK-NEXT: [[TMP1377:%.*]] = fadd <1 x float> [[TMP1374]], [[TMP1376]]
+; CHECK-NEXT: [[BLOCK1343:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP994:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1344:%.*]] = insertelement <1 x float> poison, float [[TMP994]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1345:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1344]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1379:%.*]] = fmul <1 x float> [[BLOCK1343]], [[SPLAT_SPLAT1345]]
+; CHECK-NEXT: [[TMP995:%.*]] = fadd <1 x float> [[TMP1377]], [[TMP1379]]
+; CHECK-NEXT: [[TMP996:%.*]] = shufflevector <1 x float> [[TMP995]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP997:%.*]] = shufflevector <8 x float> [[TMP979]], <8 x float> [[TMP996]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1346:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP998:%.*]] = extractelement <8 x float> [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1347:%.*]] = insertelement <1 x float> poison, float [[TMP998]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1348:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1347]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1384:%.*]] = fmul <1 x float> [[BLOCK1346]], [[SPLAT_SPLAT1348]]
+; CHECK-NEXT: [[BLOCK1349:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1000:%.*]] = extractelement <8 x float> [[TMP6]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1350:%.*]] = insertelement <1 x float> poison, float [[TMP1000]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1351:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1350]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1386:%.*]] = fmul <1 x float> [[BLOCK1349]], [[SPLAT_SPLAT1351]]
+; CHECK-NEXT: [[TMP1387:%.*]] = fadd <1 x float> [[TMP1384]], [[TMP1386]]
+; CHECK-NEXT: [[BLOCK1352:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1002:%.*]] = extractelement <8 x float> [[TMP6]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1353:%.*]] = insertelement <1 x float> poison, float [[TMP1002]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1354:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1353]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1389:%.*]] = fmul <1 x float> [[BLOCK1352]], [[SPLAT_SPLAT1354]]
+; CHECK-NEXT: [[TMP1390:%.*]] = fadd <1 x float> [[TMP1387]], [[TMP1389]]
+; CHECK-NEXT: [[BLOCK1355:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1004:%.*]] = extractelement <8 x float> [[TMP6]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1356:%.*]] = insertelement <1 x float> poison, float [[TMP1004]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1357:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1356]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1392:%.*]] = fmul <1 x float> [[BLOCK1355]], [[SPLAT_SPLAT1357]]
+; CHECK-NEXT: [[TMP1393:%.*]] = fadd <1 x float> [[TMP1390]], [[TMP1392]]
+; CHECK-NEXT: [[BLOCK1358:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1006:%.*]] = extractelement <8 x float> [[TMP6]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1359:%.*]] = insertelement <1 x float> poison, float [[TMP1006]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1360:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1359]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1395:%.*]] = fmul <1 x float> [[BLOCK1358]], [[SPLAT_SPLAT1360]]
+; CHECK-NEXT: [[TMP1396:%.*]] = fadd <1 x float> [[TMP1393]], [[TMP1395]]
+; CHECK-NEXT: [[BLOCK1361:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1008:%.*]] = extractelement <8 x float> [[TMP6]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1362:%.*]] = insertelement <1 x float> poison, float [[TMP1008]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1363:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1362]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1398:%.*]] = fmul <1 x float> [[BLOCK1361]], [[SPLAT_SPLAT1363]]
+; CHECK-NEXT: [[TMP1399:%.*]] = fadd <1 x float> [[TMP1396]], [[TMP1398]]
+; CHECK-NEXT: [[BLOCK1364:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1010:%.*]] = extractelement <8 x float> [[TMP6]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1365:%.*]] = insertelement <1 x float> poison, float [[TMP1010]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1366:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1365]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1401:%.*]] = fmul <1 x float> [[BLOCK1364]], [[SPLAT_SPLAT1366]]
+; CHECK-NEXT: [[TMP1402:%.*]] = fadd <1 x float> [[TMP1399]], [[TMP1401]]
+; CHECK-NEXT: [[BLOCK1367:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1012:%.*]] = extractelement <8 x float> [[TMP6]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1368:%.*]] = insertelement <1 x float> poison, float [[TMP1012]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1369:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1368]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1404:%.*]] = fmul <1 x float> [[BLOCK1367]], [[SPLAT_SPLAT1369]]
+; CHECK-NEXT: [[TMP1013:%.*]] = fadd <1 x float> [[TMP1402]], [[TMP1404]]
+; CHECK-NEXT: [[TMP1014:%.*]] = shufflevector <1 x float> [[TMP1013]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1015:%.*]] = shufflevector <8 x float> [[TMP997]], <8 x float> [[TMP1014]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK1370:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1016:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1371:%.*]] = insertelement <1 x float> poison, float [[TMP1016]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1372:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1371]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1409:%.*]] = fmul <1 x float> [[BLOCK1370]], [[SPLAT_SPLAT1372]]
+; CHECK-NEXT: [[BLOCK1373:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1018:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1374:%.*]] = insertelement <1 x float> poison, float [[TMP1018]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1375:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1374]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1411:%.*]] = fmul <1 x float> [[BLOCK1373]], [[SPLAT_SPLAT1375]]
+; CHECK-NEXT: [[TMP1412:%.*]] = fadd <1 x float> [[TMP1409]], [[TMP1411]]
+; CHECK-NEXT: [[BLOCK1376:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1020:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1377:%.*]] = insertelement <1 x float> poison, float [[TMP1020]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1378:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1377]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1414:%.*]] = fmul <1 x float> [[BLOCK1376]], [[SPLAT_SPLAT1378]]
+; CHECK-NEXT: [[TMP1415:%.*]] = fadd <1 x float> [[TMP1412]], [[TMP1414]]
+; CHECK-NEXT: [[BLOCK1379:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1022:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1380:%.*]] = insertelement <1 x float> poison, float [[TMP1022]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1381:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1380]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1417:%.*]] = fmul <1 x float> [[BLOCK1379]], [[SPLAT_SPLAT1381]]
+; CHECK-NEXT: [[TMP1418:%.*]] = fadd <1 x float> [[TMP1415]], [[TMP1417]]
+; CHECK-NEXT: [[BLOCK1382:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1024:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1383:%.*]] = insertelement <1 x float> poison, float [[TMP1024]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1384:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1383]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1420:%.*]] = fmul <1 x float> [[BLOCK1382]], [[SPLAT_SPLAT1384]]
+; CHECK-NEXT: [[TMP1421:%.*]] = fadd <1 x float> [[TMP1418]], [[TMP1420]]
+; CHECK-NEXT: [[BLOCK1385:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1026:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1386:%.*]] = insertelement <1 x float> poison, float [[TMP1026]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1387:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1386]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1423:%.*]] = fmul <1 x float> [[BLOCK1385]], [[SPLAT_SPLAT1387]]
+; CHECK-NEXT: [[TMP1424:%.*]] = fadd <1 x float> [[TMP1421]], [[TMP1423]]
+; CHECK-NEXT: [[BLOCK1388:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1028:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1389:%.*]] = insertelement <1 x float> poison, float [[TMP1028]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1390:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1389]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1426:%.*]] = fmul <1 x float> [[BLOCK1388]], [[SPLAT_SPLAT1390]]
+; CHECK-NEXT: [[TMP1427:%.*]] = fadd <1 x float> [[TMP1424]], [[TMP1426]]
+; CHECK-NEXT: [[BLOCK1391:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1030:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1392:%.*]] = insertelement <1 x float> poison, float [[TMP1030]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1393:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1392]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1429:%.*]] = fmul <1 x float> [[BLOCK1391]], [[SPLAT_SPLAT1393]]
+; CHECK-NEXT: [[TMP1031:%.*]] = fadd <1 x float> [[TMP1427]], [[TMP1429]]
+; CHECK-NEXT: [[TMP1032:%.*]] = shufflevector <1 x float> [[TMP1031]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1033:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP1032]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1394:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1034:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1395:%.*]] = insertelement <1 x float> poison, float [[TMP1034]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1396:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1395]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1434:%.*]] = fmul <1 x float> [[BLOCK1394]], [[SPLAT_SPLAT1396]]
+; CHECK-NEXT: [[BLOCK1397:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1036:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1398:%.*]] = insertelement <1 x float> poison, float [[TMP1036]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1399:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1398]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1436:%.*]] = fmul <1 x float> [[BLOCK1397]], [[SPLAT_SPLAT1399]]
+; CHECK-NEXT: [[TMP1437:%.*]] = fadd <1 x float> [[TMP1434]], [[TMP1436]]
+; CHECK-NEXT: [[BLOCK1400:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1038:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1401:%.*]] = insertelement <1 x float> poison, float [[TMP1038]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1402:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1401]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1439:%.*]] = fmul <1 x float> [[BLOCK1400]], [[SPLAT_SPLAT1402]]
+; CHECK-NEXT: [[TMP1440:%.*]] = fadd <1 x float> [[TMP1437]], [[TMP1439]]
+; CHECK-NEXT: [[BLOCK1403:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1040:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1404:%.*]] = insertelement <1 x float> poison, float [[TMP1040]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1405:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1404]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1442:%.*]] = fmul <1 x float> [[BLOCK1403]], [[SPLAT_SPLAT1405]]
+; CHECK-NEXT: [[TMP1443:%.*]] = fadd <1 x float> [[TMP1440]], [[TMP1442]]
+; CHECK-NEXT: [[BLOCK1406:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1042:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1407:%.*]] = insertelement <1 x float> poison, float [[TMP1042]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1408:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1407]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1445:%.*]] = fmul <1 x float> [[BLOCK1406]], [[SPLAT_SPLAT1408]]
+; CHECK-NEXT: [[TMP1446:%.*]] = fadd <1 x float> [[TMP1443]], [[TMP1445]]
+; CHECK-NEXT: [[BLOCK1409:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1044:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1410:%.*]] = insertelement <1 x float> poison, float [[TMP1044]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1411:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1410]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1448:%.*]] = fmul <1 x float> [[BLOCK1409]], [[SPLAT_SPLAT1411]]
+; CHECK-NEXT: [[TMP1449:%.*]] = fadd <1 x float> [[TMP1446]], [[TMP1448]]
+; CHECK-NEXT: [[BLOCK1412:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1046:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1413:%.*]] = insertelement <1 x float> poison, float [[TMP1046]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1414:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1413]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1451:%.*]] = fmul <1 x float> [[BLOCK1412]], [[SPLAT_SPLAT1414]]
+; CHECK-NEXT: [[TMP1452:%.*]] = fadd <1 x float> [[TMP1449]], [[TMP1451]]
+; CHECK-NEXT: [[BLOCK1415:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1048:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1416:%.*]] = insertelement <1 x float> poison, float [[TMP1048]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1417:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1416]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1454:%.*]] = fmul <1 x float> [[BLOCK1415]], [[SPLAT_SPLAT1417]]
+; CHECK-NEXT: [[TMP1049:%.*]] = fadd <1 x float> [[TMP1452]], [[TMP1454]]
+; CHECK-NEXT: [[TMP1050:%.*]] = shufflevector <1 x float> [[TMP1049]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1051:%.*]] = shufflevector <8 x float> [[TMP1033]], <8 x float> [[TMP1050]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1418:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1052:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1419:%.*]] = insertelement <1 x float> poison, float [[TMP1052]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1420:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1419]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1459:%.*]] = fmul <1 x float> [[BLOCK1418]], [[SPLAT_SPLAT1420]]
+; CHECK-NEXT: [[BLOCK1421:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1054:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1422:%.*]] = insertelement <1 x float> poison, float [[TMP1054]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1423:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1422]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1461:%.*]] = fmul <1 x float> [[BLOCK1421]], [[SPLAT_SPLAT1423]]
+; CHECK-NEXT: [[TMP1462:%.*]] = fadd <1 x float> [[TMP1459]], [[TMP1461]]
+; CHECK-NEXT: [[BLOCK1424:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1056:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1425:%.*]] = insertelement <1 x float> poison, float [[TMP1056]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1426:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1425]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1464:%.*]] = fmul <1 x float> [[BLOCK1424]], [[SPLAT_SPLAT1426]]
+; CHECK-NEXT: [[TMP1465:%.*]] = fadd <1 x float> [[TMP1462]], [[TMP1464]]
+; CHECK-NEXT: [[BLOCK1427:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1058:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1428:%.*]] = insertelement <1 x float> poison, float [[TMP1058]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1429:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1428]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1467:%.*]] = fmul <1 x float> [[BLOCK1427]], [[SPLAT_SPLAT1429]]
+; CHECK-NEXT: [[TMP1468:%.*]] = fadd <1 x float> [[TMP1465]], [[TMP1467]]
+; CHECK-NEXT: [[BLOCK1430:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1060:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1431:%.*]] = insertelement <1 x float> poison, float [[TMP1060]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1432:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1431]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1470:%.*]] = fmul <1 x float> [[BLOCK1430]], [[SPLAT_SPLAT1432]]
+; CHECK-NEXT: [[TMP1471:%.*]] = fadd <1 x float> [[TMP1468]], [[TMP1470]]
+; CHECK-NEXT: [[BLOCK1433:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1062:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1434:%.*]] = insertelement <1 x float> poison, float [[TMP1062]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1435:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1434]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1473:%.*]] = fmul <1 x float> [[BLOCK1433]], [[SPLAT_SPLAT1435]]
+; CHECK-NEXT: [[TMP1474:%.*]] = fadd <1 x float> [[TMP1471]], [[TMP1473]]
+; CHECK-NEXT: [[BLOCK1436:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1064:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1437:%.*]] = insertelement <1 x float> poison, float [[TMP1064]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1438:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1437]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1476:%.*]] = fmul <1 x float> [[BLOCK1436]], [[SPLAT_SPLAT1438]]
+; CHECK-NEXT: [[TMP1477:%.*]] = fadd <1 x float> [[TMP1474]], [[TMP1476]]
+; CHECK-NEXT: [[BLOCK1439:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1066:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1440:%.*]] = insertelement <1 x float> poison, float [[TMP1066]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1441:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1440]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1479:%.*]] = fmul <1 x float> [[BLOCK1439]], [[SPLAT_SPLAT1441]]
+; CHECK-NEXT: [[TMP1067:%.*]] = fadd <1 x float> [[TMP1477]], [[TMP1479]]
+; CHECK-NEXT: [[TMP1068:%.*]] = shufflevector <1 x float> [[TMP1067]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1069:%.*]] = shufflevector <8 x float> [[TMP1051]], <8 x float> [[TMP1068]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1442:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1070:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1443:%.*]] = insertelement <1 x float> poison, float [[TMP1070]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1444:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1443]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1484:%.*]] = fmul <1 x float> [[BLOCK1442]], [[SPLAT_SPLAT1444]]
+; CHECK-NEXT: [[BLOCK1445:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1072:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1446:%.*]] = insertelement <1 x float> poison, float [[TMP1072]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1447:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1446]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1486:%.*]] = fmul <1 x float> [[BLOCK1445]], [[SPLAT_SPLAT1447]]
+; CHECK-NEXT: [[TMP1487:%.*]] = fadd <1 x float> [[TMP1484]], [[TMP1486]]
+; CHECK-NEXT: [[BLOCK1448:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1074:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1449:%.*]] = insertelement <1 x float> poison, float [[TMP1074]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1450:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1449]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1489:%.*]] = fmul <1 x float> [[BLOCK1448]], [[SPLAT_SPLAT1450]]
+; CHECK-NEXT: [[TMP1490:%.*]] = fadd <1 x float> [[TMP1487]], [[TMP1489]]
+; CHECK-NEXT: [[BLOCK1451:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1076:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1452:%.*]] = insertelement <1 x float> poison, float [[TMP1076]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1453:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1452]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1492:%.*]] = fmul <1 x float> [[BLOCK1451]], [[SPLAT_SPLAT1453]]
+; CHECK-NEXT: [[TMP1493:%.*]] = fadd <1 x float> [[TMP1490]], [[TMP1492]]
+; CHECK-NEXT: [[BLOCK1454:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1078:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1455:%.*]] = insertelement <1 x float> poison, float [[TMP1078]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1456:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1455]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1495:%.*]] = fmul <1 x float> [[BLOCK1454]], [[SPLAT_SPLAT1456]]
+; CHECK-NEXT: [[TMP1496:%.*]] = fadd <1 x float> [[TMP1493]], [[TMP1495]]
+; CHECK-NEXT: [[BLOCK1457:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1080:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1458:%.*]] = insertelement <1 x float> poison, float [[TMP1080]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1459:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1458]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1498:%.*]] = fmul <1 x float> [[BLOCK1457]], [[SPLAT_SPLAT1459]]
+; CHECK-NEXT: [[TMP1499:%.*]] = fadd <1 x float> [[TMP1496]], [[TMP1498]]
+; CHECK-NEXT: [[BLOCK1460:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1082:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1461:%.*]] = insertelement <1 x float> poison, float [[TMP1082]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1462:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1461]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1501:%.*]] = fmul <1 x float> [[BLOCK1460]], [[SPLAT_SPLAT1462]]
+; CHECK-NEXT: [[TMP1502:%.*]] = fadd <1 x float> [[TMP1499]], [[TMP1501]]
+; CHECK-NEXT: [[BLOCK1463:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1084:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1464:%.*]] = insertelement <1 x float> poison, float [[TMP1084]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1465:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1464]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1504:%.*]] = fmul <1 x float> [[BLOCK1463]], [[SPLAT_SPLAT1465]]
+; CHECK-NEXT: [[TMP1085:%.*]] = fadd <1 x float> [[TMP1502]], [[TMP1504]]
+; CHECK-NEXT: [[TMP1086:%.*]] = shufflevector <1 x float> [[TMP1085]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1087:%.*]] = shufflevector <8 x float> [[TMP1069]], <8 x float> [[TMP1086]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1466:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1088:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1467:%.*]] = insertelement <1 x float> poison, float [[TMP1088]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1468:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1467]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1509:%.*]] = fmul <1 x float> [[BLOCK1466]], [[SPLAT_SPLAT1468]]
+; CHECK-NEXT: [[BLOCK1469:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1090:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1470:%.*]] = insertelement <1 x float> poison, float [[TMP1090]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1471:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1470]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1511:%.*]] = fmul <1 x float> [[BLOCK1469]], [[SPLAT_SPLAT1471]]
+; CHECK-NEXT: [[TMP1512:%.*]] = fadd <1 x float> [[TMP1509]], [[TMP1511]]
+; CHECK-NEXT: [[BLOCK1472:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1092:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1473:%.*]] = insertelement <1 x float> poison, float [[TMP1092]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1474:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1473]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1514:%.*]] = fmul <1 x float> [[BLOCK1472]], [[SPLAT_SPLAT1474]]
+; CHECK-NEXT: [[TMP1515:%.*]] = fadd <1 x float> [[TMP1512]], [[TMP1514]]
+; CHECK-NEXT: [[BLOCK1475:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1094:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1476:%.*]] = insertelement <1 x float> poison, float [[TMP1094]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1477:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1476]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1517:%.*]] = fmul <1 x float> [[BLOCK1475]], [[SPLAT_SPLAT1477]]
+; CHECK-NEXT: [[TMP1518:%.*]] = fadd <1 x float> [[TMP1515]], [[TMP1517]]
+; CHECK-NEXT: [[BLOCK1478:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1096:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1479:%.*]] = insertelement <1 x float> poison, float [[TMP1096]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1480:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1479]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1520:%.*]] = fmul <1 x float> [[BLOCK1478]], [[SPLAT_SPLAT1480]]
+; CHECK-NEXT: [[TMP1521:%.*]] = fadd <1 x float> [[TMP1518]], [[TMP1520]]
+; CHECK-NEXT: [[BLOCK1481:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1098:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1482:%.*]] = insertelement <1 x float> poison, float [[TMP1098]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1483:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1482]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1523:%.*]] = fmul <1 x float> [[BLOCK1481]], [[SPLAT_SPLAT1483]]
+; CHECK-NEXT: [[TMP1524:%.*]] = fadd <1 x float> [[TMP1521]], [[TMP1523]]
+; CHECK-NEXT: [[BLOCK1484:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1100:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1485:%.*]] = insertelement <1 x float> poison, float [[TMP1100]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1486:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1485]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1526:%.*]] = fmul <1 x float> [[BLOCK1484]], [[SPLAT_SPLAT1486]]
+; CHECK-NEXT: [[TMP1527:%.*]] = fadd <1 x float> [[TMP1524]], [[TMP1526]]
+; CHECK-NEXT: [[BLOCK1487:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1102:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1488:%.*]] = insertelement <1 x float> poison, float [[TMP1102]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1489:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1488]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1529:%.*]] = fmul <1 x float> [[BLOCK1487]], [[SPLAT_SPLAT1489]]
+; CHECK-NEXT: [[TMP1103:%.*]] = fadd <1 x float> [[TMP1527]], [[TMP1529]]
+; CHECK-NEXT: [[TMP1104:%.*]] = shufflevector <1 x float> [[TMP1103]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1105:%.*]] = shufflevector <8 x float> [[TMP1087]], <8 x float> [[TMP1104]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1490:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1106:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1491:%.*]] = insertelement <1 x float> poison, float [[TMP1106]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1492:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1491]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1534:%.*]] = fmul <1 x float> [[BLOCK1490]], [[SPLAT_SPLAT1492]]
+; CHECK-NEXT: [[BLOCK1493:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1108:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1494:%.*]] = insertelement <1 x float> poison, float [[TMP1108]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1495:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1494]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1536:%.*]] = fmul <1 x float> [[BLOCK1493]], [[SPLAT_SPLAT1495]]
+; CHECK-NEXT: [[TMP1537:%.*]] = fadd <1 x float> [[TMP1534]], [[TMP1536]]
+; CHECK-NEXT: [[BLOCK1496:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1110:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1497:%.*]] = insertelement <1 x float> poison, float [[TMP1110]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1498:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1497]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1539:%.*]] = fmul <1 x float> [[BLOCK1496]], [[SPLAT_SPLAT1498]]
+; CHECK-NEXT: [[TMP1540:%.*]] = fadd <1 x float> [[TMP1537]], [[TMP1539]]
+; CHECK-NEXT: [[BLOCK1499:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1112:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1500:%.*]] = insertelement <1 x float> poison, float [[TMP1112]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1501:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1500]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1542:%.*]] = fmul <1 x float> [[BLOCK1499]], [[SPLAT_SPLAT1501]]
+; CHECK-NEXT: [[TMP1543:%.*]] = fadd <1 x float> [[TMP1540]], [[TMP1542]]
+; CHECK-NEXT: [[BLOCK1502:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1114:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1503:%.*]] = insertelement <1 x float> poison, float [[TMP1114]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1504:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1503]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1545:%.*]] = fmul <1 x float> [[BLOCK1502]], [[SPLAT_SPLAT1504]]
+; CHECK-NEXT: [[TMP1546:%.*]] = fadd <1 x float> [[TMP1543]], [[TMP1545]]
+; CHECK-NEXT: [[BLOCK1505:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1116:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1506:%.*]] = insertelement <1 x float> poison, float [[TMP1116]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1507:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1506]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1548:%.*]] = fmul <1 x float> [[BLOCK1505]], [[SPLAT_SPLAT1507]]
+; CHECK-NEXT: [[TMP1549:%.*]] = fadd <1 x float> [[TMP1546]], [[TMP1548]]
+; CHECK-NEXT: [[BLOCK1508:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1118:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1509:%.*]] = insertelement <1 x float> poison, float [[TMP1118]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1510:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1509]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1551:%.*]] = fmul <1 x float> [[BLOCK1508]], [[SPLAT_SPLAT1510]]
+; CHECK-NEXT: [[TMP1552:%.*]] = fadd <1 x float> [[TMP1549]], [[TMP1551]]
+; CHECK-NEXT: [[BLOCK1511:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1120:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1512:%.*]] = insertelement <1 x float> poison, float [[TMP1120]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1513:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1512]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1554:%.*]] = fmul <1 x float> [[BLOCK1511]], [[SPLAT_SPLAT1513]]
+; CHECK-NEXT: [[TMP1121:%.*]] = fadd <1 x float> [[TMP1552]], [[TMP1554]]
+; CHECK-NEXT: [[TMP1122:%.*]] = shufflevector <1 x float> [[TMP1121]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1123:%.*]] = shufflevector <8 x float> [[TMP1105]], <8 x float> [[TMP1122]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1514:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1124:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1515:%.*]] = insertelement <1 x float> poison, float [[TMP1124]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1516:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1515]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1559:%.*]] = fmul <1 x float> [[BLOCK1514]], [[SPLAT_SPLAT1516]]
+; CHECK-NEXT: [[BLOCK1517:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1126:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1518:%.*]] = insertelement <1 x float> poison, float [[TMP1126]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1519:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1518]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1561:%.*]] = fmul <1 x float> [[BLOCK1517]], [[SPLAT_SPLAT1519]]
+; CHECK-NEXT: [[TMP1562:%.*]] = fadd <1 x float> [[TMP1559]], [[TMP1561]]
+; CHECK-NEXT: [[BLOCK1520:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1128:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1521:%.*]] = insertelement <1 x float> poison, float [[TMP1128]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1522:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1521]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1564:%.*]] = fmul <1 x float> [[BLOCK1520]], [[SPLAT_SPLAT1522]]
+; CHECK-NEXT: [[TMP1565:%.*]] = fadd <1 x float> [[TMP1562]], [[TMP1564]]
+; CHECK-NEXT: [[BLOCK1523:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1130:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1524:%.*]] = insertelement <1 x float> poison, float [[TMP1130]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1525:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1524]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1567:%.*]] = fmul <1 x float> [[BLOCK1523]], [[SPLAT_SPLAT1525]]
+; CHECK-NEXT: [[TMP1568:%.*]] = fadd <1 x float> [[TMP1565]], [[TMP1567]]
+; CHECK-NEXT: [[BLOCK1526:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1132:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1527:%.*]] = insertelement <1 x float> poison, float [[TMP1132]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1528:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1527]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1570:%.*]] = fmul <1 x float> [[BLOCK1526]], [[SPLAT_SPLAT1528]]
+; CHECK-NEXT: [[TMP1571:%.*]] = fadd <1 x float> [[TMP1568]], [[TMP1570]]
+; CHECK-NEXT: [[BLOCK1529:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1134:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1530:%.*]] = insertelement <1 x float> poison, float [[TMP1134]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1531:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1530]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1573:%.*]] = fmul <1 x float> [[BLOCK1529]], [[SPLAT_SPLAT1531]]
+; CHECK-NEXT: [[TMP1574:%.*]] = fadd <1 x float> [[TMP1571]], [[TMP1573]]
+; CHECK-NEXT: [[BLOCK1532:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1136:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1533:%.*]] = insertelement <1 x float> poison, float [[TMP1136]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1534:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1533]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1576:%.*]] = fmul <1 x float> [[BLOCK1532]], [[SPLAT_SPLAT1534]]
+; CHECK-NEXT: [[TMP1577:%.*]] = fadd <1 x float> [[TMP1574]], [[TMP1576]]
+; CHECK-NEXT: [[BLOCK1535:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1138:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1536:%.*]] = insertelement <1 x float> poison, float [[TMP1138]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1537:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1536]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1579:%.*]] = fmul <1 x float> [[BLOCK1535]], [[SPLAT_SPLAT1537]]
+; CHECK-NEXT: [[TMP1139:%.*]] = fadd <1 x float> [[TMP1577]], [[TMP1579]]
+; CHECK-NEXT: [[TMP1140:%.*]] = shufflevector <1 x float> [[TMP1139]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1141:%.*]] = shufflevector <8 x float> [[TMP1123]], <8 x float> [[TMP1140]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1538:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1142:%.*]] = extractelement <8 x float> [[TMP7]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1539:%.*]] = insertelement <1 x float> poison, float [[TMP1142]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1540:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1539]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1584:%.*]] = fmul <1 x float> [[BLOCK1538]], [[SPLAT_SPLAT1540]]
+; CHECK-NEXT: [[BLOCK1541:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1144:%.*]] = extractelement <8 x float> [[TMP7]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1542:%.*]] = insertelement <1 x float> poison, float [[TMP1144]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1543:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1542]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1586:%.*]] = fmul <1 x float> [[BLOCK1541]], [[SPLAT_SPLAT1543]]
+; CHECK-NEXT: [[TMP1587:%.*]] = fadd <1 x float> [[TMP1584]], [[TMP1586]]
+; CHECK-NEXT: [[BLOCK1544:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1146:%.*]] = extractelement <8 x float> [[TMP7]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1545:%.*]] = insertelement <1 x float> poison, float [[TMP1146]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1546:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1545]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1589:%.*]] = fmul <1 x float> [[BLOCK1544]], [[SPLAT_SPLAT1546]]
+; CHECK-NEXT: [[TMP1590:%.*]] = fadd <1 x float> [[TMP1587]], [[TMP1589]]
+; CHECK-NEXT: [[BLOCK1547:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1148:%.*]] = extractelement <8 x float> [[TMP7]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1548:%.*]] = insertelement <1 x float> poison, float [[TMP1148]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1549:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1548]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1592:%.*]] = fmul <1 x float> [[BLOCK1547]], [[SPLAT_SPLAT1549]]
+; CHECK-NEXT: [[TMP1593:%.*]] = fadd <1 x float> [[TMP1590]], [[TMP1592]]
+; CHECK-NEXT: [[BLOCK1550:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1150:%.*]] = extractelement <8 x float> [[TMP7]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1551:%.*]] = insertelement <1 x float> poison, float [[TMP1150]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1552:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1551]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1595:%.*]] = fmul <1 x float> [[BLOCK1550]], [[SPLAT_SPLAT1552]]
+; CHECK-NEXT: [[TMP1596:%.*]] = fadd <1 x float> [[TMP1593]], [[TMP1595]]
+; CHECK-NEXT: [[BLOCK1553:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1152:%.*]] = extractelement <8 x float> [[TMP7]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1554:%.*]] = insertelement <1 x float> poison, float [[TMP1152]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1555:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1554]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1598:%.*]] = fmul <1 x float> [[BLOCK1553]], [[SPLAT_SPLAT1555]]
+; CHECK-NEXT: [[TMP1599:%.*]] = fadd <1 x float> [[TMP1596]], [[TMP1598]]
+; CHECK-NEXT: [[BLOCK1556:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1154:%.*]] = extractelement <8 x float> [[TMP7]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1557:%.*]] = insertelement <1 x float> poison, float [[TMP1154]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1558:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1557]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1601:%.*]] = fmul <1 x float> [[BLOCK1556]], [[SPLAT_SPLAT1558]]
+; CHECK-NEXT: [[TMP1602:%.*]] = fadd <1 x float> [[TMP1599]], [[TMP1601]]
+; CHECK-NEXT: [[BLOCK1559:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1156:%.*]] = extractelement <8 x float> [[TMP7]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1560:%.*]] = insertelement <1 x float> poison, float [[TMP1156]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1561:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1560]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1604:%.*]] = fmul <1 x float> [[BLOCK1559]], [[SPLAT_SPLAT1561]]
+; CHECK-NEXT: [[TMP1157:%.*]] = fadd <1 x float> [[TMP1602]], [[TMP1604]]
+; CHECK-NEXT: [[TMP1158:%.*]] = shufflevector <1 x float> [[TMP1157]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1159:%.*]] = shufflevector <8 x float> [[TMP1141]], <8 x float> [[TMP1158]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: store <8 x float> [[TMP151]], ptr [[C:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP1562:%.*]] = getelementptr inbounds float, ptr [[C]], i64 8
+; CHECK-NEXT: store <8 x float> [[TMP295]], ptr [[VEC_GEP1562]], align 16
+; CHECK-NEXT: [[VEC_GEP1563:%.*]] = getelementptr inbounds float, ptr [[C]], i64 16
+; CHECK-NEXT: store <8 x float> [[TMP439]], ptr [[VEC_GEP1563]], align 16
+; CHECK-NEXT: [[VEC_GEP1564:%.*]] = getelementptr inbounds float, ptr [[C]], i64 24
+; CHECK-NEXT: store <8 x float> [[TMP583]], ptr [[VEC_GEP1564]], align 16
+; CHECK-NEXT: [[VEC_GEP1565:%.*]] = getelementptr inbounds float, ptr [[C]], i64 32
+; CHECK-NEXT: store <8 x float> [[TMP727]], ptr [[VEC_GEP1565]], align 16
+; CHECK-NEXT: [[VEC_GEP1566:%.*]] = getelementptr inbounds float, ptr [[C]], i64 40
+; CHECK-NEXT: store <8 x float> [[TMP871]], ptr [[VEC_GEP1566]], align 16
+; CHECK-NEXT: [[VEC_GEP1567:%.*]] = getelementptr inbounds float, ptr [[C]], i64 48
+; CHECK-NEXT: store <8 x float> [[TMP1015]], ptr [[VEC_GEP1567]], align 16
+; CHECK-NEXT: [[VEC_GEP1568:%.*]] = getelementptr inbounds float, ptr [[C]], i64 56
+; CHECK-NEXT: store <8 x float> [[TMP1159]], ptr [[VEC_GEP1568]], align 16
+; CHECK-NEXT: ret void
+;
+entry:
+ %loada = load <64 x float>, <64 x float>* %A, align 16
+ %loadb = load <64 x float>, <64 x float>* %B, align 16
+ %neg = fneg <64 x float> %loadb
+
+ %c = call <64 x float> @llvm.matrix.multiply(<64 x float> %loada, <64 x float> %neg, i32 8, i32 8, i32 8)
+
+ store <64 x float> %c, <64 x float>* %C, align 16
+ ret void
+}
+
+define void @multiply_multi_use(<64 x float> * noalias %A, <64 x float> * noalias %B, <64 x float>* noalias %C, <64 x float>* noalias %C2) {
+; CHECK-LABEL: @multiply_multi_use(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[COL_LOAD:%.*]] = load <8 x float>, ptr [[A:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP:%.*]] = getelementptr inbounds float, ptr [[A]], i64 8
+; CHECK-NEXT: [[COL_LOAD1:%.*]] = load <8 x float>, ptr [[VEC_GEP]], align 16
+; CHECK-NEXT: [[VEC_GEP2:%.*]] = getelementptr inbounds float, ptr [[A]], i64 16
+; CHECK-NEXT: [[COL_LOAD3:%.*]] = load <8 x float>, ptr [[VEC_GEP2]], align 16
+; CHECK-NEXT: [[VEC_GEP4:%.*]] = getelementptr inbounds float, ptr [[A]], i64 24
+; CHECK-NEXT: [[COL_LOAD5:%.*]] = load <8 x float>, ptr [[VEC_GEP4]], align 16
+; CHECK-NEXT: [[VEC_GEP6:%.*]] = getelementptr inbounds float, ptr [[A]], i64 32
+; CHECK-NEXT: [[COL_LOAD7:%.*]] = load <8 x float>, ptr [[VEC_GEP6]], align 16
+; CHECK-NEXT: [[VEC_GEP8:%.*]] = getelementptr inbounds float, ptr [[A]], i64 40
+; CHECK-NEXT: [[COL_LOAD9:%.*]] = load <8 x float>, ptr [[VEC_GEP8]], align 16
+; CHECK-NEXT: [[VEC_GEP10:%.*]] = getelementptr inbounds float, ptr [[A]], i64 48
+; CHECK-NEXT: [[COL_LOAD11:%.*]] = load <8 x float>, ptr [[VEC_GEP10]], align 16
+; CHECK-NEXT: [[VEC_GEP12:%.*]] = getelementptr inbounds float, ptr [[A]], i64 56
+; CHECK-NEXT: [[COL_LOAD13:%.*]] = load <8 x float>, ptr [[VEC_GEP12]], align 16
+; CHECK-NEXT: [[COL_LOAD14:%.*]] = load <8 x float>, ptr [[B:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP15:%.*]] = getelementptr inbounds float, ptr [[B]], i64 8
+; CHECK-NEXT: [[COL_LOAD16:%.*]] = load <8 x float>, ptr [[VEC_GEP15]], align 16
+; CHECK-NEXT: [[VEC_GEP17:%.*]] = getelementptr inbounds float, ptr [[B]], i64 16
+; CHECK-NEXT: [[COL_LOAD18:%.*]] = load <8 x float>, ptr [[VEC_GEP17]], align 16
+; CHECK-NEXT: [[VEC_GEP19:%.*]] = getelementptr inbounds float, ptr [[B]], i64 24
+; CHECK-NEXT: [[COL_LOAD20:%.*]] = load <8 x float>, ptr [[VEC_GEP19]], align 16
+; CHECK-NEXT: [[VEC_GEP21:%.*]] = getelementptr inbounds float, ptr [[B]], i64 32
+; CHECK-NEXT: [[COL_LOAD22:%.*]] = load <8 x float>, ptr [[VEC_GEP21]], align 16
+; CHECK-NEXT: [[VEC_GEP23:%.*]] = getelementptr inbounds float, ptr [[B]], i64 40
+; CHECK-NEXT: [[COL_LOAD24:%.*]] = load <8 x float>, ptr [[VEC_GEP23]], align 16
+; CHECK-NEXT: [[VEC_GEP25:%.*]] = getelementptr inbounds float, ptr [[B]], i64 48
+; CHECK-NEXT: [[COL_LOAD26:%.*]] = load <8 x float>, ptr [[VEC_GEP25]], align 16
+; CHECK-NEXT: [[VEC_GEP27:%.*]] = getelementptr inbounds float, ptr [[B]], i64 56
+; CHECK-NEXT: [[COL_LOAD28:%.*]] = load <8 x float>, ptr [[VEC_GEP27]], align 16
+; CHECK-NEXT: [[BLOCK:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP0:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT:%.*]] = insertelement <1 x float> poison, float [[TMP0]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1:%.*]] = fmul <1 x float> [[BLOCK]], [[SPLAT_SPLAT]]
+; CHECK-NEXT: [[BLOCK29:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP2:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT30:%.*]] = insertelement <1 x float> poison, float [[TMP2]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT31:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT30]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP3:%.*]] = fmul <1 x float> [[BLOCK29]], [[SPLAT_SPLAT31]]
+; CHECK-NEXT: [[TMP5:%.*]] = fadd <1 x float> [[TMP1]], [[TMP3]]
+; CHECK-NEXT: [[BLOCK32:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP4:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT33:%.*]] = insertelement <1 x float> poison, float [[TMP4]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT34:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT33]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP11:%.*]] = fmul <1 x float> [[BLOCK32]], [[SPLAT_SPLAT34]]
+; CHECK-NEXT: [[TMP7:%.*]] = fadd <1 x float> [[TMP5]], [[TMP11]]
+; CHECK-NEXT: [[BLOCK35:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP6:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT36:%.*]] = insertelement <1 x float> poison, float [[TMP6]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT37:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT36]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP9:%.*]] = fmul <1 x float> [[BLOCK35]], [[SPLAT_SPLAT37]]
+; CHECK-NEXT: [[TMP23:%.*]] = fadd <1 x float> [[TMP7]], [[TMP9]]
+; CHECK-NEXT: [[BLOCK38:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP8:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT39:%.*]] = insertelement <1 x float> poison, float [[TMP8]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT40:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT39]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP25:%.*]] = fmul <1 x float> [[BLOCK38]], [[SPLAT_SPLAT40]]
+; CHECK-NEXT: [[TMP13:%.*]] = fadd <1 x float> [[TMP23]], [[TMP25]]
+; CHECK-NEXT: [[BLOCK41:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP10:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT42:%.*]] = insertelement <1 x float> poison, float [[TMP10]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT43:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT42]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP27:%.*]] = fmul <1 x float> [[BLOCK41]], [[SPLAT_SPLAT43]]
+; CHECK-NEXT: [[TMP39:%.*]] = fadd <1 x float> [[TMP13]], [[TMP27]]
+; CHECK-NEXT: [[BLOCK44:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP12:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT45:%.*]] = insertelement <1 x float> poison, float [[TMP12]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT46:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT45]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP45:%.*]] = fmul <1 x float> [[BLOCK44]], [[SPLAT_SPLAT46]]
+; CHECK-NEXT: [[TMP19:%.*]] = fadd <1 x float> [[TMP39]], [[TMP45]]
+; CHECK-NEXT: [[BLOCK47:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP14:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT48:%.*]] = insertelement <1 x float> poison, float [[TMP14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT49:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT48]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP21:%.*]] = fmul <1 x float> [[BLOCK47]], [[SPLAT_SPLAT49]]
+; CHECK-NEXT: [[TMP15:%.*]] = fadd <1 x float> [[TMP19]], [[TMP21]]
+; CHECK-NEXT: [[TMP16:%.*]] = shufflevector <1 x float> [[TMP15]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP17:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP16]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK50:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP18:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT51:%.*]] = insertelement <1 x float> poison, float [[TMP18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT52:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT51]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP47:%.*]] = fmul <1 x float> [[BLOCK50]], [[SPLAT_SPLAT52]]
+; CHECK-NEXT: [[BLOCK53:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP20:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT54:%.*]] = insertelement <1 x float> poison, float [[TMP20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT55:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT54]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP49:%.*]] = fmul <1 x float> [[BLOCK53]], [[SPLAT_SPLAT55]]
+; CHECK-NEXT: [[TMP29:%.*]] = fadd <1 x float> [[TMP47]], [[TMP49]]
+; CHECK-NEXT: [[BLOCK56:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP22:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT57:%.*]] = insertelement <1 x float> poison, float [[TMP22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT58:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT57]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP31:%.*]] = fmul <1 x float> [[BLOCK56]], [[SPLAT_SPLAT58]]
+; CHECK-NEXT: [[TMP55:%.*]] = fadd <1 x float> [[TMP29]], [[TMP31]]
+; CHECK-NEXT: [[BLOCK59:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP24:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT60:%.*]] = insertelement <1 x float> poison, float [[TMP24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT61:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT60]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP61:%.*]] = fmul <1 x float> [[BLOCK59]], [[SPLAT_SPLAT61]]
+; CHECK-NEXT: [[TMP67:%.*]] = fadd <1 x float> [[TMP55]], [[TMP61]]
+; CHECK-NEXT: [[BLOCK62:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP26:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT63:%.*]] = insertelement <1 x float> poison, float [[TMP26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT64:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT63]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP37:%.*]] = fmul <1 x float> [[BLOCK62]], [[SPLAT_SPLAT64]]
+; CHECK-NEXT: [[TMP73:%.*]] = fadd <1 x float> [[TMP67]], [[TMP37]]
+; CHECK-NEXT: [[BLOCK65:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP28:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT66:%.*]] = insertelement <1 x float> poison, float [[TMP28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT67:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT66]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP75:%.*]] = fmul <1 x float> [[BLOCK65]], [[SPLAT_SPLAT67]]
+; CHECK-NEXT: [[TMP41:%.*]] = fadd <1 x float> [[TMP73]], [[TMP75]]
+; CHECK-NEXT: [[BLOCK68:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP30:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT69:%.*]] = insertelement <1 x float> poison, float [[TMP30]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT70:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT69]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP43:%.*]] = fmul <1 x float> [[BLOCK68]], [[SPLAT_SPLAT70]]
+; CHECK-NEXT: [[TMP77:%.*]] = fadd <1 x float> [[TMP41]], [[TMP43]]
+; CHECK-NEXT: [[BLOCK71:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP32:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT72:%.*]] = insertelement <1 x float> poison, float [[TMP32]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT73:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT72]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP83:%.*]] = fmul <1 x float> [[BLOCK71]], [[SPLAT_SPLAT73]]
+; CHECK-NEXT: [[TMP33:%.*]] = fadd <1 x float> [[TMP77]], [[TMP83]]
+; CHECK-NEXT: [[TMP34:%.*]] = shufflevector <1 x float> [[TMP33]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP35:%.*]] = shufflevector <8 x float> [[TMP17]], <8 x float> [[TMP34]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK74:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP36:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT75:%.*]] = insertelement <1 x float> poison, float [[TMP36]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT76:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT75]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP95:%.*]] = fmul <1 x float> [[BLOCK74]], [[SPLAT_SPLAT76]]
+; CHECK-NEXT: [[BLOCK77:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP38:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT78:%.*]] = insertelement <1 x float> poison, float [[TMP38]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT79:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT78]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP97:%.*]] = fmul <1 x float> [[BLOCK77]], [[SPLAT_SPLAT79]]
+; CHECK-NEXT: [[TMP99:%.*]] = fadd <1 x float> [[TMP95]], [[TMP97]]
+; CHECK-NEXT: [[BLOCK80:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP40:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT81:%.*]] = insertelement <1 x float> poison, float [[TMP40]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT82:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT81]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP111:%.*]] = fmul <1 x float> [[BLOCK80]], [[SPLAT_SPLAT82]]
+; CHECK-NEXT: [[TMP57:%.*]] = fadd <1 x float> [[TMP99]], [[TMP111]]
+; CHECK-NEXT: [[BLOCK83:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP42:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT84:%.*]] = insertelement <1 x float> poison, float [[TMP42]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT85:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT84]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP59:%.*]] = fmul <1 x float> [[BLOCK83]], [[SPLAT_SPLAT85]]
+; CHECK-NEXT: [[TMP117:%.*]] = fadd <1 x float> [[TMP57]], [[TMP59]]
+; CHECK-NEXT: [[BLOCK86:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP44:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT87:%.*]] = insertelement <1 x float> poison, float [[TMP44]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT88:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT87]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP127:%.*]] = fmul <1 x float> [[BLOCK86]], [[SPLAT_SPLAT88]]
+; CHECK-NEXT: [[TMP63:%.*]] = fadd <1 x float> [[TMP117]], [[TMP127]]
+; CHECK-NEXT: [[BLOCK89:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP46:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT90:%.*]] = insertelement <1 x float> poison, float [[TMP46]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT91:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT90]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP65:%.*]] = fmul <1 x float> [[BLOCK89]], [[SPLAT_SPLAT91]]
+; CHECK-NEXT: [[TMP133:%.*]] = fadd <1 x float> [[TMP63]], [[TMP65]]
+; CHECK-NEXT: [[BLOCK92:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP48:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT93:%.*]] = insertelement <1 x float> poison, float [[TMP48]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT94:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT93]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP139:%.*]] = fmul <1 x float> [[BLOCK92]], [[SPLAT_SPLAT94]]
+; CHECK-NEXT: [[TMP145:%.*]] = fadd <1 x float> [[TMP133]], [[TMP139]]
+; CHECK-NEXT: [[BLOCK95:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP50:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT96:%.*]] = insertelement <1 x float> poison, float [[TMP50]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT97:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT96]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP147:%.*]] = fmul <1 x float> [[BLOCK95]], [[SPLAT_SPLAT97]]
+; CHECK-NEXT: [[TMP51:%.*]] = fadd <1 x float> [[TMP145]], [[TMP147]]
+; CHECK-NEXT: [[TMP52:%.*]] = shufflevector <1 x float> [[TMP51]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP53:%.*]] = shufflevector <8 x float> [[TMP35]], <8 x float> [[TMP52]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK98:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP54:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT99:%.*]] = insertelement <1 x float> poison, float [[TMP54]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT100:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT99]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP149:%.*]] = fmul <1 x float> [[BLOCK98]], [[SPLAT_SPLAT100]]
+; CHECK-NEXT: [[BLOCK101:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP56:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT102:%.*]] = insertelement <1 x float> poison, float [[TMP56]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT103:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT102]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP155:%.*]] = fmul <1 x float> [[BLOCK101]], [[SPLAT_SPLAT103]]
+; CHECK-NEXT: [[TMP79:%.*]] = fadd <1 x float> [[TMP149]], [[TMP155]]
+; CHECK-NEXT: [[BLOCK104:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP58:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT105:%.*]] = insertelement <1 x float> poison, float [[TMP58]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT106:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT105]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP81:%.*]] = fmul <1 x float> [[BLOCK104]], [[SPLAT_SPLAT106]]
+; CHECK-NEXT: [[TMP167:%.*]] = fadd <1 x float> [[TMP79]], [[TMP81]]
+; CHECK-NEXT: [[BLOCK107:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP60:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT108:%.*]] = insertelement <1 x float> poison, float [[TMP60]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT109:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT108]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP173:%.*]] = fmul <1 x float> [[BLOCK107]], [[SPLAT_SPLAT109]]
+; CHECK-NEXT: [[TMP85:%.*]] = fadd <1 x float> [[TMP167]], [[TMP173]]
+; CHECK-NEXT: [[BLOCK110:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP62:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT111:%.*]] = insertelement <1 x float> poison, float [[TMP62]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT112:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT111]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP175:%.*]] = fmul <1 x float> [[BLOCK110]], [[SPLAT_SPLAT112]]
+; CHECK-NEXT: [[TMP183:%.*]] = fadd <1 x float> [[TMP85]], [[TMP175]]
+; CHECK-NEXT: [[BLOCK113:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP64:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT114:%.*]] = insertelement <1 x float> poison, float [[TMP64]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT115:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT114]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP189:%.*]] = fmul <1 x float> [[BLOCK113]], [[SPLAT_SPLAT115]]
+; CHECK-NEXT: [[TMP91:%.*]] = fadd <1 x float> [[TMP183]], [[TMP189]]
+; CHECK-NEXT: [[BLOCK116:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP66:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT117:%.*]] = insertelement <1 x float> poison, float [[TMP66]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT118:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT117]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP93:%.*]] = fmul <1 x float> [[BLOCK116]], [[SPLAT_SPLAT118]]
+; CHECK-NEXT: [[TMP199:%.*]] = fadd <1 x float> [[TMP91]], [[TMP93]]
+; CHECK-NEXT: [[BLOCK119:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP68:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT120:%.*]] = insertelement <1 x float> poison, float [[TMP68]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT121:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT120]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP205:%.*]] = fmul <1 x float> [[BLOCK119]], [[SPLAT_SPLAT121]]
+; CHECK-NEXT: [[TMP69:%.*]] = fadd <1 x float> [[TMP199]], [[TMP205]]
+; CHECK-NEXT: [[TMP70:%.*]] = shufflevector <1 x float> [[TMP69]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP71:%.*]] = shufflevector <8 x float> [[TMP53]], <8 x float> [[TMP70]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK122:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP72:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT123:%.*]] = insertelement <1 x float> poison, float [[TMP72]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT124:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT123]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP101:%.*]] = fmul <1 x float> [[BLOCK122]], [[SPLAT_SPLAT124]]
+; CHECK-NEXT: [[BLOCK125:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP74:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT126:%.*]] = insertelement <1 x float> poison, float [[TMP74]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT127:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT126]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP103:%.*]] = fmul <1 x float> [[BLOCK125]], [[SPLAT_SPLAT127]]
+; CHECK-NEXT: [[TMP211:%.*]] = fadd <1 x float> [[TMP101]], [[TMP103]]
+; CHECK-NEXT: [[BLOCK128:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP76:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT129:%.*]] = insertelement <1 x float> poison, float [[TMP76]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT130:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT129]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP217:%.*]] = fmul <1 x float> [[BLOCK128]], [[SPLAT_SPLAT130]]
+; CHECK-NEXT: [[TMP223:%.*]] = fadd <1 x float> [[TMP211]], [[TMP217]]
+; CHECK-NEXT: [[BLOCK131:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP78:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT132:%.*]] = insertelement <1 x float> poison, float [[TMP78]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT133:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT132]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP109:%.*]] = fmul <1 x float> [[BLOCK131]], [[SPLAT_SPLAT133]]
+; CHECK-NEXT: [[TMP225:%.*]] = fadd <1 x float> [[TMP223]], [[TMP109]]
+; CHECK-NEXT: [[BLOCK134:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP80:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT135:%.*]] = insertelement <1 x float> poison, float [[TMP80]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT136:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT135]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP227:%.*]] = fmul <1 x float> [[BLOCK134]], [[SPLAT_SPLAT136]]
+; CHECK-NEXT: [[TMP113:%.*]] = fadd <1 x float> [[TMP225]], [[TMP227]]
+; CHECK-NEXT: [[BLOCK137:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP82:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT138:%.*]] = insertelement <1 x float> poison, float [[TMP82]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT139:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT138]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP115:%.*]] = fmul <1 x float> [[BLOCK137]], [[SPLAT_SPLAT139]]
+; CHECK-NEXT: [[TMP239:%.*]] = fadd <1 x float> [[TMP113]], [[TMP115]]
+; CHECK-NEXT: [[BLOCK140:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP84:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT141:%.*]] = insertelement <1 x float> poison, float [[TMP84]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT142:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT141]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP245:%.*]] = fmul <1 x float> [[BLOCK140]], [[SPLAT_SPLAT142]]
+; CHECK-NEXT: [[TMP119:%.*]] = fadd <1 x float> [[TMP239]], [[TMP245]]
+; CHECK-NEXT: [[BLOCK143:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP86:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT144:%.*]] = insertelement <1 x float> poison, float [[TMP86]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT145:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT144]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP121:%.*]] = fmul <1 x float> [[BLOCK143]], [[SPLAT_SPLAT145]]
+; CHECK-NEXT: [[TMP87:%.*]] = fadd <1 x float> [[TMP119]], [[TMP121]]
+; CHECK-NEXT: [[TMP88:%.*]] = shufflevector <1 x float> [[TMP87]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP89:%.*]] = shufflevector <8 x float> [[TMP71]], <8 x float> [[TMP88]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK146:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP90:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT147:%.*]] = insertelement <1 x float> poison, float [[TMP90]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT148:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT147]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP247:%.*]] = fmul <1 x float> [[BLOCK146]], [[SPLAT_SPLAT148]]
+; CHECK-NEXT: [[BLOCK149:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP92:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT150:%.*]] = insertelement <1 x float> poison, float [[TMP92]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT151:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT150]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP255:%.*]] = fmul <1 x float> [[BLOCK149]], [[SPLAT_SPLAT151]]
+; CHECK-NEXT: [[TMP129:%.*]] = fadd <1 x float> [[TMP247]], [[TMP255]]
+; CHECK-NEXT: [[BLOCK152:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP94:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT153:%.*]] = insertelement <1 x float> poison, float [[TMP94]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT154:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT153]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP131:%.*]] = fmul <1 x float> [[BLOCK152]], [[SPLAT_SPLAT154]]
+; CHECK-NEXT: [[TMP261:%.*]] = fadd <1 x float> [[TMP129]], [[TMP131]]
+; CHECK-NEXT: [[BLOCK155:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP96:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT156:%.*]] = insertelement <1 x float> poison, float [[TMP96]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT157:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT156]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP273:%.*]] = fmul <1 x float> [[BLOCK155]], [[SPLAT_SPLAT157]]
+; CHECK-NEXT: [[TMP135:%.*]] = fadd <1 x float> [[TMP261]], [[TMP273]]
+; CHECK-NEXT: [[BLOCK158:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP98:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT159:%.*]] = insertelement <1 x float> poison, float [[TMP98]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT160:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT159]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP137:%.*]] = fmul <1 x float> [[BLOCK158]], [[SPLAT_SPLAT160]]
+; CHECK-NEXT: [[TMP275:%.*]] = fadd <1 x float> [[TMP135]], [[TMP137]]
+; CHECK-NEXT: [[BLOCK161:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP100:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT162:%.*]] = insertelement <1 x float> poison, float [[TMP100]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT163:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT162]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP277:%.*]] = fmul <1 x float> [[BLOCK161]], [[SPLAT_SPLAT163]]
+; CHECK-NEXT: [[TMP283:%.*]] = fadd <1 x float> [[TMP275]], [[TMP277]]
+; CHECK-NEXT: [[BLOCK164:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP102:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT165:%.*]] = insertelement <1 x float> poison, float [[TMP102]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT166:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT165]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP289:%.*]] = fmul <1 x float> [[BLOCK164]], [[SPLAT_SPLAT166]]
+; CHECK-NEXT: [[TMP295:%.*]] = fadd <1 x float> [[TMP283]], [[TMP289]]
+; CHECK-NEXT: [[BLOCK167:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP104:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT168:%.*]] = insertelement <1 x float> poison, float [[TMP104]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT169:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT168]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP297:%.*]] = fmul <1 x float> [[BLOCK167]], [[SPLAT_SPLAT169]]
+; CHECK-NEXT: [[TMP105:%.*]] = fadd <1 x float> [[TMP295]], [[TMP297]]
+; CHECK-NEXT: [[TMP106:%.*]] = shufflevector <1 x float> [[TMP105]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP107:%.*]] = shufflevector <8 x float> [[TMP89]], <8 x float> [[TMP106]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK170:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP108:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT171:%.*]] = insertelement <1 x float> poison, float [[TMP108]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT172:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT171]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP151:%.*]] = fmul <1 x float> [[BLOCK170]], [[SPLAT_SPLAT172]]
+; CHECK-NEXT: [[BLOCK173:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP110:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT174:%.*]] = insertelement <1 x float> poison, float [[TMP110]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT175:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT174]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP153:%.*]] = fmul <1 x float> [[BLOCK173]], [[SPLAT_SPLAT175]]
+; CHECK-NEXT: [[TMP299:%.*]] = fadd <1 x float> [[TMP151]], [[TMP153]]
+; CHECK-NEXT: [[BLOCK176:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP112:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT177:%.*]] = insertelement <1 x float> poison, float [[TMP112]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT178:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT177]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP311:%.*]] = fmul <1 x float> [[BLOCK176]], [[SPLAT_SPLAT178]]
+; CHECK-NEXT: [[TMP157:%.*]] = fadd <1 x float> [[TMP299]], [[TMP311]]
+; CHECK-NEXT: [[BLOCK179:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP114:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT180:%.*]] = insertelement <1 x float> poison, float [[TMP114]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT181:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT180]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP317:%.*]] = fmul <1 x float> [[BLOCK179]], [[SPLAT_SPLAT181]]
+; CHECK-NEXT: [[TMP325:%.*]] = fadd <1 x float> [[TMP157]], [[TMP317]]
+; CHECK-NEXT: [[BLOCK182:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP116:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT183:%.*]] = insertelement <1 x float> poison, float [[TMP116]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT184:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT183]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP327:%.*]] = fmul <1 x float> [[BLOCK182]], [[SPLAT_SPLAT184]]
+; CHECK-NEXT: [[TMP163:%.*]] = fadd <1 x float> [[TMP325]], [[TMP327]]
+; CHECK-NEXT: [[BLOCK185:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP118:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT186:%.*]] = insertelement <1 x float> poison, float [[TMP118]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT187:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT186]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP165:%.*]] = fmul <1 x float> [[BLOCK185]], [[SPLAT_SPLAT187]]
+; CHECK-NEXT: [[TMP333:%.*]] = fadd <1 x float> [[TMP163]], [[TMP165]]
+; CHECK-NEXT: [[BLOCK188:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP120:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT189:%.*]] = insertelement <1 x float> poison, float [[TMP120]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT190:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT189]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP345:%.*]] = fmul <1 x float> [[BLOCK188]], [[SPLAT_SPLAT190]]
+; CHECK-NEXT: [[TMP169:%.*]] = fadd <1 x float> [[TMP333]], [[TMP345]]
+; CHECK-NEXT: [[BLOCK191:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP122:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT192:%.*]] = insertelement <1 x float> poison, float [[TMP122]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT193:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT192]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP171:%.*]] = fmul <1 x float> [[BLOCK191]], [[SPLAT_SPLAT193]]
+; CHECK-NEXT: [[TMP123:%.*]] = fadd <1 x float> [[TMP169]], [[TMP171]]
+; CHECK-NEXT: [[TMP124:%.*]] = shufflevector <1 x float> [[TMP123]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP125:%.*]] = shufflevector <8 x float> [[TMP107]], <8 x float> [[TMP124]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK194:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP126:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT195:%.*]] = insertelement <1 x float> poison, float [[TMP126]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT196:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT195]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP347:%.*]] = fmul <1 x float> [[BLOCK194]], [[SPLAT_SPLAT196]]
+; CHECK-NEXT: [[BLOCK197:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP128:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT198:%.*]] = insertelement <1 x float> poison, float [[TMP128]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT199:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT198]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP349:%.*]] = fmul <1 x float> [[BLOCK197]], [[SPLAT_SPLAT199]]
+; CHECK-NEXT: [[TMP355:%.*]] = fadd <1 x float> [[TMP347]], [[TMP349]]
+; CHECK-NEXT: [[BLOCK200:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP130:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT201:%.*]] = insertelement <1 x float> poison, float [[TMP130]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT202:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT201]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP181:%.*]] = fmul <1 x float> [[BLOCK200]], [[SPLAT_SPLAT202]]
+; CHECK-NEXT: [[TMP361:%.*]] = fadd <1 x float> [[TMP355]], [[TMP181]]
+; CHECK-NEXT: [[BLOCK203:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP132:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT204:%.*]] = insertelement <1 x float> poison, float [[TMP132]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT205:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT204]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP367:%.*]] = fmul <1 x float> [[BLOCK203]], [[SPLAT_SPLAT205]]
+; CHECK-NEXT: [[TMP185:%.*]] = fadd <1 x float> [[TMP361]], [[TMP367]]
+; CHECK-NEXT: [[BLOCK206:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP134:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT207:%.*]] = insertelement <1 x float> poison, float [[TMP134]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT208:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT207]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP187:%.*]] = fmul <1 x float> [[BLOCK206]], [[SPLAT_SPLAT208]]
+; CHECK-NEXT: [[TMP373:%.*]] = fadd <1 x float> [[TMP185]], [[TMP187]]
+; CHECK-NEXT: [[BLOCK209:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP136:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT210:%.*]] = insertelement <1 x float> poison, float [[TMP136]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT211:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT210]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP383:%.*]] = fmul <1 x float> [[BLOCK209]], [[SPLAT_SPLAT211]]
+; CHECK-NEXT: [[TMP191:%.*]] = fadd <1 x float> [[TMP373]], [[TMP383]]
+; CHECK-NEXT: [[BLOCK212:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP138:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT213:%.*]] = insertelement <1 x float> poison, float [[TMP138]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT214:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT213]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP193:%.*]] = fmul <1 x float> [[BLOCK212]], [[SPLAT_SPLAT214]]
+; CHECK-NEXT: [[TMP389:%.*]] = fadd <1 x float> [[TMP191]], [[TMP193]]
+; CHECK-NEXT: [[BLOCK215:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP140:%.*]] = extractelement <8 x float> [[COL_LOAD14]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT216:%.*]] = insertelement <1 x float> poison, float [[TMP140]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT217:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT216]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP397:%.*]] = fmul <1 x float> [[BLOCK215]], [[SPLAT_SPLAT217]]
+; CHECK-NEXT: [[TMP141:%.*]] = fadd <1 x float> [[TMP389]], [[TMP397]]
+; CHECK-NEXT: [[TMP142:%.*]] = shufflevector <1 x float> [[TMP141]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP143:%.*]] = shufflevector <8 x float> [[TMP125]], <8 x float> [[TMP142]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK218:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP144:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT219:%.*]] = insertelement <1 x float> poison, float [[TMP144]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT220:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT219]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP201:%.*]] = fmul <1 x float> [[BLOCK218]], [[SPLAT_SPLAT220]]
+; CHECK-NEXT: [[BLOCK221:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP146:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT222:%.*]] = insertelement <1 x float> poison, float [[TMP146]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT223:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT222]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP203:%.*]] = fmul <1 x float> [[BLOCK221]], [[SPLAT_SPLAT223]]
+; CHECK-NEXT: [[TMP399:%.*]] = fadd <1 x float> [[TMP201]], [[TMP203]]
+; CHECK-NEXT: [[BLOCK224:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP148:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT225:%.*]] = insertelement <1 x float> poison, float [[TMP148]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT226:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT225]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP405:%.*]] = fmul <1 x float> [[BLOCK224]], [[SPLAT_SPLAT226]]
+; CHECK-NEXT: [[TMP207:%.*]] = fadd <1 x float> [[TMP399]], [[TMP405]]
+; CHECK-NEXT: [[BLOCK227:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP150:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT228:%.*]] = insertelement <1 x float> poison, float [[TMP150]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT229:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT228]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP209:%.*]] = fmul <1 x float> [[BLOCK227]], [[SPLAT_SPLAT229]]
+; CHECK-NEXT: [[TMP417:%.*]] = fadd <1 x float> [[TMP207]], [[TMP209]]
+; CHECK-NEXT: [[BLOCK230:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP152:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT231:%.*]] = insertelement <1 x float> poison, float [[TMP152]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT232:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT231]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP423:%.*]] = fmul <1 x float> [[BLOCK230]], [[SPLAT_SPLAT232]]
+; CHECK-NEXT: [[TMP425:%.*]] = fadd <1 x float> [[TMP417]], [[TMP423]]
+; CHECK-NEXT: [[BLOCK233:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP154:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT234:%.*]] = insertelement <1 x float> poison, float [[TMP154]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT235:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT234]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP427:%.*]] = fmul <1 x float> [[BLOCK233]], [[SPLAT_SPLAT235]]
+; CHECK-NEXT: [[TMP433:%.*]] = fadd <1 x float> [[TMP425]], [[TMP427]]
+; CHECK-NEXT: [[BLOCK236:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP156:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT237:%.*]] = insertelement <1 x float> poison, float [[TMP156]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT238:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT237]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP439:%.*]] = fmul <1 x float> [[BLOCK236]], [[SPLAT_SPLAT238]]
+; CHECK-NEXT: [[TMP219:%.*]] = fadd <1 x float> [[TMP433]], [[TMP439]]
+; CHECK-NEXT: [[BLOCK239:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP158:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT240:%.*]] = insertelement <1 x float> poison, float [[TMP158]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT241:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT240]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP221:%.*]] = fmul <1 x float> [[BLOCK239]], [[SPLAT_SPLAT241]]
+; CHECK-NEXT: [[TMP159:%.*]] = fadd <1 x float> [[TMP219]], [[TMP221]]
+; CHECK-NEXT: [[TMP160:%.*]] = shufflevector <1 x float> [[TMP159]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP161:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP160]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK242:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP162:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT243:%.*]] = insertelement <1 x float> poison, float [[TMP162]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT244:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT243]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP445:%.*]] = fmul <1 x float> [[BLOCK242]], [[SPLAT_SPLAT244]]
+; CHECK-NEXT: [[BLOCK245:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP164:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT246:%.*]] = insertelement <1 x float> poison, float [[TMP164]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT247:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT246]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP455:%.*]] = fmul <1 x float> [[BLOCK245]], [[SPLAT_SPLAT247]]
+; CHECK-NEXT: [[TMP229:%.*]] = fadd <1 x float> [[TMP445]], [[TMP455]]
+; CHECK-NEXT: [[BLOCK248:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP166:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT249:%.*]] = insertelement <1 x float> poison, float [[TMP166]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT250:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT249]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP461:%.*]] = fmul <1 x float> [[BLOCK248]], [[SPLAT_SPLAT250]]
+; CHECK-NEXT: [[TMP473:%.*]] = fadd <1 x float> [[TMP229]], [[TMP461]]
+; CHECK-NEXT: [[BLOCK251:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP168:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT252:%.*]] = insertelement <1 x float> poison, float [[TMP168]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT253:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT252]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP475:%.*]] = fmul <1 x float> [[BLOCK251]], [[SPLAT_SPLAT253]]
+; CHECK-NEXT: [[TMP235:%.*]] = fadd <1 x float> [[TMP473]], [[TMP475]]
+; CHECK-NEXT: [[BLOCK254:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP170:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT255:%.*]] = insertelement <1 x float> poison, float [[TMP170]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT256:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT255]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP237:%.*]] = fmul <1 x float> [[BLOCK254]], [[SPLAT_SPLAT256]]
+; CHECK-NEXT: [[TMP477:%.*]] = fadd <1 x float> [[TMP235]], [[TMP237]]
+; CHECK-NEXT: [[BLOCK257:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP172:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT258:%.*]] = insertelement <1 x float> poison, float [[TMP172]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT259:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT258]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP489:%.*]] = fmul <1 x float> [[BLOCK257]], [[SPLAT_SPLAT259]]
+; CHECK-NEXT: [[TMP241:%.*]] = fadd <1 x float> [[TMP477]], [[TMP489]]
+; CHECK-NEXT: [[BLOCK260:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP174:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT261:%.*]] = insertelement <1 x float> poison, float [[TMP174]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT262:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT261]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP243:%.*]] = fmul <1 x float> [[BLOCK260]], [[SPLAT_SPLAT262]]
+; CHECK-NEXT: [[TMP495:%.*]] = fadd <1 x float> [[TMP241]], [[TMP243]]
+; CHECK-NEXT: [[BLOCK263:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP176:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT264:%.*]] = insertelement <1 x float> poison, float [[TMP176]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT265:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT264]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP497:%.*]] = fmul <1 x float> [[BLOCK263]], [[SPLAT_SPLAT265]]
+; CHECK-NEXT: [[TMP177:%.*]] = fadd <1 x float> [[TMP495]], [[TMP497]]
+; CHECK-NEXT: [[TMP178:%.*]] = shufflevector <1 x float> [[TMP177]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP179:%.*]] = shufflevector <8 x float> [[TMP161]], <8 x float> [[TMP178]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK266:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP180:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT267:%.*]] = insertelement <1 x float> poison, float [[TMP180]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT268:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT267]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP499:%.*]] = fmul <1 x float> [[BLOCK266]], [[SPLAT_SPLAT268]]
+; CHECK-NEXT: [[BLOCK269:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP182:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT270:%.*]] = insertelement <1 x float> poison, float [[TMP182]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT271:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT270]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP253:%.*]] = fmul <1 x float> [[BLOCK269]], [[SPLAT_SPLAT271]]
+; CHECK-NEXT: [[TMP505:%.*]] = fadd <1 x float> [[TMP499]], [[TMP253]]
+; CHECK-NEXT: [[BLOCK272:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP184:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT273:%.*]] = insertelement <1 x float> poison, float [[TMP184]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT274:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT273]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP511:%.*]] = fmul <1 x float> [[BLOCK272]], [[SPLAT_SPLAT274]]
+; CHECK-NEXT: [[TMP257:%.*]] = fadd <1 x float> [[TMP505]], [[TMP511]]
+; CHECK-NEXT: [[BLOCK275:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP186:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT276:%.*]] = insertelement <1 x float> poison, float [[TMP186]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT277:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT276]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP259:%.*]] = fmul <1 x float> [[BLOCK275]], [[SPLAT_SPLAT277]]
+; CHECK-NEXT: [[TMP517:%.*]] = fadd <1 x float> [[TMP257]], [[TMP259]]
+; CHECK-NEXT: [[BLOCK278:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP188:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT279:%.*]] = insertelement <1 x float> poison, float [[TMP188]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT280:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT279]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP523:%.*]] = fmul <1 x float> [[BLOCK278]], [[SPLAT_SPLAT280]]
+; CHECK-NEXT: [[TMP263:%.*]] = fadd <1 x float> [[TMP517]], [[TMP523]]
+; CHECK-NEXT: [[BLOCK281:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP190:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT282:%.*]] = insertelement <1 x float> poison, float [[TMP190]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT283:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT282]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP265:%.*]] = fmul <1 x float> [[BLOCK281]], [[SPLAT_SPLAT283]]
+; CHECK-NEXT: [[TMP525:%.*]] = fadd <1 x float> [[TMP263]], [[TMP265]]
+; CHECK-NEXT: [[BLOCK284:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP192:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT285:%.*]] = insertelement <1 x float> poison, float [[TMP192]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT286:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT285]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP527:%.*]] = fmul <1 x float> [[BLOCK284]], [[SPLAT_SPLAT286]]
+; CHECK-NEXT: [[TMP533:%.*]] = fadd <1 x float> [[TMP525]], [[TMP527]]
+; CHECK-NEXT: [[BLOCK287:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP194:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT288:%.*]] = insertelement <1 x float> poison, float [[TMP194]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT289:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT288]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP271:%.*]] = fmul <1 x float> [[BLOCK287]], [[SPLAT_SPLAT289]]
+; CHECK-NEXT: [[TMP195:%.*]] = fadd <1 x float> [[TMP533]], [[TMP271]]
+; CHECK-NEXT: [[TMP196:%.*]] = shufflevector <1 x float> [[TMP195]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP197:%.*]] = shufflevector <8 x float> [[TMP179]], <8 x float> [[TMP196]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK290:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP198:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT291:%.*]] = insertelement <1 x float> poison, float [[TMP198]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT292:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT291]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP545:%.*]] = fmul <1 x float> [[BLOCK290]], [[SPLAT_SPLAT292]]
+; CHECK-NEXT: [[BLOCK293:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP200:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT294:%.*]] = insertelement <1 x float> poison, float [[TMP200]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT295:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT294]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP547:%.*]] = fmul <1 x float> [[BLOCK293]], [[SPLAT_SPLAT295]]
+; CHECK-NEXT: [[TMP279:%.*]] = fadd <1 x float> [[TMP545]], [[TMP547]]
+; CHECK-NEXT: [[BLOCK296:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP202:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT297:%.*]] = insertelement <1 x float> poison, float [[TMP202]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT298:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT297]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP281:%.*]] = fmul <1 x float> [[BLOCK296]], [[SPLAT_SPLAT298]]
+; CHECK-NEXT: [[TMP549:%.*]] = fadd <1 x float> [[TMP279]], [[TMP281]]
+; CHECK-NEXT: [[BLOCK299:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP204:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT300:%.*]] = insertelement <1 x float> poison, float [[TMP204]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT301:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT300]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP561:%.*]] = fmul <1 x float> [[BLOCK299]], [[SPLAT_SPLAT301]]
+; CHECK-NEXT: [[TMP567:%.*]] = fadd <1 x float> [[TMP549]], [[TMP561]]
+; CHECK-NEXT: [[BLOCK302:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP206:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT303:%.*]] = insertelement <1 x float> poison, float [[TMP206]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT304:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT303]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP577:%.*]] = fmul <1 x float> [[BLOCK302]], [[SPLAT_SPLAT304]]
+; CHECK-NEXT: [[TMP583:%.*]] = fadd <1 x float> [[TMP567]], [[TMP577]]
+; CHECK-NEXT: [[BLOCK305:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP208:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT306:%.*]] = insertelement <1 x float> poison, float [[TMP208]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT307:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT306]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP589:%.*]] = fmul <1 x float> [[BLOCK305]], [[SPLAT_SPLAT307]]
+; CHECK-NEXT: [[TMP291:%.*]] = fadd <1 x float> [[TMP583]], [[TMP589]]
+; CHECK-NEXT: [[BLOCK308:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP210:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT309:%.*]] = insertelement <1 x float> poison, float [[TMP210]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT310:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT309]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP293:%.*]] = fmul <1 x float> [[BLOCK308]], [[SPLAT_SPLAT310]]
+; CHECK-NEXT: [[TMP595:%.*]] = fadd <1 x float> [[TMP291]], [[TMP293]]
+; CHECK-NEXT: [[BLOCK311:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP212:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT312:%.*]] = insertelement <1 x float> poison, float [[TMP212]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT313:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT312]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP597:%.*]] = fmul <1 x float> [[BLOCK311]], [[SPLAT_SPLAT313]]
+; CHECK-NEXT: [[TMP213:%.*]] = fadd <1 x float> [[TMP595]], [[TMP597]]
+; CHECK-NEXT: [[TMP214:%.*]] = shufflevector <1 x float> [[TMP213]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP215:%.*]] = shufflevector <8 x float> [[TMP197]], <8 x float> [[TMP214]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK314:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP216:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT315:%.*]] = insertelement <1 x float> poison, float [[TMP216]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT316:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT315]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP301:%.*]] = fmul <1 x float> [[BLOCK314]], [[SPLAT_SPLAT316]]
+; CHECK-NEXT: [[BLOCK317:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP218:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT318:%.*]] = insertelement <1 x float> poison, float [[TMP218]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT319:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT318]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP599:%.*]] = fmul <1 x float> [[BLOCK317]], [[SPLAT_SPLAT319]]
+; CHECK-NEXT: [[TMP605:%.*]] = fadd <1 x float> [[TMP301]], [[TMP599]]
+; CHECK-NEXT: [[BLOCK320:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP220:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT321:%.*]] = insertelement <1 x float> poison, float [[TMP220]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT322:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT321]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP617:%.*]] = fmul <1 x float> [[BLOCK320]], [[SPLAT_SPLAT322]]
+; CHECK-NEXT: [[TMP307:%.*]] = fadd <1 x float> [[TMP605]], [[TMP617]]
+; CHECK-NEXT: [[BLOCK323:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP222:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT324:%.*]] = insertelement <1 x float> poison, float [[TMP222]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT325:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT324]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP309:%.*]] = fmul <1 x float> [[BLOCK323]], [[SPLAT_SPLAT325]]
+; CHECK-NEXT: [[TMP623:%.*]] = fadd <1 x float> [[TMP307]], [[TMP309]]
+; CHECK-NEXT: [[BLOCK326:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP224:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT327:%.*]] = insertelement <1 x float> poison, float [[TMP224]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT328:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT327]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP625:%.*]] = fmul <1 x float> [[BLOCK326]], [[SPLAT_SPLAT328]]
+; CHECK-NEXT: [[TMP313:%.*]] = fadd <1 x float> [[TMP623]], [[TMP625]]
+; CHECK-NEXT: [[BLOCK329:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP226:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT330:%.*]] = insertelement <1 x float> poison, float [[TMP226]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT331:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT330]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP315:%.*]] = fmul <1 x float> [[BLOCK329]], [[SPLAT_SPLAT331]]
+; CHECK-NEXT: [[TMP633:%.*]] = fadd <1 x float> [[TMP313]], [[TMP315]]
+; CHECK-NEXT: [[BLOCK332:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP228:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT333:%.*]] = insertelement <1 x float> poison, float [[TMP228]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT334:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT333]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP639:%.*]] = fmul <1 x float> [[BLOCK332]], [[SPLAT_SPLAT334]]
+; CHECK-NEXT: [[TMP319:%.*]] = fadd <1 x float> [[TMP633]], [[TMP639]]
+; CHECK-NEXT: [[BLOCK335:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP230:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT336:%.*]] = insertelement <1 x float> poison, float [[TMP230]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT337:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT336]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP649:%.*]] = fmul <1 x float> [[BLOCK335]], [[SPLAT_SPLAT337]]
+; CHECK-NEXT: [[TMP231:%.*]] = fadd <1 x float> [[TMP319]], [[TMP649]]
+; CHECK-NEXT: [[TMP232:%.*]] = shufflevector <1 x float> [[TMP231]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP233:%.*]] = shufflevector <8 x float> [[TMP215]], <8 x float> [[TMP232]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK338:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP234:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT339:%.*]] = insertelement <1 x float> poison, float [[TMP234]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT340:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT339]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP655:%.*]] = fmul <1 x float> [[BLOCK338]], [[SPLAT_SPLAT340]]
+; CHECK-NEXT: [[BLOCK341:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP236:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT342:%.*]] = insertelement <1 x float> poison, float [[TMP236]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT343:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT342]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP661:%.*]] = fmul <1 x float> [[BLOCK341]], [[SPLAT_SPLAT343]]
+; CHECK-NEXT: [[TMP329:%.*]] = fadd <1 x float> [[TMP655]], [[TMP661]]
+; CHECK-NEXT: [[BLOCK344:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP238:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT345:%.*]] = insertelement <1 x float> poison, float [[TMP238]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT346:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT345]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP331:%.*]] = fmul <1 x float> [[BLOCK344]], [[SPLAT_SPLAT346]]
+; CHECK-NEXT: [[TMP667:%.*]] = fadd <1 x float> [[TMP329]], [[TMP331]]
+; CHECK-NEXT: [[BLOCK347:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP240:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT348:%.*]] = insertelement <1 x float> poison, float [[TMP240]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT349:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT348]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP673:%.*]] = fmul <1 x float> [[BLOCK347]], [[SPLAT_SPLAT349]]
+; CHECK-NEXT: [[TMP335:%.*]] = fadd <1 x float> [[TMP667]], [[TMP673]]
+; CHECK-NEXT: [[BLOCK350:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP242:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT351:%.*]] = insertelement <1 x float> poison, float [[TMP242]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT352:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT351]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP337:%.*]] = fmul <1 x float> [[BLOCK350]], [[SPLAT_SPLAT352]]
+; CHECK-NEXT: [[TMP675:%.*]] = fadd <1 x float> [[TMP335]], [[TMP337]]
+; CHECK-NEXT: [[BLOCK353:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP244:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT354:%.*]] = insertelement <1 x float> poison, float [[TMP244]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT355:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT354]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP677:%.*]] = fmul <1 x float> [[BLOCK353]], [[SPLAT_SPLAT355]]
+; CHECK-NEXT: [[TMP689:%.*]] = fadd <1 x float> [[TMP675]], [[TMP677]]
+; CHECK-NEXT: [[BLOCK356:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP246:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT357:%.*]] = insertelement <1 x float> poison, float [[TMP246]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT358:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT357]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP343:%.*]] = fmul <1 x float> [[BLOCK356]], [[SPLAT_SPLAT358]]
+; CHECK-NEXT: [[TMP695:%.*]] = fadd <1 x float> [[TMP689]], [[TMP343]]
+; CHECK-NEXT: [[BLOCK359:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP248:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT360:%.*]] = insertelement <1 x float> poison, float [[TMP248]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT361:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT360]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP697:%.*]] = fmul <1 x float> [[BLOCK359]], [[SPLAT_SPLAT361]]
+; CHECK-NEXT: [[TMP249:%.*]] = fadd <1 x float> [[TMP695]], [[TMP697]]
+; CHECK-NEXT: [[TMP250:%.*]] = shufflevector <1 x float> [[TMP249]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP251:%.*]] = shufflevector <8 x float> [[TMP233]], <8 x float> [[TMP250]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK362:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP252:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT363:%.*]] = insertelement <1 x float> poison, float [[TMP252]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT364:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT363]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP351:%.*]] = fmul <1 x float> [[BLOCK362]], [[SPLAT_SPLAT364]]
+; CHECK-NEXT: [[BLOCK365:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP254:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT366:%.*]] = insertelement <1 x float> poison, float [[TMP254]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT367:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT366]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP353:%.*]] = fmul <1 x float> [[BLOCK365]], [[SPLAT_SPLAT367]]
+; CHECK-NEXT: [[TMP705:%.*]] = fadd <1 x float> [[TMP351]], [[TMP353]]
+; CHECK-NEXT: [[BLOCK368:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP256:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT369:%.*]] = insertelement <1 x float> poison, float [[TMP256]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT370:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT369]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP711:%.*]] = fmul <1 x float> [[BLOCK368]], [[SPLAT_SPLAT370]]
+; CHECK-NEXT: [[TMP723:%.*]] = fadd <1 x float> [[TMP705]], [[TMP711]]
+; CHECK-NEXT: [[BLOCK371:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP258:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT372:%.*]] = insertelement <1 x float> poison, float [[TMP258]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT373:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT372]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP725:%.*]] = fmul <1 x float> [[BLOCK371]], [[SPLAT_SPLAT373]]
+; CHECK-NEXT: [[TMP727:%.*]] = fadd <1 x float> [[TMP723]], [[TMP725]]
+; CHECK-NEXT: [[BLOCK374:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP260:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT375:%.*]] = insertelement <1 x float> poison, float [[TMP260]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT376:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT375]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP733:%.*]] = fmul <1 x float> [[BLOCK374]], [[SPLAT_SPLAT376]]
+; CHECK-NEXT: [[TMP363:%.*]] = fadd <1 x float> [[TMP727]], [[TMP733]]
+; CHECK-NEXT: [[BLOCK377:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP262:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT378:%.*]] = insertelement <1 x float> poison, float [[TMP262]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT379:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT378]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP365:%.*]] = fmul <1 x float> [[BLOCK377]], [[SPLAT_SPLAT379]]
+; CHECK-NEXT: [[TMP739:%.*]] = fadd <1 x float> [[TMP363]], [[TMP365]]
+; CHECK-NEXT: [[BLOCK380:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP264:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT381:%.*]] = insertelement <1 x float> poison, float [[TMP264]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT382:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT381]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP745:%.*]] = fmul <1 x float> [[BLOCK380]], [[SPLAT_SPLAT382]]
+; CHECK-NEXT: [[TMP369:%.*]] = fadd <1 x float> [[TMP739]], [[TMP745]]
+; CHECK-NEXT: [[BLOCK383:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP266:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT384:%.*]] = insertelement <1 x float> poison, float [[TMP266]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT385:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT384]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP371:%.*]] = fmul <1 x float> [[BLOCK383]], [[SPLAT_SPLAT385]]
+; CHECK-NEXT: [[TMP267:%.*]] = fadd <1 x float> [[TMP369]], [[TMP371]]
+; CHECK-NEXT: [[TMP268:%.*]] = shufflevector <1 x float> [[TMP267]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP269:%.*]] = shufflevector <8 x float> [[TMP251]], <8 x float> [[TMP268]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK386:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP270:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT387:%.*]] = insertelement <1 x float> poison, float [[TMP270]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT388:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT387]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP747:%.*]] = fmul <1 x float> [[BLOCK386]], [[SPLAT_SPLAT388]]
+; CHECK-NEXT: [[BLOCK389:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP272:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT390:%.*]] = insertelement <1 x float> poison, float [[TMP272]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT391:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT390]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP749:%.*]] = fmul <1 x float> [[BLOCK389]], [[SPLAT_SPLAT391]]
+; CHECK-NEXT: [[TMP379:%.*]] = fadd <1 x float> [[TMP747]], [[TMP749]]
+; CHECK-NEXT: [[BLOCK392:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP274:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT393:%.*]] = insertelement <1 x float> poison, float [[TMP274]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT394:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT393]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP381:%.*]] = fmul <1 x float> [[BLOCK392]], [[SPLAT_SPLAT394]]
+; CHECK-NEXT: [[TMP761:%.*]] = fadd <1 x float> [[TMP379]], [[TMP381]]
+; CHECK-NEXT: [[BLOCK395:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP276:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT396:%.*]] = insertelement <1 x float> poison, float [[TMP276]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT397:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT396]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP767:%.*]] = fmul <1 x float> [[BLOCK395]], [[SPLAT_SPLAT397]]
+; CHECK-NEXT: [[TMP385:%.*]] = fadd <1 x float> [[TMP761]], [[TMP767]]
+; CHECK-NEXT: [[BLOCK398:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP278:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT399:%.*]] = insertelement <1 x float> poison, float [[TMP278]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT400:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT399]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP387:%.*]] = fmul <1 x float> [[BLOCK398]], [[SPLAT_SPLAT400]]
+; CHECK-NEXT: [[TMP775:%.*]] = fadd <1 x float> [[TMP385]], [[TMP387]]
+; CHECK-NEXT: [[BLOCK401:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP280:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT402:%.*]] = insertelement <1 x float> poison, float [[TMP280]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT403:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT402]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP777:%.*]] = fmul <1 x float> [[BLOCK401]], [[SPLAT_SPLAT403]]
+; CHECK-NEXT: [[TMP391:%.*]] = fadd <1 x float> [[TMP775]], [[TMP777]]
+; CHECK-NEXT: [[BLOCK404:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP282:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT405:%.*]] = insertelement <1 x float> poison, float [[TMP282]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT406:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT405]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP783:%.*]] = fmul <1 x float> [[BLOCK404]], [[SPLAT_SPLAT406]]
+; CHECK-NEXT: [[TMP795:%.*]] = fadd <1 x float> [[TMP391]], [[TMP783]]
+; CHECK-NEXT: [[BLOCK407:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP284:%.*]] = extractelement <8 x float> [[COL_LOAD16]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT408:%.*]] = insertelement <1 x float> poison, float [[TMP284]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT409:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT408]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP797:%.*]] = fmul <1 x float> [[BLOCK407]], [[SPLAT_SPLAT409]]
+; CHECK-NEXT: [[TMP285:%.*]] = fadd <1 x float> [[TMP795]], [[TMP797]]
+; CHECK-NEXT: [[TMP286:%.*]] = shufflevector <1 x float> [[TMP285]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP287:%.*]] = shufflevector <8 x float> [[TMP269]], <8 x float> [[TMP286]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK410:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP288:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT411:%.*]] = insertelement <1 x float> poison, float [[TMP288]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT412:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT411]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP401:%.*]] = fmul <1 x float> [[BLOCK410]], [[SPLAT_SPLAT412]]
+; CHECK-NEXT: [[BLOCK413:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP290:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT414:%.*]] = insertelement <1 x float> poison, float [[TMP290]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT415:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT414]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP403:%.*]] = fmul <1 x float> [[BLOCK413]], [[SPLAT_SPLAT415]]
+; CHECK-NEXT: [[TMP799:%.*]] = fadd <1 x float> [[TMP401]], [[TMP403]]
+; CHECK-NEXT: [[BLOCK416:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP292:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT417:%.*]] = insertelement <1 x float> poison, float [[TMP292]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT418:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT417]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP805:%.*]] = fmul <1 x float> [[BLOCK416]], [[SPLAT_SPLAT418]]
+; CHECK-NEXT: [[TMP407:%.*]] = fadd <1 x float> [[TMP799]], [[TMP805]]
+; CHECK-NEXT: [[BLOCK419:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP294:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT420:%.*]] = insertelement <1 x float> poison, float [[TMP294]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT421:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT420]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP409:%.*]] = fmul <1 x float> [[BLOCK419]], [[SPLAT_SPLAT421]]
+; CHECK-NEXT: [[TMP811:%.*]] = fadd <1 x float> [[TMP407]], [[TMP409]]
+; CHECK-NEXT: [[BLOCK422:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP296:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT423:%.*]] = insertelement <1 x float> poison, float [[TMP296]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT424:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT423]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP817:%.*]] = fmul <1 x float> [[BLOCK422]], [[SPLAT_SPLAT424]]
+; CHECK-NEXT: [[TMP823:%.*]] = fadd <1 x float> [[TMP811]], [[TMP817]]
+; CHECK-NEXT: [[BLOCK425:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP298:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT426:%.*]] = insertelement <1 x float> poison, float [[TMP298]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT427:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT426]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP415:%.*]] = fmul <1 x float> [[BLOCK425]], [[SPLAT_SPLAT427]]
+; CHECK-NEXT: [[TMP833:%.*]] = fadd <1 x float> [[TMP823]], [[TMP415]]
+; CHECK-NEXT: [[BLOCK428:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP300:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT429:%.*]] = insertelement <1 x float> poison, float [[TMP300]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT430:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT429]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP839:%.*]] = fmul <1 x float> [[BLOCK428]], [[SPLAT_SPLAT430]]
+; CHECK-NEXT: [[TMP419:%.*]] = fadd <1 x float> [[TMP833]], [[TMP839]]
+; CHECK-NEXT: [[BLOCK431:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP302:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT432:%.*]] = insertelement <1 x float> poison, float [[TMP302]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT433:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT432]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP421:%.*]] = fmul <1 x float> [[BLOCK431]], [[SPLAT_SPLAT433]]
+; CHECK-NEXT: [[TMP303:%.*]] = fadd <1 x float> [[TMP419]], [[TMP421]]
+; CHECK-NEXT: [[TMP304:%.*]] = shufflevector <1 x float> [[TMP303]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP305:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP304]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK434:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP306:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT435:%.*]] = insertelement <1 x float> poison, float [[TMP306]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT436:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT435]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP847:%.*]] = fmul <1 x float> [[BLOCK434]], [[SPLAT_SPLAT436]]
+; CHECK-NEXT: [[BLOCK437:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP308:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT438:%.*]] = insertelement <1 x float> poison, float [[TMP308]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT439:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT438]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP849:%.*]] = fmul <1 x float> [[BLOCK437]], [[SPLAT_SPLAT439]]
+; CHECK-NEXT: [[TMP855:%.*]] = fadd <1 x float> [[TMP847]], [[TMP849]]
+; CHECK-NEXT: [[BLOCK440:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP310:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT441:%.*]] = insertelement <1 x float> poison, float [[TMP310]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT442:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT441]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP867:%.*]] = fmul <1 x float> [[BLOCK440]], [[SPLAT_SPLAT442]]
+; CHECK-NEXT: [[TMP873:%.*]] = fadd <1 x float> [[TMP855]], [[TMP867]]
+; CHECK-NEXT: [[BLOCK443:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP312:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT444:%.*]] = insertelement <1 x float> poison, float [[TMP312]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT445:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT444]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP875:%.*]] = fmul <1 x float> [[BLOCK443]], [[SPLAT_SPLAT445]]
+; CHECK-NEXT: [[TMP435:%.*]] = fadd <1 x float> [[TMP873]], [[TMP875]]
+; CHECK-NEXT: [[BLOCK446:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP314:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT447:%.*]] = insertelement <1 x float> poison, float [[TMP314]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT448:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT447]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP437:%.*]] = fmul <1 x float> [[BLOCK446]], [[SPLAT_SPLAT448]]
+; CHECK-NEXT: [[TMP877:%.*]] = fadd <1 x float> [[TMP435]], [[TMP437]]
+; CHECK-NEXT: [[BLOCK449:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP316:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT450:%.*]] = insertelement <1 x float> poison, float [[TMP316]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT451:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT450]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP883:%.*]] = fmul <1 x float> [[BLOCK449]], [[SPLAT_SPLAT451]]
+; CHECK-NEXT: [[TMP441:%.*]] = fadd <1 x float> [[TMP877]], [[TMP883]]
+; CHECK-NEXT: [[BLOCK452:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP318:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT453:%.*]] = insertelement <1 x float> poison, float [[TMP318]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT454:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT453]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP443:%.*]] = fmul <1 x float> [[BLOCK452]], [[SPLAT_SPLAT454]]
+; CHECK-NEXT: [[TMP889:%.*]] = fadd <1 x float> [[TMP441]], [[TMP443]]
+; CHECK-NEXT: [[BLOCK455:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP320:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT456:%.*]] = insertelement <1 x float> poison, float [[TMP320]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT457:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT456]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP895:%.*]] = fmul <1 x float> [[BLOCK455]], [[SPLAT_SPLAT457]]
+; CHECK-NEXT: [[TMP321:%.*]] = fadd <1 x float> [[TMP889]], [[TMP895]]
+; CHECK-NEXT: [[TMP322:%.*]] = shufflevector <1 x float> [[TMP321]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP323:%.*]] = shufflevector <8 x float> [[TMP305]], <8 x float> [[TMP322]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK458:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP324:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT459:%.*]] = insertelement <1 x float> poison, float [[TMP324]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT460:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT459]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP451:%.*]] = fmul <1 x float> [[BLOCK458]], [[SPLAT_SPLAT460]]
+; CHECK-NEXT: [[BLOCK461:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP326:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT462:%.*]] = insertelement <1 x float> poison, float [[TMP326]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT463:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT462]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP453:%.*]] = fmul <1 x float> [[BLOCK461]], [[SPLAT_SPLAT463]]
+; CHECK-NEXT: [[TMP905:%.*]] = fadd <1 x float> [[TMP451]], [[TMP453]]
+; CHECK-NEXT: [[BLOCK464:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP328:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT465:%.*]] = insertelement <1 x float> poison, float [[TMP328]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT466:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT465]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP911:%.*]] = fmul <1 x float> [[BLOCK464]], [[SPLAT_SPLAT466]]
+; CHECK-NEXT: [[TMP457:%.*]] = fadd <1 x float> [[TMP905]], [[TMP911]]
+; CHECK-NEXT: [[BLOCK467:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP330:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT468:%.*]] = insertelement <1 x float> poison, float [[TMP330]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT469:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT468]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP459:%.*]] = fmul <1 x float> [[BLOCK467]], [[SPLAT_SPLAT469]]
+; CHECK-NEXT: [[TMP923:%.*]] = fadd <1 x float> [[TMP457]], [[TMP459]]
+; CHECK-NEXT: [[BLOCK470:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP332:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT471:%.*]] = insertelement <1 x float> poison, float [[TMP332]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT472:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT471]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP925:%.*]] = fmul <1 x float> [[BLOCK470]], [[SPLAT_SPLAT472]]
+; CHECK-NEXT: [[TMP463:%.*]] = fadd <1 x float> [[TMP923]], [[TMP925]]
+; CHECK-NEXT: [[BLOCK473:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP334:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT474:%.*]] = insertelement <1 x float> poison, float [[TMP334]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT475:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT474]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP927:%.*]] = fmul <1 x float> [[BLOCK473]], [[SPLAT_SPLAT475]]
+; CHECK-NEXT: [[TMP939:%.*]] = fadd <1 x float> [[TMP463]], [[TMP927]]
+; CHECK-NEXT: [[BLOCK476:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP336:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT477:%.*]] = insertelement <1 x float> poison, float [[TMP336]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT478:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT477]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP945:%.*]] = fmul <1 x float> [[BLOCK476]], [[SPLAT_SPLAT478]]
+; CHECK-NEXT: [[TMP469:%.*]] = fadd <1 x float> [[TMP939]], [[TMP945]]
+; CHECK-NEXT: [[BLOCK479:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP338:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT480:%.*]] = insertelement <1 x float> poison, float [[TMP338]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT481:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT480]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP471:%.*]] = fmul <1 x float> [[BLOCK479]], [[SPLAT_SPLAT481]]
+; CHECK-NEXT: [[TMP339:%.*]] = fadd <1 x float> [[TMP469]], [[TMP471]]
+; CHECK-NEXT: [[TMP340:%.*]] = shufflevector <1 x float> [[TMP339]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP341:%.*]] = shufflevector <8 x float> [[TMP323]], <8 x float> [[TMP340]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK482:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP342:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT483:%.*]] = insertelement <1 x float> poison, float [[TMP342]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT484:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT483]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP947:%.*]] = fmul <1 x float> [[BLOCK482]], [[SPLAT_SPLAT484]]
+; CHECK-NEXT: [[BLOCK485:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP344:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT486:%.*]] = insertelement <1 x float> poison, float [[TMP344]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT487:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT486]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP949:%.*]] = fmul <1 x float> [[BLOCK485]], [[SPLAT_SPLAT487]]
+; CHECK-NEXT: [[TMP479:%.*]] = fadd <1 x float> [[TMP947]], [[TMP949]]
+; CHECK-NEXT: [[BLOCK488:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP346:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT489:%.*]] = insertelement <1 x float> poison, float [[TMP346]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT490:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT489]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP481:%.*]] = fmul <1 x float> [[BLOCK488]], [[SPLAT_SPLAT490]]
+; CHECK-NEXT: [[TMP955:%.*]] = fadd <1 x float> [[TMP479]], [[TMP481]]
+; CHECK-NEXT: [[BLOCK491:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP348:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT492:%.*]] = insertelement <1 x float> poison, float [[TMP348]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT493:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT492]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP961:%.*]] = fmul <1 x float> [[BLOCK491]], [[SPLAT_SPLAT493]]
+; CHECK-NEXT: [[TMP967:%.*]] = fadd <1 x float> [[TMP955]], [[TMP961]]
+; CHECK-NEXT: [[BLOCK494:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP350:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT495:%.*]] = insertelement <1 x float> poison, float [[TMP350]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT496:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT495]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP487:%.*]] = fmul <1 x float> [[BLOCK494]], [[SPLAT_SPLAT496]]
+; CHECK-NEXT: [[TMP973:%.*]] = fadd <1 x float> [[TMP967]], [[TMP487]]
+; CHECK-NEXT: [[BLOCK497:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP352:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT498:%.*]] = insertelement <1 x float> poison, float [[TMP352]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT499:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT498]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP975:%.*]] = fmul <1 x float> [[BLOCK497]], [[SPLAT_SPLAT499]]
+; CHECK-NEXT: [[TMP491:%.*]] = fadd <1 x float> [[TMP973]], [[TMP975]]
+; CHECK-NEXT: [[BLOCK500:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP354:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT501:%.*]] = insertelement <1 x float> poison, float [[TMP354]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT502:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT501]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP493:%.*]] = fmul <1 x float> [[BLOCK500]], [[SPLAT_SPLAT502]]
+; CHECK-NEXT: [[TMP977:%.*]] = fadd <1 x float> [[TMP491]], [[TMP493]]
+; CHECK-NEXT: [[BLOCK503:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP356:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT504:%.*]] = insertelement <1 x float> poison, float [[TMP356]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT505:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT504]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP983:%.*]] = fmul <1 x float> [[BLOCK503]], [[SPLAT_SPLAT505]]
+; CHECK-NEXT: [[TMP357:%.*]] = fadd <1 x float> [[TMP977]], [[TMP983]]
+; CHECK-NEXT: [[TMP358:%.*]] = shufflevector <1 x float> [[TMP357]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP359:%.*]] = shufflevector <8 x float> [[TMP341]], <8 x float> [[TMP358]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK506:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP360:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT507:%.*]] = insertelement <1 x float> poison, float [[TMP360]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT508:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT507]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP995:%.*]] = fmul <1 x float> [[BLOCK506]], [[SPLAT_SPLAT508]]
+; CHECK-NEXT: [[BLOCK509:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP362:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT510:%.*]] = insertelement <1 x float> poison, float [[TMP362]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT511:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT510]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP997:%.*]] = fmul <1 x float> [[BLOCK509]], [[SPLAT_SPLAT511]]
+; CHECK-NEXT: [[TMP999:%.*]] = fadd <1 x float> [[TMP995]], [[TMP997]]
+; CHECK-NEXT: [[BLOCK512:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP364:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT513:%.*]] = insertelement <1 x float> poison, float [[TMP364]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT514:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT513]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1011:%.*]] = fmul <1 x float> [[BLOCK512]], [[SPLAT_SPLAT514]]
+; CHECK-NEXT: [[TMP507:%.*]] = fadd <1 x float> [[TMP999]], [[TMP1011]]
+; CHECK-NEXT: [[BLOCK515:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP366:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT516:%.*]] = insertelement <1 x float> poison, float [[TMP366]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT517:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT516]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP509:%.*]] = fmul <1 x float> [[BLOCK515]], [[SPLAT_SPLAT517]]
+; CHECK-NEXT: [[TMP1017:%.*]] = fadd <1 x float> [[TMP507]], [[TMP509]]
+; CHECK-NEXT: [[BLOCK518:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP368:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT519:%.*]] = insertelement <1 x float> poison, float [[TMP368]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT520:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT519]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1027:%.*]] = fmul <1 x float> [[BLOCK518]], [[SPLAT_SPLAT520]]
+; CHECK-NEXT: [[TMP513:%.*]] = fadd <1 x float> [[TMP1017]], [[TMP1027]]
+; CHECK-NEXT: [[BLOCK521:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP370:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT522:%.*]] = insertelement <1 x float> poison, float [[TMP370]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT523:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT522]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP515:%.*]] = fmul <1 x float> [[BLOCK521]], [[SPLAT_SPLAT523]]
+; CHECK-NEXT: [[TMP1033:%.*]] = fadd <1 x float> [[TMP513]], [[TMP515]]
+; CHECK-NEXT: [[BLOCK524:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP372:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT525:%.*]] = insertelement <1 x float> poison, float [[TMP372]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT526:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT525]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1039:%.*]] = fmul <1 x float> [[BLOCK524]], [[SPLAT_SPLAT526]]
+; CHECK-NEXT: [[TMP1045:%.*]] = fadd <1 x float> [[TMP1033]], [[TMP1039]]
+; CHECK-NEXT: [[BLOCK527:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP374:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT528:%.*]] = insertelement <1 x float> poison, float [[TMP374]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT529:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT528]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1047:%.*]] = fmul <1 x float> [[BLOCK527]], [[SPLAT_SPLAT529]]
+; CHECK-NEXT: [[TMP375:%.*]] = fadd <1 x float> [[TMP1045]], [[TMP1047]]
+; CHECK-NEXT: [[TMP376:%.*]] = shufflevector <1 x float> [[TMP375]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP377:%.*]] = shufflevector <8 x float> [[TMP359]], <8 x float> [[TMP376]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK530:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP378:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT531:%.*]] = insertelement <1 x float> poison, float [[TMP378]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT532:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT531]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1049:%.*]] = fmul <1 x float> [[BLOCK530]], [[SPLAT_SPLAT532]]
+; CHECK-NEXT: [[BLOCK533:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP380:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT534:%.*]] = insertelement <1 x float> poison, float [[TMP380]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT535:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT534]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1055:%.*]] = fmul <1 x float> [[BLOCK533]], [[SPLAT_SPLAT535]]
+; CHECK-NEXT: [[TMP529:%.*]] = fadd <1 x float> [[TMP1049]], [[TMP1055]]
+; CHECK-NEXT: [[BLOCK536:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP382:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT537:%.*]] = insertelement <1 x float> poison, float [[TMP382]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT538:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT537]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP531:%.*]] = fmul <1 x float> [[BLOCK536]], [[SPLAT_SPLAT538]]
+; CHECK-NEXT: [[TMP1067:%.*]] = fadd <1 x float> [[TMP529]], [[TMP531]]
+; CHECK-NEXT: [[BLOCK539:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP384:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT540:%.*]] = insertelement <1 x float> poison, float [[TMP384]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT541:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT540]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1073:%.*]] = fmul <1 x float> [[BLOCK539]], [[SPLAT_SPLAT541]]
+; CHECK-NEXT: [[TMP535:%.*]] = fadd <1 x float> [[TMP1067]], [[TMP1073]]
+; CHECK-NEXT: [[BLOCK542:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP386:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT543:%.*]] = insertelement <1 x float> poison, float [[TMP386]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT544:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT543]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1075:%.*]] = fmul <1 x float> [[BLOCK542]], [[SPLAT_SPLAT544]]
+; CHECK-NEXT: [[TMP1083:%.*]] = fadd <1 x float> [[TMP535]], [[TMP1075]]
+; CHECK-NEXT: [[BLOCK545:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP388:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT546:%.*]] = insertelement <1 x float> poison, float [[TMP388]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT547:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT546]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1089:%.*]] = fmul <1 x float> [[BLOCK545]], [[SPLAT_SPLAT547]]
+; CHECK-NEXT: [[TMP541:%.*]] = fadd <1 x float> [[TMP1083]], [[TMP1089]]
+; CHECK-NEXT: [[BLOCK548:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP390:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT549:%.*]] = insertelement <1 x float> poison, float [[TMP390]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT550:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT549]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP543:%.*]] = fmul <1 x float> [[BLOCK548]], [[SPLAT_SPLAT550]]
+; CHECK-NEXT: [[TMP1099:%.*]] = fadd <1 x float> [[TMP541]], [[TMP543]]
+; CHECK-NEXT: [[BLOCK551:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP392:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT552:%.*]] = insertelement <1 x float> poison, float [[TMP392]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT553:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT552]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1105:%.*]] = fmul <1 x float> [[BLOCK551]], [[SPLAT_SPLAT553]]
+; CHECK-NEXT: [[TMP393:%.*]] = fadd <1 x float> [[TMP1099]], [[TMP1105]]
+; CHECK-NEXT: [[TMP394:%.*]] = shufflevector <1 x float> [[TMP393]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP395:%.*]] = shufflevector <8 x float> [[TMP377]], <8 x float> [[TMP394]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK554:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP396:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT555:%.*]] = insertelement <1 x float> poison, float [[TMP396]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT556:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT555]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP551:%.*]] = fmul <1 x float> [[BLOCK554]], [[SPLAT_SPLAT556]]
+; CHECK-NEXT: [[BLOCK557:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP398:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT558:%.*]] = insertelement <1 x float> poison, float [[TMP398]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT559:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT558]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP553:%.*]] = fmul <1 x float> [[BLOCK557]], [[SPLAT_SPLAT559]]
+; CHECK-NEXT: [[TMP1111:%.*]] = fadd <1 x float> [[TMP551]], [[TMP553]]
+; CHECK-NEXT: [[BLOCK560:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP400:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT561:%.*]] = insertelement <1 x float> poison, float [[TMP400]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT562:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT561]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1117:%.*]] = fmul <1 x float> [[BLOCK560]], [[SPLAT_SPLAT562]]
+; CHECK-NEXT: [[TMP1123:%.*]] = fadd <1 x float> [[TMP1111]], [[TMP1117]]
+; CHECK-NEXT: [[BLOCK563:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP402:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT564:%.*]] = insertelement <1 x float> poison, float [[TMP402]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT565:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT564]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP559:%.*]] = fmul <1 x float> [[BLOCK563]], [[SPLAT_SPLAT565]]
+; CHECK-NEXT: [[TMP1125:%.*]] = fadd <1 x float> [[TMP1123]], [[TMP559]]
+; CHECK-NEXT: [[BLOCK566:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP404:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT567:%.*]] = insertelement <1 x float> poison, float [[TMP404]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT568:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT567]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1127:%.*]] = fmul <1 x float> [[BLOCK566]], [[SPLAT_SPLAT568]]
+; CHECK-NEXT: [[TMP563:%.*]] = fadd <1 x float> [[TMP1125]], [[TMP1127]]
+; CHECK-NEXT: [[BLOCK569:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP406:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT570:%.*]] = insertelement <1 x float> poison, float [[TMP406]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT571:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT570]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP565:%.*]] = fmul <1 x float> [[BLOCK569]], [[SPLAT_SPLAT571]]
+; CHECK-NEXT: [[TMP1139:%.*]] = fadd <1 x float> [[TMP563]], [[TMP565]]
+; CHECK-NEXT: [[BLOCK572:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP408:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT573:%.*]] = insertelement <1 x float> poison, float [[TMP408]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT574:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT573]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1145:%.*]] = fmul <1 x float> [[BLOCK572]], [[SPLAT_SPLAT574]]
+; CHECK-NEXT: [[TMP569:%.*]] = fadd <1 x float> [[TMP1139]], [[TMP1145]]
+; CHECK-NEXT: [[BLOCK575:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP410:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT576:%.*]] = insertelement <1 x float> poison, float [[TMP410]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT577:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT576]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP571:%.*]] = fmul <1 x float> [[BLOCK575]], [[SPLAT_SPLAT577]]
+; CHECK-NEXT: [[TMP411:%.*]] = fadd <1 x float> [[TMP569]], [[TMP571]]
+; CHECK-NEXT: [[TMP412:%.*]] = shufflevector <1 x float> [[TMP411]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP413:%.*]] = shufflevector <8 x float> [[TMP395]], <8 x float> [[TMP412]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK578:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP414:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT579:%.*]] = insertelement <1 x float> poison, float [[TMP414]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT580:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT579]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1147:%.*]] = fmul <1 x float> [[BLOCK578]], [[SPLAT_SPLAT580]]
+; CHECK-NEXT: [[BLOCK581:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP416:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT582:%.*]] = insertelement <1 x float> poison, float [[TMP416]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT583:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT582]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1161:%.*]] = fmul <1 x float> [[BLOCK581]], [[SPLAT_SPLAT583]]
+; CHECK-NEXT: [[TMP579:%.*]] = fadd <1 x float> [[TMP1147]], [[TMP1161]]
+; CHECK-NEXT: [[BLOCK584:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP418:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT585:%.*]] = insertelement <1 x float> poison, float [[TMP418]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT586:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT585]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP581:%.*]] = fmul <1 x float> [[BLOCK584]], [[SPLAT_SPLAT586]]
+; CHECK-NEXT: [[TMP1164:%.*]] = fadd <1 x float> [[TMP579]], [[TMP581]]
+; CHECK-NEXT: [[BLOCK587:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP420:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT588:%.*]] = insertelement <1 x float> poison, float [[TMP420]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT589:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT588]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1167:%.*]] = fmul <1 x float> [[BLOCK587]], [[SPLAT_SPLAT589]]
+; CHECK-NEXT: [[TMP585:%.*]] = fadd <1 x float> [[TMP1164]], [[TMP1167]]
+; CHECK-NEXT: [[BLOCK590:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP422:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT591:%.*]] = insertelement <1 x float> poison, float [[TMP422]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT592:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT591]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP587:%.*]] = fmul <1 x float> [[BLOCK590]], [[SPLAT_SPLAT592]]
+; CHECK-NEXT: [[TMP1170:%.*]] = fadd <1 x float> [[TMP585]], [[TMP587]]
+; CHECK-NEXT: [[BLOCK593:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP424:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT594:%.*]] = insertelement <1 x float> poison, float [[TMP424]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT595:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT594]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1172:%.*]] = fmul <1 x float> [[BLOCK593]], [[SPLAT_SPLAT595]]
+; CHECK-NEXT: [[TMP1173:%.*]] = fadd <1 x float> [[TMP1170]], [[TMP1172]]
+; CHECK-NEXT: [[BLOCK596:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP426:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT597:%.*]] = insertelement <1 x float> poison, float [[TMP426]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT598:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT597]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1174:%.*]] = fmul <1 x float> [[BLOCK596]], [[SPLAT_SPLAT598]]
+; CHECK-NEXT: [[TMP1175:%.*]] = fadd <1 x float> [[TMP1173]], [[TMP1174]]
+; CHECK-NEXT: [[BLOCK599:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP428:%.*]] = extractelement <8 x float> [[COL_LOAD18]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT600:%.*]] = insertelement <1 x float> poison, float [[TMP428]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT601:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT600]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1177:%.*]] = fmul <1 x float> [[BLOCK599]], [[SPLAT_SPLAT601]]
+; CHECK-NEXT: [[TMP429:%.*]] = fadd <1 x float> [[TMP1175]], [[TMP1177]]
+; CHECK-NEXT: [[TMP430:%.*]] = shufflevector <1 x float> [[TMP429]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP431:%.*]] = shufflevector <8 x float> [[TMP413]], <8 x float> [[TMP430]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK602:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP432:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT603:%.*]] = insertelement <1 x float> poison, float [[TMP432]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT604:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT603]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP601:%.*]] = fmul <1 x float> [[BLOCK602]], [[SPLAT_SPLAT604]]
+; CHECK-NEXT: [[BLOCK605:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP434:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT606:%.*]] = insertelement <1 x float> poison, float [[TMP434]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT607:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT606]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP603:%.*]] = fmul <1 x float> [[BLOCK605]], [[SPLAT_SPLAT607]]
+; CHECK-NEXT: [[TMP1180:%.*]] = fadd <1 x float> [[TMP601]], [[TMP603]]
+; CHECK-NEXT: [[BLOCK608:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP436:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT609:%.*]] = insertelement <1 x float> poison, float [[TMP436]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT610:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT609]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1183:%.*]] = fmul <1 x float> [[BLOCK608]], [[SPLAT_SPLAT610]]
+; CHECK-NEXT: [[TMP607:%.*]] = fadd <1 x float> [[TMP1180]], [[TMP1183]]
+; CHECK-NEXT: [[BLOCK611:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP438:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT612:%.*]] = insertelement <1 x float> poison, float [[TMP438]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT613:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT612]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1186:%.*]] = fmul <1 x float> [[BLOCK611]], [[SPLAT_SPLAT613]]
+; CHECK-NEXT: [[TMP1189:%.*]] = fadd <1 x float> [[TMP607]], [[TMP1186]]
+; CHECK-NEXT: [[BLOCK614:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP440:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT615:%.*]] = insertelement <1 x float> poison, float [[TMP440]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT616:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT615]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1192:%.*]] = fmul <1 x float> [[BLOCK614]], [[SPLAT_SPLAT616]]
+; CHECK-NEXT: [[TMP613:%.*]] = fadd <1 x float> [[TMP1189]], [[TMP1192]]
+; CHECK-NEXT: [[BLOCK617:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP442:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT618:%.*]] = insertelement <1 x float> poison, float [[TMP442]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT619:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT618]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP615:%.*]] = fmul <1 x float> [[BLOCK617]], [[SPLAT_SPLAT619]]
+; CHECK-NEXT: [[TMP1195:%.*]] = fadd <1 x float> [[TMP613]], [[TMP615]]
+; CHECK-NEXT: [[BLOCK620:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP444:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT621:%.*]] = insertelement <1 x float> poison, float [[TMP444]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT622:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT621]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1197:%.*]] = fmul <1 x float> [[BLOCK620]], [[SPLAT_SPLAT622]]
+; CHECK-NEXT: [[TMP619:%.*]] = fadd <1 x float> [[TMP1195]], [[TMP1197]]
+; CHECK-NEXT: [[BLOCK623:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP446:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT624:%.*]] = insertelement <1 x float> poison, float [[TMP446]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT625:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT624]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP621:%.*]] = fmul <1 x float> [[BLOCK623]], [[SPLAT_SPLAT625]]
+; CHECK-NEXT: [[TMP447:%.*]] = fadd <1 x float> [[TMP619]], [[TMP621]]
+; CHECK-NEXT: [[TMP448:%.*]] = shufflevector <1 x float> [[TMP447]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP449:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP448]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK626:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP450:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT627:%.*]] = insertelement <1 x float> poison, float [[TMP450]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT628:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT627]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1198:%.*]] = fmul <1 x float> [[BLOCK626]], [[SPLAT_SPLAT628]]
+; CHECK-NEXT: [[BLOCK629:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP452:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT630:%.*]] = insertelement <1 x float> poison, float [[TMP452]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT631:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT630]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1199:%.*]] = fmul <1 x float> [[BLOCK629]], [[SPLAT_SPLAT631]]
+; CHECK-NEXT: [[TMP1200:%.*]] = fadd <1 x float> [[TMP1198]], [[TMP1199]]
+; CHECK-NEXT: [[BLOCK632:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP454:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT633:%.*]] = insertelement <1 x float> poison, float [[TMP454]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT634:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT633]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP631:%.*]] = fmul <1 x float> [[BLOCK632]], [[SPLAT_SPLAT634]]
+; CHECK-NEXT: [[TMP1202:%.*]] = fadd <1 x float> [[TMP1200]], [[TMP631]]
+; CHECK-NEXT: [[BLOCK635:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP456:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT636:%.*]] = insertelement <1 x float> poison, float [[TMP456]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT637:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT636]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1205:%.*]] = fmul <1 x float> [[BLOCK635]], [[SPLAT_SPLAT637]]
+; CHECK-NEXT: [[TMP635:%.*]] = fadd <1 x float> [[TMP1202]], [[TMP1205]]
+; CHECK-NEXT: [[BLOCK638:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP458:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT639:%.*]] = insertelement <1 x float> poison, float [[TMP458]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT640:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT639]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP637:%.*]] = fmul <1 x float> [[BLOCK638]], [[SPLAT_SPLAT640]]
+; CHECK-NEXT: [[TMP1208:%.*]] = fadd <1 x float> [[TMP635]], [[TMP637]]
+; CHECK-NEXT: [[BLOCK641:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP460:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT642:%.*]] = insertelement <1 x float> poison, float [[TMP460]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT643:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT642]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1211:%.*]] = fmul <1 x float> [[BLOCK641]], [[SPLAT_SPLAT643]]
+; CHECK-NEXT: [[TMP641:%.*]] = fadd <1 x float> [[TMP1208]], [[TMP1211]]
+; CHECK-NEXT: [[BLOCK644:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP462:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT645:%.*]] = insertelement <1 x float> poison, float [[TMP462]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT646:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT645]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP643:%.*]] = fmul <1 x float> [[BLOCK644]], [[SPLAT_SPLAT646]]
+; CHECK-NEXT: [[TMP1214:%.*]] = fadd <1 x float> [[TMP641]], [[TMP643]]
+; CHECK-NEXT: [[BLOCK647:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP464:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT648:%.*]] = insertelement <1 x float> poison, float [[TMP464]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT649:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT648]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1217:%.*]] = fmul <1 x float> [[BLOCK647]], [[SPLAT_SPLAT649]]
+; CHECK-NEXT: [[TMP465:%.*]] = fadd <1 x float> [[TMP1214]], [[TMP1217]]
+; CHECK-NEXT: [[TMP466:%.*]] = shufflevector <1 x float> [[TMP465]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP467:%.*]] = shufflevector <8 x float> [[TMP449]], <8 x float> [[TMP466]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK650:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP468:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT651:%.*]] = insertelement <1 x float> poison, float [[TMP468]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT652:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT651]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP651:%.*]] = fmul <1 x float> [[BLOCK650]], [[SPLAT_SPLAT652]]
+; CHECK-NEXT: [[BLOCK653:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP470:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT654:%.*]] = insertelement <1 x float> poison, float [[TMP470]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT655:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT654]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP653:%.*]] = fmul <1 x float> [[BLOCK653]], [[SPLAT_SPLAT655]]
+; CHECK-NEXT: [[TMP1220:%.*]] = fadd <1 x float> [[TMP651]], [[TMP653]]
+; CHECK-NEXT: [[BLOCK656:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP472:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT657:%.*]] = insertelement <1 x float> poison, float [[TMP472]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT658:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT657]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1222:%.*]] = fmul <1 x float> [[BLOCK656]], [[SPLAT_SPLAT658]]
+; CHECK-NEXT: [[TMP657:%.*]] = fadd <1 x float> [[TMP1220]], [[TMP1222]]
+; CHECK-NEXT: [[BLOCK659:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP474:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT660:%.*]] = insertelement <1 x float> poison, float [[TMP474]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT661:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT660]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP659:%.*]] = fmul <1 x float> [[BLOCK659]], [[SPLAT_SPLAT661]]
+; CHECK-NEXT: [[TMP1223:%.*]] = fadd <1 x float> [[TMP657]], [[TMP659]]
+; CHECK-NEXT: [[BLOCK662:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP476:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT663:%.*]] = insertelement <1 x float> poison, float [[TMP476]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT664:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT663]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1224:%.*]] = fmul <1 x float> [[BLOCK662]], [[SPLAT_SPLAT664]]
+; CHECK-NEXT: [[TMP1225:%.*]] = fadd <1 x float> [[TMP1223]], [[TMP1224]]
+; CHECK-NEXT: [[BLOCK665:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP478:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT666:%.*]] = insertelement <1 x float> poison, float [[TMP478]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT667:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT666]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1227:%.*]] = fmul <1 x float> [[BLOCK665]], [[SPLAT_SPLAT667]]
+; CHECK-NEXT: [[TMP1230:%.*]] = fadd <1 x float> [[TMP1225]], [[TMP1227]]
+; CHECK-NEXT: [[BLOCK668:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP480:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT669:%.*]] = insertelement <1 x float> poison, float [[TMP480]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT670:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT669]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1233:%.*]] = fmul <1 x float> [[BLOCK668]], [[SPLAT_SPLAT670]]
+; CHECK-NEXT: [[TMP669:%.*]] = fadd <1 x float> [[TMP1230]], [[TMP1233]]
+; CHECK-NEXT: [[BLOCK671:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP482:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT672:%.*]] = insertelement <1 x float> poison, float [[TMP482]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT673:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT672]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP671:%.*]] = fmul <1 x float> [[BLOCK671]], [[SPLAT_SPLAT673]]
+; CHECK-NEXT: [[TMP483:%.*]] = fadd <1 x float> [[TMP669]], [[TMP671]]
+; CHECK-NEXT: [[TMP484:%.*]] = shufflevector <1 x float> [[TMP483]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP485:%.*]] = shufflevector <8 x float> [[TMP467]], <8 x float> [[TMP484]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK674:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP486:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT675:%.*]] = insertelement <1 x float> poison, float [[TMP486]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT676:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT675]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1236:%.*]] = fmul <1 x float> [[BLOCK674]], [[SPLAT_SPLAT676]]
+; CHECK-NEXT: [[BLOCK677:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP488:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT678:%.*]] = insertelement <1 x float> poison, float [[TMP488]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT679:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT678]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1239:%.*]] = fmul <1 x float> [[BLOCK677]], [[SPLAT_SPLAT679]]
+; CHECK-NEXT: [[TMP679:%.*]] = fadd <1 x float> [[TMP1236]], [[TMP1239]]
+; CHECK-NEXT: [[BLOCK680:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP490:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT681:%.*]] = insertelement <1 x float> poison, float [[TMP490]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT682:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT681]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1242:%.*]] = fmul <1 x float> [[BLOCK680]], [[SPLAT_SPLAT682]]
+; CHECK-NEXT: [[TMP1245:%.*]] = fadd <1 x float> [[TMP679]], [[TMP1242]]
+; CHECK-NEXT: [[BLOCK683:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP492:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT684:%.*]] = insertelement <1 x float> poison, float [[TMP492]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT685:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT684]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1247:%.*]] = fmul <1 x float> [[BLOCK683]], [[SPLAT_SPLAT685]]
+; CHECK-NEXT: [[TMP685:%.*]] = fadd <1 x float> [[TMP1245]], [[TMP1247]]
+; CHECK-NEXT: [[BLOCK686:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP494:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT687:%.*]] = insertelement <1 x float> poison, float [[TMP494]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT688:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT687]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP687:%.*]] = fmul <1 x float> [[BLOCK686]], [[SPLAT_SPLAT688]]
+; CHECK-NEXT: [[TMP1248:%.*]] = fadd <1 x float> [[TMP685]], [[TMP687]]
+; CHECK-NEXT: [[BLOCK689:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP496:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT690:%.*]] = insertelement <1 x float> poison, float [[TMP496]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT691:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT690]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1249:%.*]] = fmul <1 x float> [[BLOCK689]], [[SPLAT_SPLAT691]]
+; CHECK-NEXT: [[TMP691:%.*]] = fadd <1 x float> [[TMP1248]], [[TMP1249]]
+; CHECK-NEXT: [[BLOCK692:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP498:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT693:%.*]] = insertelement <1 x float> poison, float [[TMP498]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT694:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT693]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP693:%.*]] = fmul <1 x float> [[BLOCK692]], [[SPLAT_SPLAT694]]
+; CHECK-NEXT: [[TMP1250:%.*]] = fadd <1 x float> [[TMP691]], [[TMP693]]
+; CHECK-NEXT: [[BLOCK695:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP500:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT696:%.*]] = insertelement <1 x float> poison, float [[TMP500]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT697:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT696]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1252:%.*]] = fmul <1 x float> [[BLOCK695]], [[SPLAT_SPLAT697]]
+; CHECK-NEXT: [[TMP501:%.*]] = fadd <1 x float> [[TMP1250]], [[TMP1252]]
+; CHECK-NEXT: [[TMP502:%.*]] = shufflevector <1 x float> [[TMP501]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP503:%.*]] = shufflevector <8 x float> [[TMP485]], <8 x float> [[TMP502]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK698:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP504:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT699:%.*]] = insertelement <1 x float> poison, float [[TMP504]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT700:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT699]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1255:%.*]] = fmul <1 x float> [[BLOCK698]], [[SPLAT_SPLAT700]]
+; CHECK-NEXT: [[BLOCK701:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP506:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT702:%.*]] = insertelement <1 x float> poison, float [[TMP506]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT703:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT702]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP703:%.*]] = fmul <1 x float> [[BLOCK701]], [[SPLAT_SPLAT703]]
+; CHECK-NEXT: [[TMP1258:%.*]] = fadd <1 x float> [[TMP1255]], [[TMP703]]
+; CHECK-NEXT: [[BLOCK704:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP508:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT705:%.*]] = insertelement <1 x float> poison, float [[TMP508]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT706:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT705]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1261:%.*]] = fmul <1 x float> [[BLOCK704]], [[SPLAT_SPLAT706]]
+; CHECK-NEXT: [[TMP707:%.*]] = fadd <1 x float> [[TMP1258]], [[TMP1261]]
+; CHECK-NEXT: [[BLOCK707:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP510:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT708:%.*]] = insertelement <1 x float> poison, float [[TMP510]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT709:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT708]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP709:%.*]] = fmul <1 x float> [[BLOCK707]], [[SPLAT_SPLAT709]]
+; CHECK-NEXT: [[TMP1264:%.*]] = fadd <1 x float> [[TMP707]], [[TMP709]]
+; CHECK-NEXT: [[BLOCK710:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP512:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT711:%.*]] = insertelement <1 x float> poison, float [[TMP512]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT712:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT711]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1267:%.*]] = fmul <1 x float> [[BLOCK710]], [[SPLAT_SPLAT712]]
+; CHECK-NEXT: [[TMP713:%.*]] = fadd <1 x float> [[TMP1264]], [[TMP1267]]
+; CHECK-NEXT: [[BLOCK713:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP514:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT714:%.*]] = insertelement <1 x float> poison, float [[TMP514]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT715:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT714]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP715:%.*]] = fmul <1 x float> [[BLOCK713]], [[SPLAT_SPLAT715]]
+; CHECK-NEXT: [[TMP1270:%.*]] = fadd <1 x float> [[TMP713]], [[TMP715]]
+; CHECK-NEXT: [[BLOCK716:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP516:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT717:%.*]] = insertelement <1 x float> poison, float [[TMP516]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT718:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT717]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1272:%.*]] = fmul <1 x float> [[BLOCK716]], [[SPLAT_SPLAT718]]
+; CHECK-NEXT: [[TMP1273:%.*]] = fadd <1 x float> [[TMP1270]], [[TMP1272]]
+; CHECK-NEXT: [[BLOCK719:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP518:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT720:%.*]] = insertelement <1 x float> poison, float [[TMP518]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT721:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT720]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP721:%.*]] = fmul <1 x float> [[BLOCK719]], [[SPLAT_SPLAT721]]
+; CHECK-NEXT: [[TMP519:%.*]] = fadd <1 x float> [[TMP1273]], [[TMP721]]
+; CHECK-NEXT: [[TMP520:%.*]] = shufflevector <1 x float> [[TMP519]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP521:%.*]] = shufflevector <8 x float> [[TMP503]], <8 x float> [[TMP520]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK722:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP522:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT723:%.*]] = insertelement <1 x float> poison, float [[TMP522]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT724:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT723]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1274:%.*]] = fmul <1 x float> [[BLOCK722]], [[SPLAT_SPLAT724]]
+; CHECK-NEXT: [[BLOCK725:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP524:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT726:%.*]] = insertelement <1 x float> poison, float [[TMP524]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT727:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT726]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1275:%.*]] = fmul <1 x float> [[BLOCK725]], [[SPLAT_SPLAT727]]
+; CHECK-NEXT: [[TMP729:%.*]] = fadd <1 x float> [[TMP1274]], [[TMP1275]]
+; CHECK-NEXT: [[BLOCK728:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP526:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT729:%.*]] = insertelement <1 x float> poison, float [[TMP526]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT730:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT729]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP731:%.*]] = fmul <1 x float> [[BLOCK728]], [[SPLAT_SPLAT730]]
+; CHECK-NEXT: [[TMP1277:%.*]] = fadd <1 x float> [[TMP729]], [[TMP731]]
+; CHECK-NEXT: [[BLOCK731:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP528:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT732:%.*]] = insertelement <1 x float> poison, float [[TMP528]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT733:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT732]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1280:%.*]] = fmul <1 x float> [[BLOCK731]], [[SPLAT_SPLAT733]]
+; CHECK-NEXT: [[TMP1283:%.*]] = fadd <1 x float> [[TMP1277]], [[TMP1280]]
+; CHECK-NEXT: [[BLOCK734:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP530:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT735:%.*]] = insertelement <1 x float> poison, float [[TMP530]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT736:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT735]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1286:%.*]] = fmul <1 x float> [[BLOCK734]], [[SPLAT_SPLAT736]]
+; CHECK-NEXT: [[TMP1289:%.*]] = fadd <1 x float> [[TMP1283]], [[TMP1286]]
+; CHECK-NEXT: [[BLOCK737:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP532:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT738:%.*]] = insertelement <1 x float> poison, float [[TMP532]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT739:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT738]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1292:%.*]] = fmul <1 x float> [[BLOCK737]], [[SPLAT_SPLAT739]]
+; CHECK-NEXT: [[TMP741:%.*]] = fadd <1 x float> [[TMP1289]], [[TMP1292]]
+; CHECK-NEXT: [[BLOCK740:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP534:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT741:%.*]] = insertelement <1 x float> poison, float [[TMP534]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT742:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT741]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP743:%.*]] = fmul <1 x float> [[BLOCK740]], [[SPLAT_SPLAT742]]
+; CHECK-NEXT: [[TMP1295:%.*]] = fadd <1 x float> [[TMP741]], [[TMP743]]
+; CHECK-NEXT: [[BLOCK743:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP536:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT744:%.*]] = insertelement <1 x float> poison, float [[TMP536]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT745:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT744]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1297:%.*]] = fmul <1 x float> [[BLOCK743]], [[SPLAT_SPLAT745]]
+; CHECK-NEXT: [[TMP537:%.*]] = fadd <1 x float> [[TMP1295]], [[TMP1297]]
+; CHECK-NEXT: [[TMP538:%.*]] = shufflevector <1 x float> [[TMP537]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP539:%.*]] = shufflevector <8 x float> [[TMP521]], <8 x float> [[TMP538]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK746:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP540:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT747:%.*]] = insertelement <1 x float> poison, float [[TMP540]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT748:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT747]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP751:%.*]] = fmul <1 x float> [[BLOCK746]], [[SPLAT_SPLAT748]]
+; CHECK-NEXT: [[BLOCK749:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP542:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT750:%.*]] = insertelement <1 x float> poison, float [[TMP542]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT751:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT750]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1298:%.*]] = fmul <1 x float> [[BLOCK749]], [[SPLAT_SPLAT751]]
+; CHECK-NEXT: [[TMP1299:%.*]] = fadd <1 x float> [[TMP751]], [[TMP1298]]
+; CHECK-NEXT: [[BLOCK752:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP544:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT753:%.*]] = insertelement <1 x float> poison, float [[TMP544]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT754:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT753]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1300:%.*]] = fmul <1 x float> [[BLOCK752]], [[SPLAT_SPLAT754]]
+; CHECK-NEXT: [[TMP757:%.*]] = fadd <1 x float> [[TMP1299]], [[TMP1300]]
+; CHECK-NEXT: [[BLOCK755:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP546:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT756:%.*]] = insertelement <1 x float> poison, float [[TMP546]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT757:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT756]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP759:%.*]] = fmul <1 x float> [[BLOCK755]], [[SPLAT_SPLAT757]]
+; CHECK-NEXT: [[TMP1302:%.*]] = fadd <1 x float> [[TMP757]], [[TMP759]]
+; CHECK-NEXT: [[BLOCK758:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP548:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT759:%.*]] = insertelement <1 x float> poison, float [[TMP548]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT760:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT759]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1305:%.*]] = fmul <1 x float> [[BLOCK758]], [[SPLAT_SPLAT760]]
+; CHECK-NEXT: [[TMP763:%.*]] = fadd <1 x float> [[TMP1302]], [[TMP1305]]
+; CHECK-NEXT: [[BLOCK761:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP550:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT762:%.*]] = insertelement <1 x float> poison, float [[TMP550]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT763:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT762]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP765:%.*]] = fmul <1 x float> [[BLOCK761]], [[SPLAT_SPLAT763]]
+; CHECK-NEXT: [[TMP1308:%.*]] = fadd <1 x float> [[TMP763]], [[TMP765]]
+; CHECK-NEXT: [[BLOCK764:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP552:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT765:%.*]] = insertelement <1 x float> poison, float [[TMP552]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT766:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT765]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1311:%.*]] = fmul <1 x float> [[BLOCK764]], [[SPLAT_SPLAT766]]
+; CHECK-NEXT: [[TMP769:%.*]] = fadd <1 x float> [[TMP1308]], [[TMP1311]]
+; CHECK-NEXT: [[BLOCK767:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP554:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT768:%.*]] = insertelement <1 x float> poison, float [[TMP554]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT769:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT768]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1314:%.*]] = fmul <1 x float> [[BLOCK767]], [[SPLAT_SPLAT769]]
+; CHECK-NEXT: [[TMP555:%.*]] = fadd <1 x float> [[TMP769]], [[TMP1314]]
+; CHECK-NEXT: [[TMP556:%.*]] = shufflevector <1 x float> [[TMP555]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP557:%.*]] = shufflevector <8 x float> [[TMP539]], <8 x float> [[TMP556]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK770:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP558:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT771:%.*]] = insertelement <1 x float> poison, float [[TMP558]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT772:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT771]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1317:%.*]] = fmul <1 x float> [[BLOCK770]], [[SPLAT_SPLAT772]]
+; CHECK-NEXT: [[BLOCK773:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP560:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT774:%.*]] = insertelement <1 x float> poison, float [[TMP560]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT775:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT774]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1320:%.*]] = fmul <1 x float> [[BLOCK773]], [[SPLAT_SPLAT775]]
+; CHECK-NEXT: [[TMP779:%.*]] = fadd <1 x float> [[TMP1317]], [[TMP1320]]
+; CHECK-NEXT: [[BLOCK776:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP562:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT777:%.*]] = insertelement <1 x float> poison, float [[TMP562]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT778:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT777]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP781:%.*]] = fmul <1 x float> [[BLOCK776]], [[SPLAT_SPLAT778]]
+; CHECK-NEXT: [[TMP1322:%.*]] = fadd <1 x float> [[TMP779]], [[TMP781]]
+; CHECK-NEXT: [[BLOCK779:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP564:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT780:%.*]] = insertelement <1 x float> poison, float [[TMP564]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT781:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT780]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1323:%.*]] = fmul <1 x float> [[BLOCK779]], [[SPLAT_SPLAT781]]
+; CHECK-NEXT: [[TMP785:%.*]] = fadd <1 x float> [[TMP1322]], [[TMP1323]]
+; CHECK-NEXT: [[BLOCK782:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP566:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT783:%.*]] = insertelement <1 x float> poison, float [[TMP566]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT784:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT783]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP787:%.*]] = fmul <1 x float> [[BLOCK782]], [[SPLAT_SPLAT784]]
+; CHECK-NEXT: [[TMP1324:%.*]] = fadd <1 x float> [[TMP785]], [[TMP787]]
+; CHECK-NEXT: [[BLOCK785:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP568:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT786:%.*]] = insertelement <1 x float> poison, float [[TMP568]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT787:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT786]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1325:%.*]] = fmul <1 x float> [[BLOCK785]], [[SPLAT_SPLAT787]]
+; CHECK-NEXT: [[TMP1327:%.*]] = fadd <1 x float> [[TMP1324]], [[TMP1325]]
+; CHECK-NEXT: [[BLOCK788:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP570:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT789:%.*]] = insertelement <1 x float> poison, float [[TMP570]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT790:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT789]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP793:%.*]] = fmul <1 x float> [[BLOCK788]], [[SPLAT_SPLAT790]]
+; CHECK-NEXT: [[TMP1330:%.*]] = fadd <1 x float> [[TMP1327]], [[TMP793]]
+; CHECK-NEXT: [[BLOCK791:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP572:%.*]] = extractelement <8 x float> [[COL_LOAD20]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT792:%.*]] = insertelement <1 x float> poison, float [[TMP572]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT793:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT792]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1333:%.*]] = fmul <1 x float> [[BLOCK791]], [[SPLAT_SPLAT793]]
+; CHECK-NEXT: [[TMP573:%.*]] = fadd <1 x float> [[TMP1330]], [[TMP1333]]
+; CHECK-NEXT: [[TMP574:%.*]] = shufflevector <1 x float> [[TMP573]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP575:%.*]] = shufflevector <8 x float> [[TMP557]], <8 x float> [[TMP574]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK794:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP576:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT795:%.*]] = insertelement <1 x float> poison, float [[TMP576]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT796:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT795]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP801:%.*]] = fmul <1 x float> [[BLOCK794]], [[SPLAT_SPLAT796]]
+; CHECK-NEXT: [[BLOCK797:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP578:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT798:%.*]] = insertelement <1 x float> poison, float [[TMP578]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT799:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT798]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP803:%.*]] = fmul <1 x float> [[BLOCK797]], [[SPLAT_SPLAT799]]
+; CHECK-NEXT: [[TMP1336:%.*]] = fadd <1 x float> [[TMP801]], [[TMP803]]
+; CHECK-NEXT: [[BLOCK800:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP580:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT801:%.*]] = insertelement <1 x float> poison, float [[TMP580]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT802:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT801]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1339:%.*]] = fmul <1 x float> [[BLOCK800]], [[SPLAT_SPLAT802]]
+; CHECK-NEXT: [[TMP1342:%.*]] = fadd <1 x float> [[TMP1336]], [[TMP1339]]
+; CHECK-NEXT: [[BLOCK803:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP582:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT804:%.*]] = insertelement <1 x float> poison, float [[TMP582]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT805:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT804]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1345:%.*]] = fmul <1 x float> [[BLOCK803]], [[SPLAT_SPLAT805]]
+; CHECK-NEXT: [[TMP1347:%.*]] = fadd <1 x float> [[TMP1342]], [[TMP1345]]
+; CHECK-NEXT: [[BLOCK806:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP584:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT807:%.*]] = insertelement <1 x float> poison, float [[TMP584]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT808:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT807]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1348:%.*]] = fmul <1 x float> [[BLOCK806]], [[SPLAT_SPLAT808]]
+; CHECK-NEXT: [[TMP813:%.*]] = fadd <1 x float> [[TMP1347]], [[TMP1348]]
+; CHECK-NEXT: [[BLOCK809:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP586:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT810:%.*]] = insertelement <1 x float> poison, float [[TMP586]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT811:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT810]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP815:%.*]] = fmul <1 x float> [[BLOCK809]], [[SPLAT_SPLAT811]]
+; CHECK-NEXT: [[TMP1349:%.*]] = fadd <1 x float> [[TMP813]], [[TMP815]]
+; CHECK-NEXT: [[BLOCK812:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP588:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT813:%.*]] = insertelement <1 x float> poison, float [[TMP588]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT814:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT813]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1350:%.*]] = fmul <1 x float> [[BLOCK812]], [[SPLAT_SPLAT814]]
+; CHECK-NEXT: [[TMP819:%.*]] = fadd <1 x float> [[TMP1349]], [[TMP1350]]
+; CHECK-NEXT: [[BLOCK815:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP590:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT816:%.*]] = insertelement <1 x float> poison, float [[TMP590]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT817:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT816]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP821:%.*]] = fmul <1 x float> [[BLOCK815]], [[SPLAT_SPLAT817]]
+; CHECK-NEXT: [[TMP591:%.*]] = fadd <1 x float> [[TMP819]], [[TMP821]]
+; CHECK-NEXT: [[TMP592:%.*]] = shufflevector <1 x float> [[TMP591]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP593:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP592]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK818:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP594:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT819:%.*]] = insertelement <1 x float> poison, float [[TMP594]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT820:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT819]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1352:%.*]] = fmul <1 x float> [[BLOCK818]], [[SPLAT_SPLAT820]]
+; CHECK-NEXT: [[BLOCK821:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP596:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT822:%.*]] = insertelement <1 x float> poison, float [[TMP596]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT823:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT822]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1355:%.*]] = fmul <1 x float> [[BLOCK821]], [[SPLAT_SPLAT823]]
+; CHECK-NEXT: [[TMP829:%.*]] = fadd <1 x float> [[TMP1352]], [[TMP1355]]
+; CHECK-NEXT: [[BLOCK824:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP598:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT825:%.*]] = insertelement <1 x float> poison, float [[TMP598]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT826:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT825]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP831:%.*]] = fmul <1 x float> [[BLOCK824]], [[SPLAT_SPLAT826]]
+; CHECK-NEXT: [[TMP1358:%.*]] = fadd <1 x float> [[TMP829]], [[TMP831]]
+; CHECK-NEXT: [[BLOCK827:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP600:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT828:%.*]] = insertelement <1 x float> poison, float [[TMP600]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT829:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT828]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1361:%.*]] = fmul <1 x float> [[BLOCK827]], [[SPLAT_SPLAT829]]
+; CHECK-NEXT: [[TMP835:%.*]] = fadd <1 x float> [[TMP1358]], [[TMP1361]]
+; CHECK-NEXT: [[BLOCK830:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP602:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT831:%.*]] = insertelement <1 x float> poison, float [[TMP602]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT832:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT831]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP837:%.*]] = fmul <1 x float> [[BLOCK830]], [[SPLAT_SPLAT832]]
+; CHECK-NEXT: [[TMP1364:%.*]] = fadd <1 x float> [[TMP835]], [[TMP837]]
+; CHECK-NEXT: [[BLOCK833:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP604:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT834:%.*]] = insertelement <1 x float> poison, float [[TMP604]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT835:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT834]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1367:%.*]] = fmul <1 x float> [[BLOCK833]], [[SPLAT_SPLAT835]]
+; CHECK-NEXT: [[TMP841:%.*]] = fadd <1 x float> [[TMP1364]], [[TMP1367]]
+; CHECK-NEXT: [[BLOCK836:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP606:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT837:%.*]] = insertelement <1 x float> poison, float [[TMP606]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT838:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT837]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1370:%.*]] = fmul <1 x float> [[BLOCK836]], [[SPLAT_SPLAT838]]
+; CHECK-NEXT: [[TMP1372:%.*]] = fadd <1 x float> [[TMP841]], [[TMP1370]]
+; CHECK-NEXT: [[BLOCK839:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP608:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT840:%.*]] = insertelement <1 x float> poison, float [[TMP608]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT841:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT840]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1373:%.*]] = fmul <1 x float> [[BLOCK839]], [[SPLAT_SPLAT841]]
+; CHECK-NEXT: [[TMP609:%.*]] = fadd <1 x float> [[TMP1372]], [[TMP1373]]
+; CHECK-NEXT: [[TMP610:%.*]] = shufflevector <1 x float> [[TMP609]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP611:%.*]] = shufflevector <8 x float> [[TMP593]], <8 x float> [[TMP610]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK842:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP612:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT843:%.*]] = insertelement <1 x float> poison, float [[TMP612]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT844:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT843]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP851:%.*]] = fmul <1 x float> [[BLOCK842]], [[SPLAT_SPLAT844]]
+; CHECK-NEXT: [[BLOCK845:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP614:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT846:%.*]] = insertelement <1 x float> poison, float [[TMP614]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT847:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT846]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP853:%.*]] = fmul <1 x float> [[BLOCK845]], [[SPLAT_SPLAT847]]
+; CHECK-NEXT: [[TMP1374:%.*]] = fadd <1 x float> [[TMP851]], [[TMP853]]
+; CHECK-NEXT: [[BLOCK848:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP616:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT849:%.*]] = insertelement <1 x float> poison, float [[TMP616]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT850:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT849]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1375:%.*]] = fmul <1 x float> [[BLOCK848]], [[SPLAT_SPLAT850]]
+; CHECK-NEXT: [[TMP857:%.*]] = fadd <1 x float> [[TMP1374]], [[TMP1375]]
+; CHECK-NEXT: [[BLOCK851:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP618:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT852:%.*]] = insertelement <1 x float> poison, float [[TMP618]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT853:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT852]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP859:%.*]] = fmul <1 x float> [[BLOCK851]], [[SPLAT_SPLAT853]]
+; CHECK-NEXT: [[TMP1377:%.*]] = fadd <1 x float> [[TMP857]], [[TMP859]]
+; CHECK-NEXT: [[BLOCK854:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP620:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT855:%.*]] = insertelement <1 x float> poison, float [[TMP620]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT856:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT855]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1380:%.*]] = fmul <1 x float> [[BLOCK854]], [[SPLAT_SPLAT856]]
+; CHECK-NEXT: [[TMP1383:%.*]] = fadd <1 x float> [[TMP1377]], [[TMP1380]]
+; CHECK-NEXT: [[BLOCK857:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP622:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT858:%.*]] = insertelement <1 x float> poison, float [[TMP622]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT859:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT858]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP865:%.*]] = fmul <1 x float> [[BLOCK857]], [[SPLAT_SPLAT859]]
+; CHECK-NEXT: [[TMP1386:%.*]] = fadd <1 x float> [[TMP1383]], [[TMP865]]
+; CHECK-NEXT: [[BLOCK860:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP624:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT861:%.*]] = insertelement <1 x float> poison, float [[TMP624]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT862:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT861]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1389:%.*]] = fmul <1 x float> [[BLOCK860]], [[SPLAT_SPLAT862]]
+; CHECK-NEXT: [[TMP869:%.*]] = fadd <1 x float> [[TMP1386]], [[TMP1389]]
+; CHECK-NEXT: [[BLOCK863:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP626:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT864:%.*]] = insertelement <1 x float> poison, float [[TMP626]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT865:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT864]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP871:%.*]] = fmul <1 x float> [[BLOCK863]], [[SPLAT_SPLAT865]]
+; CHECK-NEXT: [[TMP627:%.*]] = fadd <1 x float> [[TMP869]], [[TMP871]]
+; CHECK-NEXT: [[TMP628:%.*]] = shufflevector <1 x float> [[TMP627]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP629:%.*]] = shufflevector <8 x float> [[TMP611]], <8 x float> [[TMP628]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK866:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP630:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT867:%.*]] = insertelement <1 x float> poison, float [[TMP630]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT868:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT867]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1392:%.*]] = fmul <1 x float> [[BLOCK866]], [[SPLAT_SPLAT868]]
+; CHECK-NEXT: [[BLOCK869:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP632:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT870:%.*]] = insertelement <1 x float> poison, float [[TMP632]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT871:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT870]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1395:%.*]] = fmul <1 x float> [[BLOCK869]], [[SPLAT_SPLAT871]]
+; CHECK-NEXT: [[TMP1397:%.*]] = fadd <1 x float> [[TMP1392]], [[TMP1395]]
+; CHECK-NEXT: [[BLOCK872:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP634:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT873:%.*]] = insertelement <1 x float> poison, float [[TMP634]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT874:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT873]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1398:%.*]] = fmul <1 x float> [[BLOCK872]], [[SPLAT_SPLAT874]]
+; CHECK-NEXT: [[TMP1399:%.*]] = fadd <1 x float> [[TMP1397]], [[TMP1398]]
+; CHECK-NEXT: [[BLOCK875:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP636:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT876:%.*]] = insertelement <1 x float> poison, float [[TMP636]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT877:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT876]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1400:%.*]] = fmul <1 x float> [[BLOCK875]], [[SPLAT_SPLAT877]]
+; CHECK-NEXT: [[TMP885:%.*]] = fadd <1 x float> [[TMP1399]], [[TMP1400]]
+; CHECK-NEXT: [[BLOCK878:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP638:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT879:%.*]] = insertelement <1 x float> poison, float [[TMP638]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT880:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT879]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP887:%.*]] = fmul <1 x float> [[BLOCK878]], [[SPLAT_SPLAT880]]
+; CHECK-NEXT: [[TMP1402:%.*]] = fadd <1 x float> [[TMP885]], [[TMP887]]
+; CHECK-NEXT: [[BLOCK881:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP640:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT882:%.*]] = insertelement <1 x float> poison, float [[TMP640]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT883:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT882]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1405:%.*]] = fmul <1 x float> [[BLOCK881]], [[SPLAT_SPLAT883]]
+; CHECK-NEXT: [[TMP891:%.*]] = fadd <1 x float> [[TMP1402]], [[TMP1405]]
+; CHECK-NEXT: [[BLOCK884:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP642:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT885:%.*]] = insertelement <1 x float> poison, float [[TMP642]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT886:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT885]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP893:%.*]] = fmul <1 x float> [[BLOCK884]], [[SPLAT_SPLAT886]]
+; CHECK-NEXT: [[TMP1408:%.*]] = fadd <1 x float> [[TMP891]], [[TMP893]]
+; CHECK-NEXT: [[BLOCK887:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP644:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT888:%.*]] = insertelement <1 x float> poison, float [[TMP644]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT889:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT888]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1411:%.*]] = fmul <1 x float> [[BLOCK887]], [[SPLAT_SPLAT889]]
+; CHECK-NEXT: [[TMP645:%.*]] = fadd <1 x float> [[TMP1408]], [[TMP1411]]
+; CHECK-NEXT: [[TMP646:%.*]] = shufflevector <1 x float> [[TMP645]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP647:%.*]] = shufflevector <8 x float> [[TMP629]], <8 x float> [[TMP646]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK890:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP648:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT891:%.*]] = insertelement <1 x float> poison, float [[TMP648]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT892:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT891]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP901:%.*]] = fmul <1 x float> [[BLOCK890]], [[SPLAT_SPLAT892]]
+; CHECK-NEXT: [[BLOCK893:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP650:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT894:%.*]] = insertelement <1 x float> poison, float [[TMP650]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT895:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT894]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP903:%.*]] = fmul <1 x float> [[BLOCK893]], [[SPLAT_SPLAT895]]
+; CHECK-NEXT: [[TMP1414:%.*]] = fadd <1 x float> [[TMP901]], [[TMP903]]
+; CHECK-NEXT: [[BLOCK896:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP652:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT897:%.*]] = insertelement <1 x float> poison, float [[TMP652]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT898:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT897]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1417:%.*]] = fmul <1 x float> [[BLOCK896]], [[SPLAT_SPLAT898]]
+; CHECK-NEXT: [[TMP907:%.*]] = fadd <1 x float> [[TMP1414]], [[TMP1417]]
+; CHECK-NEXT: [[BLOCK899:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP654:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT900:%.*]] = insertelement <1 x float> poison, float [[TMP654]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT901:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT900]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP909:%.*]] = fmul <1 x float> [[BLOCK899]], [[SPLAT_SPLAT901]]
+; CHECK-NEXT: [[TMP1420:%.*]] = fadd <1 x float> [[TMP907]], [[TMP909]]
+; CHECK-NEXT: [[BLOCK902:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP656:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT903:%.*]] = insertelement <1 x float> poison, float [[TMP656]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT904:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT903]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1422:%.*]] = fmul <1 x float> [[BLOCK902]], [[SPLAT_SPLAT904]]
+; CHECK-NEXT: [[TMP913:%.*]] = fadd <1 x float> [[TMP1420]], [[TMP1422]]
+; CHECK-NEXT: [[BLOCK905:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP658:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT906:%.*]] = insertelement <1 x float> poison, float [[TMP658]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT907:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT906]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1423:%.*]] = fmul <1 x float> [[BLOCK905]], [[SPLAT_SPLAT907]]
+; CHECK-NEXT: [[TMP1424:%.*]] = fadd <1 x float> [[TMP913]], [[TMP1423]]
+; CHECK-NEXT: [[BLOCK908:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP660:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT909:%.*]] = insertelement <1 x float> poison, float [[TMP660]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT910:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT909]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1425:%.*]] = fmul <1 x float> [[BLOCK908]], [[SPLAT_SPLAT910]]
+; CHECK-NEXT: [[TMP919:%.*]] = fadd <1 x float> [[TMP1424]], [[TMP1425]]
+; CHECK-NEXT: [[BLOCK911:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP662:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT912:%.*]] = insertelement <1 x float> poison, float [[TMP662]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT913:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT912]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP921:%.*]] = fmul <1 x float> [[BLOCK911]], [[SPLAT_SPLAT913]]
+; CHECK-NEXT: [[TMP663:%.*]] = fadd <1 x float> [[TMP919]], [[TMP921]]
+; CHECK-NEXT: [[TMP664:%.*]] = shufflevector <1 x float> [[TMP663]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP665:%.*]] = shufflevector <8 x float> [[TMP647]], <8 x float> [[TMP664]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK914:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP666:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT915:%.*]] = insertelement <1 x float> poison, float [[TMP666]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT916:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT915]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1427:%.*]] = fmul <1 x float> [[BLOCK914]], [[SPLAT_SPLAT916]]
+; CHECK-NEXT: [[BLOCK917:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP668:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT918:%.*]] = insertelement <1 x float> poison, float [[TMP668]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT919:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT918]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1430:%.*]] = fmul <1 x float> [[BLOCK917]], [[SPLAT_SPLAT919]]
+; CHECK-NEXT: [[TMP929:%.*]] = fadd <1 x float> [[TMP1427]], [[TMP1430]]
+; CHECK-NEXT: [[BLOCK920:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP670:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT921:%.*]] = insertelement <1 x float> poison, float [[TMP670]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT922:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT921]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP931:%.*]] = fmul <1 x float> [[BLOCK920]], [[SPLAT_SPLAT922]]
+; CHECK-NEXT: [[TMP1433:%.*]] = fadd <1 x float> [[TMP929]], [[TMP931]]
+; CHECK-NEXT: [[BLOCK923:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP672:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT924:%.*]] = insertelement <1 x float> poison, float [[TMP672]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT925:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT924]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1436:%.*]] = fmul <1 x float> [[BLOCK923]], [[SPLAT_SPLAT925]]
+; CHECK-NEXT: [[TMP1439:%.*]] = fadd <1 x float> [[TMP1433]], [[TMP1436]]
+; CHECK-NEXT: [[BLOCK926:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP674:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT927:%.*]] = insertelement <1 x float> poison, float [[TMP674]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT928:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT927]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP937:%.*]] = fmul <1 x float> [[BLOCK926]], [[SPLAT_SPLAT928]]
+; CHECK-NEXT: [[TMP1442:%.*]] = fadd <1 x float> [[TMP1439]], [[TMP937]]
+; CHECK-NEXT: [[BLOCK929:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP676:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT930:%.*]] = insertelement <1 x float> poison, float [[TMP676]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT931:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT930]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1445:%.*]] = fmul <1 x float> [[BLOCK929]], [[SPLAT_SPLAT931]]
+; CHECK-NEXT: [[TMP941:%.*]] = fadd <1 x float> [[TMP1442]], [[TMP1445]]
+; CHECK-NEXT: [[BLOCK932:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP678:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT933:%.*]] = insertelement <1 x float> poison, float [[TMP678]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT934:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT933]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP943:%.*]] = fmul <1 x float> [[BLOCK932]], [[SPLAT_SPLAT934]]
+; CHECK-NEXT: [[TMP1447:%.*]] = fadd <1 x float> [[TMP941]], [[TMP943]]
+; CHECK-NEXT: [[BLOCK935:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP680:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT936:%.*]] = insertelement <1 x float> poison, float [[TMP680]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT937:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT936]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1448:%.*]] = fmul <1 x float> [[BLOCK935]], [[SPLAT_SPLAT937]]
+; CHECK-NEXT: [[TMP681:%.*]] = fadd <1 x float> [[TMP1447]], [[TMP1448]]
+; CHECK-NEXT: [[TMP682:%.*]] = shufflevector <1 x float> [[TMP681]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP683:%.*]] = shufflevector <8 x float> [[TMP665]], <8 x float> [[TMP682]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK938:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP684:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT939:%.*]] = insertelement <1 x float> poison, float [[TMP684]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT940:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT939]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1449:%.*]] = fmul <1 x float> [[BLOCK938]], [[SPLAT_SPLAT940]]
+; CHECK-NEXT: [[BLOCK941:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP686:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT942:%.*]] = insertelement <1 x float> poison, float [[TMP686]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT943:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT942]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1450:%.*]] = fmul <1 x float> [[BLOCK941]], [[SPLAT_SPLAT943]]
+; CHECK-NEXT: [[TMP1452:%.*]] = fadd <1 x float> [[TMP1449]], [[TMP1450]]
+; CHECK-NEXT: [[BLOCK944:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP688:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT945:%.*]] = insertelement <1 x float> poison, float [[TMP688]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT946:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT945]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1455:%.*]] = fmul <1 x float> [[BLOCK944]], [[SPLAT_SPLAT946]]
+; CHECK-NEXT: [[TMP957:%.*]] = fadd <1 x float> [[TMP1452]], [[TMP1455]]
+; CHECK-NEXT: [[BLOCK947:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP690:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT948:%.*]] = insertelement <1 x float> poison, float [[TMP690]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT949:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT948]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP959:%.*]] = fmul <1 x float> [[BLOCK947]], [[SPLAT_SPLAT949]]
+; CHECK-NEXT: [[TMP1458:%.*]] = fadd <1 x float> [[TMP957]], [[TMP959]]
+; CHECK-NEXT: [[BLOCK950:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP692:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT951:%.*]] = insertelement <1 x float> poison, float [[TMP692]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT952:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT951]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1461:%.*]] = fmul <1 x float> [[BLOCK950]], [[SPLAT_SPLAT952]]
+; CHECK-NEXT: [[TMP963:%.*]] = fadd <1 x float> [[TMP1458]], [[TMP1461]]
+; CHECK-NEXT: [[BLOCK953:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP694:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT954:%.*]] = insertelement <1 x float> poison, float [[TMP694]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT955:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT954]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP965:%.*]] = fmul <1 x float> [[BLOCK953]], [[SPLAT_SPLAT955]]
+; CHECK-NEXT: [[TMP1464:%.*]] = fadd <1 x float> [[TMP963]], [[TMP965]]
+; CHECK-NEXT: [[BLOCK956:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP696:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT957:%.*]] = insertelement <1 x float> poison, float [[TMP696]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT958:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT957]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1467:%.*]] = fmul <1 x float> [[BLOCK956]], [[SPLAT_SPLAT958]]
+; CHECK-NEXT: [[TMP1470:%.*]] = fadd <1 x float> [[TMP1464]], [[TMP1467]]
+; CHECK-NEXT: [[BLOCK959:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP698:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT960:%.*]] = insertelement <1 x float> poison, float [[TMP698]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT961:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT960]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1472:%.*]] = fmul <1 x float> [[BLOCK959]], [[SPLAT_SPLAT961]]
+; CHECK-NEXT: [[TMP699:%.*]] = fadd <1 x float> [[TMP1470]], [[TMP1472]]
+; CHECK-NEXT: [[TMP700:%.*]] = shufflevector <1 x float> [[TMP699]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP701:%.*]] = shufflevector <8 x float> [[TMP683]], <8 x float> [[TMP700]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK962:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP702:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT963:%.*]] = insertelement <1 x float> poison, float [[TMP702]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT964:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT963]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1473:%.*]] = fmul <1 x float> [[BLOCK962]], [[SPLAT_SPLAT964]]
+; CHECK-NEXT: [[BLOCK965:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP704:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT966:%.*]] = insertelement <1 x float> poison, float [[TMP704]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT967:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT966]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1474:%.*]] = fmul <1 x float> [[BLOCK965]], [[SPLAT_SPLAT967]]
+; CHECK-NEXT: [[TMP979:%.*]] = fadd <1 x float> [[TMP1473]], [[TMP1474]]
+; CHECK-NEXT: [[BLOCK968:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP706:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT969:%.*]] = insertelement <1 x float> poison, float [[TMP706]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT970:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT969]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP981:%.*]] = fmul <1 x float> [[BLOCK968]], [[SPLAT_SPLAT970]]
+; CHECK-NEXT: [[TMP1475:%.*]] = fadd <1 x float> [[TMP979]], [[TMP981]]
+; CHECK-NEXT: [[BLOCK971:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP708:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT972:%.*]] = insertelement <1 x float> poison, float [[TMP708]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT973:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT972]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1477:%.*]] = fmul <1 x float> [[BLOCK971]], [[SPLAT_SPLAT973]]
+; CHECK-NEXT: [[TMP985:%.*]] = fadd <1 x float> [[TMP1475]], [[TMP1477]]
+; CHECK-NEXT: [[BLOCK974:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP710:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT975:%.*]] = insertelement <1 x float> poison, float [[TMP710]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT976:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT975]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1480:%.*]] = fmul <1 x float> [[BLOCK974]], [[SPLAT_SPLAT976]]
+; CHECK-NEXT: [[TMP1483:%.*]] = fadd <1 x float> [[TMP985]], [[TMP1480]]
+; CHECK-NEXT: [[BLOCK977:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP712:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT978:%.*]] = insertelement <1 x float> poison, float [[TMP712]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT979:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT978]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1486:%.*]] = fmul <1 x float> [[BLOCK977]], [[SPLAT_SPLAT979]]
+; CHECK-NEXT: [[TMP991:%.*]] = fadd <1 x float> [[TMP1483]], [[TMP1486]]
+; CHECK-NEXT: [[BLOCK980:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP714:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT981:%.*]] = insertelement <1 x float> poison, float [[TMP714]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT982:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT981]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP993:%.*]] = fmul <1 x float> [[BLOCK980]], [[SPLAT_SPLAT982]]
+; CHECK-NEXT: [[TMP1489:%.*]] = fadd <1 x float> [[TMP991]], [[TMP993]]
+; CHECK-NEXT: [[BLOCK983:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP716:%.*]] = extractelement <8 x float> [[COL_LOAD22]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT984:%.*]] = insertelement <1 x float> poison, float [[TMP716]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT985:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT984]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1492:%.*]] = fmul <1 x float> [[BLOCK983]], [[SPLAT_SPLAT985]]
+; CHECK-NEXT: [[TMP717:%.*]] = fadd <1 x float> [[TMP1489]], [[TMP1492]]
+; CHECK-NEXT: [[TMP718:%.*]] = shufflevector <1 x float> [[TMP717]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP719:%.*]] = shufflevector <8 x float> [[TMP701]], <8 x float> [[TMP718]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK986:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP720:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT987:%.*]] = insertelement <1 x float> poison, float [[TMP720]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT988:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT987]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1001:%.*]] = fmul <1 x float> [[BLOCK986]], [[SPLAT_SPLAT988]]
+; CHECK-NEXT: [[BLOCK989:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP722:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT990:%.*]] = insertelement <1 x float> poison, float [[TMP722]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT991:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT990]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1003:%.*]] = fmul <1 x float> [[BLOCK989]], [[SPLAT_SPLAT991]]
+; CHECK-NEXT: [[TMP1495:%.*]] = fadd <1 x float> [[TMP1001]], [[TMP1003]]
+; CHECK-NEXT: [[BLOCK992:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP724:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT993:%.*]] = insertelement <1 x float> poison, float [[TMP724]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT994:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT993]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1497:%.*]] = fmul <1 x float> [[BLOCK992]], [[SPLAT_SPLAT994]]
+; CHECK-NEXT: [[TMP1498:%.*]] = fadd <1 x float> [[TMP1495]], [[TMP1497]]
+; CHECK-NEXT: [[BLOCK995:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP726:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT996:%.*]] = insertelement <1 x float> poison, float [[TMP726]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT997:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT996]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1009:%.*]] = fmul <1 x float> [[BLOCK995]], [[SPLAT_SPLAT997]]
+; CHECK-NEXT: [[TMP1499:%.*]] = fadd <1 x float> [[TMP1498]], [[TMP1009]]
+; CHECK-NEXT: [[BLOCK998:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP728:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT999:%.*]] = insertelement <1 x float> poison, float [[TMP728]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1000:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT999]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1500:%.*]] = fmul <1 x float> [[BLOCK998]], [[SPLAT_SPLAT1000]]
+; CHECK-NEXT: [[TMP1013:%.*]] = fadd <1 x float> [[TMP1499]], [[TMP1500]]
+; CHECK-NEXT: [[BLOCK1001:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP730:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1002:%.*]] = insertelement <1 x float> poison, float [[TMP730]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1003:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1002]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1015:%.*]] = fmul <1 x float> [[BLOCK1001]], [[SPLAT_SPLAT1003]]
+; CHECK-NEXT: [[TMP1502:%.*]] = fadd <1 x float> [[TMP1013]], [[TMP1015]]
+; CHECK-NEXT: [[BLOCK1004:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP732:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1005:%.*]] = insertelement <1 x float> poison, float [[TMP732]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1006:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1005]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1505:%.*]] = fmul <1 x float> [[BLOCK1004]], [[SPLAT_SPLAT1006]]
+; CHECK-NEXT: [[TMP1019:%.*]] = fadd <1 x float> [[TMP1502]], [[TMP1505]]
+; CHECK-NEXT: [[BLOCK1007:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP734:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1008:%.*]] = insertelement <1 x float> poison, float [[TMP734]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1009:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1008]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1021:%.*]] = fmul <1 x float> [[BLOCK1007]], [[SPLAT_SPLAT1009]]
+; CHECK-NEXT: [[TMP735:%.*]] = fadd <1 x float> [[TMP1019]], [[TMP1021]]
+; CHECK-NEXT: [[TMP736:%.*]] = shufflevector <1 x float> [[TMP735]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP737:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP736]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1010:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP738:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1011:%.*]] = insertelement <1 x float> poison, float [[TMP738]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1012:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1011]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1508:%.*]] = fmul <1 x float> [[BLOCK1010]], [[SPLAT_SPLAT1012]]
+; CHECK-NEXT: [[BLOCK1013:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP740:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1014:%.*]] = insertelement <1 x float> poison, float [[TMP740]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1015:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1014]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1511:%.*]] = fmul <1 x float> [[BLOCK1013]], [[SPLAT_SPLAT1015]]
+; CHECK-NEXT: [[TMP1029:%.*]] = fadd <1 x float> [[TMP1508]], [[TMP1511]]
+; CHECK-NEXT: [[BLOCK1016:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP742:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1017:%.*]] = insertelement <1 x float> poison, float [[TMP742]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1018:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1017]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1031:%.*]] = fmul <1 x float> [[BLOCK1016]], [[SPLAT_SPLAT1018]]
+; CHECK-NEXT: [[TMP1514:%.*]] = fadd <1 x float> [[TMP1029]], [[TMP1031]]
+; CHECK-NEXT: [[BLOCK1019:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP744:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1020:%.*]] = insertelement <1 x float> poison, float [[TMP744]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1021:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1020]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1517:%.*]] = fmul <1 x float> [[BLOCK1019]], [[SPLAT_SPLAT1021]]
+; CHECK-NEXT: [[TMP1035:%.*]] = fadd <1 x float> [[TMP1514]], [[TMP1517]]
+; CHECK-NEXT: [[BLOCK1022:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP746:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1023:%.*]] = insertelement <1 x float> poison, float [[TMP746]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1024:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1023]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1037:%.*]] = fmul <1 x float> [[BLOCK1022]], [[SPLAT_SPLAT1024]]
+; CHECK-NEXT: [[TMP1520:%.*]] = fadd <1 x float> [[TMP1035]], [[TMP1037]]
+; CHECK-NEXT: [[BLOCK1025:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP748:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1026:%.*]] = insertelement <1 x float> poison, float [[TMP748]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1027:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1026]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1522:%.*]] = fmul <1 x float> [[BLOCK1025]], [[SPLAT_SPLAT1027]]
+; CHECK-NEXT: [[TMP1523:%.*]] = fadd <1 x float> [[TMP1520]], [[TMP1522]]
+; CHECK-NEXT: [[BLOCK1028:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP750:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1029:%.*]] = insertelement <1 x float> poison, float [[TMP750]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1030:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1029]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1524:%.*]] = fmul <1 x float> [[BLOCK1028]], [[SPLAT_SPLAT1030]]
+; CHECK-NEXT: [[TMP1525:%.*]] = fadd <1 x float> [[TMP1523]], [[TMP1524]]
+; CHECK-NEXT: [[BLOCK1031:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP752:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1032:%.*]] = insertelement <1 x float> poison, float [[TMP752]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1033:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1032]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1527:%.*]] = fmul <1 x float> [[BLOCK1031]], [[SPLAT_SPLAT1033]]
+; CHECK-NEXT: [[TMP753:%.*]] = fadd <1 x float> [[TMP1525]], [[TMP1527]]
+; CHECK-NEXT: [[TMP754:%.*]] = shufflevector <1 x float> [[TMP753]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP755:%.*]] = shufflevector <8 x float> [[TMP737]], <8 x float> [[TMP754]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1034:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP756:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1035:%.*]] = insertelement <1 x float> poison, float [[TMP756]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1036:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1035]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1051:%.*]] = fmul <1 x float> [[BLOCK1034]], [[SPLAT_SPLAT1036]]
+; CHECK-NEXT: [[BLOCK1037:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP758:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1038:%.*]] = insertelement <1 x float> poison, float [[TMP758]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1039:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1038]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1053:%.*]] = fmul <1 x float> [[BLOCK1037]], [[SPLAT_SPLAT1039]]
+; CHECK-NEXT: [[TMP1530:%.*]] = fadd <1 x float> [[TMP1051]], [[TMP1053]]
+; CHECK-NEXT: [[BLOCK1040:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP760:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1041:%.*]] = insertelement <1 x float> poison, float [[TMP760]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1042:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1041]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1533:%.*]] = fmul <1 x float> [[BLOCK1040]], [[SPLAT_SPLAT1042]]
+; CHECK-NEXT: [[TMP1057:%.*]] = fadd <1 x float> [[TMP1530]], [[TMP1533]]
+; CHECK-NEXT: [[BLOCK1043:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP762:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1044:%.*]] = insertelement <1 x float> poison, float [[TMP762]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1045:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1044]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1536:%.*]] = fmul <1 x float> [[BLOCK1043]], [[SPLAT_SPLAT1045]]
+; CHECK-NEXT: [[TMP1539:%.*]] = fadd <1 x float> [[TMP1057]], [[TMP1536]]
+; CHECK-NEXT: [[BLOCK1046:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP764:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1047:%.*]] = insertelement <1 x float> poison, float [[TMP764]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1048:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1047]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1542:%.*]] = fmul <1 x float> [[BLOCK1046]], [[SPLAT_SPLAT1048]]
+; CHECK-NEXT: [[TMP1063:%.*]] = fadd <1 x float> [[TMP1539]], [[TMP1542]]
+; CHECK-NEXT: [[BLOCK1049:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP766:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1050:%.*]] = insertelement <1 x float> poison, float [[TMP766]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1051:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1050]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1065:%.*]] = fmul <1 x float> [[BLOCK1049]], [[SPLAT_SPLAT1051]]
+; CHECK-NEXT: [[TMP1545:%.*]] = fadd <1 x float> [[TMP1063]], [[TMP1065]]
+; CHECK-NEXT: [[BLOCK1052:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP768:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1053:%.*]] = insertelement <1 x float> poison, float [[TMP768]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1054:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1053]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1547:%.*]] = fmul <1 x float> [[BLOCK1052]], [[SPLAT_SPLAT1054]]
+; CHECK-NEXT: [[TMP1069:%.*]] = fadd <1 x float> [[TMP1545]], [[TMP1547]]
+; CHECK-NEXT: [[BLOCK1055:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP770:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1056:%.*]] = insertelement <1 x float> poison, float [[TMP770]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1057:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1056]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1071:%.*]] = fmul <1 x float> [[BLOCK1055]], [[SPLAT_SPLAT1057]]
+; CHECK-NEXT: [[TMP771:%.*]] = fadd <1 x float> [[TMP1069]], [[TMP1071]]
+; CHECK-NEXT: [[TMP772:%.*]] = shufflevector <1 x float> [[TMP771]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP773:%.*]] = shufflevector <8 x float> [[TMP755]], <8 x float> [[TMP772]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1058:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP774:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1059:%.*]] = insertelement <1 x float> poison, float [[TMP774]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1060:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1059]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1548:%.*]] = fmul <1 x float> [[BLOCK1058]], [[SPLAT_SPLAT1060]]
+; CHECK-NEXT: [[BLOCK1061:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP776:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1062:%.*]] = insertelement <1 x float> poison, float [[TMP776]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1063:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1062]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1549:%.*]] = fmul <1 x float> [[BLOCK1061]], [[SPLAT_SPLAT1063]]
+; CHECK-NEXT: [[TMP1550:%.*]] = fadd <1 x float> [[TMP1548]], [[TMP1549]]
+; CHECK-NEXT: [[BLOCK1064:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP778:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1065:%.*]] = insertelement <1 x float> poison, float [[TMP778]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1066:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1065]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1081:%.*]] = fmul <1 x float> [[BLOCK1064]], [[SPLAT_SPLAT1066]]
+; CHECK-NEXT: [[TMP1552:%.*]] = fadd <1 x float> [[TMP1550]], [[TMP1081]]
+; CHECK-NEXT: [[BLOCK1067:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP780:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1068:%.*]] = insertelement <1 x float> poison, float [[TMP780]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1069:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1068]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1555:%.*]] = fmul <1 x float> [[BLOCK1067]], [[SPLAT_SPLAT1069]]
+; CHECK-NEXT: [[TMP1085:%.*]] = fadd <1 x float> [[TMP1552]], [[TMP1555]]
+; CHECK-NEXT: [[BLOCK1070:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP782:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1071:%.*]] = insertelement <1 x float> poison, float [[TMP782]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1072:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1071]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1087:%.*]] = fmul <1 x float> [[BLOCK1070]], [[SPLAT_SPLAT1072]]
+; CHECK-NEXT: [[TMP1558:%.*]] = fadd <1 x float> [[TMP1085]], [[TMP1087]]
+; CHECK-NEXT: [[BLOCK1073:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP784:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1074:%.*]] = insertelement <1 x float> poison, float [[TMP784]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1075:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1074]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1561:%.*]] = fmul <1 x float> [[BLOCK1073]], [[SPLAT_SPLAT1075]]
+; CHECK-NEXT: [[TMP1091:%.*]] = fadd <1 x float> [[TMP1558]], [[TMP1561]]
+; CHECK-NEXT: [[BLOCK1076:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP786:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1077:%.*]] = insertelement <1 x float> poison, float [[TMP786]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1078:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1077]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1093:%.*]] = fmul <1 x float> [[BLOCK1076]], [[SPLAT_SPLAT1078]]
+; CHECK-NEXT: [[TMP1564:%.*]] = fadd <1 x float> [[TMP1091]], [[TMP1093]]
+; CHECK-NEXT: [[BLOCK1079:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP788:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1080:%.*]] = insertelement <1 x float> poison, float [[TMP788]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1081:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1080]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1567:%.*]] = fmul <1 x float> [[BLOCK1079]], [[SPLAT_SPLAT1081]]
+; CHECK-NEXT: [[TMP789:%.*]] = fadd <1 x float> [[TMP1564]], [[TMP1567]]
+; CHECK-NEXT: [[TMP790:%.*]] = shufflevector <1 x float> [[TMP789]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP791:%.*]] = shufflevector <8 x float> [[TMP773]], <8 x float> [[TMP790]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1082:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP792:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1083:%.*]] = insertelement <1 x float> poison, float [[TMP792]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1084:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1083]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1101:%.*]] = fmul <1 x float> [[BLOCK1082]], [[SPLAT_SPLAT1084]]
+; CHECK-NEXT: [[BLOCK1085:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP794:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1086:%.*]] = insertelement <1 x float> poison, float [[TMP794]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1087:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1086]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1103:%.*]] = fmul <1 x float> [[BLOCK1085]], [[SPLAT_SPLAT1087]]
+; CHECK-NEXT: [[TMP1570:%.*]] = fadd <1 x float> [[TMP1101]], [[TMP1103]]
+; CHECK-NEXT: [[BLOCK1088:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP796:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1089:%.*]] = insertelement <1 x float> poison, float [[TMP796]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1090:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1089]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1572:%.*]] = fmul <1 x float> [[BLOCK1088]], [[SPLAT_SPLAT1090]]
+; CHECK-NEXT: [[TMP1107:%.*]] = fadd <1 x float> [[TMP1570]], [[TMP1572]]
+; CHECK-NEXT: [[BLOCK1091:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP798:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1092:%.*]] = insertelement <1 x float> poison, float [[TMP798]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1093:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1092]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1109:%.*]] = fmul <1 x float> [[BLOCK1091]], [[SPLAT_SPLAT1093]]
+; CHECK-NEXT: [[TMP1573:%.*]] = fadd <1 x float> [[TMP1107]], [[TMP1109]]
+; CHECK-NEXT: [[BLOCK1094:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP800:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1095:%.*]] = insertelement <1 x float> poison, float [[TMP800]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1096:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1095]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1574:%.*]] = fmul <1 x float> [[BLOCK1094]], [[SPLAT_SPLAT1096]]
+; CHECK-NEXT: [[TMP1575:%.*]] = fadd <1 x float> [[TMP1573]], [[TMP1574]]
+; CHECK-NEXT: [[BLOCK1097:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP802:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1098:%.*]] = insertelement <1 x float> poison, float [[TMP802]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1099:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1098]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1577:%.*]] = fmul <1 x float> [[BLOCK1097]], [[SPLAT_SPLAT1099]]
+; CHECK-NEXT: [[TMP1580:%.*]] = fadd <1 x float> [[TMP1575]], [[TMP1577]]
+; CHECK-NEXT: [[BLOCK1100:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP804:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1101:%.*]] = insertelement <1 x float> poison, float [[TMP804]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1102:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1101]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1583:%.*]] = fmul <1 x float> [[BLOCK1100]], [[SPLAT_SPLAT1102]]
+; CHECK-NEXT: [[TMP1119:%.*]] = fadd <1 x float> [[TMP1580]], [[TMP1583]]
+; CHECK-NEXT: [[BLOCK1103:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP806:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1104:%.*]] = insertelement <1 x float> poison, float [[TMP806]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1105:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1104]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1121:%.*]] = fmul <1 x float> [[BLOCK1103]], [[SPLAT_SPLAT1105]]
+; CHECK-NEXT: [[TMP807:%.*]] = fadd <1 x float> [[TMP1119]], [[TMP1121]]
+; CHECK-NEXT: [[TMP808:%.*]] = shufflevector <1 x float> [[TMP807]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP809:%.*]] = shufflevector <8 x float> [[TMP791]], <8 x float> [[TMP808]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1106:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP810:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1107:%.*]] = insertelement <1 x float> poison, float [[TMP810]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1108:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1107]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1586:%.*]] = fmul <1 x float> [[BLOCK1106]], [[SPLAT_SPLAT1108]]
+; CHECK-NEXT: [[BLOCK1109:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP812:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1110:%.*]] = insertelement <1 x float> poison, float [[TMP812]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1111:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1110]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1589:%.*]] = fmul <1 x float> [[BLOCK1109]], [[SPLAT_SPLAT1111]]
+; CHECK-NEXT: [[TMP1129:%.*]] = fadd <1 x float> [[TMP1586]], [[TMP1589]]
+; CHECK-NEXT: [[BLOCK1112:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP814:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1113:%.*]] = insertelement <1 x float> poison, float [[TMP814]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1114:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1113]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1592:%.*]] = fmul <1 x float> [[BLOCK1112]], [[SPLAT_SPLAT1114]]
+; CHECK-NEXT: [[TMP1595:%.*]] = fadd <1 x float> [[TMP1129]], [[TMP1592]]
+; CHECK-NEXT: [[BLOCK1115:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP816:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1116:%.*]] = insertelement <1 x float> poison, float [[TMP816]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1117:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1116]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1597:%.*]] = fmul <1 x float> [[BLOCK1115]], [[SPLAT_SPLAT1117]]
+; CHECK-NEXT: [[TMP1135:%.*]] = fadd <1 x float> [[TMP1595]], [[TMP1597]]
+; CHECK-NEXT: [[BLOCK1118:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP818:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1119:%.*]] = insertelement <1 x float> poison, float [[TMP818]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1120:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1119]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1137:%.*]] = fmul <1 x float> [[BLOCK1118]], [[SPLAT_SPLAT1120]]
+; CHECK-NEXT: [[TMP1598:%.*]] = fadd <1 x float> [[TMP1135]], [[TMP1137]]
+; CHECK-NEXT: [[BLOCK1121:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP820:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1122:%.*]] = insertelement <1 x float> poison, float [[TMP820]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1123:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1122]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1599:%.*]] = fmul <1 x float> [[BLOCK1121]], [[SPLAT_SPLAT1123]]
+; CHECK-NEXT: [[TMP1141:%.*]] = fadd <1 x float> [[TMP1598]], [[TMP1599]]
+; CHECK-NEXT: [[BLOCK1124:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP822:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1125:%.*]] = insertelement <1 x float> poison, float [[TMP822]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1126:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1125]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1143:%.*]] = fmul <1 x float> [[BLOCK1124]], [[SPLAT_SPLAT1126]]
+; CHECK-NEXT: [[TMP1600:%.*]] = fadd <1 x float> [[TMP1141]], [[TMP1143]]
+; CHECK-NEXT: [[BLOCK1127:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP824:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1128:%.*]] = insertelement <1 x float> poison, float [[TMP824]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1129:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1128]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1601:%.*]] = fmul <1 x float> [[BLOCK1127]], [[SPLAT_SPLAT1129]]
+; CHECK-NEXT: [[TMP825:%.*]] = fadd <1 x float> [[TMP1600]], [[TMP1601]]
+; CHECK-NEXT: [[TMP826:%.*]] = shufflevector <1 x float> [[TMP825]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP827:%.*]] = shufflevector <8 x float> [[TMP809]], <8 x float> [[TMP826]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1130:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP828:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1131:%.*]] = insertelement <1 x float> poison, float [[TMP828]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1132:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1131]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1602:%.*]] = fmul <1 x float> [[BLOCK1130]], [[SPLAT_SPLAT1132]]
+; CHECK-NEXT: [[BLOCK1133:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP830:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1134:%.*]] = insertelement <1 x float> poison, float [[TMP830]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1135:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1134]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1603:%.*]] = fmul <1 x float> [[BLOCK1133]], [[SPLAT_SPLAT1135]]
+; CHECK-NEXT: [[TMP1604:%.*]] = fadd <1 x float> [[TMP1602]], [[TMP1603]]
+; CHECK-NEXT: [[BLOCK1136:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP832:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1137:%.*]] = insertelement <1 x float> poison, float [[TMP832]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1138:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1137]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1605:%.*]] = fmul <1 x float> [[BLOCK1136]], [[SPLAT_SPLAT1138]]
+; CHECK-NEXT: [[TMP1606:%.*]] = fadd <1 x float> [[TMP1604]], [[TMP1605]]
+; CHECK-NEXT: [[BLOCK1139:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP834:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1140:%.*]] = insertelement <1 x float> poison, float [[TMP834]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1141:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1140]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1607:%.*]] = fmul <1 x float> [[BLOCK1139]], [[SPLAT_SPLAT1141]]
+; CHECK-NEXT: [[TMP1160:%.*]] = fadd <1 x float> [[TMP1606]], [[TMP1607]]
+; CHECK-NEXT: [[BLOCK1142:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP836:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1143:%.*]] = insertelement <1 x float> poison, float [[TMP836]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1144:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1143]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1162:%.*]] = fmul <1 x float> [[BLOCK1142]], [[SPLAT_SPLAT1144]]
+; CHECK-NEXT: [[TMP1163:%.*]] = fadd <1 x float> [[TMP1160]], [[TMP1162]]
+; CHECK-NEXT: [[BLOCK1145:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP838:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1146:%.*]] = insertelement <1 x float> poison, float [[TMP838]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1147:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1146]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1165:%.*]] = fmul <1 x float> [[BLOCK1145]], [[SPLAT_SPLAT1147]]
+; CHECK-NEXT: [[TMP1166:%.*]] = fadd <1 x float> [[TMP1163]], [[TMP1165]]
+; CHECK-NEXT: [[BLOCK1148:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP840:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1149:%.*]] = insertelement <1 x float> poison, float [[TMP840]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1150:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1149]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1168:%.*]] = fmul <1 x float> [[BLOCK1148]], [[SPLAT_SPLAT1150]]
+; CHECK-NEXT: [[TMP1169:%.*]] = fadd <1 x float> [[TMP1166]], [[TMP1168]]
+; CHECK-NEXT: [[BLOCK1151:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP842:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1152:%.*]] = insertelement <1 x float> poison, float [[TMP842]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1153:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1152]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1171:%.*]] = fmul <1 x float> [[BLOCK1151]], [[SPLAT_SPLAT1153]]
+; CHECK-NEXT: [[TMP843:%.*]] = fadd <1 x float> [[TMP1169]], [[TMP1171]]
+; CHECK-NEXT: [[TMP844:%.*]] = shufflevector <1 x float> [[TMP843]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP845:%.*]] = shufflevector <8 x float> [[TMP827]], <8 x float> [[TMP844]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1154:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP846:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1155:%.*]] = insertelement <1 x float> poison, float [[TMP846]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1156:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1155]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1176:%.*]] = fmul <1 x float> [[BLOCK1154]], [[SPLAT_SPLAT1156]]
+; CHECK-NEXT: [[BLOCK1157:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP848:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1158:%.*]] = insertelement <1 x float> poison, float [[TMP848]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1159:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1158]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1178:%.*]] = fmul <1 x float> [[BLOCK1157]], [[SPLAT_SPLAT1159]]
+; CHECK-NEXT: [[TMP1179:%.*]] = fadd <1 x float> [[TMP1176]], [[TMP1178]]
+; CHECK-NEXT: [[BLOCK1160:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP850:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1161:%.*]] = insertelement <1 x float> poison, float [[TMP850]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1162:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1161]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1181:%.*]] = fmul <1 x float> [[BLOCK1160]], [[SPLAT_SPLAT1162]]
+; CHECK-NEXT: [[TMP1182:%.*]] = fadd <1 x float> [[TMP1179]], [[TMP1181]]
+; CHECK-NEXT: [[BLOCK1163:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP852:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1164:%.*]] = insertelement <1 x float> poison, float [[TMP852]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1165:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1164]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1184:%.*]] = fmul <1 x float> [[BLOCK1163]], [[SPLAT_SPLAT1165]]
+; CHECK-NEXT: [[TMP1185:%.*]] = fadd <1 x float> [[TMP1182]], [[TMP1184]]
+; CHECK-NEXT: [[BLOCK1166:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP854:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1167:%.*]] = insertelement <1 x float> poison, float [[TMP854]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1168:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1167]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1187:%.*]] = fmul <1 x float> [[BLOCK1166]], [[SPLAT_SPLAT1168]]
+; CHECK-NEXT: [[TMP1188:%.*]] = fadd <1 x float> [[TMP1185]], [[TMP1187]]
+; CHECK-NEXT: [[BLOCK1169:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP856:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1170:%.*]] = insertelement <1 x float> poison, float [[TMP856]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1171:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1170]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1190:%.*]] = fmul <1 x float> [[BLOCK1169]], [[SPLAT_SPLAT1171]]
+; CHECK-NEXT: [[TMP1191:%.*]] = fadd <1 x float> [[TMP1188]], [[TMP1190]]
+; CHECK-NEXT: [[BLOCK1172:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP858:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1173:%.*]] = insertelement <1 x float> poison, float [[TMP858]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1174:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1173]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1193:%.*]] = fmul <1 x float> [[BLOCK1172]], [[SPLAT_SPLAT1174]]
+; CHECK-NEXT: [[TMP1194:%.*]] = fadd <1 x float> [[TMP1191]], [[TMP1193]]
+; CHECK-NEXT: [[BLOCK1175:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP860:%.*]] = extractelement <8 x float> [[COL_LOAD24]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1176:%.*]] = insertelement <1 x float> poison, float [[TMP860]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1177:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1176]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1196:%.*]] = fmul <1 x float> [[BLOCK1175]], [[SPLAT_SPLAT1177]]
+; CHECK-NEXT: [[TMP861:%.*]] = fadd <1 x float> [[TMP1194]], [[TMP1196]]
+; CHECK-NEXT: [[TMP862:%.*]] = shufflevector <1 x float> [[TMP861]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP863:%.*]] = shufflevector <8 x float> [[TMP845]], <8 x float> [[TMP862]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK1178:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP864:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1179:%.*]] = insertelement <1 x float> poison, float [[TMP864]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1180:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1179]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1201:%.*]] = fmul <1 x float> [[BLOCK1178]], [[SPLAT_SPLAT1180]]
+; CHECK-NEXT: [[BLOCK1181:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP866:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1182:%.*]] = insertelement <1 x float> poison, float [[TMP866]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1183:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1182]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1203:%.*]] = fmul <1 x float> [[BLOCK1181]], [[SPLAT_SPLAT1183]]
+; CHECK-NEXT: [[TMP1204:%.*]] = fadd <1 x float> [[TMP1201]], [[TMP1203]]
+; CHECK-NEXT: [[BLOCK1184:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP868:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1185:%.*]] = insertelement <1 x float> poison, float [[TMP868]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1186:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1185]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1206:%.*]] = fmul <1 x float> [[BLOCK1184]], [[SPLAT_SPLAT1186]]
+; CHECK-NEXT: [[TMP1207:%.*]] = fadd <1 x float> [[TMP1204]], [[TMP1206]]
+; CHECK-NEXT: [[BLOCK1187:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP870:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1188:%.*]] = insertelement <1 x float> poison, float [[TMP870]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1189:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1188]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1209:%.*]] = fmul <1 x float> [[BLOCK1187]], [[SPLAT_SPLAT1189]]
+; CHECK-NEXT: [[TMP1210:%.*]] = fadd <1 x float> [[TMP1207]], [[TMP1209]]
+; CHECK-NEXT: [[BLOCK1190:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP872:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1191:%.*]] = insertelement <1 x float> poison, float [[TMP872]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1192:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1191]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1212:%.*]] = fmul <1 x float> [[BLOCK1190]], [[SPLAT_SPLAT1192]]
+; CHECK-NEXT: [[TMP1213:%.*]] = fadd <1 x float> [[TMP1210]], [[TMP1212]]
+; CHECK-NEXT: [[BLOCK1193:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP874:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1194:%.*]] = insertelement <1 x float> poison, float [[TMP874]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1195:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1194]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1215:%.*]] = fmul <1 x float> [[BLOCK1193]], [[SPLAT_SPLAT1195]]
+; CHECK-NEXT: [[TMP1216:%.*]] = fadd <1 x float> [[TMP1213]], [[TMP1215]]
+; CHECK-NEXT: [[BLOCK1196:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP876:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1197:%.*]] = insertelement <1 x float> poison, float [[TMP876]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1198:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1197]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1218:%.*]] = fmul <1 x float> [[BLOCK1196]], [[SPLAT_SPLAT1198]]
+; CHECK-NEXT: [[TMP1219:%.*]] = fadd <1 x float> [[TMP1216]], [[TMP1218]]
+; CHECK-NEXT: [[BLOCK1199:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP878:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1200:%.*]] = insertelement <1 x float> poison, float [[TMP878]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1201:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1200]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1221:%.*]] = fmul <1 x float> [[BLOCK1199]], [[SPLAT_SPLAT1201]]
+; CHECK-NEXT: [[TMP879:%.*]] = fadd <1 x float> [[TMP1219]], [[TMP1221]]
+; CHECK-NEXT: [[TMP880:%.*]] = shufflevector <1 x float> [[TMP879]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP881:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP880]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1202:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP882:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1203:%.*]] = insertelement <1 x float> poison, float [[TMP882]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1204:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1203]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1226:%.*]] = fmul <1 x float> [[BLOCK1202]], [[SPLAT_SPLAT1204]]
+; CHECK-NEXT: [[BLOCK1205:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP884:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1206:%.*]] = insertelement <1 x float> poison, float [[TMP884]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1207:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1206]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1228:%.*]] = fmul <1 x float> [[BLOCK1205]], [[SPLAT_SPLAT1207]]
+; CHECK-NEXT: [[TMP1229:%.*]] = fadd <1 x float> [[TMP1226]], [[TMP1228]]
+; CHECK-NEXT: [[BLOCK1208:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP886:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1209:%.*]] = insertelement <1 x float> poison, float [[TMP886]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1210:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1209]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1231:%.*]] = fmul <1 x float> [[BLOCK1208]], [[SPLAT_SPLAT1210]]
+; CHECK-NEXT: [[TMP1232:%.*]] = fadd <1 x float> [[TMP1229]], [[TMP1231]]
+; CHECK-NEXT: [[BLOCK1211:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP888:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1212:%.*]] = insertelement <1 x float> poison, float [[TMP888]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1213:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1212]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1234:%.*]] = fmul <1 x float> [[BLOCK1211]], [[SPLAT_SPLAT1213]]
+; CHECK-NEXT: [[TMP1235:%.*]] = fadd <1 x float> [[TMP1232]], [[TMP1234]]
+; CHECK-NEXT: [[BLOCK1214:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP890:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1215:%.*]] = insertelement <1 x float> poison, float [[TMP890]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1216:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1215]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1237:%.*]] = fmul <1 x float> [[BLOCK1214]], [[SPLAT_SPLAT1216]]
+; CHECK-NEXT: [[TMP1238:%.*]] = fadd <1 x float> [[TMP1235]], [[TMP1237]]
+; CHECK-NEXT: [[BLOCK1217:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP892:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1218:%.*]] = insertelement <1 x float> poison, float [[TMP892]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1219:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1218]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1240:%.*]] = fmul <1 x float> [[BLOCK1217]], [[SPLAT_SPLAT1219]]
+; CHECK-NEXT: [[TMP1241:%.*]] = fadd <1 x float> [[TMP1238]], [[TMP1240]]
+; CHECK-NEXT: [[BLOCK1220:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP894:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1221:%.*]] = insertelement <1 x float> poison, float [[TMP894]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1222:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1221]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1243:%.*]] = fmul <1 x float> [[BLOCK1220]], [[SPLAT_SPLAT1222]]
+; CHECK-NEXT: [[TMP1244:%.*]] = fadd <1 x float> [[TMP1241]], [[TMP1243]]
+; CHECK-NEXT: [[BLOCK1223:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP896:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1224:%.*]] = insertelement <1 x float> poison, float [[TMP896]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1225:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1224]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1246:%.*]] = fmul <1 x float> [[BLOCK1223]], [[SPLAT_SPLAT1225]]
+; CHECK-NEXT: [[TMP897:%.*]] = fadd <1 x float> [[TMP1244]], [[TMP1246]]
+; CHECK-NEXT: [[TMP898:%.*]] = shufflevector <1 x float> [[TMP897]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP899:%.*]] = shufflevector <8 x float> [[TMP881]], <8 x float> [[TMP898]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1226:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP900:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1227:%.*]] = insertelement <1 x float> poison, float [[TMP900]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1228:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1227]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1251:%.*]] = fmul <1 x float> [[BLOCK1226]], [[SPLAT_SPLAT1228]]
+; CHECK-NEXT: [[BLOCK1229:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP902:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1230:%.*]] = insertelement <1 x float> poison, float [[TMP902]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1231:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1230]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1253:%.*]] = fmul <1 x float> [[BLOCK1229]], [[SPLAT_SPLAT1231]]
+; CHECK-NEXT: [[TMP1254:%.*]] = fadd <1 x float> [[TMP1251]], [[TMP1253]]
+; CHECK-NEXT: [[BLOCK1232:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP904:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1233:%.*]] = insertelement <1 x float> poison, float [[TMP904]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1234:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1233]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1256:%.*]] = fmul <1 x float> [[BLOCK1232]], [[SPLAT_SPLAT1234]]
+; CHECK-NEXT: [[TMP1257:%.*]] = fadd <1 x float> [[TMP1254]], [[TMP1256]]
+; CHECK-NEXT: [[BLOCK1235:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP906:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1236:%.*]] = insertelement <1 x float> poison, float [[TMP906]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1237:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1236]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1259:%.*]] = fmul <1 x float> [[BLOCK1235]], [[SPLAT_SPLAT1237]]
+; CHECK-NEXT: [[TMP1260:%.*]] = fadd <1 x float> [[TMP1257]], [[TMP1259]]
+; CHECK-NEXT: [[BLOCK1238:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP908:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1239:%.*]] = insertelement <1 x float> poison, float [[TMP908]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1240:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1239]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1262:%.*]] = fmul <1 x float> [[BLOCK1238]], [[SPLAT_SPLAT1240]]
+; CHECK-NEXT: [[TMP1263:%.*]] = fadd <1 x float> [[TMP1260]], [[TMP1262]]
+; CHECK-NEXT: [[BLOCK1241:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP910:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1242:%.*]] = insertelement <1 x float> poison, float [[TMP910]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1243:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1242]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1265:%.*]] = fmul <1 x float> [[BLOCK1241]], [[SPLAT_SPLAT1243]]
+; CHECK-NEXT: [[TMP1266:%.*]] = fadd <1 x float> [[TMP1263]], [[TMP1265]]
+; CHECK-NEXT: [[BLOCK1244:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP912:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1245:%.*]] = insertelement <1 x float> poison, float [[TMP912]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1246:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1245]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1268:%.*]] = fmul <1 x float> [[BLOCK1244]], [[SPLAT_SPLAT1246]]
+; CHECK-NEXT: [[TMP1269:%.*]] = fadd <1 x float> [[TMP1266]], [[TMP1268]]
+; CHECK-NEXT: [[BLOCK1247:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP914:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1248:%.*]] = insertelement <1 x float> poison, float [[TMP914]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1249:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1248]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1271:%.*]] = fmul <1 x float> [[BLOCK1247]], [[SPLAT_SPLAT1249]]
+; CHECK-NEXT: [[TMP915:%.*]] = fadd <1 x float> [[TMP1269]], [[TMP1271]]
+; CHECK-NEXT: [[TMP916:%.*]] = shufflevector <1 x float> [[TMP915]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP917:%.*]] = shufflevector <8 x float> [[TMP899]], <8 x float> [[TMP916]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1250:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP918:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1251:%.*]] = insertelement <1 x float> poison, float [[TMP918]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1252:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1251]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1276:%.*]] = fmul <1 x float> [[BLOCK1250]], [[SPLAT_SPLAT1252]]
+; CHECK-NEXT: [[BLOCK1253:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP920:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1254:%.*]] = insertelement <1 x float> poison, float [[TMP920]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1255:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1254]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1278:%.*]] = fmul <1 x float> [[BLOCK1253]], [[SPLAT_SPLAT1255]]
+; CHECK-NEXT: [[TMP1279:%.*]] = fadd <1 x float> [[TMP1276]], [[TMP1278]]
+; CHECK-NEXT: [[BLOCK1256:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP922:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1257:%.*]] = insertelement <1 x float> poison, float [[TMP922]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1258:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1257]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1281:%.*]] = fmul <1 x float> [[BLOCK1256]], [[SPLAT_SPLAT1258]]
+; CHECK-NEXT: [[TMP1282:%.*]] = fadd <1 x float> [[TMP1279]], [[TMP1281]]
+; CHECK-NEXT: [[BLOCK1259:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP924:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1260:%.*]] = insertelement <1 x float> poison, float [[TMP924]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1261:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1260]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1284:%.*]] = fmul <1 x float> [[BLOCK1259]], [[SPLAT_SPLAT1261]]
+; CHECK-NEXT: [[TMP1285:%.*]] = fadd <1 x float> [[TMP1282]], [[TMP1284]]
+; CHECK-NEXT: [[BLOCK1262:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP926:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1263:%.*]] = insertelement <1 x float> poison, float [[TMP926]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1264:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1263]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1287:%.*]] = fmul <1 x float> [[BLOCK1262]], [[SPLAT_SPLAT1264]]
+; CHECK-NEXT: [[TMP1288:%.*]] = fadd <1 x float> [[TMP1285]], [[TMP1287]]
+; CHECK-NEXT: [[BLOCK1265:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP928:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1266:%.*]] = insertelement <1 x float> poison, float [[TMP928]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1267:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1266]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1290:%.*]] = fmul <1 x float> [[BLOCK1265]], [[SPLAT_SPLAT1267]]
+; CHECK-NEXT: [[TMP1291:%.*]] = fadd <1 x float> [[TMP1288]], [[TMP1290]]
+; CHECK-NEXT: [[BLOCK1268:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP930:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1269:%.*]] = insertelement <1 x float> poison, float [[TMP930]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1270:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1269]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1293:%.*]] = fmul <1 x float> [[BLOCK1268]], [[SPLAT_SPLAT1270]]
+; CHECK-NEXT: [[TMP1294:%.*]] = fadd <1 x float> [[TMP1291]], [[TMP1293]]
+; CHECK-NEXT: [[BLOCK1271:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP932:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1272:%.*]] = insertelement <1 x float> poison, float [[TMP932]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1273:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1272]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1296:%.*]] = fmul <1 x float> [[BLOCK1271]], [[SPLAT_SPLAT1273]]
+; CHECK-NEXT: [[TMP933:%.*]] = fadd <1 x float> [[TMP1294]], [[TMP1296]]
+; CHECK-NEXT: [[TMP934:%.*]] = shufflevector <1 x float> [[TMP933]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP935:%.*]] = shufflevector <8 x float> [[TMP917]], <8 x float> [[TMP934]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1274:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP936:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1275:%.*]] = insertelement <1 x float> poison, float [[TMP936]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1276:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1275]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1301:%.*]] = fmul <1 x float> [[BLOCK1274]], [[SPLAT_SPLAT1276]]
+; CHECK-NEXT: [[BLOCK1277:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP938:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1278:%.*]] = insertelement <1 x float> poison, float [[TMP938]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1279:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1278]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1303:%.*]] = fmul <1 x float> [[BLOCK1277]], [[SPLAT_SPLAT1279]]
+; CHECK-NEXT: [[TMP1304:%.*]] = fadd <1 x float> [[TMP1301]], [[TMP1303]]
+; CHECK-NEXT: [[BLOCK1280:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP940:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1281:%.*]] = insertelement <1 x float> poison, float [[TMP940]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1282:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1281]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1306:%.*]] = fmul <1 x float> [[BLOCK1280]], [[SPLAT_SPLAT1282]]
+; CHECK-NEXT: [[TMP1307:%.*]] = fadd <1 x float> [[TMP1304]], [[TMP1306]]
+; CHECK-NEXT: [[BLOCK1283:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP942:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1284:%.*]] = insertelement <1 x float> poison, float [[TMP942]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1285:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1284]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1309:%.*]] = fmul <1 x float> [[BLOCK1283]], [[SPLAT_SPLAT1285]]
+; CHECK-NEXT: [[TMP1310:%.*]] = fadd <1 x float> [[TMP1307]], [[TMP1309]]
+; CHECK-NEXT: [[BLOCK1286:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP944:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1287:%.*]] = insertelement <1 x float> poison, float [[TMP944]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1288:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1287]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1312:%.*]] = fmul <1 x float> [[BLOCK1286]], [[SPLAT_SPLAT1288]]
+; CHECK-NEXT: [[TMP1313:%.*]] = fadd <1 x float> [[TMP1310]], [[TMP1312]]
+; CHECK-NEXT: [[BLOCK1289:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP946:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1290:%.*]] = insertelement <1 x float> poison, float [[TMP946]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1291:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1290]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1315:%.*]] = fmul <1 x float> [[BLOCK1289]], [[SPLAT_SPLAT1291]]
+; CHECK-NEXT: [[TMP1316:%.*]] = fadd <1 x float> [[TMP1313]], [[TMP1315]]
+; CHECK-NEXT: [[BLOCK1292:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP948:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1293:%.*]] = insertelement <1 x float> poison, float [[TMP948]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1294:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1293]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1318:%.*]] = fmul <1 x float> [[BLOCK1292]], [[SPLAT_SPLAT1294]]
+; CHECK-NEXT: [[TMP1319:%.*]] = fadd <1 x float> [[TMP1316]], [[TMP1318]]
+; CHECK-NEXT: [[BLOCK1295:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP950:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1296:%.*]] = insertelement <1 x float> poison, float [[TMP950]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1297:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1296]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1321:%.*]] = fmul <1 x float> [[BLOCK1295]], [[SPLAT_SPLAT1297]]
+; CHECK-NEXT: [[TMP951:%.*]] = fadd <1 x float> [[TMP1319]], [[TMP1321]]
+; CHECK-NEXT: [[TMP952:%.*]] = shufflevector <1 x float> [[TMP951]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP953:%.*]] = shufflevector <8 x float> [[TMP935]], <8 x float> [[TMP952]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1298:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP954:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1299:%.*]] = insertelement <1 x float> poison, float [[TMP954]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1300:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1299]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1326:%.*]] = fmul <1 x float> [[BLOCK1298]], [[SPLAT_SPLAT1300]]
+; CHECK-NEXT: [[BLOCK1301:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP956:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1302:%.*]] = insertelement <1 x float> poison, float [[TMP956]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1303:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1302]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1328:%.*]] = fmul <1 x float> [[BLOCK1301]], [[SPLAT_SPLAT1303]]
+; CHECK-NEXT: [[TMP1329:%.*]] = fadd <1 x float> [[TMP1326]], [[TMP1328]]
+; CHECK-NEXT: [[BLOCK1304:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP958:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1305:%.*]] = insertelement <1 x float> poison, float [[TMP958]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1306:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1305]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1331:%.*]] = fmul <1 x float> [[BLOCK1304]], [[SPLAT_SPLAT1306]]
+; CHECK-NEXT: [[TMP1332:%.*]] = fadd <1 x float> [[TMP1329]], [[TMP1331]]
+; CHECK-NEXT: [[BLOCK1307:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP960:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1308:%.*]] = insertelement <1 x float> poison, float [[TMP960]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1309:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1308]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1334:%.*]] = fmul <1 x float> [[BLOCK1307]], [[SPLAT_SPLAT1309]]
+; CHECK-NEXT: [[TMP1335:%.*]] = fadd <1 x float> [[TMP1332]], [[TMP1334]]
+; CHECK-NEXT: [[BLOCK1310:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP962:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1311:%.*]] = insertelement <1 x float> poison, float [[TMP962]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1312:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1311]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1337:%.*]] = fmul <1 x float> [[BLOCK1310]], [[SPLAT_SPLAT1312]]
+; CHECK-NEXT: [[TMP1338:%.*]] = fadd <1 x float> [[TMP1335]], [[TMP1337]]
+; CHECK-NEXT: [[BLOCK1313:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP964:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1314:%.*]] = insertelement <1 x float> poison, float [[TMP964]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1315:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1314]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1340:%.*]] = fmul <1 x float> [[BLOCK1313]], [[SPLAT_SPLAT1315]]
+; CHECK-NEXT: [[TMP1341:%.*]] = fadd <1 x float> [[TMP1338]], [[TMP1340]]
+; CHECK-NEXT: [[BLOCK1316:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP966:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1317:%.*]] = insertelement <1 x float> poison, float [[TMP966]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1318:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1317]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1343:%.*]] = fmul <1 x float> [[BLOCK1316]], [[SPLAT_SPLAT1318]]
+; CHECK-NEXT: [[TMP1344:%.*]] = fadd <1 x float> [[TMP1341]], [[TMP1343]]
+; CHECK-NEXT: [[BLOCK1319:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP968:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1320:%.*]] = insertelement <1 x float> poison, float [[TMP968]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1321:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1320]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1346:%.*]] = fmul <1 x float> [[BLOCK1319]], [[SPLAT_SPLAT1321]]
+; CHECK-NEXT: [[TMP969:%.*]] = fadd <1 x float> [[TMP1344]], [[TMP1346]]
+; CHECK-NEXT: [[TMP970:%.*]] = shufflevector <1 x float> [[TMP969]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP971:%.*]] = shufflevector <8 x float> [[TMP953]], <8 x float> [[TMP970]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1322:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP972:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1323:%.*]] = insertelement <1 x float> poison, float [[TMP972]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1324:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1323]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1351:%.*]] = fmul <1 x float> [[BLOCK1322]], [[SPLAT_SPLAT1324]]
+; CHECK-NEXT: [[BLOCK1325:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP974:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1326:%.*]] = insertelement <1 x float> poison, float [[TMP974]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1327:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1326]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1353:%.*]] = fmul <1 x float> [[BLOCK1325]], [[SPLAT_SPLAT1327]]
+; CHECK-NEXT: [[TMP1354:%.*]] = fadd <1 x float> [[TMP1351]], [[TMP1353]]
+; CHECK-NEXT: [[BLOCK1328:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP976:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1329:%.*]] = insertelement <1 x float> poison, float [[TMP976]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1330:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1329]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1356:%.*]] = fmul <1 x float> [[BLOCK1328]], [[SPLAT_SPLAT1330]]
+; CHECK-NEXT: [[TMP1357:%.*]] = fadd <1 x float> [[TMP1354]], [[TMP1356]]
+; CHECK-NEXT: [[BLOCK1331:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP978:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1332:%.*]] = insertelement <1 x float> poison, float [[TMP978]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1333:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1332]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1359:%.*]] = fmul <1 x float> [[BLOCK1331]], [[SPLAT_SPLAT1333]]
+; CHECK-NEXT: [[TMP1360:%.*]] = fadd <1 x float> [[TMP1357]], [[TMP1359]]
+; CHECK-NEXT: [[BLOCK1334:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP980:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1335:%.*]] = insertelement <1 x float> poison, float [[TMP980]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1336:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1335]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1362:%.*]] = fmul <1 x float> [[BLOCK1334]], [[SPLAT_SPLAT1336]]
+; CHECK-NEXT: [[TMP1363:%.*]] = fadd <1 x float> [[TMP1360]], [[TMP1362]]
+; CHECK-NEXT: [[BLOCK1337:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP982:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1338:%.*]] = insertelement <1 x float> poison, float [[TMP982]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1339:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1338]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1365:%.*]] = fmul <1 x float> [[BLOCK1337]], [[SPLAT_SPLAT1339]]
+; CHECK-NEXT: [[TMP1366:%.*]] = fadd <1 x float> [[TMP1363]], [[TMP1365]]
+; CHECK-NEXT: [[BLOCK1340:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP984:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1341:%.*]] = insertelement <1 x float> poison, float [[TMP984]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1342:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1341]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1368:%.*]] = fmul <1 x float> [[BLOCK1340]], [[SPLAT_SPLAT1342]]
+; CHECK-NEXT: [[TMP1369:%.*]] = fadd <1 x float> [[TMP1366]], [[TMP1368]]
+; CHECK-NEXT: [[BLOCK1343:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP986:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1344:%.*]] = insertelement <1 x float> poison, float [[TMP986]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1345:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1344]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1371:%.*]] = fmul <1 x float> [[BLOCK1343]], [[SPLAT_SPLAT1345]]
+; CHECK-NEXT: [[TMP987:%.*]] = fadd <1 x float> [[TMP1369]], [[TMP1371]]
+; CHECK-NEXT: [[TMP988:%.*]] = shufflevector <1 x float> [[TMP987]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP989:%.*]] = shufflevector <8 x float> [[TMP971]], <8 x float> [[TMP988]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1346:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP990:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1347:%.*]] = insertelement <1 x float> poison, float [[TMP990]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1348:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1347]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1376:%.*]] = fmul <1 x float> [[BLOCK1346]], [[SPLAT_SPLAT1348]]
+; CHECK-NEXT: [[BLOCK1349:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP992:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1350:%.*]] = insertelement <1 x float> poison, float [[TMP992]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1351:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1350]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1378:%.*]] = fmul <1 x float> [[BLOCK1349]], [[SPLAT_SPLAT1351]]
+; CHECK-NEXT: [[TMP1379:%.*]] = fadd <1 x float> [[TMP1376]], [[TMP1378]]
+; CHECK-NEXT: [[BLOCK1352:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP994:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1353:%.*]] = insertelement <1 x float> poison, float [[TMP994]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1354:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1353]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1381:%.*]] = fmul <1 x float> [[BLOCK1352]], [[SPLAT_SPLAT1354]]
+; CHECK-NEXT: [[TMP1382:%.*]] = fadd <1 x float> [[TMP1379]], [[TMP1381]]
+; CHECK-NEXT: [[BLOCK1355:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP996:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1356:%.*]] = insertelement <1 x float> poison, float [[TMP996]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1357:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1356]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1384:%.*]] = fmul <1 x float> [[BLOCK1355]], [[SPLAT_SPLAT1357]]
+; CHECK-NEXT: [[TMP1385:%.*]] = fadd <1 x float> [[TMP1382]], [[TMP1384]]
+; CHECK-NEXT: [[BLOCK1358:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP998:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1359:%.*]] = insertelement <1 x float> poison, float [[TMP998]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1360:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1359]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1387:%.*]] = fmul <1 x float> [[BLOCK1358]], [[SPLAT_SPLAT1360]]
+; CHECK-NEXT: [[TMP1388:%.*]] = fadd <1 x float> [[TMP1385]], [[TMP1387]]
+; CHECK-NEXT: [[BLOCK1361:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1000:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1362:%.*]] = insertelement <1 x float> poison, float [[TMP1000]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1363:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1362]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1390:%.*]] = fmul <1 x float> [[BLOCK1361]], [[SPLAT_SPLAT1363]]
+; CHECK-NEXT: [[TMP1391:%.*]] = fadd <1 x float> [[TMP1388]], [[TMP1390]]
+; CHECK-NEXT: [[BLOCK1364:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1002:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1365:%.*]] = insertelement <1 x float> poison, float [[TMP1002]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1366:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1365]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1393:%.*]] = fmul <1 x float> [[BLOCK1364]], [[SPLAT_SPLAT1366]]
+; CHECK-NEXT: [[TMP1394:%.*]] = fadd <1 x float> [[TMP1391]], [[TMP1393]]
+; CHECK-NEXT: [[BLOCK1367:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1004:%.*]] = extractelement <8 x float> [[COL_LOAD26]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1368:%.*]] = insertelement <1 x float> poison, float [[TMP1004]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1369:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1368]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1396:%.*]] = fmul <1 x float> [[BLOCK1367]], [[SPLAT_SPLAT1369]]
+; CHECK-NEXT: [[TMP1005:%.*]] = fadd <1 x float> [[TMP1394]], [[TMP1396]]
+; CHECK-NEXT: [[TMP1006:%.*]] = shufflevector <1 x float> [[TMP1005]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1007:%.*]] = shufflevector <8 x float> [[TMP989]], <8 x float> [[TMP1006]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[BLOCK1370:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1008:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1371:%.*]] = insertelement <1 x float> poison, float [[TMP1008]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1372:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1371]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1401:%.*]] = fmul <1 x float> [[BLOCK1370]], [[SPLAT_SPLAT1372]]
+; CHECK-NEXT: [[BLOCK1373:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1010:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1374:%.*]] = insertelement <1 x float> poison, float [[TMP1010]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1375:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1374]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1403:%.*]] = fmul <1 x float> [[BLOCK1373]], [[SPLAT_SPLAT1375]]
+; CHECK-NEXT: [[TMP1404:%.*]] = fadd <1 x float> [[TMP1401]], [[TMP1403]]
+; CHECK-NEXT: [[BLOCK1376:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1012:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1377:%.*]] = insertelement <1 x float> poison, float [[TMP1012]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1378:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1377]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1406:%.*]] = fmul <1 x float> [[BLOCK1376]], [[SPLAT_SPLAT1378]]
+; CHECK-NEXT: [[TMP1407:%.*]] = fadd <1 x float> [[TMP1404]], [[TMP1406]]
+; CHECK-NEXT: [[BLOCK1379:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1014:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1380:%.*]] = insertelement <1 x float> poison, float [[TMP1014]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1381:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1380]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1409:%.*]] = fmul <1 x float> [[BLOCK1379]], [[SPLAT_SPLAT1381]]
+; CHECK-NEXT: [[TMP1410:%.*]] = fadd <1 x float> [[TMP1407]], [[TMP1409]]
+; CHECK-NEXT: [[BLOCK1382:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1016:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1383:%.*]] = insertelement <1 x float> poison, float [[TMP1016]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1384:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1383]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1412:%.*]] = fmul <1 x float> [[BLOCK1382]], [[SPLAT_SPLAT1384]]
+; CHECK-NEXT: [[TMP1413:%.*]] = fadd <1 x float> [[TMP1410]], [[TMP1412]]
+; CHECK-NEXT: [[BLOCK1385:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1018:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1386:%.*]] = insertelement <1 x float> poison, float [[TMP1018]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1387:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1386]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1415:%.*]] = fmul <1 x float> [[BLOCK1385]], [[SPLAT_SPLAT1387]]
+; CHECK-NEXT: [[TMP1416:%.*]] = fadd <1 x float> [[TMP1413]], [[TMP1415]]
+; CHECK-NEXT: [[BLOCK1388:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1020:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1389:%.*]] = insertelement <1 x float> poison, float [[TMP1020]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1390:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1389]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1418:%.*]] = fmul <1 x float> [[BLOCK1388]], [[SPLAT_SPLAT1390]]
+; CHECK-NEXT: [[TMP1419:%.*]] = fadd <1 x float> [[TMP1416]], [[TMP1418]]
+; CHECK-NEXT: [[BLOCK1391:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1022:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1392:%.*]] = insertelement <1 x float> poison, float [[TMP1022]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1393:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1392]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1421:%.*]] = fmul <1 x float> [[BLOCK1391]], [[SPLAT_SPLAT1393]]
+; CHECK-NEXT: [[TMP1023:%.*]] = fadd <1 x float> [[TMP1419]], [[TMP1421]]
+; CHECK-NEXT: [[TMP1024:%.*]] = shufflevector <1 x float> [[TMP1023]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1025:%.*]] = shufflevector <8 x float> poison, <8 x float> [[TMP1024]], <8 x i32> <i32 8, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1394:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1026:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1395:%.*]] = insertelement <1 x float> poison, float [[TMP1026]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1396:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1395]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1426:%.*]] = fmul <1 x float> [[BLOCK1394]], [[SPLAT_SPLAT1396]]
+; CHECK-NEXT: [[BLOCK1397:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1028:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1398:%.*]] = insertelement <1 x float> poison, float [[TMP1028]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1399:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1398]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1428:%.*]] = fmul <1 x float> [[BLOCK1397]], [[SPLAT_SPLAT1399]]
+; CHECK-NEXT: [[TMP1429:%.*]] = fadd <1 x float> [[TMP1426]], [[TMP1428]]
+; CHECK-NEXT: [[BLOCK1400:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1030:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1401:%.*]] = insertelement <1 x float> poison, float [[TMP1030]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1402:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1401]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1431:%.*]] = fmul <1 x float> [[BLOCK1400]], [[SPLAT_SPLAT1402]]
+; CHECK-NEXT: [[TMP1432:%.*]] = fadd <1 x float> [[TMP1429]], [[TMP1431]]
+; CHECK-NEXT: [[BLOCK1403:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1032:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1404:%.*]] = insertelement <1 x float> poison, float [[TMP1032]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1405:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1404]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1434:%.*]] = fmul <1 x float> [[BLOCK1403]], [[SPLAT_SPLAT1405]]
+; CHECK-NEXT: [[TMP1435:%.*]] = fadd <1 x float> [[TMP1432]], [[TMP1434]]
+; CHECK-NEXT: [[BLOCK1406:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1034:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1407:%.*]] = insertelement <1 x float> poison, float [[TMP1034]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1408:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1407]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1437:%.*]] = fmul <1 x float> [[BLOCK1406]], [[SPLAT_SPLAT1408]]
+; CHECK-NEXT: [[TMP1438:%.*]] = fadd <1 x float> [[TMP1435]], [[TMP1437]]
+; CHECK-NEXT: [[BLOCK1409:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1036:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1410:%.*]] = insertelement <1 x float> poison, float [[TMP1036]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1411:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1410]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1440:%.*]] = fmul <1 x float> [[BLOCK1409]], [[SPLAT_SPLAT1411]]
+; CHECK-NEXT: [[TMP1441:%.*]] = fadd <1 x float> [[TMP1438]], [[TMP1440]]
+; CHECK-NEXT: [[BLOCK1412:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1038:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1413:%.*]] = insertelement <1 x float> poison, float [[TMP1038]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1414:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1413]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1443:%.*]] = fmul <1 x float> [[BLOCK1412]], [[SPLAT_SPLAT1414]]
+; CHECK-NEXT: [[TMP1444:%.*]] = fadd <1 x float> [[TMP1441]], [[TMP1443]]
+; CHECK-NEXT: [[BLOCK1415:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 1>
+; CHECK-NEXT: [[TMP1040:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1416:%.*]] = insertelement <1 x float> poison, float [[TMP1040]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1417:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1416]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1446:%.*]] = fmul <1 x float> [[BLOCK1415]], [[SPLAT_SPLAT1417]]
+; CHECK-NEXT: [[TMP1041:%.*]] = fadd <1 x float> [[TMP1444]], [[TMP1446]]
+; CHECK-NEXT: [[TMP1042:%.*]] = shufflevector <1 x float> [[TMP1041]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1043:%.*]] = shufflevector <8 x float> [[TMP1025]], <8 x float> [[TMP1042]], <8 x i32> <i32 0, i32 8, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1418:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1044:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1419:%.*]] = insertelement <1 x float> poison, float [[TMP1044]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1420:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1419]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1451:%.*]] = fmul <1 x float> [[BLOCK1418]], [[SPLAT_SPLAT1420]]
+; CHECK-NEXT: [[BLOCK1421:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1046:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1422:%.*]] = insertelement <1 x float> poison, float [[TMP1046]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1423:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1422]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1453:%.*]] = fmul <1 x float> [[BLOCK1421]], [[SPLAT_SPLAT1423]]
+; CHECK-NEXT: [[TMP1454:%.*]] = fadd <1 x float> [[TMP1451]], [[TMP1453]]
+; CHECK-NEXT: [[BLOCK1424:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1048:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1425:%.*]] = insertelement <1 x float> poison, float [[TMP1048]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1426:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1425]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1456:%.*]] = fmul <1 x float> [[BLOCK1424]], [[SPLAT_SPLAT1426]]
+; CHECK-NEXT: [[TMP1457:%.*]] = fadd <1 x float> [[TMP1454]], [[TMP1456]]
+; CHECK-NEXT: [[BLOCK1427:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1050:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1428:%.*]] = insertelement <1 x float> poison, float [[TMP1050]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1429:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1428]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1459:%.*]] = fmul <1 x float> [[BLOCK1427]], [[SPLAT_SPLAT1429]]
+; CHECK-NEXT: [[TMP1460:%.*]] = fadd <1 x float> [[TMP1457]], [[TMP1459]]
+; CHECK-NEXT: [[BLOCK1430:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1052:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1431:%.*]] = insertelement <1 x float> poison, float [[TMP1052]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1432:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1431]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1462:%.*]] = fmul <1 x float> [[BLOCK1430]], [[SPLAT_SPLAT1432]]
+; CHECK-NEXT: [[TMP1463:%.*]] = fadd <1 x float> [[TMP1460]], [[TMP1462]]
+; CHECK-NEXT: [[BLOCK1433:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1054:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1434:%.*]] = insertelement <1 x float> poison, float [[TMP1054]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1435:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1434]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1465:%.*]] = fmul <1 x float> [[BLOCK1433]], [[SPLAT_SPLAT1435]]
+; CHECK-NEXT: [[TMP1466:%.*]] = fadd <1 x float> [[TMP1463]], [[TMP1465]]
+; CHECK-NEXT: [[BLOCK1436:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1056:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1437:%.*]] = insertelement <1 x float> poison, float [[TMP1056]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1438:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1437]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1468:%.*]] = fmul <1 x float> [[BLOCK1436]], [[SPLAT_SPLAT1438]]
+; CHECK-NEXT: [[TMP1469:%.*]] = fadd <1 x float> [[TMP1466]], [[TMP1468]]
+; CHECK-NEXT: [[BLOCK1439:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 2>
+; CHECK-NEXT: [[TMP1058:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1440:%.*]] = insertelement <1 x float> poison, float [[TMP1058]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1441:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1440]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1471:%.*]] = fmul <1 x float> [[BLOCK1439]], [[SPLAT_SPLAT1441]]
+; CHECK-NEXT: [[TMP1059:%.*]] = fadd <1 x float> [[TMP1469]], [[TMP1471]]
+; CHECK-NEXT: [[TMP1060:%.*]] = shufflevector <1 x float> [[TMP1059]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1061:%.*]] = shufflevector <8 x float> [[TMP1043]], <8 x float> [[TMP1060]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1442:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1062:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1443:%.*]] = insertelement <1 x float> poison, float [[TMP1062]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1444:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1443]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1476:%.*]] = fmul <1 x float> [[BLOCK1442]], [[SPLAT_SPLAT1444]]
+; CHECK-NEXT: [[BLOCK1445:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1064:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1446:%.*]] = insertelement <1 x float> poison, float [[TMP1064]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1447:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1446]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1478:%.*]] = fmul <1 x float> [[BLOCK1445]], [[SPLAT_SPLAT1447]]
+; CHECK-NEXT: [[TMP1479:%.*]] = fadd <1 x float> [[TMP1476]], [[TMP1478]]
+; CHECK-NEXT: [[BLOCK1448:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1066:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1449:%.*]] = insertelement <1 x float> poison, float [[TMP1066]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1450:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1449]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1481:%.*]] = fmul <1 x float> [[BLOCK1448]], [[SPLAT_SPLAT1450]]
+; CHECK-NEXT: [[TMP1482:%.*]] = fadd <1 x float> [[TMP1479]], [[TMP1481]]
+; CHECK-NEXT: [[BLOCK1451:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1068:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1452:%.*]] = insertelement <1 x float> poison, float [[TMP1068]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1453:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1452]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1484:%.*]] = fmul <1 x float> [[BLOCK1451]], [[SPLAT_SPLAT1453]]
+; CHECK-NEXT: [[TMP1485:%.*]] = fadd <1 x float> [[TMP1482]], [[TMP1484]]
+; CHECK-NEXT: [[BLOCK1454:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1070:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1455:%.*]] = insertelement <1 x float> poison, float [[TMP1070]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1456:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1455]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1487:%.*]] = fmul <1 x float> [[BLOCK1454]], [[SPLAT_SPLAT1456]]
+; CHECK-NEXT: [[TMP1488:%.*]] = fadd <1 x float> [[TMP1485]], [[TMP1487]]
+; CHECK-NEXT: [[BLOCK1457:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1072:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1458:%.*]] = insertelement <1 x float> poison, float [[TMP1072]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1459:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1458]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1490:%.*]] = fmul <1 x float> [[BLOCK1457]], [[SPLAT_SPLAT1459]]
+; CHECK-NEXT: [[TMP1491:%.*]] = fadd <1 x float> [[TMP1488]], [[TMP1490]]
+; CHECK-NEXT: [[BLOCK1460:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1074:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1461:%.*]] = insertelement <1 x float> poison, float [[TMP1074]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1462:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1461]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1493:%.*]] = fmul <1 x float> [[BLOCK1460]], [[SPLAT_SPLAT1462]]
+; CHECK-NEXT: [[TMP1494:%.*]] = fadd <1 x float> [[TMP1491]], [[TMP1493]]
+; CHECK-NEXT: [[BLOCK1463:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 3>
+; CHECK-NEXT: [[TMP1076:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1464:%.*]] = insertelement <1 x float> poison, float [[TMP1076]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1465:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1464]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1496:%.*]] = fmul <1 x float> [[BLOCK1463]], [[SPLAT_SPLAT1465]]
+; CHECK-NEXT: [[TMP1077:%.*]] = fadd <1 x float> [[TMP1494]], [[TMP1496]]
+; CHECK-NEXT: [[TMP1078:%.*]] = shufflevector <1 x float> [[TMP1077]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1079:%.*]] = shufflevector <8 x float> [[TMP1061]], <8 x float> [[TMP1078]], <8 x i32> <i32 0, i32 1, i32 2, i32 8, i32 4, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1466:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1080:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1467:%.*]] = insertelement <1 x float> poison, float [[TMP1080]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1468:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1467]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1501:%.*]] = fmul <1 x float> [[BLOCK1466]], [[SPLAT_SPLAT1468]]
+; CHECK-NEXT: [[BLOCK1469:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1082:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1470:%.*]] = insertelement <1 x float> poison, float [[TMP1082]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1471:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1470]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1503:%.*]] = fmul <1 x float> [[BLOCK1469]], [[SPLAT_SPLAT1471]]
+; CHECK-NEXT: [[TMP1504:%.*]] = fadd <1 x float> [[TMP1501]], [[TMP1503]]
+; CHECK-NEXT: [[BLOCK1472:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1084:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1473:%.*]] = insertelement <1 x float> poison, float [[TMP1084]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1474:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1473]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1506:%.*]] = fmul <1 x float> [[BLOCK1472]], [[SPLAT_SPLAT1474]]
+; CHECK-NEXT: [[TMP1507:%.*]] = fadd <1 x float> [[TMP1504]], [[TMP1506]]
+; CHECK-NEXT: [[BLOCK1475:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1086:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1476:%.*]] = insertelement <1 x float> poison, float [[TMP1086]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1477:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1476]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1509:%.*]] = fmul <1 x float> [[BLOCK1475]], [[SPLAT_SPLAT1477]]
+; CHECK-NEXT: [[TMP1510:%.*]] = fadd <1 x float> [[TMP1507]], [[TMP1509]]
+; CHECK-NEXT: [[BLOCK1478:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1088:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1479:%.*]] = insertelement <1 x float> poison, float [[TMP1088]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1480:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1479]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1512:%.*]] = fmul <1 x float> [[BLOCK1478]], [[SPLAT_SPLAT1480]]
+; CHECK-NEXT: [[TMP1513:%.*]] = fadd <1 x float> [[TMP1510]], [[TMP1512]]
+; CHECK-NEXT: [[BLOCK1481:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1090:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1482:%.*]] = insertelement <1 x float> poison, float [[TMP1090]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1483:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1482]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1515:%.*]] = fmul <1 x float> [[BLOCK1481]], [[SPLAT_SPLAT1483]]
+; CHECK-NEXT: [[TMP1516:%.*]] = fadd <1 x float> [[TMP1513]], [[TMP1515]]
+; CHECK-NEXT: [[BLOCK1484:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1092:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1485:%.*]] = insertelement <1 x float> poison, float [[TMP1092]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1486:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1485]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1518:%.*]] = fmul <1 x float> [[BLOCK1484]], [[SPLAT_SPLAT1486]]
+; CHECK-NEXT: [[TMP1519:%.*]] = fadd <1 x float> [[TMP1516]], [[TMP1518]]
+; CHECK-NEXT: [[BLOCK1487:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 4>
+; CHECK-NEXT: [[TMP1094:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1488:%.*]] = insertelement <1 x float> poison, float [[TMP1094]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1489:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1488]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1521:%.*]] = fmul <1 x float> [[BLOCK1487]], [[SPLAT_SPLAT1489]]
+; CHECK-NEXT: [[TMP1095:%.*]] = fadd <1 x float> [[TMP1519]], [[TMP1521]]
+; CHECK-NEXT: [[TMP1096:%.*]] = shufflevector <1 x float> [[TMP1095]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1097:%.*]] = shufflevector <8 x float> [[TMP1079]], <8 x float> [[TMP1096]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 5, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1490:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1098:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1491:%.*]] = insertelement <1 x float> poison, float [[TMP1098]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1492:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1491]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1526:%.*]] = fmul <1 x float> [[BLOCK1490]], [[SPLAT_SPLAT1492]]
+; CHECK-NEXT: [[BLOCK1493:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1100:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1494:%.*]] = insertelement <1 x float> poison, float [[TMP1100]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1495:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1494]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1528:%.*]] = fmul <1 x float> [[BLOCK1493]], [[SPLAT_SPLAT1495]]
+; CHECK-NEXT: [[TMP1529:%.*]] = fadd <1 x float> [[TMP1526]], [[TMP1528]]
+; CHECK-NEXT: [[BLOCK1496:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1102:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1497:%.*]] = insertelement <1 x float> poison, float [[TMP1102]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1498:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1497]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1531:%.*]] = fmul <1 x float> [[BLOCK1496]], [[SPLAT_SPLAT1498]]
+; CHECK-NEXT: [[TMP1532:%.*]] = fadd <1 x float> [[TMP1529]], [[TMP1531]]
+; CHECK-NEXT: [[BLOCK1499:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1104:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1500:%.*]] = insertelement <1 x float> poison, float [[TMP1104]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1501:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1500]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1534:%.*]] = fmul <1 x float> [[BLOCK1499]], [[SPLAT_SPLAT1501]]
+; CHECK-NEXT: [[TMP1535:%.*]] = fadd <1 x float> [[TMP1532]], [[TMP1534]]
+; CHECK-NEXT: [[BLOCK1502:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1106:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1503:%.*]] = insertelement <1 x float> poison, float [[TMP1106]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1504:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1503]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1537:%.*]] = fmul <1 x float> [[BLOCK1502]], [[SPLAT_SPLAT1504]]
+; CHECK-NEXT: [[TMP1538:%.*]] = fadd <1 x float> [[TMP1535]], [[TMP1537]]
+; CHECK-NEXT: [[BLOCK1505:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1108:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1506:%.*]] = insertelement <1 x float> poison, float [[TMP1108]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1507:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1506]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1540:%.*]] = fmul <1 x float> [[BLOCK1505]], [[SPLAT_SPLAT1507]]
+; CHECK-NEXT: [[TMP1541:%.*]] = fadd <1 x float> [[TMP1538]], [[TMP1540]]
+; CHECK-NEXT: [[BLOCK1508:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1110:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1509:%.*]] = insertelement <1 x float> poison, float [[TMP1110]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1510:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1509]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1543:%.*]] = fmul <1 x float> [[BLOCK1508]], [[SPLAT_SPLAT1510]]
+; CHECK-NEXT: [[TMP1544:%.*]] = fadd <1 x float> [[TMP1541]], [[TMP1543]]
+; CHECK-NEXT: [[BLOCK1511:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 5>
+; CHECK-NEXT: [[TMP1112:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1512:%.*]] = insertelement <1 x float> poison, float [[TMP1112]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1513:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1512]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1546:%.*]] = fmul <1 x float> [[BLOCK1511]], [[SPLAT_SPLAT1513]]
+; CHECK-NEXT: [[TMP1113:%.*]] = fadd <1 x float> [[TMP1544]], [[TMP1546]]
+; CHECK-NEXT: [[TMP1114:%.*]] = shufflevector <1 x float> [[TMP1113]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1115:%.*]] = shufflevector <8 x float> [[TMP1097]], <8 x float> [[TMP1114]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[BLOCK1514:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1116:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1515:%.*]] = insertelement <1 x float> poison, float [[TMP1116]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1516:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1515]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1551:%.*]] = fmul <1 x float> [[BLOCK1514]], [[SPLAT_SPLAT1516]]
+; CHECK-NEXT: [[BLOCK1517:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1118:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1518:%.*]] = insertelement <1 x float> poison, float [[TMP1118]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1519:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1518]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1553:%.*]] = fmul <1 x float> [[BLOCK1517]], [[SPLAT_SPLAT1519]]
+; CHECK-NEXT: [[TMP1554:%.*]] = fadd <1 x float> [[TMP1551]], [[TMP1553]]
+; CHECK-NEXT: [[BLOCK1520:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1120:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1521:%.*]] = insertelement <1 x float> poison, float [[TMP1120]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1522:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1521]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1556:%.*]] = fmul <1 x float> [[BLOCK1520]], [[SPLAT_SPLAT1522]]
+; CHECK-NEXT: [[TMP1557:%.*]] = fadd <1 x float> [[TMP1554]], [[TMP1556]]
+; CHECK-NEXT: [[BLOCK1523:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1122:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1524:%.*]] = insertelement <1 x float> poison, float [[TMP1122]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1525:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1524]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1559:%.*]] = fmul <1 x float> [[BLOCK1523]], [[SPLAT_SPLAT1525]]
+; CHECK-NEXT: [[TMP1560:%.*]] = fadd <1 x float> [[TMP1557]], [[TMP1559]]
+; CHECK-NEXT: [[BLOCK1526:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1124:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1527:%.*]] = insertelement <1 x float> poison, float [[TMP1124]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1528:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1527]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1562:%.*]] = fmul <1 x float> [[BLOCK1526]], [[SPLAT_SPLAT1528]]
+; CHECK-NEXT: [[TMP1563:%.*]] = fadd <1 x float> [[TMP1560]], [[TMP1562]]
+; CHECK-NEXT: [[BLOCK1529:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1126:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1530:%.*]] = insertelement <1 x float> poison, float [[TMP1126]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1531:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1530]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1565:%.*]] = fmul <1 x float> [[BLOCK1529]], [[SPLAT_SPLAT1531]]
+; CHECK-NEXT: [[TMP1566:%.*]] = fadd <1 x float> [[TMP1563]], [[TMP1565]]
+; CHECK-NEXT: [[BLOCK1532:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1128:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1533:%.*]] = insertelement <1 x float> poison, float [[TMP1128]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1534:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1533]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1568:%.*]] = fmul <1 x float> [[BLOCK1532]], [[SPLAT_SPLAT1534]]
+; CHECK-NEXT: [[TMP1569:%.*]] = fadd <1 x float> [[TMP1566]], [[TMP1568]]
+; CHECK-NEXT: [[BLOCK1535:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 6>
+; CHECK-NEXT: [[TMP1130:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1536:%.*]] = insertelement <1 x float> poison, float [[TMP1130]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1537:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1536]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1571:%.*]] = fmul <1 x float> [[BLOCK1535]], [[SPLAT_SPLAT1537]]
+; CHECK-NEXT: [[TMP1131:%.*]] = fadd <1 x float> [[TMP1569]], [[TMP1571]]
+; CHECK-NEXT: [[TMP1132:%.*]] = shufflevector <1 x float> [[TMP1131]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1133:%.*]] = shufflevector <8 x float> [[TMP1115]], <8 x float> [[TMP1132]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 7>
+; CHECK-NEXT: [[BLOCK1538:%.*]] = shufflevector <8 x float> [[COL_LOAD]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1134:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1539:%.*]] = insertelement <1 x float> poison, float [[TMP1134]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1540:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1539]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1576:%.*]] = fmul <1 x float> [[BLOCK1538]], [[SPLAT_SPLAT1540]]
+; CHECK-NEXT: [[BLOCK1541:%.*]] = shufflevector <8 x float> [[COL_LOAD1]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1136:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 1
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1542:%.*]] = insertelement <1 x float> poison, float [[TMP1136]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1543:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1542]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1578:%.*]] = fmul <1 x float> [[BLOCK1541]], [[SPLAT_SPLAT1543]]
+; CHECK-NEXT: [[TMP1579:%.*]] = fadd <1 x float> [[TMP1576]], [[TMP1578]]
+; CHECK-NEXT: [[BLOCK1544:%.*]] = shufflevector <8 x float> [[COL_LOAD3]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1138:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 2
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1545:%.*]] = insertelement <1 x float> poison, float [[TMP1138]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1546:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1545]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1581:%.*]] = fmul <1 x float> [[BLOCK1544]], [[SPLAT_SPLAT1546]]
+; CHECK-NEXT: [[TMP1582:%.*]] = fadd <1 x float> [[TMP1579]], [[TMP1581]]
+; CHECK-NEXT: [[BLOCK1547:%.*]] = shufflevector <8 x float> [[COL_LOAD5]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1140:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 3
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1548:%.*]] = insertelement <1 x float> poison, float [[TMP1140]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1549:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1548]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1584:%.*]] = fmul <1 x float> [[BLOCK1547]], [[SPLAT_SPLAT1549]]
+; CHECK-NEXT: [[TMP1585:%.*]] = fadd <1 x float> [[TMP1582]], [[TMP1584]]
+; CHECK-NEXT: [[BLOCK1550:%.*]] = shufflevector <8 x float> [[COL_LOAD7]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1142:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 4
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1551:%.*]] = insertelement <1 x float> poison, float [[TMP1142]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1552:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1551]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1587:%.*]] = fmul <1 x float> [[BLOCK1550]], [[SPLAT_SPLAT1552]]
+; CHECK-NEXT: [[TMP1588:%.*]] = fadd <1 x float> [[TMP1585]], [[TMP1587]]
+; CHECK-NEXT: [[BLOCK1553:%.*]] = shufflevector <8 x float> [[COL_LOAD9]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1144:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 5
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1554:%.*]] = insertelement <1 x float> poison, float [[TMP1144]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1555:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1554]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1590:%.*]] = fmul <1 x float> [[BLOCK1553]], [[SPLAT_SPLAT1555]]
+; CHECK-NEXT: [[TMP1591:%.*]] = fadd <1 x float> [[TMP1588]], [[TMP1590]]
+; CHECK-NEXT: [[BLOCK1556:%.*]] = shufflevector <8 x float> [[COL_LOAD11]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1146:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 6
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1557:%.*]] = insertelement <1 x float> poison, float [[TMP1146]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1558:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1557]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1593:%.*]] = fmul <1 x float> [[BLOCK1556]], [[SPLAT_SPLAT1558]]
+; CHECK-NEXT: [[TMP1594:%.*]] = fadd <1 x float> [[TMP1591]], [[TMP1593]]
+; CHECK-NEXT: [[BLOCK1559:%.*]] = shufflevector <8 x float> [[COL_LOAD13]], <8 x float> poison, <1 x i32> <i32 7>
+; CHECK-NEXT: [[TMP1148:%.*]] = extractelement <8 x float> [[COL_LOAD28]], i64 7
+; CHECK-NEXT: [[SPLAT_SPLATINSERT1560:%.*]] = insertelement <1 x float> poison, float [[TMP1148]], i64 0
+; CHECK-NEXT: [[SPLAT_SPLAT1561:%.*]] = shufflevector <1 x float> [[SPLAT_SPLATINSERT1560]], <1 x float> poison, <1 x i32> zeroinitializer
+; CHECK-NEXT: [[TMP1596:%.*]] = fmul <1 x float> [[BLOCK1559]], [[SPLAT_SPLAT1561]]
+; CHECK-NEXT: [[TMP1149:%.*]] = fadd <1 x float> [[TMP1594]], [[TMP1596]]
+; CHECK-NEXT: [[TMP1150:%.*]] = shufflevector <1 x float> [[TMP1149]], <1 x float> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP1151:%.*]] = shufflevector <8 x float> [[TMP1133]], <8 x float> [[TMP1150]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 8>
+; CHECK-NEXT: [[TMP1152:%.*]] = fneg <8 x float> [[TMP143]]
+; CHECK-NEXT: [[TMP1153:%.*]] = fneg <8 x float> [[TMP287]]
+; CHECK-NEXT: [[TMP1154:%.*]] = fneg <8 x float> [[TMP431]]
+; CHECK-NEXT: [[TMP1155:%.*]] = fneg <8 x float> [[TMP575]]
+; CHECK-NEXT: [[TMP1156:%.*]] = fneg <8 x float> [[TMP719]]
+; CHECK-NEXT: [[TMP1157:%.*]] = fneg <8 x float> [[TMP863]]
+; CHECK-NEXT: [[TMP1158:%.*]] = fneg <8 x float> [[TMP1007]]
+; CHECK-NEXT: [[TMP1159:%.*]] = fneg <8 x float> [[TMP1151]]
+; CHECK-NEXT: store <8 x float> [[TMP143]], ptr [[C:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP1562:%.*]] = getelementptr inbounds float, ptr [[C]], i64 8
+; CHECK-NEXT: store <8 x float> [[TMP287]], ptr [[VEC_GEP1562]], align 16
+; CHECK-NEXT: [[VEC_GEP1563:%.*]] = getelementptr inbounds float, ptr [[C]], i64 16
+; CHECK-NEXT: store <8 x float> [[TMP431]], ptr [[VEC_GEP1563]], align 16
+; CHECK-NEXT: [[VEC_GEP1564:%.*]] = getelementptr inbounds float, ptr [[C]], i64 24
+; CHECK-NEXT: store <8 x float> [[TMP575]], ptr [[VEC_GEP1564]], align 16
+; CHECK-NEXT: [[VEC_GEP1565:%.*]] = getelementptr inbounds float, ptr [[C]], i64 32
+; CHECK-NEXT: store <8 x float> [[TMP719]], ptr [[VEC_GEP1565]], align 16
+; CHECK-NEXT: [[VEC_GEP1566:%.*]] = getelementptr inbounds float, ptr [[C]], i64 40
+; CHECK-NEXT: store <8 x float> [[TMP863]], ptr [[VEC_GEP1566]], align 16
+; CHECK-NEXT: [[VEC_GEP1567:%.*]] = getelementptr inbounds float, ptr [[C]], i64 48
+; CHECK-NEXT: store <8 x float> [[TMP1007]], ptr [[VEC_GEP1567]], align 16
+; CHECK-NEXT: [[VEC_GEP1568:%.*]] = getelementptr inbounds float, ptr [[C]], i64 56
+; CHECK-NEXT: store <8 x float> [[TMP1151]], ptr [[VEC_GEP1568]], align 16
+; CHECK-NEXT: store <8 x float> [[TMP1152]], ptr [[C2:%.*]], align 16
+; CHECK-NEXT: [[VEC_GEP1569:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 8
+; CHECK-NEXT: store <8 x float> [[TMP1153]], ptr [[VEC_GEP1569]], align 16
+; CHECK-NEXT: [[VEC_GEP1570:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 16
+; CHECK-NEXT: store <8 x float> [[TMP1154]], ptr [[VEC_GEP1570]], align 16
+; CHECK-NEXT: [[VEC_GEP1571:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 24
+; CHECK-NEXT: store <8 x float> [[TMP1155]], ptr [[VEC_GEP1571]], align 16
+; CHECK-NEXT: [[VEC_GEP1572:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 32
+; CHECK-NEXT: store <8 x float> [[TMP1156]], ptr [[VEC_GEP1572]], align 16
+; CHECK-NEXT: [[VEC_GEP1573:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 40
+; CHECK-NEXT: store <8 x float> [[TMP1157]], ptr [[VEC_GEP1573]], align 16
+; CHECK-NEXT: [[VEC_GEP1574:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 48
+; CHECK-NEXT: store <8 x float> [[TMP1158]], ptr [[VEC_GEP1574]], align 16
+; CHECK-NEXT: [[VEC_GEP1575:%.*]] = getelementptr inbounds float, ptr [[C2]], i64 56
+; CHECK-NEXT: store <8 x float> [[TMP1159]], ptr [[VEC_GEP1575]], align 16
+; CHECK-NEXT: ret void
+;
+entry:
+ %loada = load <64 x float>, <64 x float>* %A, align 16
+ %loadb = load <64 x float>, <64 x float>* %B, align 16
+
+ %c = call <64 x float> @llvm.matrix.multiply(<64 x float> %loada, <64 x float> %loadb, i32 8, i32 8, i32 8)
+ %neg = fneg <64 x float> %c
+
+ store <64 x float> %c, <64 x float>* %C, align 16
+ store <64 x float> %neg, <64 x float>* %C2, align 16
+ ret void
+}
+
+declare <64 x float> @llvm.matrix.multiply(<64 x float>, <64 x float>, i32, i32, i32)
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; DISABLED-REMARKS: {{.*}}
>From 9003e170f3b7da778dae540663e89486f5dd976d Mon Sep 17 00:00:00 2001
From: Jon Roelofs <jonathan_roelofs at apple.com>
Date: Thu, 23 Jul 2026 08:46:26 -0700
Subject: [PATCH 2/2] undef -> zeroinitializer
---
.../double-transpose-asserts-shape.ll | 88 +++++++++----------
1 file changed, 44 insertions(+), 44 deletions(-)
diff --git a/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll b/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
index b368e6801dcc5..9ce5dfaa32620 100644
--- a/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
+++ b/llvm/test/Transforms/LowerMatrixIntrinsics/double-transpose-asserts-shape.ll
@@ -18,25 +18,25 @@ define void @test_jskew_right(ptr %Rv, ptr %R, ptr %v) {
; CHECK-NEXT: [[TMP0:%.*]] = shufflevector <3 x double> [[COL_LOAD]], <3 x double> [[COL_LOAD1]], <6 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5>
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <3 x double> [[COL_LOAD3]], <3 x double> poison, <6 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <6 x double> [[TMP0]], <6 x double> [[TMP1]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8>
-; CHECK-NEXT: [[SPLAT_SPLAT_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 2, i32 2, i32 2>
-; CHECK-NEXT: [[T3:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 3, i32 4, i32 5>
+; CHECK-NEXT: [[SPLAT_SPLAT_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> zeroinitializer, <3 x i32> <i32 2, i32 2, i32 2>
+; CHECK-NEXT: [[T3:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> zeroinitializer, <3 x i32> <i32 3, i32 4, i32 5>
; CHECK-NEXT: [[MUL_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT_I]], [[T3]]
-; CHECK-NEXT: [[SPLAT_SPLAT8_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 1, i32 1, i32 1>
-; CHECK-NEXT: [[T4:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 6, i32 7, i32 8>
+; CHECK-NEXT: [[SPLAT_SPLAT8_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> zeroinitializer, <3 x i32> <i32 1, i32 1, i32 1>
+; CHECK-NEXT: [[T4:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> zeroinitializer, <3 x i32> <i32 6, i32 7, i32 8>
; CHECK-NEXT: [[MUL10_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT8_I]], [[T4]]
; CHECK-NEXT: [[SUB_I:%.*]] = fsub <3 x double> [[MUL_I]], [[MUL10_I]]
-; CHECK-NEXT: [[T5:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
-; CHECK-NEXT: [[SPLAT_SPLAT13_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> zeroinitializer
+; CHECK-NEXT: [[T5:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+; CHECK-NEXT: [[SPLAT_SPLAT13_I:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> zeroinitializer, <3 x i32> zeroinitializer
; CHECK-NEXT: [[MUL15_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT13_I]], [[T4]]
-; CHECK-NEXT: [[T6:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> undef, <3 x i32> <i32 0, i32 1, i32 2>
+; CHECK-NEXT: [[T6:%.*]] = shufflevector <9 x double> [[TMP2]], <9 x double> zeroinitializer, <3 x i32> <i32 0, i32 1, i32 2>
; CHECK-NEXT: [[MUL20_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT_I]], [[T6]]
; CHECK-NEXT: [[SUB21_I:%.*]] = fsub <3 x double> [[MUL15_I]], [[MUL20_I]]
-; CHECK-NEXT: [[T7:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
-; CHECK-NEXT: [[T8:%.*]] = shufflevector <9 x double> [[T5]], <9 x double> [[T7]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T7:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+; CHECK-NEXT: [[T8:%.*]] = shufflevector <9 x double> [[T5]], <9 x double> [[T7]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 0, i32 0, i32 0>
; CHECK-NEXT: [[MUL26_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT8_I]], [[T6]]
; CHECK-NEXT: [[MUL31_I:%.*]] = fmul <3 x double> [[SPLAT_SPLAT13_I]], [[T3]]
; CHECK-NEXT: [[SUB32_I:%.*]] = fsub <3 x double> [[MUL26_I]], [[MUL31_I]]
-; CHECK-NEXT: [[T9:%.*]] = shufflevector <3 x double> [[SUB32_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T9:%.*]] = shufflevector <3 x double> [[SUB32_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
; CHECK-NEXT: [[T10:%.*]] = shufflevector <9 x double> [[T8]], <9 x double> [[T9]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
; CHECK-NEXT: [[SPLIT:%.*]] = shufflevector <9 x double> [[T10]], <9 x double> poison, <3 x i32> <i32 0, i32 1, i32 2>
; CHECK-NEXT: [[SPLIT4:%.*]] = shufflevector <9 x double> [[T10]], <9 x double> poison, <3 x i32> <i32 3, i32 4, i32 5>
@@ -53,25 +53,25 @@ entry:
%RR = load <9 x double>, ptr %R, align 8
%t1 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %RR, i32 3, i32 3)
%t2 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t1, i32 3, i32 3)
- %splat.splat.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 2, i32 2, i32 2>
- %t3 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 3, i32 4, i32 5>
+ %splat.splat.i = shufflevector <3 x double> %vv, <3 x double> zeroinitializer, <3 x i32> <i32 2, i32 2, i32 2>
+ %t3 = shufflevector <9 x double> %t2, <9 x double> zeroinitializer, <3 x i32> <i32 3, i32 4, i32 5>
%mul.i = fmul <3 x double> %splat.splat.i, %t3
- %splat.splat8.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 1, i32 1, i32 1>
- %t4 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 6, i32 7, i32 8>
+ %splat.splat8.i = shufflevector <3 x double> %vv, <3 x double> zeroinitializer, <3 x i32> <i32 1, i32 1, i32 1>
+ %t4 = shufflevector <9 x double> %t2, <9 x double> zeroinitializer, <3 x i32> <i32 6, i32 7, i32 8>
%mul10.i = fmul <3 x double> %splat.splat8.i, %t4
%sub.i = fsub <3 x double> %mul.i, %mul10.i
- %t5 = shufflevector <3 x double> %sub.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
- %splat.splat13.i = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> zeroinitializer
+ %t5 = shufflevector <3 x double> %sub.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+ %splat.splat13.i = shufflevector <3 x double> %vv, <3 x double> zeroinitializer, <3 x i32> zeroinitializer
%mul15.i = fmul <3 x double> %splat.splat13.i, %t4
- %t6 = shufflevector <9 x double> %t2, <9 x double> undef, <3 x i32> <i32 0, i32 1, i32 2>
+ %t6 = shufflevector <9 x double> %t2, <9 x double> zeroinitializer, <3 x i32> <i32 0, i32 1, i32 2>
%mul20.i = fmul <3 x double> %splat.splat.i, %t6
%sub21.i = fsub <3 x double> %mul15.i, %mul20.i
- %t7 = shufflevector <3 x double> %sub21.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
- %t8 = shufflevector <9 x double> %t5, <9 x double> %t7, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 undef, i32 undef, i32 undef>
+ %t7 = shufflevector <3 x double> %sub21.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+ %t8 = shufflevector <9 x double> %t5, <9 x double> %t7, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 0, i32 0, i32 0>
%mul26.i = fmul <3 x double> %splat.splat8.i, %t6
%mul31.i = fmul <3 x double> %splat.splat13.i, %t3
%sub32.i = fsub <3 x double> %mul26.i, %mul31.i
- %t9 = shufflevector <3 x double> %sub32.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t9 = shufflevector <3 x double> %sub32.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
%t10 = shufflevector <9 x double> %t8, <9 x double> %t9, <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
%t11 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t10, i32 3, i32 3)
%t12 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t11, i32 3, i32 3)
@@ -94,27 +94,27 @@ define void @test_jskew_left(ptr %vmR, ptr %R, ptr %v) {
; CHECK-NEXT: [[TMP4:%.*]] = shufflevector <3 x double> [[TMP2]], <3 x double> poison, <6 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP5:%.*]] = shufflevector <6 x double> [[TMP3]], <6 x double> [[TMP4]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8>
; CHECK-NEXT: [[VV:%.*]] = load <3 x double>, ptr [[V:%.*]], align 8
-; CHECK-NEXT: [[T4:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
-; CHECK-NEXT: [[T5:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+; CHECK-NEXT: [[T4:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> zeroinitializer, <3 x i32> <i32 1, i32 2, i32 0>
+; CHECK-NEXT: [[T5:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 2, i32 0, i32 1>
; CHECK-NEXT: [[MUL_I:%.*]] = fmul <3 x double> [[T4]], [[T5]]
-; CHECK-NEXT: [[T6:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
-; CHECK-NEXT: [[T7:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+; CHECK-NEXT: [[T6:%.*]] = shufflevector <3 x double> [[VV]], <3 x double> zeroinitializer, <3 x i32> <i32 2, i32 0, i32 1>
+; CHECK-NEXT: [[T7:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 1, i32 2, i32 0>
; CHECK-NEXT: [[MUL7_I:%.*]] = fmul <3 x double> [[T6]], [[T7]]
; CHECK-NEXT: [[SUB_I:%.*]] = fsub <3 x double> [[MUL_I]], [[MUL7_I]]
-; CHECK-NEXT: [[T8:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
-; CHECK-NEXT: [[T9:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 5, i32 3, i32 4>
+; CHECK-NEXT: [[T8:%.*]] = shufflevector <3 x double> [[SUB_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+; CHECK-NEXT: [[T9:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 5, i32 3, i32 4>
; CHECK-NEXT: [[MUL10_I:%.*]] = fmul <3 x double> [[T4]], [[T9]]
-; CHECK-NEXT: [[T10:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 4, i32 5, i32 3>
+; CHECK-NEXT: [[T10:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 4, i32 5, i32 3>
; CHECK-NEXT: [[MUL13_I:%.*]] = fmul <3 x double> [[T6]], [[T10]]
; CHECK-NEXT: [[SUB14_I:%.*]] = fsub <3 x double> [[MUL10_I]], [[MUL13_I]]
-; CHECK-NEXT: [[T11:%.*]] = shufflevector <3 x double> [[SUB14_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
-; CHECK-NEXT: [[T12:%.*]] = shufflevector <9 x double> [[T8]], <9 x double> [[T11]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 poison, i32 poison, i32 poison>
-; CHECK-NEXT: [[T13:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 8, i32 6, i32 7>
+; CHECK-NEXT: [[T11:%.*]] = shufflevector <3 x double> [[SUB14_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+; CHECK-NEXT: [[T12:%.*]] = shufflevector <9 x double> [[T8]], <9 x double> [[T11]], <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 0, i32 0, i32 0>
+; CHECK-NEXT: [[T13:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 8, i32 6, i32 7>
; CHECK-NEXT: [[MUL17_I:%.*]] = fmul <3 x double> [[T4]], [[T13]]
-; CHECK-NEXT: [[T14:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> undef, <3 x i32> <i32 7, i32 8, i32 6>
+; CHECK-NEXT: [[T14:%.*]] = shufflevector <9 x double> [[TMP5]], <9 x double> zeroinitializer, <3 x i32> <i32 7, i32 8, i32 6>
; CHECK-NEXT: [[MUL20_I:%.*]] = fmul <3 x double> [[T6]], [[T14]]
; CHECK-NEXT: [[SUB21_I:%.*]] = fsub <3 x double> [[MUL17_I]], [[MUL20_I]]
-; CHECK-NEXT: [[T15:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[T15:%.*]] = shufflevector <3 x double> [[SUB21_I]], <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
; CHECK-NEXT: [[T16:%.*]] = shufflevector <9 x double> [[T12]], <9 x double> [[T15]], <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
; CHECK-NEXT: [[SPLIT:%.*]] = shufflevector <9 x double> [[T16]], <9 x double> poison, <3 x i32> <i32 0, i32 1, i32 2>
; CHECK-NEXT: [[SPLIT4:%.*]] = shufflevector <9 x double> [[T16]], <9 x double> poison, <3 x i32> <i32 3, i32 4, i32 5>
@@ -132,27 +132,27 @@ entry:
%vv = load <3 x double>, ptr %v, align 8
%t2 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t1, i32 3, i32 3)
%t3 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t2, i32 3, i32 3)
- %t4 = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
- %t5 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
+ %t4 = shufflevector <3 x double> %vv, <3 x double> zeroinitializer, <3 x i32> <i32 1, i32 2, i32 0>
+ %t5 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 2, i32 0, i32 1>
%mul.i = fmul <3 x double> %t4, %t5
- %t6 = shufflevector <3 x double> %vv, <3 x double> undef, <3 x i32> <i32 2, i32 0, i32 1>
- %t7 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 1, i32 2, i32 0>
+ %t6 = shufflevector <3 x double> %vv, <3 x double> zeroinitializer, <3 x i32> <i32 2, i32 0, i32 1>
+ %t7 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 1, i32 2, i32 0>
%mul7.i = fmul <3 x double> %t6, %t7
%sub.i = fsub <3 x double> %mul.i, %mul7.i
- %t8 = shufflevector <3 x double> %sub.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
- %t9 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 5, i32 3, i32 4>
+ %t8 = shufflevector <3 x double> %sub.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+ %t9 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 5, i32 3, i32 4>
%mul10.i = fmul <3 x double> %t4, %t9
- %t10 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 4, i32 5, i32 3>
+ %t10 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 4, i32 5, i32 3>
%mul13.i = fmul <3 x double> %t6, %t10
%sub14.i = fsub <3 x double> %mul10.i, %mul13.i
- %t11 = shufflevector <3 x double> %sub14.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
- %t12 = shufflevector <9 x double> %t8, <9 x double> %t11, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 undef, i32 undef, i32 undef>
- %t13 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 8, i32 6, i32 7>
+ %t11 = shufflevector <3 x double> %sub14.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
+ %t12 = shufflevector <9 x double> %t8, <9 x double> %t11, <9 x i32> <i32 0, i32 1, i32 2, i32 9, i32 10, i32 11, i32 0, i32 0, i32 0>
+ %t13 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 8, i32 6, i32 7>
%mul17.i = fmul <3 x double> %t4, %t13
- %t14 = shufflevector <9 x double> %t3, <9 x double> undef, <3 x i32> <i32 7, i32 8, i32 6>
+ %t14 = shufflevector <9 x double> %t3, <9 x double> zeroinitializer, <3 x i32> <i32 7, i32 8, i32 6>
%mul20.i = fmul <3 x double> %t6, %t14
%sub21.i = fsub <3 x double> %mul17.i, %mul20.i
- %t15 = shufflevector <3 x double> %sub21.i, <3 x double> undef, <9 x i32> <i32 0, i32 1, i32 2, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+ %t15 = shufflevector <3 x double> %sub21.i, <3 x double> zeroinitializer, <9 x i32> <i32 0, i32 1, i32 2, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>
%t16 = shufflevector <9 x double> %t12, <9 x double> %t15, <9 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 9, i32 10, i32 11>
%t17 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t16, i32 3, i32 3)
%t18 = tail call <9 x double> @llvm.matrix.transpose.v9f64(<9 x double> %t17, i32 3, i32 3)
More information about the llvm-branch-commits
mailing list