;;; -*- Mode:LISP; Package:LISP-INTERNALS; Base:10; Readtable:CL -*-

;;;;;;;;;;;Known Bugs;;;;;;;;;;;;;;;
;;; This file is being tested using the code in K-SYS:K;STACK-GROUP-TOGGLE.
;;; Stack-group-toggle sets up two control-pdl's and swaps them back and
;;; forth, dumping and restoring along its merry way. This has revealed several bugs.
;;; Some of this code has been written in assembler. This is because the
;;; compiler has a bug. The lisp code that generated the assembler is nearby
;;; and should be used as a reference only as slight changes in the assembler
;;; have been made since.
;;; After restoring a dumped control-pdl the frame associated with the currently running
;;; function is not correct.
;;; I suspect that frames are not being properly returned to the heap by the
;;; dumper. Something needs to be written for inspecting the current state of the heap
;;; and comparing that to the frames on the call stack.


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; OPERATIONS ON CONTROL PDLs

;;; SWAP IN AND WIRE
;;; The control PDL (or at least the part being dumped to) must be wired
;;; since the call hardware dumper isn't allowed to take page faults (or
;;; any call hardware operation).

;;; UNWIRE
;;; only the current control pdl need be wired.

;;; ASSURE SPACE TO DUMP IN
;;; For the current stack group, there must be enough remaining space in the
;;; control pdl (which must be wired) to hold what could potentially be the
;;; entire state of the call hardware.

;;; GROW
;;; control flow for the program might have a deep enough call stack
;;; that the previously allocated control pdl might not be big enough.
;;; this operation is similar to that of growing arrays.
;;; Wiring and unwiring must occur when a bigger control pdl is created.

;;; CONTEXT SWITCH
;;; when a context switch between stack groups occurs the entire call hardware
;;; state must be dumped into the control pdl associated with the outgoing
;;; stack group and restored from the control pdl state of the incomming stack group.
;;; These operations are similar to overflow and underflow handling.
;;; Wiring and unwiring occur at this point.

;;; HANDLE OVERFLOW
;;; when the program overflows the call hardware then its state must be dumped
;;; to the control pdl and restored later.  This dumping must occur on call boundaries.

;;; HANDLE UNDERFLOW
;;; when the program does more returns than the call hardware remembers and there
;;; was previously an overflow, then the state that was dumped to service the overflow
;;; must now be restored.  If there was no previously dumped state then the machine
;;; will have returned to the event horizon.

;;; SCAVENGE
;;; The control pdl must be scavenged in a manner similar to the way the registers
;;; are scavenged.  The scavenger must touch those pieces of the dumped call hardware state
;;; which are boxed, and only those which are boxed.

;;; TOOLS FOR THE DEBUGGER TO LOOK AT THEM
;;; It is probably the case that the debugger will run in a different stack group than
;;; the program being debugged.  In this case, the entire state of the call hardware
;;; for the debugged stack group will be represented in a control pdl.


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; at the base of the call hardware stack a CALL has just occurred.
;;; That call will have come from the call stack underflow handler.

;;; The call stack underflow handler (catcher) uses register set #xff for O and A.
;;; At the base of the call stack will be an entry which will return #xff to O and A,
;;; and the RPC will be a routine which preserves the return values, scrolls the call
;;; stack, and returns with the preserved return values.
;;; This is why the call hardware may only be scrolled so that the base is at a call boundary.

;;; These global registers are used by the control pdl code:
;;;  GR:*CONTROL-PDL*		contains the currently active control pdl.
;;;  GR:*CONTROL-PDL-POINTER*	virtual address into the current control pdl where the next
;;;				record will be written as an unboxed locative.
;;;  GR:*CONTROL-PDL-LIMIT*	if GR:*CONTROL-PDL-POINTER* reaches this then the control pdl is full. 
;;;  GR:*CH-BASE-CSP*		the value of the call stack pointer above which the call stack is valid.
;;;  GR:*CH-TEMP-0*		temporaries used by the call hardware dumper and restorer while
;;;  GR:*CH-TEMP-1*		they can't use locals
;;;  GR:*CH-TEMP-2*
;;;  GR:*CH-TEMP-3*
;;;  GR:*CH-TEMP-4*
;;;  GR:*CH-TEMP-5*
;;;  GR:*CH-TEMP-6*
;;;  GR:*CH-CONTROL-PDL-INDEX*	used by the restorer.  (could just be another temporary)


;;; The control pdl object.  Control pdls are arrays of type ART-CONTROL-PDL.

;;; At the base of each control pdl are several words used for bookkeeping.  Immediately after
;;; these words the call hardware dump starts.  These words include
;;;    - pointer to the stack group it belongs to
;;;    - the allocation pointer where dumping continues

;;; The limit after which the control pdl structure must be grown to accomodate more call records
;;; can be calculated from the control pdl's size.

;;; Each frame of the control pdl consists of CONTROL-PDL-FRAME-SIZE words.
;;; The first word contains:
;;;    - the type code: OPEN, OPEN-CALL, TOPEN (2 bits), PROTECTED-OPEN-CALL,
;;;    - the return-destination (7 bits),
;;;    - the global return destination (4 bits) and
;;;    - 16 box bits for the saved registers
;;; The second word contains the typed RPC
;;; The third through eighteenth words contain the saved registers.
(defconstant %%cpdl0-type-code		(byte 2 0))
(defconstant %%cpdl0-rdest		(byte 7 2))
(defconstant %%cpdl0-global-frame	(byte 4 9))
(defconstant %%cpdl0-box-bits		(byte 16 16))	;register zero's box bit is LSB of this field
(defconstant $$cpdl0-type-open			0)	;for type code field
(defconstant $$cpdl0-type-open-call		1)
(defconstant $$cpdl0-type-topen			2)
(defconstant $$cpdl0-type-protected-open-call	3)

(defconstant control-pdl-frame-size 18)
(defconstant control-pdl-frame-offset-to-registers 2)

;;; The control pdl could be full of OPEN-CALL TOPEN frames
(defconstant max-call-hardware-dump (* 2 control-pdl-frame-size 256)
  "The largest possible size that a call hardware dump can be")

(defvar control-pdl-area nil
  "This is the area in which control pdls live")

