diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -495,6 +495,11 @@
 
   /// Fix the non-induction PHIs in the OrigPHIsToFix vector.
   void fixNonInductionPHIs(void);
+  /// Maps values from the original loop to their corresponding values in the
+  /// vectorized loop. A key value can map to either vector values, scalar
+  /// values or both kinds of values, depending on whether the key was
+  /// vectorized and scalarized.
+  VectorizerValueMap VectorLoopValueMap;
 
 protected:
   friend class LoopVectorizationPlanner;
@@ -738,12 +743,6 @@
   /// The induction variable of the old basic block.
   PHINode *OldInduction = nullptr;
 
-  /// Maps values from the original loop to their corresponding values in the
-  /// vectorized loop. A key value can map to either vector values, scalar
-  /// values or both kinds of values, depending on whether the key was
-  /// vectorized and scalarized.
-  VectorizerValueMap VectorLoopValueMap;
-
   /// Store instructions that were predicated.
   SmallVector<Instruction *, 4> PredicatedInstructions;
 
@@ -6962,19 +6961,15 @@
     return false;
   // If this ingredient's recipe is to be recorded, keep its recipe a singleton
   // to avoid having to split recipes later.
-  bool IsSingleton = Ingredient2Recipe.count(I);
 
   // Success: widen this instruction.
 
-  // Use the default widening recipe. We optimize the common case where
-  // consecutive instructions can be represented by a single recipe.
-  if (!IsSingleton && !VPBB->empty() && LastExtensibleRecipe == &VPBB->back() &&
-      LastExtensibleRecipe->appendInstruction(I))
-    return true;
-
-  VPWidenRecipe *WidenRecipe = new VPWidenRecipe(I);
-  if (!IsSingleton)
-    LastExtensibleRecipe = WidenRecipe;
+  VPlan &Plan = *VPBB->getParentPlan();
+  SmallVector<VPValue *, 4> Ops;
+  for (Value *Op : I->operands())
+    Ops.push_back(Plan.getOrAddVPValue(Op));
+  VPWidenInstruction *WidenRecipe = new VPWidenInstruction(I->getOpcode(), Ops);
+  WidenRecipe->setUnderlyingInstr(I);
   setRecipe(I, WidenRecipe);
   VPBB->appendRecipe(WidenRecipe);
   return true;
@@ -7370,9 +7365,14 @@
         << Indent << "\"  " << VPlanIngredient(I) << " " << i << "\\l\"";
 }
 
