    ^ArrayList outputs (ArrayList.)]
   []
   Watched
-  (add-watcher! [sw w] #_(println :AW sw w) #_ (assert (not (some #(= % w) watchers)))
+  (add-watcher! [sw w] #_(println :AW sw w) 
     (.add watchers w) 
-    (doseq [o (doall (seq outputs))] (swap! *out-count* inc) (w o))#_ (println :WF sw))
+    (doseq [o (doall (seq outputs))] (swap! *out-count* inc) (w o)) )
   (add-output! [sw o] ;               (println :AO sw o) (Thread/sleep 10)
     (.add outputs o)
-    (doseq [w (doall (seq watchers))] (swap! *out-count* inc) (w o)) #_(println :OF sw))
+    (doseq [w (doall (seq watchers))] (swap! *out-count* inc) (w o)))
   (get-outputs [sw] (doall (seq outputs))))
 
 

;; Here we properly deal with weirdness of stubs/inner-sps decreaseing as they add
;; children, by makig sure to do the updates synchronously.


;; TODO: pessimistic

;; TODO: pseudo-solve


(declare make-state-abstracted-subproblem)
(defn make-state-abstracted-stub [inner-stub in-set]
  (let [ret (traits/reify-traits [or-summarizable (simple-stub [:SA (stub-name inner-stub) in-set] in-set)])]
    (connect-and-watch! ret inner-stub #(set-stub-output! ret (make-state-abstracted-subproblem ret %)))
    ret))

;; Note: subsumed subproblems can have different irrelevant vars
(defn make-state-abstracted-subproblem [stb inner-sp]
  (let [ts  (tree-summarizer inner-sp)
        in  (input-set stb)
        out (state/transfer-effects in (output-set inner-sp))
        ri-fn #(if (=-state-sets %2 in) stb (refine-input inner-sp %2))
        ret (traits/reify-traits
             [or-summarizable (simple-subproblem stb out ts (terminal? inner-sp) ri-fn)])]
    (connect-and-watch! ret inner-sp
      (fn [o] (connect-and-watch! ret (make-state-abstracted-stub (stub o) in) #(add-sp-child! ret %))))    
    ret))


