                           vertex-res (if with-vertices? vertex (select-keys vertex [:*id*]))
                           edges-res (map (fn [edge]
                                            (assoc (if with-edges? edge {})
-                                             :opp (eb/get-oppisite edge vertex-id)))
+                                             :*opp* (eb/get-oppisite edge vertex-id)))
                                          neighbours)]
                       [vertex-res edges-res]))))
               vertices-stack)

; I also took some idea from Charles E. Leiserson and Tao B. Schardl, for the underlying BSP data processing mechanism.
; Morpueus will use the task founder server as the only machine for join operations in each level.

(def superstep-tasks (atom {}))
(def searched-stacks (atom {}))

(defn fetch-local-edges [task-id vertex-ids]
  )

      :task-id task-id)))

(defn proc-return-msg [task-id data]
  (let [[superstep-id vertices-stack] data
        deepth (get-in @tasks-vertices [task-id :current-level])]
    (a/go
      (doseq [[vertex-res edges-res] vertices-stack]
        (let [vertex-id (:*id* vertex-res)]
          (swap! tasks-vertices update-in [task-id vertex-id]
                 #(merge % vertex-res
                         {:*visited* true
                          :*edges* edges-res}))
          (doseq [edge edges-res]
            (let [opp-id (:*opp* edge)]
              (swap! tasks-vertices update-in [task-id opp-id]
                     #(if % % {:*visited* false
                               :*level* deepth}))))))
      (a/>! (get @superstep-tasks superstep-id) true))))

(defn proc-stack [task-id stack]
  (let[server-vertices (partation-vertices stack)
