;(def! main (fn* (argv) 2))
;(def! main (fn* () (let* (a 13 b 12 c 11) b)))
;(def! main (fn* () (do 13 12 11)))
;(def! main (fn* () (if false 1 2)))
;(def! main (fn* () (+ 13 1)))
;(def! main (fn* () (- 13 -1)))
;(def! main (fn* () (- 13 -1)))
;(def! main (fn* () (+ 13 -)))
;(def! main (fn* () (+ 13 1 2)))
;(def! main (fn* () (cond false 1 false 2 true 3 true 4 false 5)))
;(def! main (fn* () ((fn* () (+ (+ 1 2) 3)) 13 1 2)))
;(def! main (fn* () (((fn* () (fn* () 1))))))
;(def! main (fn* () ((fn* (a b c) (- (+ a b) c)) 13 1 4)))
;(def! main (fn* () (fn* () 1)))

;(def! other (fn* (a b c) (- (+ a b) c)))
;(def! main (fn* () (other 13 1 4)))

;(def! other 12)
;(def! main (fn* () (+ other 4)))

;(def! fact (fn* (n) (if (<= n 1) 1 (* (fact (- n 1)) n))))
;(def! main (fn* () (let* (to_ret (fact 5)) (do (println to_ret) to_ret))))

;(def! ret_with_call (fn* (n) (fn* (x) (+ n x))))
;(def! main (fn* () ((ret_with_call 3) 5)))

(def! test (fn* () (let* (
                        ;(l (list 3 4 5))
                        a 5
                        ;l '(a 4 5)
                        ;l (vector 3 4 5)
                        ;l [a 4 5]
                        l '[3 4 5]
                        ;l '[a 4 5]
                        )
                        (nth l 0))))
;(def! main (fn* () (let* (it (test)) (do (println it) it))))
;(def! main (fn* () (let* (it "asdf") (do (println it) 0))))
;(def! main (fn* () (let* (it 'sym_baby) (do (println it) 0))))
;(def! main (fn* () (let* (it [1 2 3]) (do (println it) 0))))
;(def! main (fn* () (let* (it '(1 2 3)) (do (println it) 0))))
;(def! my_str "asdf")
;(def! main (fn* () (do (println my_str) 0)))

;(def! main (fn* () (let* (it (atom 7)) (do
;                                           (println it)
;                                           (println (deref it))
;                                           (reset! it 8)
;                                           (println (deref it))
;                                           (deref it)
;                                       ))))
;(def! my_atom (atom 5))
;(def! main (fn* () (do
;                       (println my_atom)
;                       (println (deref my_atom))
;                       (reset! my_atom 1337)
;                       (println my_atom)
;                       (println (deref my_atom))
;                       7)))


;(def! inner (fn* (x) (do (throw (+ x 1)) (+ x 2))))
;(def! inner (fn* (x) (do (println 7) (+ x 2))))
;(def! main (fn* () (do (println (try*
;                                (inner 7)
;                                (catch* exp (+ exp 10))))
;                        7)))
;(def! main (fn* () (do (println (try*
;                                (inner 7)))
;                        7)))

(def! to_be_saved (with-meta [1] [2]))
(def! to_be_saved_s "asdfasdf")

(def! main (fn* () (let* ( a 7
                           b [1]
                           c (with-meta b "yolo") )
                           (do
                            (try*
                                ((fn* () (do
                                            (println b)
                                            (set-nth! b 0 2)
                                            (println b)
                                            (println c)
                                            (println (meta c))
                                            (println "world")
                                            (println to_be_saved)
                                            (println (meta to_be_saved))
                                            (println to_be_saved_s)
                                            a)))
                                )))))
(do
    (println "interp-main")
    (main)
    (println "done interp-main")
    nil)