Index: src/vdbesort.c
==================================================================
--- src/vdbesort.c
+++ src/vdbesort.c
@@ -1405,27 +1405,23 @@
   assert( rc!=SQLITE_OK || pTask->file.iEof==iSz );
   return rc;
 }
 
 /*
-** Advance the MergeEngine pMerge (passed as the second argument) to
-** its next entry.  Set *pbEof to true there is no next entry because
+** Advance the MergeEngine to its next entry.
+** Set *pbEof to true there is no next entry because
 ** the MergeEngine has reached the end of all its inputs.
 **
 ** Return SQLITE_OK if successful or an error code if an error occurs.
 */
 static int vdbeMergeEngineStep(
-  SortSubtask *pTask,        /* The thread in which this MergeEngine runs */
   MergeEngine *pMerger,      /* The merge engine to advance to the next row */
   int *pbEof                 /* Set TRUE at EOF.  Set false for more content */
 ){
   int rc;
   int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */
-
-  /* A MergeEngine object is only used by a single thread */
-  assert( pMerger->pTask==0 || pMerger->pTask==pTask );
-  pMerger->pTask = pTask;
+  SortSubtask *pTask = pMerger->pTask;
 
   /* Advance the current PmaReader */
   rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]);
 
   /* Update contents of aTree[] */
@@ -1691,11 +1687,12 @@
     if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break;
 
     /* Write the next key to the output. */
     vdbePmaWriteVarint(&writer, nKey);
     vdbePmaWriteBlob(&writer, pReader->aKey, nKey);
-    rc = vdbeMergeEngineStep(pTask, pIncr->pMerger, &dummy);
+    assert( pIncr->pMerger->pTask==pTask );
+    rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy);
   }
 
   rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
   if( rc==SQLITE_OK ) rc = rc2;
   vdbeSorterPopulateDebug(pTask, "exit");
@@ -1778,11 +1775,11 @@
 ** Allocate and return a new IncrMerger object to read data from pMerger.
 **
 ** If an OOM condition is encountered, return NULL. In this case free the
 ** pMerger argument before returning.
 */
-static int vdbeIncrNew(
+static int vdbeIncrMergerNew(
   SortSubtask *pTask,     /* The thread that will be using the new IncrMerger */
   MergeEngine *pMerger,   /* The MergeEngine that the IncrMerger will control */
   IncrMerger **ppOut      /* Write the new IncrMerger here */
 ){
   int rc = SQLITE_OK;
@@ -1802,11 +1799,11 @@
 
 #if SQLITE_MAX_WORKER_THREADS>0
 /*
 ** Set the "use-threads" flag on object pIncr.
 */
-static void vdbeIncrSetThreads(IncrMerger *pIncr){
+static void vdbeIncrMergerSetThreads(IncrMerger *pIncr){
   pIncr->bUseThread = 1;
   pIncr->pTask->file2.iEof -= pIncr->mxSz;
 }
 #endif /* SQLITE_MAX_WORKER_THREADS>0 */
 
@@ -1900,11 +1897,11 @@
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* For looping over PmaReader objects */
   int nTree = pMerger->nTree;
 
   /* Verify that the MergeEngine is assigned to a single thread */
-  assert( pMerger->pTask==0 || pMerger->pTask==pTask );
+  assert( pMerger->pTask==0 ); // || pMerger->pTask==pTask );
   pMerger->pTask = pTask;
 
   for(i=0; i<nTree; i++){
     if( eMode==INCRINIT_ROOT ){
       /* PmaReaders should be normally initialized in order, as if they are
@@ -2123,11 +2120,11 @@
   int nDiv = 1;
   int i;
   MergeEngine *p = pRoot;
   IncrMerger *pIncr;
 
-  rc = vdbeIncrNew(pTask, pLeaf, &pIncr);
+  rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr);
 
   for(i=1; i<nDepth; i++){
     nDiv = nDiv * SORTER_MAX_MERGE_COUNT;
   }
 
@@ -2138,11 +2135,11 @@
     if( pReadr->pIncr==0 ){
       MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT);
       if( pNew==0 ){
         rc = SQLITE_NOMEM;
       }else{
-        rc = vdbeIncrNew(pTask, pNew, &pReadr->pIncr);
+        rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr);
       }
     }
     if( rc==SQLITE_OK ){
       p = pReadr->pIncr->pMerger;
       nDiv = nDiv / SORTER_MAX_MERGE_COUNT;
@@ -2214,11 +2211,11 @@
       }
 
       if( rc==SQLITE_OK ){
 #if SQLITE_MAX_WORKER_THREADS>0
         if( pMain!=0 ){
-          rc = vdbeIncrNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr);
+          rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr);
         }else
 #endif
         {
           assert( pMain==0 );
           pMain = pRoot;
@@ -2267,17 +2264,17 @@
         pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader));
         pSorter->pReader = pReadr;
         if( pReadr==0 ) rc = SQLITE_NOMEM;
       }
       if( rc==SQLITE_OK ){
-        rc = vdbeIncrNew(pLast, pMain, &pReadr->pIncr);
+        rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr);
         if( rc==SQLITE_OK ){
-          vdbeIncrSetThreads(pReadr->pIncr);
+          vdbeIncrMergerSetThreads(pReadr->pIncr);
           for(iTask=0; iTask<(pSorter->nTask-1); iTask++){
             IncrMerger *pIncr;
             if( (pIncr = pMain->aReadr[iTask].pIncr) ){
-              vdbeIncrSetThreads(pIncr);
+              vdbeIncrMergerSetThreads(pIncr);
               assert( pIncr->pTask!=pLast );
             }
           }
           for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
             PmaReader *p = &pMain->aReadr[iTask];
@@ -2377,11 +2374,12 @@
       rc = vdbePmaReaderNext(pSorter->pReader);
       *pbEof = (pSorter->pReader->pFd==0);
     }else
 #endif
     /*if( !pSorter->bUseThreads )*/ {
-      rc = vdbeMergeEngineStep(&pSorter->aTask[0], pSorter->pMerger, pbEof);
+      assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
+      rc = vdbeMergeEngineStep(pSorter->pMerger, pbEof);
     }
   }else{
     SorterRecord *pFree = pSorter->list.pList;
     pSorter->list.pList = pFree->u.pNext;
     pFree->u.pNext = 0;