           ;; Arguments related to the Push interpreter
           ;;----------------------------------------
 
-         :pop-when-tagging true
+          :pop-when-tagging true
           ;; When true, tagging instructions will pop the exec stack when tagging; otherwise, the
           ;; exec stack is not popped.
 
-         :tag-limit 10000
+          :tag-limit 10000
           ;; The size of the tag space.
 
-         :top-level-push-code false
+          :top-level-push-code false
           ;; When true, run-push will push the program's code onto the code stack prior to running.
 
-         :top-level-pop-code false
+          :top-level-pop-code false
           ;; When true, run-push will pop the code stack after running the program.
 
           ;;----------------------------------------
           ;; Arguments related to generational and final reports
           ;;----------------------------------------
 
-         :report-simplifications 100
+          :report-simplifications 100
           ;; The number of simplification steps that will happen during report simplifications
 
-         :final-report-simplifications 1000
+          :final-report-simplifications 1000
           ;; The number of simplification steps that will happen during final report
           ;; simplifications.
 
-         :problem-specific-initial-report default-problem-specific-initial-report
+          :problem-specific-initial-report default-problem-specific-initial-report
           ;; A function can be called to provide a problem-specific initial report, which happens
           ;; before the normal initial report is printed.
 
-         :problem-specific-report default-problem-specific-report
+          :problem-specific-report default-problem-specific-report
           ;; A function can be called to provide a problem-specific report, which happens before
           ;; the normal generational report is printed.
 
-         :return-simplified-on-failure false
+          :return-simplified-on-failure false
           ;; When true, will simplify the best indivual and return it, even if the error threshold
           ;; has not been reached. This will make failures return the same as successes.
 
-         :print-errors true
+          :print-errors true
           ;; When true, prints the error vector of the best individual.
 
-         :print-history false
+          :print-history false
           ;; When true, prints the history of the best individual's ancestors' total errors.
 
-         :print-timings false
+          :print-timings false
           ;; If true, report prints how long different parts of evolution have taken during the
           ;; current run.
 
-         :print-error-frequencies-by-case false
+          :print-error-frequencies-by-case false
           ; If true, print reports of error frequencies by case each generation.
 
-         :print-cosmos-data false
+          :print-cosmos-data false
           ;; If true, report prints COSMOS data each generation.
 
-         :maintain-ancestors false
+          :maintain-ancestors false
           ;; If true, save all ancestors in each individual (costly).
 
-         :print-ancestors-of-solution false
+          :print-ancestors-of-solution false
           ;; If true, final report prints the ancestors of the solution. Requires
           ;; :maintain-ancestors to be true.
 
-         :print-homology-data false
+          :print-homology-data false
           ;; If true, prints the homology statistics.
 
-         :exit-on-success true
+          :exit-on-success true
           ;; When true, will exit the run when there is an individual with a zero-error vector
 
