   (swapVals [_ f]
     (ut/assert-not-released! release)
     (ut/with-locking lock
-                     (let [result (.swapVals underlying-atom f)]
+      (let [result (.swapVals underlying-atom f)]
         (storage/commit storage-backend)
         result)))
   (swapVals [_ f arg1]
     (ut/assert-not-released! release)
     (ut/with-locking lock
-                     (let [result (.swapVals underlying-atom f arg1)]
+      (let [result (.swapVals underlying-atom f arg1)]
         (storage/commit storage-backend)
         result)))
   (swapVals [_ f arg1 arg2]
     (ut/assert-not-released! release)
     (ut/with-locking lock
-                     (let [result (.swapVals underlying-atom f arg1 arg2)]
+      (let [result (.swapVals underlying-atom f arg1 arg2)]
         (storage/commit storage-backend)
         result)))
   (swapVals [_ f arg1 arg2 more]
     (ut/assert-not-released! release)
     (ut/with-locking lock
-                     (let [result (.swapVals underlying-atom f arg1 arg2 more)]
+      (let [result (.swapVals underlying-atom f arg1 arg2 more)]
         (storage/commit storage-backend)
         result)))
   (resetVals [_ newvals]
     (ut/assert-not-released! release)
     (ut/with-locking lock
-                     (let [result (.resetVals underlying-atom newvals)]
+      (let [result (.resetVals underlying-atom newvals)]
         (storage/commit storage-backend)
         result)))
 

  (swap [_ f]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.swap underlying-atom f)]
        (storage/commit storage-backend)
        result)))
  (swap [_ f arg]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.swap underlying-atom f arg)]
        (storage/commit storage-backend)
        result)))
  (swap [_ f arg1 arg2]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.swap underlying-atom f arg1 arg2)]
        (storage/commit storage-backend)
        result)))
  (swap [_ f arg1 arg2 more]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.swap underlying-atom f arg1 arg2 more)]
        (storage/commit storage-backend)
        result)))
  (compareAndSet [_ oldv newv]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.compareAndSet underlying-atom oldv newv)]
        (when result
          (storage/commit storage-backend))
        result)))
  (reset [_ newval]
    (ut/assert-not-released! release)
    (ut/with-locking lock
                     (let [result (.reset underlying-atom newval)]
        (storage/commit storage-backend)
        result)))
  IRef

  (:require [duratom.backends :as storage]
            [duratom.utils :as ut]
            [clojure.java.io :as jio]
            [duratom.readers :as readers]
            [duratom.utils :as ut])
  (:import (clojure.lang IAtom IDeref IRef ARef IMeta IObj Atom IAtom2)