(defun make-control-pdl-area ()
  (when (or (not (boundp 'control-pdl-area))
	    (null control-pdl-area))
    (setq control-pdl-area
	  (area-data:make-area
	    7 (vinc:dpb-multiple-boxed
		(ceiling max-call-hardware-dump vinc:*qs-in-cluster*) 	region-bits:%%region-bits-swapin-quantum
		region-bits:$$scavenge-enabled				region-bits:%%region-bits-scavenge-bit
		region-bits:$$region-read-write				region-bits:%%region-bits-read-only
		region-bits:$$region-space-structure			region-bits:%%region-bits-space-type
		region-bits:$$region-new-space				region-bits:%%region-bits-new-space
		;;; what should this really be:
		region-bits:$$region-fixed				region-bits:%%region-bits-flippable
		region-bits:$$region-internal-memory			region-bits:%%region-bits-external-bus
		0) 10))))
	 
(defconstant control-pdl-allocation-quantum  ;;#x4800
	     (* 2 max-call-hardware-dump)
  "amount by which a control pdl is grown when it fills up")	;at least enough for one full call hardware dump

;;; The zeroth slot of the control pdl contains a pointer 
;;; back to the stack group to which the control pdl belongs.
(defmacro CONTROL-PDL-STACK-GROUP (control-pdl)
  "Return the stack group associated with the CONTROL-PDL"
  `(array:%vm-read (hw:24+ 1 ,control-pdl)))

(defmacro SET-CONTROL-PDL-STACK-GROUP (control-pdl stack-group)
  "Set the stack group associated with CONTROL-PDL to STACK-GROUP"
  `(array:%vm-write (hw:24+ 1 ,control-pdl) ,stack-group))

;;; The first slot of the control pdl contains the saved value of the control pdl pointer
;;; when the control pdl is not the current one.
(defmacro CONTROL-PDL-POINTER (control-pdl)
  "Return the saved value of CONTROL-PDL's top of stack pointer"
  `(array:%vm-read (hw:24+ 2 ,control-pdl)))

(defmacro SET-CONTROL-PDL-POINTER (control-pdl new-pointer)
  "Changes the saved value of CONTROL-PDL's top of stack pointer to NEW-POINTER"
  `(array:%vm-write (hw:24+ 2 ,control-pdl) ,new-pointer))

(defconstant control-pdl-base 3
  "Add to a control-pdl objects pointer to find the base for call hardware dumps")

(defun make-control-pdl (stack-group &optional (total-size control-pdl-allocation-quantum))
  (setq total-size (* (ceiling (max total-size control-pdl-allocation-quantum)
			       vinc:*qs-in-cluster*)
		      vinc:*qs-in-cluster*))	;must fall on cluster boundary (for ease in wiring).
  (let ((control-pdl (cons:allocate-structure-in-area
		       control-pdl-base					;3 words including header
		       (- total-size 3)
		       vinc:$$dtp-array
		       (vinc:dpb-multiple-boxed
			 (1- total-size)		array::%%bounds	;don't count header word
			 array:art-control-pdl		array::%%sv-art
			 vinc:$$dtp-array-header-single	vinc:%%data-type
			 0)
		       control-pdl-area)))
    ;;; touch each page
    (do ((i 3 (1+ i)))
	((>= i (1- total-size)))
      (array:%vm-write32 control-pdl i (hw:unboxed-constant 0)))
    (set-control-pdl-pointer control-pdl control-pdl-base)
    (set-control-pdl-stack-group control-pdl stack-group)
    control-pdl))

;control-pdl-p is array:control-pdl-p and this one don't work too good anyhow
;(defun control-pdl-p (object)
;  (and (array:arrayp object)
;       (= array:art-control-pdl
;	  (hw:ldb object array::%%sv-art 0))))

(defsubst control-pdl-empty-p (control-pdl)
  (progn (when (< (control-pdl-pointer control-pdl) control-pdl-base)
	   (error "control-pdl-pointer below control-pdl-base"))
	 (<= (control-pdl-pointer control-pdl) control-pdl-base)))

(defsubst control-pdl-limit (control-pdl)
  "if control-pdl-pointer reaches here we are out of room"
  (hw:ldb (array:%vm-read32 control-pdl 0) array::%%bounds 0))

(defun control-pdl-assure-room (control-pdl)
  (if (>= (+ (control-pdl-pointer control-pdl)
	     max-call-hardware-dump)		;max size of call hardware
	  (control-pdl-limit control-pdl))
      (grow-control-pdl control-pdl)
    control-pdl))

(defun grow-control-pdl (control-pdl)
  (let* ((stack-group (control-pdl-stack-group control-pdl))
	 (new-control-pdl (make-control-pdl stack-group
					    (+ (control-pdl-limit control-pdl)
					       control-pdl-allocation-quantum))))
    ;;; this will copy stack-group, pointer and the dumped call hardware state
    (do ((offset 1 (1+ offset))
	 (end (control-pdl-limit control-pdl)))
	((>= offset end))
      (array:%vm-write32 new-control-pdl offset
			 (array:%vm-read32 control-pdl offset)))
    ;;; change the control pdl in the stack group
    ;(setf (sg-control-pdl stack-group) new-control-pdl)  ;**** causes it to bomb --rg 2/21/88
    (set-control-pdl-stack-group control-pdl nil)	;disassociate the old control pdl from any stack group
    new-control-pdl))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; The state of the current control pdl is stored in global registers rather than
;;; in the object itself.  These are used to maintain consistency and for context switching.

(defsubst save-control-pdl-state ()
  (set-control-pdl-pointer gr:*control-pdl*
			   (hw:ldb (hw:24- gr:*control-pdl-pointer* gr:*control-pdl*)
				   (byte 24 0) 0)))

(defsubst load-control-pdl-state ()
  (macrolet ((index-to-address (index)
	       `(cons:make-pointer vinc:$$dtp-unboxed-locative
				   (hw:24+ gr:*control-pdl* ,index))))
    (setq gr:*control-pdl-limit*   (index-to-address (control-pdl-limit gr:*control-pdl*))
	  gr:*control-pdl-pointer* (index-to-address (control-pdl-pointer gr:*control-pdl*)))))

(defun select-control-pdl (control-pdl)
  "Set up the global registers associated with the call hardware dump/restore code
to use CONTROL-PDL.  The previous values are stored in the outgoing control pdl"
  ;;; make sure it is a control pdl
  (unless (array::control-pdl-p control-pdl)
    (trap:illop "This is not a control pdl"))	; control-pdl
  (save-control-pdl-state)
  (setq gr:*control-pdl* control-pdl)
  (load-control-pdl-state))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; hooks for the debugger
;;; read and modify registers in a frame

;(defun control-pdl-depth (control-pdl)
;  "Index of topmost frame of control pdl"
;  (floor (- (control-pdl-pointer control-pdl) control-pdl-base)
;	 control-pdl-frame-size))

;(defun control-pdl-frame-info (control-pdl frame-number)
;;  (declare (values type rpc rdest global-frame))
;  (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number)))
;	word0 word1)
;    (when (>= frame-index (control-pdl-pointer control-pdl))
;      (li:error "frame not in control pdl"))
;    (setq word0 (array:%vm-read32 control-pdl frame-index))
;    (setq word1 (array:%vm-read32 control-pdl (1+ frame-index)))
;    (values (hw:ldb word0 %%cpdl0-type-code 0)		;type
;	    word1					;RPC
;	    (hw:ldb word0 %%cpdl0-rdest	0)		;RDEST
;	    (hw:ldb word0 %%cpdl0-global-frame 0))))	;global frame

;(defun control-pdl-frame-examine-register (control-pdl frame-number register-number)
;  (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number)))
;	box-bits datum)
;    (when (>= frame-index (control-pdl-pointer control-pdl))
;      (li:error "frame not in control pdl"))
;    (setq box-bits (hw:ldb (array:%vm-read32 control-pdl frame-index) %%cpdl0-box-bits 0))
;    (setq datum (array:%vm-read32 control-pdl (+ control-pdl-frame-offset-to-registers
;						 register-number frame-index)))
;    (if (hw::32logbitp register-number box-bits)
;	(hw:dpb-boxed datum (byte 32 32) (hw:unboxed-constant 0))	;make boxed
;      datum)))								;unboxed

;(defun control-pdl-frame-modify-register (control-pdl frame-number register-number new-value boxed-p)
;  (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number)))
;	word0)
;    (when (>= frame-index (control-pdl-pointer control-pdl))
;      (li:error "frame not in control pdl"))
;    (setq word0 (array:%vm-read32 control-pdl frame-index))
;    (flet ((change-datum ()
;	     (array:%vm-write32 control-pdl (+ control-pdl-frame-offset-to-registers
;					 register-number frame-index) new-value))
;	   (change-box-bit ()
;	     (array:%vm-write32 control-pdl frame-index
;			  (hw:dpb (hw:dpb (if boxed-p 1 0)
;					  (byte 1 register-number)
;					  (hw:ldb word0 %%cpdl0-box-bits 0))
;				  %%cpdl0-box-bits
;				  word0))))
;      (if boxed-p				;try and do this safely
;	  (progn (change-datum)
;		 (change-box-bit))
;	(progn (change-box-bit)
;	       (change-datum))) )))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;(defun scavenge-control-pdl (control-pdl)
;  (macrolet ((scavenge-word (word)
;	       `(hw:vma-start-read ,word)))
;    (SCAVENGE-WORD (control-pdl-stack-group control-pdl))
;    (do ((frame-offset control-pdl-base (+ frame-offset control-pdl-frame-size))
;	 (end (control-pdl-pointer control-pdl))
;	 frame-box-bits)
;	((>= frame-offset end))
;      (setq frame-box-bits (hw:ldb (array:%vm-read32 control-pdl frame-offset)
;				   %%cpdl0-box-bits 0))
;      ;;; scavenge the pc also
;      (dotimes (register 16)
;	(when (hw:32logbitb register frame-box-bits)
;	  (SCAVENGE-WORD (array:%vm-read32 control-pdl			;do we need to make sure it is boxed
;					   (+ frame-offset		;in case the transporter refuses to move it?
;					      control-pdl-frame-offset-to-registers
;					      register)))) )) ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; we should maybe use a vanilla global variable for the interlock
(defmacro DUMPING-OR-RESTORING-CALL-HARDWARE (doing-it)
  (let ((interlock 'gr:*ch-dumper-return-pc*))
    (if doing-it
	`(progn
	   (unless (null ,interlock)
	     (trap:illop "call hardware dump or restore entered recursively"))
	   (setq ,interlock t))
      `(setq ,interlock nil))))

(defmacro set-rpc-rdest (rpc rdest global-frame)
  `(let ((rpc-rdest (hw:dpb ,rdest hw:%%ch-rpcd-return-dest ,rpc)))
     (hw:trap-off)
     ;;;once Kent fixes the hardware we won't need to do the hack with SPARE-17 any more.
     (hw:write-processor-control
       (vinc:dpb-multiple-unboxed
	 ,global-frame	hw:%%processor-control-misc
	 1		hw:%%processor-control-spare-17
	 (hw:read-processor-control)))
     (hw:nop) (hw:nop) (hw:nop) (hw:nop)
     (hw:write-return-pc-return-dest rpc-rdest)
     (hw:nop)
     (hw:ch-open-call)
     (hw:write-processor-control
       (hw:dpb-unboxed 0 hw:%%processor-control-spare-17
		       (hw:read-processor-control)))
     (hw:nop) (hw:nop)
     (hw:write-memory-control
       (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable
		       (hw:read-memory-control)))))

(defmacro FORGE-CATCHER-FRAME ()
  `(set-rpc-rdest (k2:%compiled-function-code
		    (symbol-function
		      'call-hardware-underflow-catcher))
		  (vinc::dpb-multiple-unboxed
		    hw:$$i-reg-base-active	hw:%%i-reg-base	; return destination A0
		    0				hw:%%i-reg-offset
		    (hw:unboxed-constant 0))
		  0))

;;; This is what lives at the bottom of the call hardware stack.  It is never called.  Things return
;;; to it at PC offset 0.  The macro FORGE-CATCHER-FRAME knows how to install it.  Be sure the call hardware is
;;; empty when you install it otherwise the frames below it will be lost.
(defun CALL-HARDWARE-UNDERFLOW-CATCHER (result)
  ;;; traps are on.  This is guaranteed by some hack somewhere.
  ;;; Forge an open call frame onto the control pdl.
  ;;; It should look like this:
  ;;;    RPC:		either CALL-HARDWARE-UNDERFLOW-RETURN-MULTIPLE-VALUES or CALL-HARDWARE-UNDERFLOW-RETURN-1-VALUE.
  ;;;    RDEST:		ignore, return-frame-0.
  ;;;    type:		unprotected open-call.
  ;;;    boxed bits:	register zero is same as result, all others unboxed.
  ;;;    global frame:	doesn't matter.
  ;;;    registers:	saved A0 has value of RESULT, all others are unboxed zero.
  (if (control-pdl-empty-p gr:*control-pdl*) 
      (trap:illop "Control PDL is empty")	; if the control pdl is empty we should loose in some appropriate way
    (let ((return-function (if (hw:return-code-mv-p)
			       'call-hardware-underflow-return-multiple-values 
			     'call-hardware-underflow-return-1-value))
	  (word-1 (vinc:dpb-multiple-unboxed
		    (hw:accumulate-box-bits (hw:unboxed-constant 0) result)	%%cpdl0-box-bits
		    $$cpdl0-type-open-call					%%cpdl0-type-code
		    (vinc:dpb-multiple-unboxed
		      hw:$$i-reg-base-return	hw:%%i-reg-base
		      0				hw:%%i-reg-offset
		      (hw:unboxed-constant 0))					%%cpdl0-rdest
		    0								%%cpdl0-global-frame
		    (hw:unboxed-constant 0))))
      (macrolet ((control-pdl-write-word (word)
		   `(progn (hw:write-md-unboxed ,word)
			   (hw:vma-start-write-no-gc-trap-unboxed gr:*control-pdl-pointer*)
			   (setq gr:*control-pdl-pointer* (hw:24+ 1 gr:*control-pdl-pointer*)))))
	(control-pdl-write-word word-1)
	(control-pdl-write-word (k2:%compiled-function-code (symbol-function return-function)))
	(control-pdl-write-word result) 		 (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))
	(control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)))
      (restore-call-hardware))))

(defun call-hardware-underflow-return-1-value (value)
  (hw:return value))

(defun call-hardware-underflow-return-multiple-values (value)
  (hw:return-mv value))

(defun where-to-restore-from-control-pdl (control-pdl)
  ;;; find a place to start restoring the call hardware from.  Must be an unprotected open-call frame
  (do* ((control-pdl-index (- (control-pdl-pointer control-pdl) control-pdl-frame-size)
			   (- control-pdl-index control-pdl-frame-size))
	(number-of-frames 0 (1+ number-of-frames))
	open-call-index
	(open-call-index-number-of-frames 0))
       (nil)
    (cond ((= control-pdl-index control-pdl-base)	;empty control pdl?
	   (return control-pdl-base))
	  ((>= open-call-index-number-of-frames (floor 256 3))	;one third of call hardware size?
	   (return open-call-index))
	  ((< control-pdl-index control-pdl-base)
	   (trap:illop "phase error in control pdl"))
	  ((hw:field= (array::%vm-read32 gr:*control-pdl* control-pdl-index)
		      $$cpdl0-type-open-call
		      %%cpdl0-type-code)
	   (setq open-call-index control-pdl-index
		 open-call-index-number-of-frames number-of-frames)))))

;;; should get called with traps ON!

(defafun restore-call-hardware ()
      P_248
         (MOVE NOP (REGISTER *CH-DUMPER-RETURN-PC* 7 10) BOXED-RIGHT)
         (TEST BR-ZERO)
         (BRANCH B_262 NIL)
      C_250
         (MOVEI O0 (QUOTE 376) BOXED CH-OPEN)
	 (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL)
      B_262
         (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE T) BOXED)
         (MOVEI O0 (QUOTE CALL-HARDWARE-UNDERFLOW-CATCHER) BOXED CH-OPEN)
         (CALL (SYMBOL-FUNCTION 1) (NEW-OPEN 0) NIL)
         (CALL (k2:%COMPILED-FUNCTION-CODE 1) R2 NIL)
         (MOVEI R0 16 UNBOXED)
         (ALU-FIELD FIELD-PASS r8 R0 R2 (QUOTE 1816) PW-II DT-NONE BOXED-RIGHT)
         (MOVE IGNORE TRAP-OFF)
         (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
         (ALU-FIELD FIELD-PASS R2 (REGISTER *ONE* 4 1) R2 (QUOTE 273) PW-II DT-NONE UNBOXED)
         (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 1033) PW-II 
                    DT-NONE UNBOXED)
         (NOP)
        (NOP)
        (NOP)
        (NOP)
        (MOVE RETURN-PC-RETURN-DEST r8 BOXED-RIGHT)
        (NOP)
        (OPEN-CALL (0 0) IGNORE NIL NEXT-PC-PC+1)
        (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 273) PW-II 
                    DT-NONE UNBOXED)
        (NOP)
        (NOP)
        (MOVE R2 MEMORY-CONTROL BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE 
                    UNBOXED)
        (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
        (ALU L+R r9 R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT)
        (ALU L-R R2 (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CONTROL-PDL* 7 0) BW-24 
              BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (MD BOXED-MD) R2 (REGISTER *ZERO* 4 0) (BYTE 24 0) PW-II DT-NONE 
                    BOXED-RIGHT)
        (MOVE (VMA-START-WRITE BOXED-VMA) r9)
        (OPEN-CALL (WHERE-TO-RESTORE-FROM-CONTROL-PDL 1) r10 
                    (O0 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT))
        (MOVEI R0 (QUOTE 11) BOXED)
        (ALU-FIELD FIELD-PASS R2 R0 (REGISTER *CONTROL-PDL* 7 0) (QUOTE 1562) PW-II DT-NONE BOXED)
        (ALU L+R (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) r10 R2 BW-24 BOXED-RIGHT)
      TAGBODY_353
        (MOVE R2 CALL-SP-HP BOXED-RIGHT)
        (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-BASE-CSP* 7 9) R2 R1 (BYTE 8 0) PW-II DT-NONE 
                    BOXED-RIGHT)
        (MOVE (REGISTER *CH-TEMP-4* 7 8) (REGISTER *CONTROL-PDL-POINTER* 7 1))
        (MOVE (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
      LOOP_357
        (ALU L-R NOP (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) (REGISTER *CH-TEMP-4* 7 8) BW-24)
        (TEST BR-EQUAL)
        (BRANCH B_1986 NIL)
      C_363
      P_371
        (ALU L-R NOP (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) (REGISTER *CH-TEMP-4* 7 8) BW-24)
        (TEST BR-NOT-GREATER-THAN)
        (BRANCH B_388 NIL)
      C_372
        (MOVEI O0 (QUOTE 352) BOXED CH-OPEN)
        (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL)
      B_388
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (MEMORY-WAIT)
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
        (MOVE (REGISTER *CH-TEMP-1* 7 5) MD)
      BLOCK_401
        (ALU-FIELD FIELD-EXTRACT-R R0 IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 2 0) PW-II UNBOXED)
        (ALU L+R R1 gr:*TRAP-DTP-CODE-5* TRAP-PC+ BW-32 BOXED)
        (ALU L+R NOP R0 R1 BW-32 BOXED)
        (NOP)
        (NOP NEXT-PC-DISPATCH)
        (UNCONDITIONAL-BRANCH P_492 NIL)
        (UNCONDITIONAL-BRANCH P_405 NIL)
        (UNCONDITIONAL-BRANCH P_505 NIL)
        (UNCONDITIONAL-BRANCH P_405 NIL)
      P_402
      RESTORE-O-FRAME_526
        (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-1* 7 5) (REGISTER *CH-TEMP-1* 7 5) R1 
                    (BYTE 16 -16) PW-II DT-NONE BOXED-RIGHT)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_542
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_552 NIL)
      C_543
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_574
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_586
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_596 NIL)
      C_587
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_618
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_630
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_640 NIL)
      C_631
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_662
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_674
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
       (BRANCH C_684 NIL)
      C_675
        (MOVE R2 MD BOXED-RIGHT)
	(ALU-FIELD FIELD-PASS O3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_706
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_718
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_728 NIL)
      C_719
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_750
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_762
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_772 NIL)
      C_763
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_794
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_806
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_816 NIL)
      C_807
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_838
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_850
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_860 NIL)
      C_851
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_882
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_894
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
	(TEST BR-ZERO)
        (BRANCH C_904 NIL)
      C_895
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_926
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_938
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_948 NIL)
      C_939
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_970
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_982
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_992 NIL)
      C_983
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1014
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1026
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_1036 NIL)
      C_1027
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1058
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1070
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
	(BRANCH C_1080 NIL)
      C_1071
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1102
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1114
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_1124 NIL)
      C_1115
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1146
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1158
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_1168 NIL)
      C_1159
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1190
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1202
        (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
        (TEST BR-ZERO)
        (BRANCH C_1212 NIL)
      C_1203
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1234
        (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
        (UNCONDITIONAL-BRANCH LOOP_357 NIL)
      C_1212
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
	(UNCONDITIONAL-BRANCH B_1234 NIL)
      C_1168
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_1190 NIL)
      C_1124
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_1146 NIL)
      C_1080
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_1102 NIL)
      C_1036
        (MOVE R2 MD BOXED-RIGHT)
	(ALU-FIELD FIELD-PASS O11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_1058 NIL)
      C_992
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_1014 NIL)
      C_948
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_970 NIL)
      C_904
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_926 NIL)
      C_860
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_882 NIL)
      C_816
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_838 NIL)
      C_772
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_794 NIL)
      C_728
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_750 NIL)
      C_684
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_706 NIL)
      C_640
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_662 NIL)
      C_596
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS O1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_618 NIL)
      C_552
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS O0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
        (UNCONDITIONAL-BRANCH B_574 NIL)
      P_505
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
        (k:TAIL-OPEN)
        (UNCONDITIONAL-BRANCH RESTORE-O-FRAME_526 NIL)
      P_492
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
        (k:OPEN)
        (UNCONDITIONAL-BRANCH RESTORE-O-FRAME_526 NIL)
      P_405
        (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
        (MEMORY-WAIT)
        (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
        (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) (REGISTER *CH-TEMP-1* 7 5) R1 
                    (BYTE 7 -2) PW-II DT-NONE BOXED-RIGHT)
        (MOVE r11 (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT)
      C_428
        (MOVE R2 MD BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) r11 R2 (QUOTE 1816) PW-II DT-NONE 
                    BOXED-RIGHT)
       (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-3* 7 7) (REGISTER *CH-TEMP-1* 7 5) R1 
                    (BYTE 4 -9) PW-II DT-NONE BOXED-RIGHT)
       (MOVE IGNORE TRAP-OFF)
       (MOVE r12 (REGISTER *CH-TEMP-3* 7 7) BOXED-RIGHT)
      C_449
       (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS R2 (REGISTER *ONE* 4 1) R2 (QUOTE 273) PW-II DT-NONE UNBOXED)
       (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL r12 R2 (QUOTE 1033) PW-II DT-NONE UNBOXED)
       (NOP)
       (NOP)
       (NOP)
       (NOP)
       (MOVE RETURN-PC-RETURN-DEST (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT)
       (NOP)
       (OPEN-CALL (0 0) IGNORE NIL NEXT-PC-PC+1)
       (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 273) PW-II 
                    DT-NONE UNBOXED)
       (NOP)
       (NOP)
       (MOVE R2 MEMORY-CONTROL BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE 
                    UNBOXED)
      RESTORE-A-FRAME_1245
       (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-1* 7 5) (REGISTER *CH-TEMP-1* 7 5) R1 
                    (BYTE 16 -16) PW-II DT-NONE BOXED-RIGHT)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1261
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1271 NIL)
      C_1262
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1293
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1305
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1315 NIL)
      C_1306
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1337
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1349
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1359 NIL)
      C_1350
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1381
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1393
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1403 NIL)
      C_1394
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1425
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1437
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1447 NIL)
      C_1438
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1469
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1481
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1491 NIL)
      C_1482
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1513
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1525
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1535 NIL)
      C_1526
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1557
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1569
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1579 NIL)
      C_1570
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1601
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1613
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1623 NIL)
      C_1614
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1645
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1657
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1667 NIL)
      C_1658
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1689
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1701
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1711 NIL)
      C_1702
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1733
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1745
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1755 NIL)
      C_1746
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1777
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1789
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1799 NIL)
      C_1790
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1821
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1833
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1843 NIL)
      C_1834
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1865
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1877
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1887 NIL)
      C_1878
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1909
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) 
               (REGISTER *CH-CONTROL-PDL-INDEX* 7 3))
       (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE 
              (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT)
      P_1921
       (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II)
       (TEST BR-ZERO)
       (BRANCH C_1931 NIL)
      C_1922
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED)
      B_1953
       (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) 
                    (BYTE 0 -1) PW-II)
       (UNCONDITIONAL-BRANCH LOOP_357 NIL)
      C_1931
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1953 NIL)
      C_1887
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1909 NIL)
      C_1843
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1865 NIL)
      C_1799
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1821 NIL)
      C_1755
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1777 NIL)
      C_1711
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1733 NIL)
      C_1667
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1689 NIL)
      C_1623
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1645 NIL)
      C_1579
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1601 NIL)
      C_1535
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1557 NIL)
      C_1491
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1513 NIL)
      C_1447
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1469 NIL)
      C_1403
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1425 NIL)
      C_1359
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1381 NIL)
      C_1315
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1337 NIL)
      C_1271
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS A0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED)
       (UNCONDITIONAL-BRANCH B_1293 NIL)
      B_1986
       (MOVEI O0 "call hardware restored" BOXED CH-OPEN)
       (CALL (ERROR 1) IGNORE NIL)
       (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
       (ALU L+R r13 R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT)
       (ALU L-R r13 (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CONTROL-PDL* 7 0) BW-24 
              BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS (MD BOXED-MD) R2 (REGISTER *ZERO* 4 0) (BYTE 24 0) PW-II DT-NONE 
                    BOXED-RIGHT)
       (MOVE (VMA-START-WRITE BOXED-VMA) r13)
       (OPEN-CALL (CONTROL-PDL-ASSURE-ROOM 1) (REGISTER *CONTROL-PDL* 7 0) 
                    (O0 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT))
       (MOVE r14 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT)
      C_2035
       (MOVE R0 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
       (ALU L+R (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) R0 
              (REGISTER *CONTROL-PDL* 7 0))
       (MEMORY-WAIT)
       (MOVE R2 MD BOXED-RIGHT)
       (ALU-FIELD FIELD-PASS R2 R2 (REGISTER *ZERO* 4 0) (BYTE 21 0) PW-II DT-NONE BOXED-RIGHT)
       (ALU L+R R2 r14 R2 BW-24 BOXED-RIGHT)
       (MOVEI R0 (QUOTE 11) BOXED)
       (ALU-FIELD FIELD-PASS (REGISTER *CONTROL-PDL-LIMIT* 7 2) R0 R2 (QUOTE 1562) PW-II DT-NONE 
                    BOXED)
       (MOVE r15 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT)
      C_2053
       (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
       (ALU L+R (VMA-START-READ BOXED-VMA BOXED-MD) R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 
              BOXED-RIGHT)
       (MEMORY-WAIT)
       (MOVE R2 MD BOXED-RIGHT)
       (ALU L+R R2 r15 R2 BW-24 BOXED-RIGHT)
       (MOVEI R0 (QUOTE 11) BOXED)
       (ALU-FIELD FIELD-PASS (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 R2 (QUOTE 1562) PW-II 
                    DT-NONE BOXED)
       (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE NIL) BOXED)
       (MOVE RETURN (REGISTER *NIL* 4 5) BOXED-RIGHT CH-RETURN NEXT-PC-RETURN))

;(defun restore-call-hardware () ;(return-value)
;;  (error "about to restore")
;  (dumping-or-restoring-call-hardware t)
;  (macrolet (;(saved-return-value ()	'gr:*ch-temp-0*)
;	     (frame-first-word ()	'gr:*ch-temp-1*)
;	     (next-rpc-rdest ()		'gr:*ch-temp-2*)
;	     (global-frame ()		'gr:*ch-temp-3*)
;	     (control-pdl-top ()	'gr:*ch-temp-4*)
;	     (restore-register-prep ()
;	       `(setf (frame-first-word)
;		      (hw:ldb (frame-first-word) %%cpdl0-box-bits (hw:unboxed-constant 0))))
;	     (restore-register (register)
;	       `(progn
;		  (hw:vma-start-read-no-transport-vma-unboxed-md-unboxed gr:*ch-control-pdl-index* 0)
;		  (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*))
;		  (if (hw:32logbitp 0 (frame-first-word))
;		      (setf (,register) (hw:dpb-boxed (hw:read-md) (byte 32. 0) 0))
;		    (setf (,register) (hw:dpb-unboxed (hw:read-md) (byte 32. 0) 0)))
;		  (setf (frame-first-word) (hw:32logical-shift-down (frame-first-word) 1)))))
;;   (setf (saved-return-value) return-value)
;    (forge-catcher-frame)
;    (save-control-pdl-state)
;;    (error "catcher frame installed")
;    (setq gr:*ch-control-pdl-index* (hw:24+ (where-to-restore-from-control-pdl gr:*control-pdl*)
;					    (cons:make-pointer vinc:$$dtp-unboxed-locative gr:*control-pdl*)))

;    ;;; we should probably flush our frames so they will return to the heap

;    (tagbody 	;;; WARNING: no locals are allowed.  Use of OPEN and ACTIVE frames is prohibited
;	(setq gr:*ch-base-csp* (hw:ldb (hw:read-call-sp-hp)
;				       hw:%%ch-csphp-call-stack-pointer 0))
;	(setf (control-pdl-top) gr:*control-pdl-pointer*)
;	(setq gr:*control-pdl-pointer* gr:*ch-control-pdl-index*)
;     loop
;	(when (hw:24= gr:*ch-control-pdl-index* (control-pdl-top))
;	  (go end))
;	(when (hw:24> gr:*ch-control-pdl-index* (control-pdl-top))
;	  (trap:illop "frame alignment phase error in control pdl"))
;	(hw:vma-start-read-no-transport-vma-unboxed-md-unboxed gr:*ch-control-pdl-index*)
;	(setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*))			;point to second word
;	(setf (frame-first-word) (hw:read-md))
;	(dispatch %%cpdl0-type-code (frame-first-word)
;		  (($$cpdl0-type-open-call $$cpdl0-type-protected-open-call)
		   
;		     (hw:vma-start-read-no-transport-vma-unboxed-md-unboxed
;		      gr:*ch-control-pdl-index*)
;		     (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*))
;		     (setf (next-rpc-rdest) (hw:ldb (frame-first-word) %%cpdl0-rdest (hw:unboxed-constant 0)))
;		     (setf (next-rpc-rdest) (hw:dpb (next-rpc-rdest) hw:%%ch-rpcd-return-dest (hw:read-md)))
;		     (setf (global-frame) (hw:ldb (frame-first-word) %%cpdl0-global-frame (hw:unboxed-constant 0)))
;		     (hw:trap-off)
;		     ;;;once Kent fixes the hardware we won't need to do the hack with SPARE-17 any more.
;		     (hw:write-processor-control
;		       (vinc:dpb-multiple-unboxed
;			 (global-frame)	hw:%%processor-control-misc	;global frame number
;			 1		hw:%%processor-control-spare-17
;			 (hw:read-processor-control)))	;read boxed rpc
;		     (hw:nop) (hw:nop) (hw:nop) (hw:nop)
;		     (hw:write-return-pc-return-dest (next-rpc-rdest))
;		     (hw:nop)
;		     (hw:ch-open-call)
;		     (hw:write-processor-control
;		       (hw:dpb-unboxed 0 hw:%%processor-control-spare-17
;				       (hw:read-processor-control)))
;		     ;(trap:trap-on)
;		     (hw:nop) (hw:nop)
;		     (hw:write-memory-control
;		       (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable
;				       (hw:read-memory-control)))
;		    ;;; setup RPC, RDEST and global return destination for next time around:
		    
;		    (go restore-a-frame))
;		  ($$cpdl0-type-open
;		    ;;; we need only restore the open frame
;		    (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*))		;skip RPC
;		    (hw:open-frame)
;		    (go restore-o-frame))
;		  ($$cpdl0-type-topen
;		    ;;; we need only restore the active frame
;		    (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*))		;skip RPC
;		    (hw:ch-topen)
;		    (go restore-o-frame)))
;     restore-o-frame
;	(progn
;	  (restore-register-prep)
;	  (restore-register hw:o0)  (restore-register hw:o1)
;	  (restore-register hw:o2)  (restore-register hw:o3)
;	  (restore-register hw:o4)  (restore-register hw:o5)
;	  (restore-register hw:o6)  (restore-register hw:o7)
;	  (restore-register hw:o8)  (restore-register hw:o9)
;	  (restore-register hw:o10) (restore-register hw:o11)
;	  (restore-register hw:o12) (restore-register hw:o13)
;	  (restore-register hw:o14) (restore-register hw:o15)
;	  (go loop))
;     restore-a-frame
;	(progn
;	  (restore-register-prep)
;	  (restore-register hw:a0)  (restore-register hw:a1)
;	  (restore-register hw:a2)  (restore-register hw:a3)
;	  (restore-register hw:a4)  (restore-register hw:a5)
;	  (restore-register hw:a6)  (restore-register hw:a7)
;	  (restore-register hw:a8)  (restore-register hw:a9)
;	  (restore-register hw:a10) (restore-register hw:a11)
;	  (restore-register hw:a12) (restore-register hw:a13)
;	  (restore-register hw:a14) (restore-register hw:a15)
;	  (go loop))
;     end)
;    (li:error "call hardware restored")
;    (save-control-pdl-state)
;    (setq gr:*control-pdl* (control-pdl-assure-room gr:*control-pdl*))
;    (load-control-pdl-state)
;    (dumping-or-restoring-call-hardware nil)
    
;    ))


;;; when the control pdl and call hardware are scrolled the base of the call hardware
;;; must be an open-call frame so that the underflow catcher can be reached via a return operation.
;;; Since the call hardware dumper and restorer play with traps and can only be invoked while
;;; traps are enabled, this boundary can not fall on an open-call across which traps are disabled.
;;; To prevent the restorer from putting the underflow handler boundary at an open-call across which
;;; traps are disabled, we make the rule that only the trap handler is allowed to disable traps.
;;; We also have the rule that it must reenable traps by the time is goes TRAP-CALL-PROTECTION-COUNT
;;; deep in calls.  When the call hardware dumper sees a return pc that is a trap entry (pc < 64)
;;; it protects the next TRAP-CALL-PROTECTION-COUNT open-calls that is sees by recording them
;;; as being control pdl frame type $$CPDL0-TYPE-PROTECTED-OPEN-CALL rather than $$CPDL0-TYPE-OPEN-CALL.
;;; The restorer only looks for $$CPDL0-TYPE-OPEN-CALL when deciding how much to restore but when
;;; it does restore, it treats both type codes the same.
(defconstant trap-call-protection-count 2)

(defmacro with-dumper-macros (&body body)
  `(macrolet ((previous-a-frame ()	'gr:*ch-temp-0*)
	      (accumulated-box-bits ()	'gr:*ch-temp-1*)
	      (saved-csp ()		'gr:*ch-temp-2*)
	      (protection-count ()	'gr:*ch-temp-3*)
	      (this-rpc ()		'gr:*ch-temp-4*)
	      (word-1 ()		'gr:*ch-temp-5*)
	      (save-register (register)
		`(progn (hw:write-md-unboxed (,register))
			(hw:vma-start-write-no-gc-trap-unboxed gr:*control-pdl-pointer*)
			(setq gr:*control-pdl-pointer* (hw:24+ 1 gr:*control-pdl-pointer*))))
	      (save-box-bit (register)
		`(setf (accumulated-box-bits) (HW:ACCUMULATE-BOX-BITS (accumulated-box-bits) (,register)))))
       ,@body))


;;; CLEAR-R-FRAME, WRITE-OPEN-CALL-FRAME and WRITE-OPEN-FRAME are invoked using the same hack that CONS-REST
;;; is called with.  This allows the function to return to its caller (whose pc is stored in 
;;; GR:*RETURN-PC-1*).  This hack is required so that no call hardware operation is performed
;;; when calling the function or returning from it.  This way we can access the same registers
;;; as our caller.

(defafun write-open-call-frame ()
  (movei gr:*ch-temp-1* 0)
  (move (md unboxed-md) a0)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a15 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a1)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a14 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a2)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a13 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a3)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a12 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a4)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a11 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a5)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a10 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a6)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a9 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a7)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a8 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a8)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a7 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a9)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a6 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a10)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a5 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a11)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a4 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a12)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a3 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a13)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a2 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a14)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a1 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) a15)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a0 bw-24 carry-1 boxed-right)

;      (save-register hw:a0)  (save-box-bit hw:a15)   (save-register hw:a1)  (save-box-bit hw:a14)
;      (save-register hw:a2)  (save-box-bit hw:a13)   (save-register hw:a3)  (save-box-bit hw:a12)
;      (save-register hw:a4)  (save-box-bit hw:a11)   (save-register hw:a5)  (save-box-bit hw:a10)
;      (save-register hw:a6)  (save-box-bit hw:a9)    (save-register hw:a7)  (save-box-bit hw:a8)
;      (save-register hw:a8)  (save-box-bit hw:a7)    (save-register hw:a9)  (save-box-bit hw:a6)
;      (save-register hw:a10) (save-box-bit hw:a5)    (save-register hw:a11) (save-box-bit hw:a4)
;      (save-register hw:a12) (save-box-bit hw:a3)    (save-register hw:a13) (save-box-bit hw:a2)
;      (save-register hw:a14) (save-box-bit hw:a1)    (save-register hw:a15) (save-box-bit hw:a0))

  (alu setr nop gr:*ch-temp-3* gr:*ch-temp-3* bw-24 boxed dt-both-fixnum)
  (test br-not-zero)
  (branch c_12 nil)
  
  (move r2 gr:*one* boxed-right)
  c_28
     (alu-field field-pass gr:*ch-temp-5* r2 gr:*ch-temp-5* (quote 512) pw-II dt-none unboxed)

  (move r0 gr:*ch-temp-4* boxed-right)
  (alu-field field-pass r2 r0 gr:*zero* (byte 26 0) pw-II dt-none boxed-right)
  (movei r1 (quote 64) boxed)
  (alu l-r nop r2 r1  bw-24 dt-both-fixnum)
  (test br-not-less-than)
  (branch b_59 nil)

  (movei gr:*ch-temp-3* (quote 2) boxed)

  b_59
     (alu-field field-pass (md unboxed-md) gr:*ch-temp-1* gr:*ch-temp-5* (quote 4112) pw-II dt-none unboxed)
     (movei r0 '-18 boxed)
     (alu l+r (vma-start-write-no-gc-trap unboxed-vma) r0 gr:*control-pdl-pointer* bw-24 boxed-right)
;     (move r0 gr:*one* boxed-right)
;     (alu l+r r2 r0 gr:*ch-dumper-return-pc* bw-24 boxed-right)
     (alu r+1 gr:*ch-dumper-return-pc*  gr:*ch-dumper-return-pc* gr:*ch-dumper-return-pc*  bw-24 boxed-right)
;     (move nop r2 boxed-right)
     (nop)
     (nop next-pc-dispatch)
     (move return gr:*nil* boxed-right ch-return next-pc-return)
  c_12
     (alu r-1 gr:*ch-temp-3* gr:*ch-temp-3* gr:*ch-temp-3* bw-24 boxed dt-both-fixnum-with-overflow)
     (unconditional-branch c_28 (move r2 gr:*three* boxed-right)))
  
;(defun foo ()
;    (setf gr:*ch-temp-5*
;	  (hw:dpb-unboxed (if (zerop gr:*ch-temp-3*)
;			      $$cpdl0-type-open-call
;			    (progn (setf gr:*ch-temp-3* (1- gr:*ch-temp-3*))
;				   $$cpdl0-type-protected-open-call))
;			  %%cpdl0-type-code
;			  gr:*ch-temp-5*))
;    (when (< (hw:ldb gr:*ch-temp-4* vinc:%%pointer 0) 64.)
;      (setf gr:*ch-temp-3* trap-call-protection-count))
;    (hw:write-md-unboxed (hw:dpb-unboxed gr:*ch-temp-1* %%cpdl0-box-bits gr:*ch-temp-5*))
;    (hw:vma-start-write-no-gc-trap-unboxed
;      (hw:24+ (- control-pdl-frame-size) gr:*control-pdl-pointer*))
;    (hw:dispatch (hw:24+ 1 gr:*ch-dumper-return-pc*)))

(defafun write-open-frame ()
  (movei gr:*ch-temp-1* 0)
  (move (md unboxed-md) o0)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o15 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o1)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o14 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o2)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o13 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o3)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o12 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o4)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o11 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o5)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o10 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o6)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o9 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o7)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o8 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o8)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o7 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o9)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o6 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o10)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o5 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o11)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o4 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o12)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o3 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o13)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o2 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o14)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o1 bw-24 carry-1 boxed-right)
  
  (move (md unboxed-md) o15)
  (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1))
  (move r0 (register *one* 4 1) boxed-right)
  (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right)
  (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o0 bw-24 carry-1 boxed-right)

