    [:explist [:exp [:prefixexp [:var [:Name "g"]]]]]]]]
 
 (pprint (lua-parser (slurp "resources/test/basic1.lua")))
-
+(proteus/let-mutable 
+  [G__19303 nil G__19304 false 
+   g 55;nil 
+   (do (cond true 
+             (proteus/let-mutable 
+               [l "local_var" 
+                luaclj.core/_ (set! l "local_var_modified") 
+                luaclj.core/_ (do (set! G__19304 true) (println "setting:" l) (set! G__19303 l))])) 
+       (set! g "global_var") (do (set! G__19304 true) (println "g:" g) (set! G__19303 g)))]
+  G__19303)
+(eval (insta/transform transform-map (lua-parser (slurp "resources/test/basic1.lua"))))
   (try (pprint (insta/transform transform-map (lua-parser (slurp "resources/test/basic1.lua"))))
        (catch Exception ex (clojure.stacktrace/print-stack-trace ex)))
   (pprint tree)

                                               (first ret-val))]
                                 `(do (set! ~returned? true)
                                      (set! ~return-value ~ret-val))))
        let-statements (transform (walker #(= "return" (safe-some-> %1 first)))
                                  process-return-stmts
                                  let-statements)
        process-returned? (fn [arg]
                            returned?
                            )
        let-statements (transform (walker #(= %1 :returned?)) 
                                    process-returned? 
                                    let-statements)
        expr `(let-mutable ~(vec (into [return-value nil
                                        returned? false] 
                                       (apply concat global-var-init-statements 
                                         (next let-statements)
                                         )))
                ~return-value)]
    (println "chunk-fn2:" global-var-init-statements)
    expr
    ))

  (cons 'some->> (interpose '((fn [arg] 
                              (when (sequential? arg) arg)))
                           args)))

(def third #(nth %1 2))
(def fourth #(nth %1 3))

(defn leave [odd-or-even-kw items]
  (map second (remove #((if (= odd-or-even-kw :odd) odd? even?) (first %1)) (map #(vector %1 %2) (range) items))))

(comment
  (let [s [[{:a 1} ['(set! a 3) :b #{'('(set! b 4))}]] ['(['(set! a 6)])]]
        walker-fn #(safe-some->> %1 (some (fn [arg] (= arg 'set!))))
