anchor.diff:  
   (defun assignment-val (exp)
     (caddr exp))
  -
  -(defun eval-definition (exp env)
  -  (let ((var (definition-var exp))
  -	(val (definition-val exp)))
  -    (define-variable! (env-first-frame env)
  -	var
  -      (t-eval val env))
  -    'ok))
  -
  -(defun eval-assignment (exp env)
  -  (format t "eval-assignment: exp=~a~%" exp)
  -  (format t "eval-assignment: env=~a~%" env)
  -  (let ((var (assignment-var exp))
  -	(val (t-eval (assignment-val exp)) env))
  -    (set-variable-value! env var val)
  -    'ok))
   
   (defun define-variable! (frame var val)
     (labels ((iter (vars vals)
  
positive.code: (defun lambda-p (exp)
    (tagged-list-p exp 'lambda))
  
  (defun eval-lambda (exp env)
    (make-procedure exp env))
  
  (defun make-procedure (exp env)
    (let ((parameters (lambda-parameters exp))
  	(body (lambda-body exp)))
      (format t "lambda: ~a~%" exp)
      (format t "lambda parameters: ~a~%" parameters)
      (format t "lambda body: ~a~%" body)
     `(procedure ,parameters ,body ,env)))
  
  (defun procedure-parameters (procedure)
    (cadr procedure))
  
  (defun procedure-body (procedure)
    (caddr procedure))
  
  (defun procedure-env (procedure)
  
negative.code: 
  (defun apply-compound-procedure (procedure args)
    (let ((vars (procedure-parameters procedure))
  	(body-proc (procedure-body-proc procedure))
  	(env (procedure-env procedure)))
      (let ((extended-env (env-extend env vars args)))
        (format t "apply-cp vars: ~a~%" vars)
        (format t "apply-cp args: ~a~%" args)
        (format t "apply-cp body: ~a~%" body-proc)
        (format t "apply-cp env: ~a~%" extended-env)
        (funcall body-proc extended-env))))
  
  (defun to-boolean (exp)
    (if (null exp)
  