                             time (max
                                    (+ (:entry-time prev) heval/time-unit)
                                    (min (iv/end (:interval trans))
-                                        (:t opt)))
+                                        (:entry-time cur)))
                             _ (assert (= (get-in prev [:objects (:id opt) :state])
                                          (:state opt))
                                       (str "not="

                           explored
                           (assoc opt
                             :t
                             (- time (get-in cur [:objects (:id opt) :entry-time]))))
                         seen]))
                    [[] explored seen]
                    removed-opts)

        [playouts _ _ explored seen]
        (reduce
          (fn [[playouts path prev-opts explored seen] [prev cur]]
            (let [cur-opts (into #{} (map #(option-desc cur % heval/time-unit)
                                          (second (roll/next-transitions cur))))
                  ; _ (println "explore" (get-in cur [:objects :m :state]))
                  next-path (if (some? prev)
                              (conj path prev)
                              path)
                  removed-opts (filter #(not (contains? explored (assoc % :t (- (:entry-time cur) (:entry-time prev)))))
                                       (sets/difference prev-opts cur-opts))
                  _ (println "removed" removed-opts)
                  [remove-explore-playouts explored seen]
