                          (some #(when (= cid (:cid %)) %) (get-in @state (cons :runner (vec zone))))
                          (some #(when (= cid (:cid %)) %) (get-in @state (cons :corp (vec zone))))))
        (doseq [h (:hosted card)]
-         (trash state side (dissoc (update-in h [:zone] #(map to-keyword %)) :facedown)))
+         (trash state side (dissoc (update-in h [:zone] #(map to-keyword %)) :facedown) {:unpreventable true}))
        (let [dest (if (sequential? to) (vec to) [to])
              c (if (and (= side :corp) (= (first dest) :discard) (:rezzed card))
                  (assoc card :seen true) card)

           (swap! state update-in (cons side dest) #(conj (vec %) moved-card)))
         (doseq [s [:runner :corp]]
           (if host
             (when-let [host-card (some #(when (= (:cid host) (:cid %)) %)
                                        (get-in @state (cons s (vec zone))))]
               (update! state side (update-in host-card [:hosted]
                                              (fn [coll] (remove-once #(not= (:cid %) cid) coll)))))
             (swap! state update-in (cons s (vec zone))
                    (fn [coll] (remove-once #(not= (:cid %) cid) coll)))))
         (let [z (vec (cons :corp (butlast zone)))
               n (last z)]
           (when (and (not keep-server-alive)

    (say state side {:user "__system__" :text (str username " " text "." (when hr "[hr]"))}))))

(declare prompt! forfeit trigger-event handle-end-run trash update-advancement-cost update-all-advancement-costs
         update! get-card update-all-ice update-ice-strength update-breaker-strength all-installed resolve-steal-events)

(defn can-pay? [state side & args]
  (let [costs (merge-costs (remove #(or (nil? %) (= % [:forfeit])) args))
