diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp
index d65736a1ead..bc38751048a 100644
--- a/tools/bugpoint/ExtractFunction.cpp
+++ b/tools/bugpoint/ExtractFunction.cpp
@@ -143,9 +143,18 @@ Module *BugDriver::ExtractLoop(Module *M) {
 
   // Check to see if we created any new functions.  If not, no loops were
   // extracted and we should return null.
-  if (M->size() == NewM->size()) {
+  static unsigned NumExtracted = 15;
+
+  if (M->size() == NewM->size() || --NumExtracted == 0) {
     delete NewM;
     return 0;
+  } else {
+    assert(M->size() < NewM->size() && "Loop extract removed functions?");
+    Module::iterator MI = NewM->begin();
+    for (unsigned i = 0, e = M->size(); i != e; ++i)
+      ++MI;
+    for (; MI != NewM->end(); ++MI)
+      std::cerr << "NEW FUNCTION: " << *MI;
   }
   
   return NewM;
diff --git a/tools/bugpoint/ListReducer.h b/tools/bugpoint/ListReducer.h
index 9e248ff1ccd..2af1ae769de 100644
--- a/tools/bugpoint/ListReducer.h
+++ b/tools/bugpoint/ListReducer.h
@@ -90,7 +90,7 @@ struct ListReducer {
     // could.  If there is more two elements in the list, try deleting interior
     // elements and testing that.
     //
-    if (TheList.size() > 2) {
+    if (0 && TheList.size() > 2) {
       bool Changed = true;
       std::vector<ElTy> EmptyList;
       while (Changed) {
diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index ca4fb618265..b578202402a 100644
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -171,13 +171,16 @@ static bool TestMergedProgram(BugDriver &BD, Module *M1, Module *M2,
                               bool DeleteInputs) {
   // Link the two portions of the program back to together.
   std::string ErrorMsg;
-  if (!DeleteInputs) M1 = CloneModule(M1);
+  if (!DeleteInputs) {
+    M1 = CloneModule(M1);
+    M2 = CloneModule(M2);
+  }
   if (LinkModules(M1, M2, &ErrorMsg)) {
     std::cerr << BD.getToolName() << ": Error linking modules together:"
               << ErrorMsg << '\n';
     exit(1);
   }
-  if (DeleteInputs) delete M2;  // We are done with this module...
+  delete M2;   // We are done with this module.
 
   Module *OldProgram = BD.swapProgramIn(M1);
 
@@ -289,6 +292,12 @@ static bool ExtractLoops(BugDriver &BD,
 
     std::cout << "*** Loop extraction successful!\n";
 
+    std::vector<std::pair<std::string, const FunctionType*> > MisCompFunctions;
+    for (Module::iterator I = ToOptimizeLoopExtracted->begin(),
+           E = ToOptimizeLoopExtracted->end(); I != E; ++I)
+      MisCompFunctions.push_back(std::make_pair(I->getName(),
+                                                I->getFunctionType()));
+
     // Okay, great!  Now we know that we extracted a loop and that loop
     // extraction both didn't break the program, and didn't mask the problem.
     // Replace the current program with the loop extracted version, and try to
@@ -299,21 +308,18 @@ static bool ExtractLoops(BugDriver &BD,
                 << ErrorMsg << '\n';
       exit(1);
     }
+    delete ToOptimizeLoopExtracted;
 
     // All of the Function*'s in the MiscompiledFunctions list are in the old
     // module.  Update this list to include all of the functions in the
     // optimized and loop extracted module.
     MiscompiledFunctions.clear();
-    for (Module::iterator I = ToOptimizeLoopExtracted->begin(),
-           E = ToOptimizeLoopExtracted->end(); I != E; ++I) {
-      if (!I->isExternal()) {
-        Function *NewF = ToNotOptimize->getFunction(I->getName(),
-                                                    I->getFunctionType());
-        assert(NewF && "Function not found??");
-        MiscompiledFunctions.push_back(NewF);
-      }
+    for (unsigned i = 0, e = MisCompFunctions.size(); i != e; ++i) {
+      Function *NewF = ToNotOptimize->getFunction(MisCompFunctions[i].first,
+                                                  MisCompFunctions[i].second);
+      assert(NewF && "Function not found??");
+      MiscompiledFunctions.push_back(NewF);
     }
-    delete ToOptimizeLoopExtracted;
 
     BD.setNewProgram(ToNotOptimize);
     MadeChange = true;
@@ -423,12 +429,19 @@ static bool ExtractBlocks(BugDriver &BD,
   // together.
   delete ToExtract;
 
+  std::vector<std::pair<std::string, const FunctionType*> > MisCompFunctions;
+  for (Module::iterator I = Extracted->begin(), E = Extracted->end();
+       I != E; ++I)
+    MisCompFunctions.push_back(std::make_pair(I->getName(),
+                                              I->getFunctionType()));
+
   std::string ErrorMsg;
   if (LinkModules(ProgClone, Extracted, &ErrorMsg)) {
     std::cerr << BD.getToolName() << ": Error linking modules together:"
               << ErrorMsg << '\n';
     exit(1);
   }
+  delete Extracted;
 
   // Set the new program and delete the old one.
   BD.setNewProgram(ProgClone);
@@ -436,15 +449,12 @@ static bool ExtractBlocks(BugDriver &BD,
   // Update the list of miscompiled functions.
   MiscompiledFunctions.clear();
 
-  for (Module::iterator I = Extracted->begin(), E = Extracted->end(); I != E;
-       ++I)
-    if (!I->isExternal()) {
-      Function *NF = ProgClone->getFunction(I->getName(), I->getFunctionType());
-      assert(NF && "Mapped function not found!");
-      MiscompiledFunctions.push_back(NF);
-    }
-
-  delete Extracted;
+  for (unsigned i = 0, e = MisCompFunctions.size(); i != e; ++i) {
+    Function *NewF = ProgClone->getFunction(MisCompFunctions[i].first,
+                                            MisCompFunctions[i].second);
+    assert(NewF && "Function not found??");
+    MiscompiledFunctions.push_back(NewF);
+  }
 
   return true;
 }