                                             // 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);
+                                                if (cta->advance_type == gunrock::oprtr::advance::V2V) {
+                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
+                                                            neighbor_id,
+                                                            cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank); 
+                                                } else if (cta->advance_type == gunrock::oprtr::advance::V2E) {
+                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
+                                                            (VertexId)(coop_offset+threadIdx.x),
+                                                            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);
+                                            }
+
+                                            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_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
+                                                    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);
+                                                if (cta->advance_type == gunrock::oprtr::advance::V2V) {
+                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
+                                                            neighbor_id,
+                                                            cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank); 
+                                                } else if (cta->advance_type == gunrock::oprtr::advance::V2E) {
+                                                    util::io::ModifiedStore<ProblemData::QUEUE_WRITE_MODIFIER>::St(
+                                                            (VertexId)(coop_offset+threadIdx.x),
+                                                            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,

            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;

                                                    cta->d_out + cta->smem_storage.state.coarse_enqueue_offset + coop_rank);
                                            }

                                        }
                                    }

