 (defn- parse-decimal
   [string-decimal]
   (when-let [match (re-find #"(\d+)\/(\d+)" string-decimal)]
-    (apply / (->> match
-                  rest
-                  (map bigdec)))))
+    (with-precision 4
+      (apply / (->> match
+                    rest
+                    (map bigdec))))))
 
 (def ^:private namespace-map
   (->> ["gnc" "act" "trn" "ts" "split" "bgt" "recurrence" "slot" "cd" "cmdty" "price"]

        progress-chan (chan)
        result (go
                 (with-open [input-stream (FileInputStream. input-file)]
                   (->> (read-source :gnucash input-stream)
                        (transduce
                          (comp filter-record
                                append-record
                                (partial notify-record progress-chan))
                          evaluate-output
                          {:output-paths []
                           :verbose (-> opts :options :verbose)
                           :records []
                           :max-record-count (-> opts :options :maximum)
                           :file-name (second (re-matches #"^(.+)(\..+)$" file-name))
                           :output-folder output-folder
                           :progress-chan progress-chan})
                        process-output)))]
    (go-loop [value (<! progress-chan)]
             (case (first value)
               :record

                              (count output-paths))]
      (binding [*print-meta* true]
        (with-open [writer (io/writer (GZIPOutputStream. (FileOutputStream. output-path)))]
          (with-precision 4
            (.write writer (prn-str records)))))
      (>!! progress-chan [:output-path output-path])
      (-> context
          (assoc :records [])
