             // fill the neighbor queue
             // loop through particles in the excell list and add them to the queue if they pass the circumsphere check
 
-            // prefetch j
-            unsigned int j, next_j = 0;
-            if ((k>>1) < excell_size)
-                next_j = __ldg(&d_excell_idx[excli(k>>1, my_cell)]);
-
-            // add to the queue as long as the queue is not full, and we have not yet reached the end of our own list
-            // and as long as no overlaps have been found
-            while (s_queue_size < max_queue_size && (k>>1) < excell_size)
+            // active threads add to the queue
+            if (active)
                 {
-                // which configuration are we handling?
-                bool old = k & 1;
-
-                Scalar4 postype_j;
-                Scalar4 orientation_j = make_scalar4(1,0,0,0);
-                vec3<Scalar> r_jk;
-
-                // build some shapes, but we only need them to get diameters, so don't load orientations
-
-                // prefetch next j
-                k += group_size;
-                j = next_j;
-
-                if ((k >> 1) < excell_size)
+                // prefetch j
+                unsigned int j, next_j = 0;
+                if ((k>>1) < excell_size)
                     next_j = __ldg(&d_excell_idx[excli(k>>1, my_cell)]);
 
-                // read in position of neighboring particle, do not need it's orientation for circumsphere check
-                postype_j = old ? d_postype[j] : d_trial_postype[j];
-                unsigned int type_j = __scalar_as_int(postype_j.w);
-                Shape shape_j(quat<Scalar>(orientation_j), s_params[type_j]);
-
-                for (; q < depletant_queue_size; q += n_groups)
+                // add to the queue as long as the queue is not full, and we have not yet reached the end of our own list
+                // and as long as no overlaps have been found
+                while (s_queue_size < max_queue_size && (k>>1) < excell_size)
                     {
-                    // regenerate depletant using seed from queue, this costs a few flops but is probably
-                    // better than storing one Scalar4 and a Scalar3 per depletant in shared mem
-                    unsigned int i_dep_queue = s_queue_didx[q];
-                    hoomd::RandomGenerator rng(hoomd::RNGIdentifier::HPMCDepletants, seed+i, i_dep_queue, select*num_types + depletant_type, timestep);
-
-                    // depletant position and orientation
-                    vec3<Scalar> pos_test = vec3<Scalar>(generatePositionInOBB(rng, obb_i, dim));
-                    Shape shape_test(quat<Scalar>(), s_params[depletant_type]);
+                    // which configuration are we handling?
+                    bool old = k & 1;
+
+                    Scalar4 postype_j;
+                    Scalar4 orientation_j = make_scalar4(1,0,0,0);
+                    vec3<Scalar> r_jk;
+
+                    // build some shapes, but we only need them to get diameters, so don't load orientations
+
+                    // prefetch next j
+                    k += group_size;
+                    j = next_j;
+
+                    if ((k >> 1) < excell_size)
+                        next_j = __ldg(&d_excell_idx[excli(k>>1, my_cell)]);
+
+                    // read in position of neighboring particle, do not need it's orientation for circumsphere check
+                    postype_j = old ? d_postype[j] : d_trial_postype[j];
+                    unsigned int type_j = __scalar_as_int(postype_j.w);
+                    Shape shape_j(quat<Scalar>(orientation_j), s_params[type_j]);
+
+                    // load test particle configuration from shared mem
+                    vec3<Scalar> pos_test(s_pos_group[group]);
+                    Shape shape_test(quat<Scalar>(s_orientation_group[group]), s_params[depletant_type]);
 
                     // put particle j into the coordinate system of particle i
                     r_jk = vec3<Scalar>(postype_j) - vec3<Scalar>(pos_test);

                Scalar4 orientation_j;
                vec3<Scalar> r_jk;

                // regenerate depletant using seed from queue
                hoomd::RandomGenerator rng(hoomd::RNGIdentifier::HPMCDepletants, seed+i, check_didx, select*num_types + depletant_type, timestep);
                vec3<Scalar> pos_test = vec3<Scalar>(generatePositionInOBB(rng, obb_i, dim));
                Shape shape_test(quat<Scalar>(), s_params[depletant_type]);
                if (shape_test.hasOrientation())
                    {
                    shape_test.orientation = generateRandomOrientation(rng,dim);
                    }

                // build shape j from global memory
                postype_j = check_old ? d_postype[check_j] : d_trial_postype[check_j];

            __syncthreads();
            if (master && group == 0)
                s_queue_size = 0;
            if (active && (k>>1) < excell_size)
                atomicAdd(&s_still_searching, 1);
            __syncthreads();

            } // end while (s_still_searching)

        // do we still need to process depletants?
