$ ./llm
;; function definitions:
(def and (lm (a b) (nand (nand a b) (nand a b))))
(def not (lm (a) (nand a a)))
(def or (lm (a b) (nand (nand a a) (nand b b))))
(def nor (lm (a b) (not (or a b))))
(def gt (lm (a b) (lt b a)))
(def neq (lm (a b) (not (eq a b))))
(def geq (lm (a b) (or (eq a b) (gt a b))))
(def eq (lm (a b) (and (not (lt a b)) (not (lt b a)))))
(def leq (lm (a b) (or (eq a b) (lt a b))))
(def sub (lm (a b) (add a (inv b))))
(def mult (lm (a b)
              (if (eq b 1)
                  a
                  (add a (mult a (sub b 1))))))
(def div (lm (a b)
                 (if (geq a b) (add 1 (div (sub a b) b))
								   0)))
(def modsubr (lm (a b last)
                 (if (lt a 0) last
                     (modsubr (sub a b) b a))))
(def mod (lm (a b) (modsubr a b 0)))
(def sumarg (lm (a b erg)
             (if (gt a b) 
                 erg 
                 (sumarg (add a 1) b (add erg a)))))
(def sum (lm (x y) (sumarg x y 0)))
(def inc (lm (x) (add x 1)))
(def dec (lm (x) (add x (inv 1))))
(def fac (lm (x)
     (if (eq x 0) 1
         (mult x (fac (dec x))))))
(def abs (lm (x) (if (lt x 0) (inv x) x)))
(def cons (lm (a b) (lm (x) (if x a b))))
(def car (lm (cell) (cell t)))
(def cdr (lm (cell) (cell nil)))

(def countfn (lm (x) (if (lt x 0) dec inc)))
(def countdir (lm (x) ((countfn x) x)))

(def execop (lm (x y z) (x y z)))
(def myadd (lm (x y) (add x y)))

;; -------------------------------------------------------
;; read eval print loop:
(and t t)
t
(and t nil)
nil
(nand t nil)
t
(gt 8 1)
t
(neq 1 1)
nil

(eq 1 1)
t
(leq 1 5)
t



(inc 5)
6
(mult 5 5)
25
(div 8 2)
4

fac
#fn
(fac 5)
120



(countdir (inv 1))
-2
(countdir (countdir 5))
7


(myadd 4 3)
7
(execop myadd 4 3)
7


cons
#fn
(def cell (cons 1 2))
(car cell)
1
(cdr cell)
2

(def cell2 (cons 0 cell))
(car cell2)
0
(car (cdr cell2))
1
(cdr (cdr cell2))
2