;  (with-dumper-macros
;    (progn
;      (save-register hw:o0)  (save-box-bit hw:o15)   (save-register hw:o1)  (save-box-bit hw:o14)
;      (save-register hw:o2)  (save-box-bit hw:o13)   (save-register hw:o3)  (save-box-bit hw:o12)
;      (save-register hw:o4)  (save-box-bit hw:o11)   (save-register hw:o5)  (save-box-bit hw:o10)
;      (save-register hw:o6)  (save-box-bit hw:o9)    (save-register hw:o7)  (save-box-bit hw:o8)
;      (save-register hw:o8)  (save-box-bit hw:o7)    (save-register hw:o9)  (save-box-bit hw:o6)
;      (save-register hw:o10) (save-box-bit hw:o5)    (save-register hw:o11) (save-box-bit hw:o4)
;      (save-register hw:o12) (save-box-bit hw:o3)    (save-register hw:o13) (save-box-bit hw:o2)
;      (save-register hw:o14) (save-box-bit hw:o1)    (save-register hw:o15) (save-box-bit hw:o0))

;    (hw:write-md-unboxed (hw:dpb-unboxed gr:*ch-temp-1* %%cpdl0-box-bits gr:*ch-temp-5*))
;    (hw:vma-start-write-no-gc-trap-unboxed
;      (hw:24+ (- control-pdl-frame-size) gr:*control-pdl-pointer*))
;    (hw:dispatch (hw:24+ 1 gr:*ch-dumper-return-pc*))
  (alu-field field-pass (md unboxed-md)  gr:*ch-temp-1*  gr:*ch-temp-5* (quote 4112) pw-II dt-none unboxed)
  (movei r0 '-18 boxed)
  (alu l+r (vma-start-write-no-gc-trap unboxed-vma) r0 gr:*control-pdl-pointer* bw-24 boxed-right)
  (move r0 gr:*one* boxed-right)
  (alu l+r r2 r0 gr:*ch-dumper-return-pc* bw-24 boxed-right)
  (move nop r2 boxed-right)
  (nop)
  (nop next-pc-dispatch)
  (move return gr:*nil* boxed-right ch-return next-pc-return))
  
    

(defun clear-r-frame ()
  (setf (hw:r0)  (hw:unboxed-constant 0))   (setf (hw:r1)  (hw:unboxed-constant 0))
  (setf (hw:r2)  (hw:unboxed-constant 0))   (setf (hw:r3)  (hw:unboxed-constant 0))
  (setf (hw:r4)  (hw:unboxed-constant 0))   (setf (hw:r5)  (hw:unboxed-constant 0))
  (setf (hw:r6)  (hw:unboxed-constant 0))   (setf (hw:r7)  (hw:unboxed-constant 0))
  (setf (hw:r8)  (hw:unboxed-constant 0))   (setf (hw:r9)  (hw:unboxed-constant 0))
  (setf (hw:r10) (hw:unboxed-constant 0))   (setf (hw:r11) (hw:unboxed-constant 0))
  (setf (hw:r12) (hw:unboxed-constant 0))   (setf (hw:r13) (hw:unboxed-constant 0))
  (setf (hw:r14) (hw:unboxed-constant 0))   (setf (hw:r15) (hw:unboxed-constant 0))
  (hw:dispatch (hw:24+ 1 gr:*return-pc-1*)))

(defafun Dump-Call-Hardware ()
      P_315
         (MOVE NOP (REGISTER *CH-DUMPER-RETURN-PC* 7 10) BOXED-RIGHT)
         (TEST BR-ZERO)
         (BRANCH B_329 NIL)
      C_317
         (MOVEI O0 (QUOTE 376) BOXED CH-OPEN)
         (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL)
      B_329
         (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE T) BOXED)
         (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
         (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 274) PW-II 
                    DT-NONE BOXED-RIGHT)
         (MOVEI (REGISTER *CH-TEMP-3* 7 7) (QUOTE 0) BOXED)
         (MOVEI (REGISTER *CH-TEMP-0* 7 4) (QUOTE 256) BOXED)
         (MOVE R2 CALL-SP-HP BOXED-RIGHT)
         (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
         (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) R2 R1 (BYTE 8 0) PW-II DT-NONE 
                    BOXED-RIGHT)
         (MOVE IGNORE TRAP-OFF)
      LOOP_40
         (ALU R+1 (REGISTER *CH-BASE-CSP* 7 9) IGNORE (REGISTER *CH-BASE-CSP* 7 9) BW-8 
              BOXED-RIGHT)
         (MOVE r13 (REGISTER *CH-BASE-CSP* 7 9) BOXED-RIGHT)
      C_48
        (MOVE R2 CALL-SP-HP BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS CALL-SP-HP r13 R2 (QUOTE 2048) PW-II DT-NONE UNBOXED)
        (NOP)
        (NOP)
        (NOP)
	(NOP)
        (NOP)
        (MOVE R2 RETURN-PC-RETURN-DEST BOXED-RIGHT)
        (MOVE R1 (REGISTER *TRAP-DTP-CODE-5* 0 15) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-4* 7 8) R2 R1 (BYTE 24 0) PW-II DT-NONE 
                    BOXED-RIGHT)
        (MOVEI (REGISTER *CH-TEMP-5* 7 11) 0 UNBOXED)
        (MOVE R2 RETURN-PC-RETURN-DEST BOXED-RIGHT)
	(MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
	(ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 7 -24) PW-II DT-NONE 
                    BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) (REGISTER *CH-TEMP-6* 7 12) 
                    (REGISTER *CH-TEMP-5* 7 11) (QUOTE 1794) PW-II DT-NONE UNBOXED)
        (MOVE R2 PROCESSOR-STATUS BOXED-RIGHT)
        (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 4 -9) PW-II DT-NONE 
                    BOXED-RIGHT)
	(ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) (REGISTER *CH-TEMP-6* 7 12) 
		   (REGISTER *CH-TEMP-5* 7 11) (QUOTE 1033) PW-II DT-NONE UNBOXED)
        (NOP CH-RETURN)
        (NOP)
        (NOP)
        (NOP)
        (NOP)
        (NOP)
        (MOVE r14 (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT)
      C_122
        (MOVE R2 CALL-SP-HP BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS CALL-SP-HP r14 R2 (QUOTE 2048) PW-II DT-NONE UNBOXED)
        (NOP)
	(NOP)
        (NOP)
        (NOP)
        (NOP)
	(MOVE R2 MEMORY-CONTROL BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE 
		   UNBOXED)
        (NOP)
        (NOP)
        (NOP)
	(NOP)
        (MOVE (MD UNBOXED-MD) (REGISTER *CH-TEMP-4* 7 8))
        (MOVE R0 (REGISTER *ONE* 4 1) BOXED-RIGHT)
        (ALU L+R (VMA-START-WRITE-NO-GC-TRAP UNBOXED-VMA) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) 
	     BW-24 BOXED-RIGHT)
        (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT)
        (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 8 -8) PW-II DT-NONE 
		   BOXED-RIGHT)
        (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
        (ALU L+R (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) 
              BW-24 BOXED-RIGHT)
      P_174
        (MOVE r15 (REGISTER *CH-TEMP-6* 7 12) BOXED-RIGHT)
      C_272
        (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS R2 R2 (REGISTER *ZERO* 4 0) (BYTE 8 -16) PW-II DT-NONE BOXED-RIGHT)
        (ALU XOR NOP r15 R2 BW-24 DT-BOTH-FIXNUM)
        (TEST BR-NOT-EQUAL)
        (BRANCH C_188 NIL)
      C_175
        (JUMP WRITE-OPEN-CALL-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+))
        (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT)
        (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE 
                  BOXED-RIGHT)
        (MOVE IGNORE TRAP-OFF)
      B_298
        (ALU XOR NOP (REGISTER *CH-BASE-CSP* 7 9) (REGISTER *CH-TEMP-2* 7 6) BW-24 DT-BOTH-FIXNUM)
        (TEST BR-NOT-EQUAL)
	(BRANCH LOOP_40 NIL)
      END_303
       ; (TAIL-CALL (0 0) NIL NEXT-PC-PC+1)
        (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 274) PW-II DT-NONE 
                  BOXED-RIGHT)
	(nop)
	(nop ch-tail-open next-pc-pc+1)
	(move r0 open-active-return unboxed)
	(alu-field field-pass r1 r0 gr:*zero* (byte 8 -16) )
	(alu-field field-pass open-active-return r1 r0 (byte 8 8) )
	(nop) (nop) (nop) (nop) (nop)
        (OPEN-CALL (trap:TRAP-ON 0) IGNORE NIL)
      B_361
        (MOVEI O0 "dumped" BOXED CH-OPEN)
        (CALL (ERROR 1) IGNORE NIL)
        (OPEN-CALL (SELECT-CONTROL-PDL 1) IGNORE 
                    (O0 (REGISTER *NEXT-CONTROL-PDL* 7 15) BOXED-RIGHT))
        (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE NIL) BOXED)	
        (OPEN-TAIL-CALL (RESTORE-CALL-HARDWARE 0) NIL)
      C_188
        (ALU XOR NOP (REGISTER *CH-TEMP-6* 7 12) (REGISTER *CH-TEMP-0* 7 4) BW-24 DT-BOTH-FIXNUM)
        (TEST BR-NOT-EQUAL)
        (BRANCH C_218 NIL)
      C_191
        (MOVE R0 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) R0 (REGISTER *CH-TEMP-5* 7 11) 
		   (QUOTE 512) PW-II DT-NONE UNBOXED)
        (JUMP WRITE-OPEN-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+))
        (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT)
        (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE 
                    BOXED-RIGHT)
        (TAIL-CALL (0 0) (IGNORE TRAP-OFF) NEXT-PC-PC+1)
        (TAIL-OPEN-CALL (0 0) NIL NEXT-PC-PC+1)
        (TAIL-OPEN)
        (UNCONDITIONAL-BRANCH B_298 NIL)
      C_218
        (JUMP WRITE-OPEN-CALL-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+))
        (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
        (ALU L+R (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) 
              BW-24 BOXED-RIGHT)
        (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) R0 (REGISTER *CH-TEMP-5* 7 11) 
                    (QUOTE 512) PW-II DT-NONE UNBOXED)
        (JUMP WRITE-OPEN-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+))
	(MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT)
        (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT)
        (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE 
                    BOXED-RIGHT)
        (TAIL-CALL (0 0) (IGNORE TRAP-OFF) NEXT-PC-PC+1)
        (UNCONDITIONAL-BRANCH B_298 NIL))

