컨트롤러 구간 하나가 여러 호출자로 돌아갈 수 있다.

(begin
  (define controller
    (vector
      '(assign val constant 3)
      '(assign continue constant 3)
      '(goto 9)
      '(assign left copy val)
      '(assign val constant 5)
      '(assign continue constant 7)
      '(goto 9)
      '(assign result add left val)
      '(halt)
      '(assign val double val)
      '(goto-register continue)))
  (define (register-index name)
    (cond ((eq? name 'val) 0)
          ((eq? name 'left) 1)
          ((eq? name 'result) 2)
          ((eq? name 'continue) 3)
          ((eq? name 'pc) 4)))
  (define (run-machine)
    (let ((registers (vector 0 0 0 0 0))
          (path '())
          (return-addresses '()))
      (define (get name)
        (vector-ref registers (register-index name)))
      (define (put! name value)
        (vector-set! registers (register-index name) value))
      (define (advance!) (put! 'pc (+ (get 'pc) 1)))
      (define (assignment instruction)
        (let ((operation (caddr instruction)))
          (cond ((eq? operation 'constant)
                 (cadddr instruction))
                ((eq? operation 'copy)
                 (get (cadddr instruction)))
                ((eq? operation 'double)
                 (* 2 (get (cadddr instruction))))
                ((eq? operation 'add)
                 (+ (get (cadddr instruction))
                    (get (list-ref instruction 4)))))))
      (define (execute remaining-steps)
        (if (= remaining-steps 0)
            'step-limit
            (let* ((pc (get 'pc))
                   (instruction (vector-ref controller pc))
                   (operation (car instruction)))
              (set! path (cons pc path))
              (cond
                ((eq? operation 'halt)
                 (list (get 'result)
                       (reverse return-addresses)
                       (reverse path)))
                ((eq? operation 'assign)
                 (let ((target (cadr instruction))
                       (value (assignment instruction)))
                   (put! target value)
                   (if (eq? target 'continue)
                       (set! return-addresses
                             (cons value return-addresses)))
                   (advance!)
                   (execute (- remaining-steps 1))))
                ((eq? operation 'goto)
                 (put! 'pc (cadr instruction))
                 (execute (- remaining-steps 1)))
                ((eq? operation 'goto-register)
                 (put! 'pc (get (cadr instruction)))
                 (execute (- remaining-steps 1)))))))
      (execute 100)))
  (run-machine))