-void VPWidenRecipe::execute(VPTransformState &State) {
-  for (auto &Instr : make_range(Begin, End))
-    State.ILV->widenInstruction(Instr);
+void VPTransformState::set(VPValue *Def, Value *V, unsigned Part) {
+  if (!Data.PerPartOutput.count(Def)) {
+    DataState::PerPartValuesTy Entry(UF);
+    Data.PerPartOutput[Def] = Entry;
+  }
+  Data.PerPartOutput[Def][Part] = V;
+  if (auto VPI = dyn_cast<VPWidenInstruction>(Def))
+    ILV->VectorLoopValueMap.setVectorValue(VPI->getUnderlyingInstr(), Part, V);
 }
 
 void VPTransformState::addMetadata(ArrayRef<Value *> To, Instruction *From) {
diff --git a/llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h b/llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h
--- a/llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h
+++ b/llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h
@@ -53,13 +53,10 @@
   // VPWidenRecipe, also avoid compressing other ingredients into it to avoid
   // having to split such recipes later.
   DenseMap<Instruction *, VPRecipeBase *> Ingredient2Recipe;
-  VPWidenRecipe *LastExtensibleRecipe = nullptr;
 
   /// Set the recipe created for given ingredient. This operation is a no-op for
   /// ingredients that were not marked using a nullptr entry in the map.
   void setRecipe(Instruction *I, VPRecipeBase *R) {
-    if (!Ingredient2Recipe.count(I))
-      return;
     assert(Ingredient2Recipe[I] == nullptr &&
            "Recipe already set for ingredient");
     Ingredient2Recipe[I] = R;
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -283,13 +283,7 @@
   }
 
   /// Set the generated Value for a given VPValue and a given Part.
-  void set(VPValue *Def, Value *V, unsigned Part) {
-    if (!Data.PerPartOutput.count(Def)) {
-      DataState::PerPartValuesTy Entry(UF);
-      Data.PerPartOutput[Def] = Entry;
-    }
-    Data.PerPartOutput[Def][Part] = V;
-  }
+  void set(VPValue *Def, Value *V, unsigned Part);
 
   void addMetadata(ArrayRef<Value *> To, Instruction *From);
 
@@ -617,6 +611,7 @@
     VPBlendSC,
     VPBranchOnMaskSC,
     VPInstructionSC,
+    VPWidenInstructionSC,
     VPInterleaveSC,
     VPPredInstPHISC,
     VPReplicateSC,
@@ -624,7 +619,6 @@
     VPWidenIntOrFpInductionSC,
     VPWidenMemoryInstructionSC,
     VPWidenPHISC,
-    VPWidenSC,
   };
 
   VPRecipeBase(const unsigned char SC) : SubclassID(SC) {}
@@ -693,16 +687,23 @@
   void generateInstruction(VPTransformState &State, unsigned Part);
 
 protected:
+  VPInstruction(const unsigned char ValueSC, VPRecipeTy RecipeSC,
+                unsigned Opcode, ArrayRef<VPValue *> Operands)
+      : VPUser(ValueSC, Operands), VPRecipeBase(RecipeSC), Opcode(Opcode) {}
+
+public:
   Instruction *getUnderlyingInstr() {
     return cast_or_null<Instruction>(getUnderlyingValue());
   }
 
-  void setUnderlyingInstr(Instruction *I) { setUnderlyingValue(I); }
+  const Instruction *getUnderlyingInstr() const {
+    return cast_or_null<Instruction>(getUnderlyingValue());
+  }
 
-public:
+  void setUnderlyingInstr(Instruction *I) { setUnderlyingValue(I); }
   VPInstruction(unsigned Opcode, ArrayRef<VPValue *> Operands)
-      : VPUser(VPValue::VPInstructionSC, Operands),
-        VPRecipeBase(VPRecipeBase::VPInstructionSC), Opcode(Opcode) {}
+      : VPInstruction(VPValue::VPInstructionSC, VPRecipeBase::VPInstructionSC,
+                      Opcode, Operands) {}
 
   VPInstruction(unsigned Opcode, std::initializer_list<VPValue *> Operands)
       : VPInstruction(Opcode, ArrayRef<VPValue *>(Operands)) {}
@@ -742,46 +743,26 @@
     return Opcode == Instruction::Store || Opcode == Instruction::Call ||
            Opcode == Instruction::Invoke || Opcode == SLPStore;
   }
-};
 
-/// VPWidenRecipe is a recipe for producing a copy of vector type for each
-/// Instruction in its ingredients independently, in order. This recipe covers
-/// most of the traditional vectorization cases where each ingredient transforms
-/// into a vectorized version of itself.
-class VPWidenRecipe : public VPRecipeBase {
-private:
-  /// Hold the ingredients by pointing to their original BasicBlock location.
-  BasicBlock::iterator Begin;
-  BasicBlock::iterator End;
+  DebugLoc getDebugLoc(unsigned Factor) const;
+};
 
