(define foo null)
(define a 5)
(define x 4)
(* 3 (+ (let/cc cont
          (set! foo cont)
          (/ 4 x))
        a))
(define product0
  (lambda (lst)
    (if (null? lst)
        1
        (multiply (car lst) (product0 (cdr lst))))))

(define product1
  (lambda (lst)
    (cond
      ((null? lst) 1)
      ((zero? (car lst)) 0)
      (else (multiply (car lst) (product1 (cdr lst)))))))

(define product
  (lambda (lst)
    (let/cc escape
      (letrec ((kernel 
                (lambda (lst)
                  (cond
                    ((null? lst) 1)
                    ((zero? (car lst)) (escape 0))
                    (else (multiply (car lst) (kernel (cdr lst))))))))
        (kernel lst)))))

(define multiply
  (lambda (x y)
    (let ((result (* x y)))
      (display x)
      (display "*")
      (display y)
      (display "=")
      (display result)
      (newline)
      result)))

(define silly
  (lambda (a x def)
    (times 3 
       (plus
        (divide 4 x)
        a))))

(define times
  (lambda (val1 val2)
    (let ((result1 val1)
          (result2 val2))
      (cond
        ((not (number? val1))
         val1)
        ((not (number? val2))
         val2)
        (else (* val1 val2))))))

Continuations permit exceptions!