!(set-env (letrec
               (

                (false
                 nil)
                (not
                 (lambda (x) (if x nil t)))
                (nullp
                 not)
                (pairp
                 (lambda (x) (not (atom x))))
                (eqv
                 (lambda (x y) (eq x y)))

                (assp
                 (lambda (p l)
                   (if (nullp l) false
                       (if (p (car (car l))) (car l)
                           (assp p (cdr l))))))

                (var
                 (lambda (c) (cons 'var c)))
                (varp
                 (lambda (x) (if (pairp x) (eq (car x) 'var) nil)))
                (var=p
                 (lambda (x1 x2) (eqv (cdr x1) (cdr x2))))

                (walk (lambda (u s)
                        (letrec ((pr (if (varp u) (assp (lambda (v) (var=p u v)) s) nil)))
                          (if pr (walk (cdr pr) s) u))))

                (ext-s (lambda (x v s) (cons (cons x v) s)))

                (mzero '())
                (unit (lambda (s/c) (cons s/c mzero)))

                (unify
                 (lambda (u1 v1 s)
                   ((lambda (u v)
                      (if (if (varp u) (if (varp v) (var=p u v) nil) nil) s
                          (if (varp u) (ext-s u v s)
                              (if (varp v) (ext-s v u s)
                                  (if (if (pairp u) (pairp v) nil)
                                      ((lambda (s) (if s (unify (cdr u) (cdr v) s) nil))
                                       (unify (car u) (car v) s))
                                      (if (eqv u v) s nil))))))
                    (walk u1 s) (walk v1 s))))

                (== (lambda (u v)
                      (lambda (s/c)
                        (letrec ((s (unify u v (car s/c))))
                          (if s (unit (cons s (cdr s/c))) mzero)))))

                (call/fresh (lambda (f)
                              (lambda (s/c)
                                (letrec ((c (cdr s/c)))
                                  ((f (var c)) (cons (car s/c) (+ c 1)))))))

                (mplus
                 (lambda (x1 x3)
                   (if (nullp x1) x3
                       (if (pairp x1) (cons (car x1) (mplus (cdr x1) x3))
                           (lambda () (mplus x3 (x1)))))))

                (bind
                 (lambda (x g)
                   (if (nullp x) mzero
                       (if (pairp x) (mplus (g (car x)) (bind (cdr x) g))
                           (lambda () (bind (x) g))))))

                (disj (lambda (g1 g2) (lambda (s/c) (mplus (g1 s/c) (g2 s/c)))))
                (conj (lambda (g1 g2) (lambda (s/c) (bind (g1 s/c) g2))))

                (empty-state
                 '((((var dummy))) . 0))

                (pull
                 (lambda (x)
                   (if (if (nullp x) t (pairp x)) x (pull (x)))))

                (take-all
                 (lambda (x)
                   ((lambda (x) (if (nullp x) '() (cons (car x) (take-all (cdr x)))))
                    (pull x))))

                (take
                 (lambda (n x)
                   (if (= n 0) '()
                       ((lambda (x) (if (nullp x) '() (cons (car x) (take (- n 1) (cdr x)))))
                        (pull x)))))
                )
             (current-env)
             ))