   (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)))))))
+        (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)))

;        _ (println "Created data processing function vector from DSL:" fn-body-vec)
        fn-body (create-let-expression input-sym rules let-body-creation-fn output-sym 0)
;        _ (println "Created data processing function body:" fn-body)
;        _ (pprint fn-body)
;        _ (println "")
        data-processing-fn (if (not (nil? output-sym))
                             (eval `(fn [~input-sym ~output-sym] ~fn-body))
                             (eval `(fn [~input-sym] ~fn-body)))]

      (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)) (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
