   [s]
   (when-let [v (resolve s)]
     (when-let [{:keys [raw wrapped]} (get @instrumented-vars v)]
+      (swap! instrumented-vars dissoc v)
       (let [current @v]
         (when (= wrapped current)
-          (alter-var-root v (constantly raw))))
-      (swap! instrumented-vars dissoc v))
-    (->sym v)))
+          (alter-var-root v (constantly raw))
+          (->sym v))))))
 
 (defn- opt-syms
   "Returns set of symbols referenced by 'instrument' opts map"


(defn- check-call
  "Returns true if call passes specs, otherwise *returns* an exception
with explain-data under ::check-call."
  [f specs args]
  (let [cargs (when (:args specs) (s/conform (:args specs) args))]
    (if (= cargs ::s/invalid)

         (when check-sym
           {:sym check-sym})
         (when-let [result (-> test-check-ret :result)]
           (when-not (true? result) {:failure result}))
         (when-let [shrunk (-> test-check-ret :shrunk)]
           {:failure (:result shrunk)})))

(defn- check-1
  [{:keys [s f v spec] :as foo} {:keys [result-callback] :as opts}]
  (let [f (or v (when v @v))
        re-inst? (and v (seq (unstrument s)) true)]
    (try
     (cond
      (nil? f)
      {:failure (ex-info "No fn to spec" {::s/failure :no-fn})
       :sym s :spec spec}
    
      (:args spec)
      (let [tcret (quick-check f spec opts)]
        (make-check-result s spec tcret))
    
      :default
      {:failure (ex-info "No :args spec" {::s/failure :no-args-spec})
       :sym s :spec spec})
     (finally
      (when re-inst? (instrument s))))))

(defn- sym->check-map
  [s]
