       (let [rule-name (first rule)
             rule-expression (second rule)]
         (cond
+          (and
+            (list? rule-expression)
+            (every? vector? rule-expression)) (do
+                                                (println "NESTED SEQUENCE!!")
+                                                (into
+                                                  (conj v
+                                                        rule-name
+                                                        nil)
+                                                  ['abc 123]
+                                                  ))
           (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))))
+            (every? vector? rule-expression)) (let [nested-expr (create-let-expression
+                                                                  input
+                                                                  rule-expression
+                                                                  body-creation-fn
+                                                                  output
+                                                                  (inc nesting-level))]
+                                                (conj v (prefix-rule-name rule-name nesting-level) nested-expr))
           (cond-rule-expr? rule-expression) (let [cond-expr (reduce
                                                               (fn [vect v]
                                                                 (cond

  (reduce
    (fn [v rule]
      (cond
        (list? (second rule)) (conj v
                                    `(assoc
                                      ~(name (first rule))
                                      ~(prefix-rule-name (first rule) nesting-level)))
        (and
          (vector? (second rule))
          (every? vector? (second rule))) (do
                                            ;(println "Java Map Body: Got a Vector..." (first rule) (second rule))
                                            (conj v
                                                  `(assoc
                                                     ~(name (first rule))
                                                     ~(reverse (into '() (create-let-body-vec-clj-map-out (second rule) nil (inc nesting-level)))))))
        (cond-rule-expr? (second rule)) (conj v
                                              `(assoc ~(name (first rule))
                                                      ~(prefix-rule-name (first rule) nesting-level)))

                     (conj tmp-k `(.append "\""))
                     tmp-k)
            tmp-v (cond
                    (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))
            tmp-v2 (if (some #{:string} rule)
                     (conj tmp-v `(.append "\""))
                     tmp-v)]