+class VPWidenInstruction : public VPInstruction {
 public:
-  VPWidenRecipe(Instruction *I) : VPRecipeBase(VPWidenSC) {
-    End = I->getIterator();
-    Begin = End++;
-  }
+  VPWidenInstruction(unsigned Opcode, ArrayRef<VPValue *> Operands)
+      : VPInstruction(VPValue::VPWidenInstructionSC,
+                      VPRecipeBase::VPWidenInstructionSC, Opcode, Operands) {}
 
-  ~VPWidenRecipe() override = default;
+  VPWidenInstruction(unsigned Opcode, std::initializer_list<VPValue *> Operands)
+      : VPWidenInstruction(Opcode, ArrayRef<VPValue *>(Operands)) {}
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
-  static inline bool classof(const VPRecipeBase *V) {
-    return V->getVPRecipeID() == VPRecipeBase::VPWidenSC;
+  static inline bool classof(const VPValue *V) {
+    return V->getVPValueID() == VPValue::VPWidenInstructionSC;
   }
 
-  /// Produce widened copies of all Ingredients.
   void execute(VPTransformState &State) override;
-
-  /// Augment the recipe to include Instr, if it lies at its End.
-  bool appendInstruction(Instruction *Instr) {
-    if (End != Instr->getIterator())
-      return false;
-    End++;
-    return true;
-  }
-
-  /// Print the recipe.
-  void print(raw_ostream &O, const Twine &Indent) const override;
 };
-
 /// A recipe for handling GEP instructions.
 class VPWidenGEPRecipe : public VPRecipeBase {
 private:
@@ -1458,7 +1439,7 @@
   void addVPValue(Value *V) {
     assert(V && "Trying to add a null Value to VPlan");
     assert(!Value2VPValue.count(V) && "Value already exists in VPlan");
-    Value2VPValue[V] = new VPValue();
+    Value2VPValue[V] = new VPValue(V);
   }
 
   VPValue *getVPValue(Value *V) {
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -25,6 +25,8 @@
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
@@ -307,6 +309,222 @@
   insertAfter(InsertPos);
 }
 
+void VPWidenInstruction::execute(VPTransformState &State) {
+  SmallVector<Value *, 4> VecOps;
+  auto *OriginalI = cast<Instruction>(getUnderlyingInstr());
+  State.setDebugLocFromInst(State.Builder, OriginalI);
+  switch (getOpcode()) {
+  case Instruction::Br:
+  case Instruction::PHI:
+  case Instruction::GetElementPtr:
+    llvm_unreachable("This instruction is handled by a different recipe.");
+  case Instruction::UDiv:
+  case Instruction::SDiv:
+  case Instruction::SRem:
+  case Instruction::URem:
+  case Instruction::Add:
+  case Instruction::FAdd:
+  case Instruction::Sub:
+  case Instruction::FSub:
+  case Instruction::FNeg:
+  case Instruction::Mul:
+  case Instruction::FMul:
+  case Instruction::FDiv:
+  case Instruction::FRem:
+  case Instruction::Shl:
+  case Instruction::LShr:
+  case Instruction::AShr:
+  case Instruction::And:
+  case Instruction::Or:
+  case Instruction::Xor: {
+    // Just widen unops and binops.
+    if (auto DL = getDebugLoc(State.VF * State.UF))
+      State.Builder.SetCurrentDebugLocation(DL);
+
+    for (unsigned Part = 0; Part < State.UF; ++Part) {
+      SmallVector<Value *, 2> Ops;
+      for (VPValue *Op : operands())
+        Ops.push_back(State.get(Op, Part));
+
+      Value *V = State.Builder.CreateNAryOp(getOpcode(), Ops);
+
+      // Use this vector value for all users of the original instruction.
+      State.set(this, V, Part);
+
+      if (auto VecOp = dyn_cast<Instruction>(V))
+        VecOp->copyIRFlags(OriginalI);
+
+      VecOps.push_back(V);
+    }
+    break;
+  }
+  case Instruction::Select: {
+    // Widen selects.
+    // If the selector is loop invariant we can create a select
+    // instruction with a scalar condition. Otherwise, use vector-select.
+    auto *SE = State.PSE.getSE();
+    bool InvariantCond =
+        getOperand(0)->getUnderlyingValue()
+            ? SE->isLoopInvariant(
+                  State.PSE.getSCEV(getOperand(0)->getUnderlyingValue()),
+                  State.OriginalLoop)
+            : false;
+
+    // The condition can be loop invariant  but still defined inside the
+    // loop. This means that we can't just use the original 'cond' value.
+    // We have to take the 'vectorized' value and pick the first lane.
+    // Instcombine will make this a no-op.
+
+    auto *ScalarCond = State.get(getOperand(0), {0, 0});
+
+    for (unsigned Part = 0; Part < State.UF; ++Part) {
+      Value *Cond = State.get(getOperand(0), Part);
+      Value *Op0 = State.get(getOperand(1), Part);
+      Value *Op1 = State.get(getOperand(2), Part);
+      Value *Sel = State.Builder.CreateSelect(InvariantCond ? ScalarCond : Cond,
+                                              Op0, Op1);
+      State.set(this, Sel, Part);
+      VecOps.push_back(Sel);
+    }
+
+    break;
+  }
+
+  case Instruction::ICmp:
+  case Instruction::FCmp: {
+    // Widen compares. Generate vector compares.
+    bool FCmp = (getOpcode() == Instruction::FCmp);
+    auto *Cmp = cast<CmpInst>(getUnderlyingInstr());
+
+    for (unsigned Part = 0; Part < State.UF; ++Part) {
+      Value *A = State.get(getOperand(0), Part);
+      Value *B = State.get(getOperand(1), Part);
+      Value *C = nullptr;
+      if (FCmp) {
+        // Propagate fast math flags.
+        IRBuilder<>::FastMathFlagGuard FMFG(State.Builder);
+        State.Builder.setFastMathFlags(Cmp->getFastMathFlags());
+        C = State.Builder.CreateFCmp(Cmp->getPredicate(), A, B);
+      } else {
+        C = State.Builder.CreateICmp(Cmp->getPredicate(), A, B);
+      }
+      State.set(this, C, Part);
+      VecOps.push_back(C);
+    }
+
+    break;
+  }
+
+  case Instruction::ZExt:
+  case Instruction::SExt:
+  case Instruction::FPToUI:
+  case Instruction::FPToSI:
+  case Instruction::FPExt:
+  case Instruction::PtrToInt:
+  case Instruction::IntToPtr:
+  case Instruction::SIToFP:
+  case Instruction::UIToFP:
+  case Instruction::Trunc:
+  case Instruction::FPTrunc:
+  case Instruction::BitCast: {
+    /// Vectorize casts.
+    Type *DestTy = (State.VF == 1)
+                       ? OriginalI->getType()
+                       : VectorType::get(OriginalI->getType(), State.VF);
+
+    for (unsigned Part = 0; Part < State.UF; ++Part) {
+      Value *A = State.get(getOperand(0), Part);
+      Value *Cast = State.Builder.CreateCast(Instruction::CastOps(getOpcode()),
+                                             A, DestTy);
+      State.set(this, Cast, Part);
+      VecOps.push_back(Cast);
+    }
+    break;
+  }
+
+  case Instruction::Call: {
+    auto *CI = cast<CallInst>(getUnderlyingInstr());
+    // Ignore dbg intrinsics.
+    if (isa<DbgInfoIntrinsic>(CI))
+      break;
+
+    Module *M = CI->getParent()->getParent()->getParent();
+
+    SmallVector<Type *, 4> Tys;
+    for (Value *ArgOperand : CI->arg_operands())
+      Tys.push_back(ToVectorTy(ArgOperand->getType(), State.VF));
+
+    Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, State.TLI);
+
+    // The flag shows whether we use Intrinsic or a usual Call for vectorized
+    // version of the instruction.
+    // Is it beneficial to perform intrinsic call compared to lib call?
+    bool NeedToScalarize;
+    unsigned CallCost = State.getVectorCallCost(CI, State.VF, NeedToScalarize);
+    bool UseVectorIntrinsic =
+        ID && State.getVectorIntrinsicCost(CI, State.VF) <= CallCost;
+    assert((UseVectorIntrinsic || !NeedToScalarize) &&
+           "Instruction should be scalarized elsewhere.");
+
+    for (unsigned Part = 0; Part < State.UF; ++Part) {
+      SmallVector<Value *, 4> Args;
+      for (unsigned i = 0, ie = getNumOperands() - 1; i != ie; ++i) {
+        VPValue *VPArg = getOperand(i);
+        // Some intrinsics have a scalar argument - don't replace it with a
+        // vector.
+        Value *Arg = VPArg->getUnderlyingValue();
+        if (!UseVectorIntrinsic || !hasVectorInstrinsicScalarOpd(ID, i))
+          Arg = State.get(VPArg, Part);
+        Args.push_back(Arg);
+      }
+
+      Function *VectorF;
+      if (UseVectorIntrinsic) {
+        // Use vector version of the intrinsic.
+        Type *TysForDecl[] = {CI->getType()};
+        if (State.VF > 1)
+          TysForDecl[0] =
+              VectorType::get(CI->getType()->getScalarType(), State.VF);
+        VectorF = Intrinsic::getDeclaration(M, ID, TysForDecl);
+      } else {
+        // Use vector version of the function call.
+        const VFShape Shape = VFShape::get(*CI, {State.VF, false} /*EC*/,
+                                           false /*HasGlobalPred*/);
+#ifndef NDEBUG
+        const SmallVector<VFInfo, 8> Infos = VFDatabase::getMappings(*CI);
+        assert(std::find_if(Infos.begin(), Infos.end(),
+                            [&Shape](const VFInfo &Info) {
+                              return Info.Shape == Shape;
+                            }) != Infos.end() &&
+               "Vector function shape is missing from the database.");
+#endif
+        VectorF = VFDatabase(*CI).getVectorizedFunction(Shape);
+      }
+      assert(VectorF && "Can't create vector function.");
+
+      SmallVector<OperandBundleDef, 1> OpBundles;
+      CI->getOperandBundlesAsDefs(OpBundles);
+      CallInst *V = State.Builder.CreateCall(VectorF, Args, OpBundles);
+
+      if (isa<FPMathOperator>(V))
+        V->copyFastMathFlags(CI);
+
+      State.set(this, V, Part);
+      VecOps.push_back(V);
+    }
+
+    break;
+  }
+
+  default:
+    // This instruction is not vectorized by simple widening.
+    LLVM_DEBUG(dbgs() << "LV: Found an unhandled VPInstruction: " << *this);
+    llvm_unreachable("Unhandled instruction!");
+  } // end of switch.
+
+  State.addMetadata(VecOps, OriginalI);
+}
+
 void VPInstruction::generateInstruction(VPTransformState &State,
                                         unsigned Part) {
   IRBuilder<> &Builder = State.Builder;
@@ -385,6 +603,25 @@
   }
 }
 
