                                                   `(assoc
                                                      ~(name (first rule))
                                                      ~(reverse (into '() (create-let-body-vec-clj-map-out (second rule) nil (inc nesting-level)))))))
-;        (cond-rule-expr? (second rule)) 
+        (cond-rule-expr? (second rule)) (conj v
+                                              `(assoc ~(name (first rule))
+                                                      ~(prefix-rule-name (first rule) nesting-level)))
         :default (do (println "Clj Map Body: unknown element for rule:" (str rule))
                      ;(throw (RuntimeException. "Clj Map Body: unknown element for rule"))
                      )))

        (list? (second rule)) (conj v
                                    `(assoc
                                      ~(name (first rule))
                                      ~(if (> 1 nesting-level)
                                         (first rule)
                                         (symbol (str "__" nesting-level "_" (first rule))))))
        (and
          (vector? (second rule))
          (every? vector? (second rule))) (do

                                                    body-creation-fn
                                                    output
                                                    (inc nesting-level))))
          (cond-rule-expr? rule-expression) (let [cond-expr (reduce
                                                              (fn [vect v]
                                                                (cond
                                                                  (or (list? v)
                                                                      (keyword? v)) (conj vect v)
                                                                  (vector? v) (conj vect
                                                                                    (create-let-expression
                                                                                      input
                                                                                      v
                                                                                      body-creation-fn
                                                                                      output
                                                                                      (inc nesting-level)))
                                                                  :default (do
                                                                             (println "Unknown rule expression part:" v)
                                                                             vect)))
                                                              ['clojure.core/cond]
                                                              rule-expression)]
                                              (conj v (prefix-rule-name rule-name nesting-level) (into '() (reverse cond-expr))))
          :default (println "Binding: unknown element for rule:" (str rule)))))
    []
    rules))
