(define lambda?
  (lambda (x)
    (and (not (null? x))
         (eqv? (car x) 'lambda))))

(define if-exp?
  (lambda (x)
    (and (not (null? x))
         (eqv? (car x) 'if))))

(define extend-env
  (lambda (vars env)
    (cons vars env)))

(define find-env
  (lambda (a env)
    (letrec ([find-env-helper 
           (lambda (a env depth)
             (if (null? env)
                 #f
                 (if (member a (car env))
                     (list a ': depth (list-index a 0 (car env)))
                     (find-env-helper a (cdr env) (+ 1 depth))
                 )))]
             [list-index 
              (lambda (a index lst)
                (if (null? lst)
                    #f
                    (if (eqv? a (car lst))
                        index
                        (list-index a (+ 1 index) (cdr lst)))))])
      (find-env-helper a env 0))))

(define lex-addr
  (lambda (exp env)
                (cond
                  ((null? exp) '())
                  ((symbol? exp)   
                   (let ([addr (find-env exp env)])
                     (if (eq? addr #f)
                         (list exp 'free)
                         addr)))
                  ((lambda? exp)
                   (cons (car exp)
                         (cons (cadr exp)
                               (list 
                                (lex-addr (caddr exp)
                                          (extend-env (cadr exp) env))))))
                  ((if-exp? exp) 
                   (list (car exp) 
                         (lex-addr (cadr exp) env) 
                         (lex-addr (caddr exp) env) 
                         (lex-addr (cadddr exp) env) ))
                  (else (append (list (lex-addr (car exp) env))
                                (lex-addr (cdr exp) env))))))

(define lexical-address
  (lambda (exp)
    (lex-addr exp '())))