Index: trunk/ppStack/src/ppStack.h
===================================================================
--- trunk/ppStack/src/ppStack.h	(revision 19343)
+++ trunk/ppStack/src/ppStack.h	(revision 19346)
@@ -96,4 +96,8 @@
     );
 
+// Concatenate inspection lists for each input image
+bool ppStackInspect(psThreadJob *job    // Job to process
+    );
+
 // Perform stacking on a readout
 bool ppStackReadoutFinal(const pmConfig *config,   // Configuration
Index: trunk/ppStack/src/ppStackLoop.c
===================================================================
--- trunk/ppStack/src/ppStackLoop.c	(revision 19343)
+++ trunk/ppStack/src/ppStackLoop.c	(revision 19346)
@@ -477,4 +477,5 @@
     pmReadout *outRO = NULL;            // Output readout
     pmFPAview *view = NULL;             // View to readout
+    psArray *inspect = NULL;            // Array of arrays of pixels to inspect
     {
         int row0, col0;                 // Offset for readout
@@ -518,5 +519,6 @@
 
         bool status;                    // Status of read
-        for (int numChunk = 0; true; numChunk++) {
+        int numChunk;                   // Number of chunks
+        for (numChunk = 0; true; numChunk++) {
             ppStackThread *thread = ppStackThreadRead(&status, stack, config, numChunk, overlap);
             if (!status) {
@@ -567,4 +569,24 @@
         }
 
+        // Harvest the jobs, gathering the inspection lists
+        inspect = psArrayAlloc(num);
+        for (int i = 0; i < num; i++) {
+            if (inputMask->data.U8[i]) {
+                continue;
+            }
+            inspect->data[i] = psArrayAllocEmpty(numChunk);
+        }
+        psThreadJob *job;               // Completed job
+        while ((job = psThreadJobGetDone())) {
+            psArray *results = job->results; // Results of job
+            for (int i = 0; i < num; i++) {
+                if (inputMask->data.U8[i]) {
+                    continue;
+                }
+                inspect->data[i] = psArrayAdd(inspect->data[i], 1, results->data[i]);
+            }
+            psFree(job);
+        }
+
         memDump("initial");
     }
@@ -573,5 +595,4 @@
     psArray *rejected = psArrayAlloc(num);
     {
-        psArray *inspect = psArrayAlloc(num); // Pixels to inspect
         int numRejected = 0;        // Number of inputs rejected completely
 
@@ -581,19 +602,4 @@
                 numRejected++;
             }
-            inspect->data[i] = psPixelsAllocEmpty(PIXELS_BUFFER);
-        }
-
-        // Harvest the jobs, combining the inspection lists
-        psThreadJob *job;           // Completed job
-        while ((job = psThreadJobGetDone())) {
-            psArray *results = job->results; // Results of job
-            psAssert(results && results->n == num, "Results array.");
-            for (int i = 0; i < num; i++) {
-                if (inputMask->data.U8[i]) {
-                    continue;
-                }
-                inspect->data[i] = psPixelsConcatenate(inspect->data[i], results->data[i]);
-            }
-            psFree(job);
         }
 
@@ -602,4 +608,42 @@
                 continue;
             }
+
+            psThreadJob *job = psThreadJobAlloc("PPSTACK_INSPECT"); // Job to start
+            psArrayAdd(job->args, 1, inspect);
+            PS_ARRAY_ADD_SCALAR(job->args, i, PS_TYPE_S32);
+            if (!psThreadJobAddPending(job)) {
+                psFree(job);
+                psFree(subKernels);
+                psFree(subRegions);
+                psFree(stack);
+                psFree(inputMask);
+                psFree(view);
+                psFree(outRO);
+                psFree(inspect);
+                psFree(rejected);
+                return false;
+            }
+            psFree(job);
+        }
+
+        if (!psThreadPoolWait(false)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to concatenate inspection lists.");
+            psFree(subKernels);
+            psFree(subRegions);
+            psFree(stack);
+            psFree(inputMask);
+            psFree(view);
+            psFree(outRO);
+            psFree(inspect);
+            psFree(rejected);
+            return false;
+        }
+
+        if (psMetadataLookupS32(NULL, config->arguments, "-threads") > 0) {
+            pmStackRejectThreadsInit();
+        }
+
+        // Reject bad pixels
+        for (int i = 0; i < num; i++) {
 
 #ifdef TESTING
Index: trunk/ppStack/src/ppStackReadout.c
===================================================================
--- trunk/ppStack/src/ppStackReadout.c	(revision 19343)
+++ trunk/ppStack/src/ppStackReadout.c	(revision 19346)
@@ -46,4 +46,29 @@
 
     return status;
+}
+
+
+bool ppStackInspect(psThreadJob *job)
+{
+    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
+
+    psArray *args = job->args;  // Input arguments
+    psArray *inspect = args->data[0]; // Array of pixel arrays
+    int index = PS_SCALAR_VALUE(args->data[1], S32); // Index of interest
+
+    psArray *inputs = inspect->data[index]; // Array of interest
+    psPixels *output = NULL;    // Output pixel list
+    for (int i = 0; i < inputs->n; i++) {
+        psPixels *input = inputs->data[i]; // Input pixel list
+        if (!input || input->n == 0) {
+            continue;
+        }
+        output = psPixelsConcatenate(output, input);
+    }
+
+    psFree(inputs);
+    inspect->data[index] = output;
+
+    return true;
 }
 
Index: trunk/ppStack/src/ppStackThread.c
===================================================================
--- trunk/ppStack/src/ppStackThread.c	(revision 19343)
+++ trunk/ppStack/src/ppStackThread.c	(revision 19346)
@@ -242,4 +242,11 @@
 
     {
+        psThreadTask *task = psThreadTaskAlloc("PPSTACK_INSPECT", 2);
+        task->function = &ppStackInspect;
+        psThreadTaskAdd(task);
+        psFree(task);
+    }
+
+    {
         psThreadTask *task = psThreadTaskAlloc("PPSTACK_FINAL_COMBINE", 4);
         task->function = &ppStackReadoutFinalThread;