-         :visualize false
+          :visualize false
           ;; When true, graphics will be displayed to indicate system progress.
           ;; See the comments in src/clojush/pushgp/visualize.clj
 

          ;; Arguments related to genetic operators
          ;;----------------------------------------

         :alternation-rate 0.01
          ;; When using alternation, the probability of alternating between the parents when moving
          ;; to the next gene.

         :alignment-deviation 10
          ;; When using alternation, the standard deviation of how far alternation may jump between
          ;; indices when switching between parents.

         :uniform-mutation-rate 0.01
          ;; The probability of each token being mutated during uniform mutation.

         :uniform-mutation-constant-tweak-rate 0.5
          ;; The probability of mutating a constant instead of simply replacing the token
          ;; with a random instruction during uniform mutation.

         :uniform-mutation-float-gaussian-standard-deviation 1.0
          ;; The standard deviation used when tweaking float constants with Gaussian noise.

         :uniform-mutation-int-gaussian-standard-deviation 1
          ;; The standard deviation used when tweaking integer constants with Gaussian noise.

         :uniform-mutation-string-char-change-rate 0.1
          ;; The probability of each character being changed when doing string constant tweaking.

         :uniform-mutation-tag-gaussian-standard-deviation 100
          ;; The standard deviation used when tweaking tag locations with Gaussian noise.

         :uniform-close-mutation-rate 0.1
          ;; The probability of each :close being incremented or decremented during uniform close
          ;; mutation.

         :close-increment-rate 0.2
          ;; The probability of making an increment change to :close during uniform close mutation,
          ;; as opposed to a decrement change.

         :uniform-deletion-rate 0.01
          ;; The probability that any instruction will be deleted during uniform deletion.

         :uniform-addition-rate 0.01
          ;; The probability that any instruction will have a new one added before or after it during
          ;; uniform addition.

         :uniform-addition-and-deletion-rate 0.01
          ;; The probability, per gene, for additions in the first phase, and deletions in the second
          ;; phase (calculated for size-neutrality), of uniform-addition-and-deletion.

         :uniform-combination-rate 0.01
          ;; The probability, per gene, for combinations during uniform-combination

         :uniform-combination-and-deletion-rate 0.01
          ;; The probability, per gene, for combinations in the first phase, and deletions in
          ;; the second phase (calculated for size-neutrality), of uniform-combination-and-deletion.

         :uniform-silence-mutation-rate 0.1
          ;; The probability of each :silent being switched during uniform silent mutation.

         :replace-child-that-exceeds-size-limit-with :random
          ;; When a child is produced that exceeds the size limit of (max-points / 4), this is
          ;; used to determine what program to return. Options include :parent, :empty, :random,
          ;; :truncate.

         :parent-reversion-probability 1.0
          ;; The probability of a child being reverted to its parent by a genetic operator that
          ;; has been made revertable, if the child is not as good as the parent on at least one
          ;; test case.

         :tag-enrichment 0
          ;; The number of extra copies of tag-related instructions that will be included in
          ;; the atom-generators.

         :tag-enrichment-types [:integer :boolean :exec :float :char :string :code]
          ;; The types for tag-related instructions that will be included in the atom-generators
          ;; when :tag-enrichment is greater than 0.

         :gene-selection-rate 1.0
          ;; When using gene-selection, the probability of selecting a new parent when moving
          ;; to the next gene.

         :autoconstructive false
          ;; If true, then :genetic-operator-probabilities will be {:autoconstruction 1.0},
          ;; :epigenetic-markers will be [:close :silent], and :atom-generators will include
          ;; instructions specified via :autoconstructive-genome-instructions, and other settings

          ;; Arguments related to parent selection
          ;;----------------------------------------

          :parent-selection :lexicase
          ;; The parent selection method. Options include :tournament, :lexicase, :epsilon-lexicase,
          ;; :elitegroup-lexicase, :uniform, :leaky-lexicase, :random-threshold-lexicase,
          ;; :random-toggle-lexicase, :randomly-truncated-lexicase, :novelty-search

          :epsilon-lexicase-epsilon nil
          ;; When parent-selection is :epsilon-lexicase,
          ;; the value for epsilon. If nil, automatic epsilon lexicase selection will be used.

          :epsilon-lexicase-probability 1
          ;; The probability that each filtering step in epsilon lexicase selection will allow
          ;; candidates with errors within epsilon of the best to survive, rather than just
          ;; the best.

          :random-threshold-lexicase-probability 1
          ;; The probability that each filtering step in random threshold lexicase selection will 
          ;; allow candidates with errors equal to or better than a randomly chosen threshold to 
          ;; survive, rather than just the best.

          :random-toggle-lexicase-probability 1
          ;; The probability that each filtering step in random toggle lexicase selection will 
          ;; allow just the best to survive, rather than all individuals in the pool.

          :randomly-truncated-lexicase-probability 1
          ;; The probability that an application of randomly-truncated-lexicase-selection
          ;; will consider only a random subset of the test cases, rather than all of them.

          :lexicase-leakage 0.1
          ;; If using leaky lexicase selection, the probability that a selection event will return
          ;; a random (tourny 1) individual from the entire population.

          :lexicase-slippage 0
          ;; If using lexicase, leaky lexicase, epsilon lexicase, or random threshold lexicase
          ;; selection, the probability that each step of the lexicase selection process will
          ;; "slip" and return a random candidate from the current pool, rather than continuing 
          ;; to filter the pool.

          :sort-meta-errors-for-lexicase :random
          ;; If using lexicase selection, determines how meta-errors will be sorted among
          ;; the actual errors. Options are :random (errors and meta-errors are shuffled 
          ;; together), :first (meta-errors come first), or :last (meta-errors come last).

          :tournament-size 7
          ;; If using tournament selection, the size of the tournaments.

          :total-error-method :sum
          ;; The method used to compute total error. Options include :sum (standard), :hah
          ;; (historically-assessed hardness), :rmse (root mean squared error), and :ifs
          ;; (implicit fitness sharing).

          :normalization :none
          ;; The method used to normalize the errors to the range [0,1], with 0 being best. Options
          ;; include :none (no normalization), :divide-by-max-error (divides by value of argument
          ;; :max-error), :e-over-e-plus-1 (e/(e+1) = 1 - 1/(e+1))

          :max-error 1000
          ;; If :normalization is set to :divide-by-max-error, will use this number for
          ;; normalization.

          :meta-error-categories []
          ;; A vector containing meta-error categories that can be used for parent selection, 
          ;; but that do not affect total error or the determination of whether an individual 
          ;; is considered to be a solution. Each meta-error-category should either be a function 
