                      (conj tmp-k `(.append "\""))
                      tmp-k)
             tmp-v (cond
-                    (list? (second rule)) (conj
-                                            tmp-k2
-                                            `(.append ~(prefix-rule-name (first rule) nesting-level)))
-                    (and
-                      (vector? (second rule))
-                      (every? vector? (second rule))) (do
-                                                        (conj tmp-k2 (reverse
-                                                                       (into '()
-                                                                             (create-let-body-vec-json-str-out
-                                                                               (second rule)
-                                                                               output
-                                                                               (inc nesting-level))))))
+                    (sequential? (second rule)) (conj
+                                                  tmp-k2
+                                                  `(.append ~(prefix-rule-name (first rule) nesting-level)))
                     (cond-rule-expr? (second rule)) (conj tmp-k2 `(.append ~(prefix-rule-name (first rule) nesting-level)))
-                    :default (do (println "JSON String Body: unknown element for rule:" (str rule))
-                                 tmp-k2))
+                    :default (do
+                               (println "JSON String Body: unknown element for rule:" (str rule))
+                               tmp-k2))
             tmp-v2 (if (some #{:string} rule)
                      (conj tmp-v `(.append "\""))
                      tmp-v)]

      (let [rule-name (first rule)
            rule-expression (second rule)]
        (cond
          (list? rule-expression) (conj v
                                    (prefix-rule-name rule-name nesting-level)
                                    (create-proc-sub-fn rule-expression input))
          (and
            (vector? rule-expression)
            (every? vector? rule-expression)
            (some #{:seq} rule)) (println "NESTED SEQUENCE!!")
          (and
            (vector? rule-expression)
            (every? vector? rule-expression)) (do
                                                ;(println "Binding: Got a VECTOR..." (first rule) (second rule))
                                                (into
                                                  (conj v
                                                        rule-name
                                                        nil)
                                                  (create-bindings-vector
                                                    input
                                                    rule-expression
                                                    body-creation-fn
                                                    output
                                                    (inc nesting-level))))
          (cond-rule-expr? rule-expression) (let [cond-expr (reduce
                                                              (fn [vect v]
                                                                (cond

  (reduce
    (fn [v rule]
      (cond
        (sequential? (second rule)) (conj v
                                          `(assoc
                                            ~(name (first rule))
                                            ~(prefix-rule-name (first rule) nesting-level)))
        (cond-rule-expr? (second rule)) (conj v
                                              `(assoc ~(name (first rule))
                                                      ~(prefix-rule-name (first rule) nesting-level)))
