 
         __syncthreads();
 
-        // actual size of queue
-        unsigned int depletant_queue_size = min(s_depletant_queue_size, max_depletant_queue_size);
-
-        // starting offset in depletant queue for this thread
-        unsigned int q = group;
+        // is this group processing work from the first queue?
+        bool active = group < min(s_depletant_queue_size, max_depletant_queue_size);
+
+        if (active)
+            {
+            // regenerate depletant using seed from queue, this costs a few flops but is probably
+            // better than storing one Scalar4 and a Scalar3 per thread in shared mem
+            unsigned int i_dep_queue = s_queue_didx[group];
+            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]);
+            if (shape_test.hasOrientation())
+                {
+                shape_test.orientation = generateRandomOrientation(rng,dim);
+                }
+
+            // store them per group
+            if (master)
+                {
+                s_pos_group[group] = vec_to_scalar3(pos_test);
+                s_orientation_group[group] = quat_to_scalar4(shape_test.orientation);
+                }
+            }
+
+        __syncthreads();
 
         // counters to track progress through the loop over potential neighbors
-        unsigned int excell_size = d_excell_size[my_cell];
+        unsigned int excell_size;
         unsigned int k = offset;
 
-        if (master)
-            overlap_checks += 2*excell_size;
+        if (active)
+            {
+            excell_size = d_excell_size[my_cell];
+
+            if (master)
+                overlap_checks += 2*excell_size;
+            }
 
         // loop while still searching
         while (s_still_searching)

            max_queue_size = n_groups*tpp;
            max_depletant_queue_size = n_groups;

            shared_bytes = max_queue_size*2*sizeof(unsigned int) +
                           max_depletant_queue_size*sizeof(unsigned int) +
                           min_shared_bytes;
            }

            // fill the neighbor queue
            // loop through particles in the excell list and add them to the queue if they pass the circumsphere check

            // active threads add to the queue
            if (active)
                {
                // 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)
                    {
                    // 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);
