 
    "Trick of Light"
    {:choices {:req #(and (contains? % :advance-counter) (> (:advance-counter %) 0))}
-    :effect  (req (let [fr target tol card]
-                       (resolve-ability state side
-                         {:prompt  "Move how many advancement tokens?"
-                          :choices (take (inc (:advance-counter fr)) ["0" "1" "2"])
-                          :effect  (req (let [c (Integer/parseInt target)]
-                                             (resolve-ability state side
-                                               {:prompt  "Move to where?"
-                                                :choices {:req #(and (not= (:cid fr) (:cid %))
-                                                                     (or (= (:advanceable %) "always")
-                                                                         (and (= (:advanceable %) "while-rezzed") (:rezzed %))
-                                                                         (= (:type %) "Agenda")))}
-                                                :effect  (effect (add-prop :corp target :advance-counter c)
-                                                                 (add-prop :corp fr :advance-counter (- c))
-                                                                 (system-msg (str "moves " c " advancement tokens from "
-                                                                                  (if (:rezzed fr) (:title fr) "a card") " to "
-                                                                                  (if (:rezzed target) (:title target) "a card"))))
-                                                } tol nil)))
-                          } card nil)))}
+    :effect
+    (req (let [fr target tol card]
+           (resolve-ability
+            state side
+            {:prompt "Move how many advancement tokens?"
+             :choices (take (inc (:advance-counter fr)) ["0" "1" "2"])
+             :effect (req (let [c (Integer/parseInt target)]
+                            (resolve-ability
+                             state side
+                             {:prompt  "Move to where?"
+                              :choices {:req #(and (not= (:cid fr) (:cid %))
+                                                   (or (= (:advanceable %) "always")
+                                                       (and (= (:advanceable %) "while-rezzed") (:rezzed %))
+                                                       (= (:type %) "Agenda")))}
+                              :effect  (effect (add-prop :corp target :advance-counter c)
+                                               (add-prop :corp fr :advance-counter (- c))
+                                               (system-msg (str "moves " c " advancement tokens from "
+                                                                (if (:rezzed fr) (:title fr) "a card") " to "
+                                                                (if (:rezzed target) (:title target) "a card"))))}
+                             tol nil)))}
+            card nil)))}
 
    "Turtlebacks"
    {:events {:server-created {:msg "gain 1 [Credits]" :effect (effect (gain :credit 1))}}}
 
    "Tyrs Hand"
    {:abilities [{:label "Prevent a subroutine on a Bioroid from being broken"
-                 :req (req (prn "tyr" (:zone current-ice) (:zone card))
-                       (and (= (butlast (:zone current-ice)) (butlast (:zone card)))
+                 :req (req (and (= (butlast (:zone current-ice)) (butlast (:zone card)))
                                 (has? current-ice :subtype "Bioroid"))) :effect (effect (trash card))
                  :msg (msg "prevent a subroutine on " (:title current-ice) " from being broken")}]}
 

   {:abilities [{:player :runner :prompt "Choose one" :choices ["Lose [Click]" "End the run"]
                 :label "Force the Runner to lose [Click] or end the run"
                 :effect (req (if-not (and (= target "Lose [Click]") (pay state side card :click 1))
                             (do (end-run state side) (system-msg state side "ends the run"))
                             (system-msg state side "loses [Click]")))}]}

   "Tsurugi"
   {:abilities [{:msg "end the run" :effect (effect (end-run))}

                        :effect (req (let [dest (server->zone state target)]
                                       (swap! state update-in [:run]
                                              #(assoc % :position (count (get-in corp (conj dest :ices)))
                                                      :server (rest dest))))
                                     (move state side card (conj (server->zone state target) :ices)))}}}]}

   "Burke Bugs"
