; This is code you can add to your interpreter for part b.
(define display-traced-output
  (let ([multi-indent-string
	 (lambda (level)
	   (let loop ([level level] [result ""])
	     (if (zero? level)
		 result
		 (loop (- level 1) (string-append result "| ")))))])
  (lambda args; (level proc-name args) or (level answer)
    (let ([indent-string (multi-indent-string (car args))])
      (display indent-string)
      (display (if (= 2(length args))
		   (cadr args)
		   (cons (cadr args) (caddr args)))))
      (newline))))

;  -------------- Test cases for option (a)
(eval-one-exp (quote
(let ([v (vector 0 2)])
    (for ((vector-set! v 0 1)
	  (< (vector-ref v 0) 5)
	  (vector-set! v 0 (+ 1 (vector-ref v 0))))
	 (vector-set! v 1 (+ (vector-ref v 0)
			     (vector-ref v 1))))
    (list (vector-ref v 0) (vector-ref v 1)))))

; for simpler debugging you might want to first try this with
; [n 3] and [lengths '(0 1 2 3)], or [n 2] and [lengths '(0 1 2)]
(eval-one-exp (quote
(let ([n 6]
      [row 0]
      [col 0]
      [lengths '(0 1 2 3 4 5 6)])
 (let ([result
	(list->vector
	 (map (lambda (i)
		(make-vector (+ 1 i) 1))
	      lengths))])
  (for ((set! row 2) (<= row n) (set! row (+ 1 row)))
    (for ((set! col 1) (< col row) (set! col (+ 1 col)))
     (vector-set! (vector-ref result row)
		  col
		  (+ (vector-ref (vector-ref result (- row 1))
				 (- col 1) )
		     (vector-ref (vector-ref result (- row 1))
				 col )))))
  (map vector->list (vector->list result))))))


;  --------------  Test cases for option (b).
(eval-one-exp (quote
(let ([a (trace-lambda aa (n)
          (+ 1 n))])
  (let ([b (trace-lambda bb (n m)
            (+ m (a n)))])
    ((trace-lambda cc (n)
		   (+ n (b n (a n))))
     (a 3))))))

(eval-one-exp (quote
(let ([a 2])
  (let ([g (let ([b (+ a 3)])
	     (trace-lambda g (x y) 
	       (+ x y b)))])
    ((trace-lambda r (x) (g (g x 2) 1))
     7)))))

(eval-one-exp (quote
(let ([f1 (trace-lambda f1 (b c) (+ b c))]
      [f2 (trace-lambda f2 (x) (* x x ))])
  (let ([f3 (trace-lambda f3 (x y) 
	      (f2 (f1 (+ x y) 1)))])
    (let ([f4 (trace-lambda f4 (x) 
	        (f3 (f2 4) (f3 x 3)))])
      (f4 (f4 2)))))))

(eval-one-exp (quote
(let ([f1 (trace-lambda f1 (x y) (+ x y))]
      [f2 (lambda (n) (+ n 3))]
      [f3 (trace-lambda f3 (t) (+ 8 t))])
  (f1 (f1 (f2 (f3 4)) (f2 5)) 6))))