+DebugLoc VPInstruction::getDebugLoc(unsigned Factor) const {
+  if (const Instruction *Inst =
+          dyn_cast_or_null<Instruction>(getUnderlyingInstr())) {
+    const DILocation *DIL = Inst->getDebugLoc();
+    if (DIL && Inst->getFunction()->isDebugInfoForProfiling() &&
+        !isa<DbgInfoIntrinsic>(Inst)) {
+      auto NewDIL = DIL->cloneByMultiplyingDuplicationFactor(Factor);
+      if (NewDIL)
+        return NewDIL.getValue();
+      else
+        LLVM_DEBUG(dbgs() << "Failed to create new discriminator: "
+                          << DIL->getFilename() << " Line: " << DIL->getLine());
+      return DebugLoc();
+    } else
+      return DIL;
+  } else
+    return DebugLoc();
+}
+
 /// Generate the code inside the body of the vectorized loop. Assumes a single
 /// LoopVectorBody basic-block was created for this. Introduce additional
 /// basic-blocks as needed, and fill them all.
@@ -670,12 +907,6 @@
   O << DOT::EscapeString(IngredientString);
 }
 
-void VPWidenRecipe::print(raw_ostream &O, const Twine &Indent) const {
-  O << " +\n" << Indent << "\"WIDEN\\l\"";
-  for (auto &Instr : make_range(Begin, End))
-    O << " +\n" << Indent << "\"  " << VPlanIngredient(&Instr) << "\\l\"";
-}
-
 void VPWidenIntOrFpInductionRecipe::print(raw_ostream &O,
                                           const Twine &Indent) const {
   O << " +\n" << Indent << "\"WIDEN-INDUCTION";
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -69,15 +69,8 @@
       } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
         NewRecipe = new VPWidenGEPRecipe(GEP, OrigLoop);
       } else {
-        // If the last recipe is a VPWidenRecipe, add Inst to it instead of
-        // creating a new recipe.
-        if (VPWidenRecipe *WidenRecipe =
-                dyn_cast_or_null<VPWidenRecipe>(LastRecipe)) {
-          WidenRecipe->appendInstruction(Inst);
-          Ingredient->eraseFromParent();
-          continue;
-        }
-        NewRecipe = new VPWidenRecipe(Inst);
+        SmallVector<VPValue *, 2> Operands(VPInst->operands());
+        NewRecipe = new VPWidenInstruction(Inst->getOpcode(), Operands);
       }
 
       NewRecipe->insertBefore(Ingredient);