;(defun dump-call-hardware ()
;; (setq gr:*control-pdl-pointer* (hw:24+ (control-pdl-pointer gr:*control-pdl*)
;;				 (cons:make-pointer vinc:$$dtp-unboxed-locative gr:*control-pdl*)))
;  (with-dumper-macros
;    (tagbody
;	(dumping-or-restoring-call-hardware t)
;	(hw:write-processor-control (hw:dpb hw:$$call-heap-underflow-trap-disable
;					    hw:%%processor-control-heap-underflow-trap-enable
;					    (hw:read-processor-control)))
;	(setf (protection-count) 0)
;	(setf (previous-a-frame) 256)	;nonexistant
;	(setf (saved-csp) (hw:ldb (hw:read-call-sp-hp) hw:%%ch-csphp-call-stack-pointer 0))
;	(hw:trap-off)
;     loop
;	(setq gr:*ch-base-csp* (hw:8-1+ gr:*ch-base-csp*))
;	(hw:write-call-sp-hp (hw:dpb-unboxed gr:*ch-base-csp*
;					     hw:%%ch-csphp-call-stack-pointer (hw:read-call-sp-hp)))
;	(hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop)	;how many do we need?
;	(setf (this-rpc) (hw:ldb (hw:read-return-pc-return-dest)
;				 hw:%%ch-rpcd-return-pc gr:*trap-dtp-code-5*))
;	(setf (word-1) (hw:unboxed-constant 0))
;	(setq gr:*ch-temp-6* (hw:ldb (hw:read-return-pc-return-dest)
;				     hw:%%ch-rpcd-return-dest (hw:unboxed-constant 0)))
;	(setf (word-1) (hw:dpb-unboxed gr:*ch-temp-6* %%cpdl0-rdest (word-1)))
;	(setq gr:*ch-temp-6* (hw:ldb (hw:read-processor-status)
;				     hw:%%processor-status-global-return-frame
;				     (hw:unboxed-constant 0)))
;	(setf (word-1) (hw:dpb-unboxed gr:*ch-temp-6* %%cpdl0-global-frame (word-1)))
;;	(hw:jump-saving-pc 'clear-r-frame gr:*ch-dumper-return-pc*)
;	(hw::ch-return) (hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop)	;do we need these NOPs
;	(hw:write-call-sp-hp (hw:dpb-unboxed (saved-csp)
;					     hw:%%ch-csphp-call-stack-pointer (hw:read-call-sp-hp)))
;	(hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop)
;;	(trap:trap-on)
;	(hw:write-memory-control
;	  (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable
;			  (hw:read-memory-control)))
;	(hw:nop) (hw:nop) (hw:nop) (hw:nop)
;	(hw:write-md-unboxed (this-rpc))
;	(hw:vma-start-write-no-gc-trap-unboxed (hw:24+ 1 gr:*control-pdl-pointer*))
;	(setq gr:*ch-temp-6* (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0))
;	(setq gr:*control-pdl-pointer* (hw:24+ control-pdl-frame-offset-to-registers
;					       gr:*control-pdl-pointer*))
;	(cond ((= gr:*ch-temp-6*
;		  (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-open 0))	;OPEN-CALL
;	       (hw:jump-saving-pc 'write-open-call-frame gr:*ch-dumper-return-pc*)
;	       (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0))
;	       (hw:trap-off))
;	      ((= gr:*ch-temp-6* (previous-a-frame))		;OPEN
;	       (setf (word-1) (hw:dpb-unboxed $$cpdl0-type-open %%cpdl0-type-code (word-1)))
;	       (hw:jump-saving-pc 'write-open-frame gr:*ch-dumper-return-pc*)
;	       (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0))
;	       (hw:trap-off)
;	       (hw:ch-tcall)
;	       (hw:ch-topen-call)
;	       (hw:ch-topen))
;	      (t				;OPEN-CALL TOPEN
;	       (hw:jump-saving-pc 'write-open-call-frame gr:*ch-dumper-return-pc*)
;	       (setq gr:*control-pdl-pointer* (hw:24+ control-pdl-frame-offset-to-registers
;						      gr:*control-pdl-pointer*))
;	       (setf (word-1) (hw:dpb-unboxed $$cpdl0-type-topen %%cpdl0-type-code (word-1)))
;	       (hw:jump-saving-pc 'write-open-frame gr:*ch-dumper-return-pc*)
;	       (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0))
;	       (hw:trap-off)
;	       (hw::ch-tcall)))
;	(unless (= gr:*ch-base-csp* (saved-csp))
;	  (go loop))
;     end
;	(hw:ch-tcall)
;	(hw:write-processor-control (hw:dpb hw:$$call-heap-underflow-trap-enable
;					    hw:%%processor-control-heap-underflow-trap-enable
;					    (hw:read-processor-control)))
;	(trap:trap-on))
;    (error "dumped")
;    (select-control-pdl gr:*next-control-pdl*)
;    (dumping-or-restoring-call-hardware nil)

;    (restore-call-hardware)))