(def myEval (lambda (myList Env) ;  evaluate myList in Env
	(cond
		((null myList) nil)
		((atom myList) 
			(cond
				; missing case
				(t (Lookup myList Env))))
		((eq (car myList) (quote quote)) (car (cdr myList)))
		((eq (car myList) (quote cond))
			(EvalCond (cdr myList) Env))
		(t (myApply (car myList)
			(EvalList (cdr myList) Env) Env)))
))

(def myApply (lambda (Fct Parms Env) ;  apply Fct to Parms
	(cond
		((atom Fct) (cond
			((eq Fct (quote car)) (car (car Parms)))
			((eq Fct (quote cdr)) (cdr (car Parms)))
			((eq Fct (quote cons))
				(cons (car Parms) (car (cdr Parms))))
			; ignoring get
			((eq Fct (quote atom)) (atom (car Parms)))
			((eq Fct (quote error)) (error (car Parms)))
			((eq Fct (quote eq))
				(eq (car Parms) (car (cdr Parms))))
			(t (cond
				 ; ignoring another case
				(t (myApply (Lookup Fct Env)
					Parms Env)))))
		) ;  (atom Fct) 
		((eq (car Fct) (quote lambda))
			(myEval (car (cdr (cdr Fct)))
				(Update (car (cdr Fct)) Parms Env)))
		(t (myApply (myEval Fct Env) Parms Env)))
))

(def EvalCond (lambda (Conds Env) ;  evaluate cond
	(cond
		((null Conds) nil) ;  could treat as error
		((myEval (car (car Conds)) Env)
			(myEval (car (cdr (car Conds))) Env))
		(t (EvalCond (cdr Conds) Env)))
))

(def EvalList (lambda (myList Env) ;  evaluate list
	(cond
		((null myList) nil)
		(t (cons (myEval (car myList) Env)
			(EvalList (cdr myList) Env))))
))

(def Lookup (lambda (Id Env) ;  lookup Id
	(cond
		((null Env) (error (quote UnboundVar)))
		((eq Id (car (car Env))) (car (cdr (car Env))))
		(t (Lookup Id (cdr Env))))
))

(def Update (lambda (Formals Actuals Env) ;  bind parameters
	(cond
		((null Formals)
			(cond ((null Actuals) Env)
				(t (error (quote ArgCount)))))
		((null Actuals) (error (quote ArgCount)))
		(t (cons
			(cons (car Formals) (cons (car Actuals) nil))
			(Update (cdr Formals) (cdr Actuals) Env)))
	)
))