   (concat (list
             (fn [] (lrand-nth (list true false))) ;Boolean
             ;;; end ERCs
-            (tag-instruction-erc [:exec :integer :boolean :string :char] 1000)
+            (tag-instruction-erc [:integer :boolean :string :exec] 1000)
             (tagged-instruction-erc 1000)
             ;;; end tag ERCs
             'in1
+            'in2
+            'in3
             ;;; end input instructions
             )
-          (registered-for-stacks [:integer :boolean :string :char :exec :print])))
+          (registered-for-stacks [:integer :boolean :string :exec])))
 
 
 ;; Define test cases
 (defn csl-input
-  "Makes a Compare String Lengths input of length len."
+  "Makes a Compare String Lengths input string of length len."
   [len]
   (apply str
          (repeatedly len

        (the-actual-csl-error-function program data-cases false))
      ([program data-cases print-outputs]
        (let [behavior (atom '())
              errors (flatten
                       (doall
                         (for [[input correct-output] (case data-cases
                                                                   :train train-cases
                                                                   :test test-cases
                                                                   [])]
                           (let [final-state (run-push program
                                                       (->> (make-push-state)
                                                         (push-item input :input)
                                                         (push-item "" :output)))
                                 printed-result (stack-ref :output 0 final-state)]
                             (when print-outputs
                               (println (format "Correct output: %-19s | Program output: %-19s" correct-output printed-result)))
                             ; Record the behavior
                             (when @global-print-behavioral-diversity
                               (swap! behavior conj printed-result))
                             ; Error is Levenshtein distance and, if correct format, distance from correct character
                             (vector
                               (levenshtein-distance correct-output printed-result)
                               (if (not (empty? printed-result))
                                 (abs (- (int (last correct-output)) (int (last printed-result)))) ;distance from correct last character
                                 1000) ;penalty for wrong format
                               )))))]
          (when @global-print-behavioral-diversity
            (swap! population-behaviors conj @behavior))
          errors)))))

  [data-domains]
  (let [[train-cases test-cases] (map csl-test-cases
                                      (test-and-train-data-from-domains data-domains))]
    (when true ;; Change to false to not print test cases
      (doseq [[i case] (map vector (range) train-cases)]
        (println (format "Train Case: %3d | Input/Output: %s" i (str case))))
      (doseq [[i case] (map vector (range) test-cases)]
