    [[input1 input2 input3 input4] output]."
   [inputs]
   (map #(vector %
-    (loop [time (first %) total (second %)]
-      (if (= time 0) total
-                     (recur (dec time) (+ (* total (- 1 (last %))) (nth % 2))))))
+    (loop [time (first %)
+           total (second %)]
+      (if (= time 0)
+        total
+        (recur (dec time)
+               (+ (* total (- 1 (last %))) 
+                  (nth % 2))))))
        inputs))
 
 (defn make-snow-day-error-function-from-cases

                           ; Error is float error rounded to 3 decimal places
                           (round-to-n-decimal-places
                            (if (number? result)
                              (abs (- result correct-output)) ; distance from correct integer
                              1000000.0) ; penalty for no return value
                            3)
                             )))]
        (if (= data-cases :train)
          (assoc individual :behaviors @behavior :errors errors)
          (assoc individual :test-errors errors))))))

                                                                               [])]
                         (let [final-state (run-push (:program individual)
                                                     (->> (make-push-state)
                                                          (push-item input4 :input)
                                                          (push-item input3 :input)
                                                          (push-item input2 :input)
                                                          (push-item input1 :input)))
                               result (top-item :float final-state)]
                           (when print-outputs
                             (let [res-str (if (float? result)
