                                                     cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
                                             }
 
-                                            coop_offset += KernelPolicy::THREADS;
-                                            coop_rank += KernelPolicy::THREADS;
-                                        }
-
-                                        if (coop_offset + threadIdx.x < coop_oob) {
-
-                                            // Gather
-                                            //neighbor_id = tex1Dfetch(ColumnIndicesTex<VertexId>::ref, coop_offset+threadIdx.x);
-                                            util::io::ModifiedLoad<ProblemData::COLUMN_READ_MODIFIER>::Ld(
-                                                    neighbor_id,
-                                                    cta->d_column_indices + coop_offset+threadIdx.x);
-
-                                            // Users can insert a functor call here ProblemData::Apply(pred_id, neighbor_id)
-                                            // if Cond(neighbor_id) returns true
-                                            // if Cond(neighbor_id) returns false or Apply returns false
-                                            // set neighbor_id to -1 for invalid                                    
-                                            if (Functor::CondEdge(pred_id, neighbor_id, cta->problem, coop_offset+threadIdx.x)) {
-                                                Functor::ApplyEdge(pred_id, neighbor_id, cta->problem, coop_offset+threadIdx.x);
-                                                util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
-                                                    neighbor_id,
-                                                    cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
-                                                if (ProblemData::ENABLE_IDEMPOTENCE && ProblemData::MARK_PREDECESSORS && cta->d_pred_out != NULL) {
-                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
-                                                            pred_id,
-                                                            cta->d_pred_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
-                                                }
-                                            }
-                                            else {
-                                                util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
-                                                    -1,
-                                                    cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
-                                            }
-
                                         }
                                     }
 

            SizeT                   max_out_frontier;           // Maximum size (in elements) of outgoing frontier
            int                     num_gpus;                   // Number of GPUs
            int                     label;                      // Current label of the frontier
            gunrock::oprtr::advance::TYPE           ADVANCE_TYPE;

            // Operational details for raking grid
            RakingSoaDetails        raking_soa_details;

                                                // set neighbor_id to -1 for invalid 
                                                if (Functor::CondEdge(pred_id, neighbor_id, cta->problem, coop_offset+lane_id)) {
                                                    Functor::ApplyEdge(pred_id, neighbor_id, cta->problem, coop_offset+lane_id);
                                                    if (cta->advance_type == gunrock::oprtr::advance::V2E) {
                                                        neighbor_id = coop_offset+lane_id;
                                                    }
                                                }
                                                else
                                                    neighbor_id = -1;

                                                if (ProblemData::ENABLE_IDEMPOTENCE && ProblemData::MARK_PREDECESSORS && cta->d_pred_out != NULL) {
                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
                                                            pred_id,
                                                            cta->d_pred_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
                                                }

                                                // Scatter neighbor
                                                util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
