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

;        _ (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)))]

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