diff --git a/llvm/lib/Transforms/Vectorize/VPlanValue.h b/llvm/lib/Transforms/Vectorize/VPlanValue.h
--- a/llvm/lib/Transforms/Vectorize/VPlanValue.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanValue.h
@@ -40,6 +40,7 @@
   friend class VPlanTransforms;
   friend class VPBasicBlock;
   friend class VPInterleavedAccessInfo;
+  friend class VPWidenInstruction;
 
 private:
   const unsigned char SubclassID; ///< Subclass identifier (for isa/dyn_cast).
@@ -62,6 +63,7 @@
 
   /// Return the underlying Value attached to this VPValue.
   Value *getUnderlyingValue() { return UnderlyingVal; }
+  const Value *getUnderlyingValue() const { return UnderlyingVal; }
 
   // Set \p Val as the underlying Value of this VPValue.
   void setUnderlyingValue(Value *Val) {
@@ -74,7 +76,7 @@
   /// are actually instantiated. Values of this enumeration are kept in the
   /// SubclassID field of the VPValue objects. They are used for concrete
   /// type identification.
-  enum { VPValueSC, VPUserSC, VPInstructionSC };
+  enum { VPValueSC, VPUserSC, VPInstructionSC, VPWidenInstructionSC };
 
   VPValue(Value *UV = nullptr) : VPValue(VPValueSC, UV) {}
   VPValue(const VPValue &) = delete;
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
--- a/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
@@ -142,15 +142,15 @@
   auto *Load = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
   EXPECT_NE(nullptr, Load);
 
-  auto *Add = dyn_cast<VPWidenRecipe>(&*Iter++);
-  EXPECT_NE(nullptr, Add);
+  /*  auto *Add = dyn_cast<VPWidenRecipe>(&*Iter++);*/
+  // EXPECT_NE(nullptr, Add);
 
-  auto *Store = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
-  EXPECT_NE(nullptr, Store);
+  // auto *Store = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
+  // EXPECT_NE(nullptr, Store);
 
-  auto *LastWiden = dyn_cast<VPWidenRecipe>(&*Iter++);
-  EXPECT_NE(nullptr, LastWiden);
-  EXPECT_EQ(VecBB->end(), Iter);
+  // auto *LastWiden = dyn_cast<VPWidenRecipe>(&*Iter++);
+  // EXPECT_NE(nullptr, LastWiden);
+  /*EXPECT_EQ(VecBB->end(), Iter);*/
 }
 
 } // namespace