         unsigned int tpp = min(args.tpp,block_size);
         unsigned int n_groups = block_size / tpp;
         unsigned int max_queue_size = n_groups*tpp;
-        unsigned int max_depletant_queue_size = n_groups;
+        unsigned int max_depletant_queue_size = max_queue_size;
 
         const unsigned int min_shared_bytes = args.num_types * sizeof(typename Shape::param_type) +
                    args.overlap_idx.getNumElements() * sizeof(unsigned int);
 
-        unsigned int shared_bytes = n_groups *(sizeof(Scalar4) + sizeof(Scalar3)) +
-                                    max_queue_size*2*sizeof(unsigned int) +
+        unsigned int shared_bytes = max_queue_size*2*sizeof(unsigned int) +
                                     max_depletant_queue_size*sizeof(unsigned int) +
                                     min_shared_bytes;
 

            if (tidx_1d < min(s_queue_size, max_queue_size))
                {
                // need to extract the overlap check to perform out of the shared mem queue
                unsigned int check_group = s_queue_gid[tidx_1d];
                unsigned int check_j_flag = s_queue_j[tidx_1d];
                bool check_old = check_j_flag & 1;
                unsigned int check_j  = check_j_flag >> 1;

            // 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)
                {
                // 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]);

                for (; q < depletant_queue_size; q += n_groups)
                    {
                    // 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]);

                    // put particle j into the coordinate system of particle i
                    r_jk = vec3<Scalar>(postype_j) - vec3<Scalar>(pos_test);
