;; -*- Mode:LISP; Package:LAMBDA; Base:8 -*-
;-- INITIAL SYMS  LAMBDA VERSION
; FIELDS
(DEFPROP FUNCTION-SOURCE 1_32. LAM-LAP-SYM)
  (DEFPROP FUNCTION-SOURCE 1_38. LAM-LAP-ADDITIVE-CONSTANT)
(DEFPROP BYTE-SIZE (OR (BYTE-INSTRUCTION-P 1_6.)
		       (DISPATCH-INSTRUCTION-P 1_6.)) LAM-LAP-SYM)
(DEFPROP BYTE-ROTATE 0 LAM-LAP-SYM)
(DEFPROP FUNCTION-DESTINATION 1_20. LAM-LAP-SYM)
(DEFPROP A-SOURCE-MULTIPLIER 1_39. LAM-LAP-SYM)
(DEFPROP M-SOURCE-MULTIPLIER 1_32. LAM-LAP-SYM)
(DEFPROP A-DESTINATION-MULTIPLIER 1_14. LAM-LAP-SYM)
(DEFPROP M-DESTINATION-MULTIPLIER 1_14. LAM-LAP-SYM)
(DEFPROP JUMP-ADDRESS-MULTIPLIER 1_14. LAM-LAP-SYM)
(DEFPROP DISPATCH-ADDRESS-MULTIPLIER 1_39. LAM-LAP-SYM)
(DEFPROP ALU-OP (FORCE-ALU 1_3) LAM-LAP-SYM)
(DEFPROP ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER (FORCE-ALU 1_9.) LAM-LAP-SYM)

(DEFPROP ALU-INST (FORCE-ALU 0) LAM-LAP-SYM)
(DEFPROP DISPATCH (FORCE-DISPATCH 0) LAM-LAP-SYM)
(DEFPROP BYTE-INST (FORCE-BYTE 0) LAM-LAP-SYM)
(DEFPROP JUMP-INST (FORCE-JUMP 0) LAM-LAP-SYM)

(DEFPROP MACRO-IR-DISPATCH 1_52. LAM-LAP-SYM)
(DEFPROP SOURCE-TO-MACRO-IR 1_53. LAM-LAP-SYM)
(DEFPROP MACRO-STREAM-ADVANCE 1_54. LAM-LAP-SYM)
(DEFPROP SLOW-DESTINATION 1_55. LAM-LAP-SYM)
(DEFPROP GC-MAP-TEST 1_55. LAM-LAP-SYM)  ;slow destination bit on in a dispatch instruction
	;triggers the hack to wait for write cycle to complete and map to re-set-up from MD.
(DEFPROP CLOBBERS-MEM-SUBR 1_58. LAM-LAP-SYM)	;MUST ALSO BE SET IN ANY DISPATCH WHICH
		;TESTS LEVEL-2-MAP-TESTED-BITS TO ASSURE ALL MEMORY CYCLES ARE OVER AND
		;MAP INPUTS ARE BACK TO MD.

;(DEFPROP DISPATCH-ADVANCE-INSTRUCTION-STREAM 1_24. LAM-LAP-SYM)
(DEFPROP DISPATCH-PUSH-OWN-ADDRESS 1_26. LAM-LAP-SYM)
;(DEFPROP DISPATCH-WRITE-VMA 1_27. LAM-LAP-SYM)
(putprop 'dispatch-write-vma (+ 1_27. (get 'clobbers-mem-subr 'lam-lap-sym)) 'lam-lap-sym)

(SETQ SR-BIT 1_28.)
(DEFPROP SR-BIT (FORCE-BYTE 1_28.) LAM-LAP-SYM)
(DEFPROP MR-BIT (FORCE-BYTE 1_29.) LAM-LAP-SYM)

(DEFPROP ALU-CARRY-IN-ZERO (FORCE-ALU 0_2) LAM-LAP-SYM)
(DEFPROP ALU-CARRY-IN-ONE (FORCE-ALU 1_2) LAM-LAP-SYM)

;NOTE! BIT 2 OF THE OUTPUT SELECTOR FIELD CONDITIONS SEL.0 INPUT OF THE SELECTOR.
(DEFPROP OUTPUT-SELECTOR-NORMAL 
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 1) LAM-LAP-SYM)	;2 ON SELECTOR
(DEFPROP OUTPUT-SELECTOR-RIGHTSHIFT-1 
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 2) LAM-LAP-SYM)	;4 ON SELECTOR
(DEFPROP OUTPUT-SELECTOR-LEFTSHIFT-1 
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 6) LAM-LAP-SYM)	;5 ON SELECTOR

(DEFPROP SHIFT-ALU-RIGHT
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 2) LAM-LAP-SYM)
(DEFPROP SHIFT-ALU-LEFT
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 6) LAM-LAP-SYM)

(DEFPROP OUTPUT-SELECTOR-EXTEND-25 
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 3) LAM-LAP-SYM)	;6 ON SELECTOR
(DEFPROP OUTPUT-SELECTOR-BIT-MIRROR
	(FIELD ALU-OUTPUT-BUS-SELECTOR-MULTIPLIER 7) LAM-LAP-SYM)	;7 ON SELECTOR

(defprop output-selector-mask-25 	;independant of Q.control
   (plus (field alu-output-bus-selector-multiplier 1)
	 (field alu-op 40)) lam-lap-sym)

(defprop output-selector-mask-11 	;independant of Q.control
   (plus (field alu-output-bus-selector-multiplier 5)
	 (field alu-op 40)) lam-lap-sym)

(defun setup-os-mask (aluc5 ob2 u29 q)
  `(plus (field-alu-output-bus-selector-multiplier ,(dpb ob2 0201 1))
	 (field alu-op ,(dpb aluc5 0501 0))
	 (ash u29 29.)
	 (ash q 1)))

;all the output-selector-mask s below affect the Q register.  The ones with Q in the name
;  load it, others shift it left or right.
;next time, add output-selector-mask-30 for flushing CDR-CODES.
(defprop output-selector-mask-28 (setup-os-mask 1 0 1 2) lam-lap-sym)
(defprop output-selector-mask-24 (setup-os-mask 0 1 1 2) lam-lap-sym)
(defprop output-selector-mask-20 (setup-os-mask 0 0 1 2) lam-lap-sym)
(defprop output-selector-mask-16 (setup-os-mask 1 1 1 1) lam-lap-sym)
(defprop output-selector-mask-12 (setup-os-mask 1 0 1 1) lam-lap-sym)
(defprop output-selector-mask-8 (setup-os-mask  0 1 1 1) lam-lap-sym)
(defprop output-selector-mask-4 (setup-os-mask  0 0 1 1) lam-lap-sym)
(defprop output-selector-mask-jadr (setup-os-mask 1 1 1 2) lam-lap-sym)
(defprop output-selector-mask-byte-pos-and-load-q (setup-os-mask 0 0 1 3) lam-lap-sym)
(defprop output-selector-mask-byte-len-and-load-q (setup-os-mask 0 1 1 3) lam-lap-sym)
(defprop output-selector-mask-m-source-and-load-q (setup-os-mask 1 0 1 3) lam-lap-sym)
(defprop output-selector-mask-a-source-and-load-q (setup-os-mask 1 1 1 3) lam-lap-sym)

	
(DEFPROP SHIFT-Q-LEFT (FORCE-ALU 1_0) LAM-LAP-SYM)
(DEFPROP SHIFT-Q-RIGHT (FORCE-ALU 2_0) LAM-LAP-SYM)
(DEFPROP LOAD-Q (FORCE-ALU 3_0) LAM-LAP-SYM)

;THESE APPLY BOTH TO JUMPS (AS DEFINED) AND TO DISPATCH-MEMORY (SHIFTED TO BITS 16.-18.)
(DEFPROP R-BIT 1_10. LAM-LAP-SYM)
(DEFPROP P-BIT 1_9. LAM-LAP-SYM)
(DEFPROP N-BIT 1_8. LAM-LAP-SYM)
(DEFPROP INHIBIT-XCT-NEXT-BIT 1_8. LAM-LAP-SYM)

;ONLY IN DISPATCH MEMORY.  IT IS REALLY 1_19., BUT IS ASSEMBLED HERE AND MOVED
; TO THE RIGHT PLACE BY LAM-LAP-PASS2.  (THE HACK IS NECESSARY BECAUSE THE REAL PLACE
; WOULD OVERLAP WITH THE ADDRESS FIELD OF A JUMP INSTRUCTION, AND DISPATCH MEMORY
; IS ASSEMBLE PSEUDO AS IF IT WERE INSTRUCTIONS).
(DEFPROP DISPATCH-START-MEM-READ-BIT 1 LAM-LAP-SYM)

(DEFPROP INVERT-JUMP-SENSE (FORCE-JUMP 1_7) LAM-LAP-SYM)

(DEFPROP JUMP-LESS-THAN-CONDITION 101 LAM-LAP-SYM)
(DEFPROP JUMP-LESS-CONDITION 101 LAM-LAP-SYM)
(DEFPROP JUMP-LESS-OR-EQUAL-CONDITION 102 LAM-LAP-SYM)
(DEFPROP JUMP-EQUAL-CONDITION 303 LAM-LAP-SYM)		;inverted from CADR
(DEFPROP JUMP-NOT-EQUAL-CONDITION 103 LAM-LAP-SYM)	;inverted
(DEFPROP JUMP-GREATER-THAN-CONDITION 
	    (PLUS INVERT-JUMP-SENSE JUMP-LESS-OR-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-GREATER-CONDITION 
	    (PLUS INVERT-JUMP-SENSE JUMP-LESS-OR-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-GREATER-OR-EQUAL-CONDITION 
	    (PLUS INVERT-JUMP-SENSE JUMP-LESS-CONDITION) LAM-LAP-SYM)

(DEFPROP JUMP-DATA-TYPE-EQUAL-CONDITION 311 LAM-LAP-SYM)
(DEFPROP JUMP-DATA-TYPE-NOT-EQUAL-CONDITION 111 LAM-LAP-SYM)

(DEFPROP JUMP-ON-PAGE-FAULT-CONDITION 304 LAM-LAP-SYM)  ;inverted from CADR
(DEFPROP JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-CONDITION 105 LAM-LAP-SYM)
(DEFPROP JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-OR-SEQUENCE-BREAK-CONDITION 106 LAM-LAP-SYM)
(DEFPROP JUMP-ALWAYS 107 LAM-LAP-SYM)

(DEFPROP JUMP-ON-BIT-CONDITION 0 LAM-LAP-SYM)

;MISC FUNCTION CODES

;(DEFPROP INSTRUCTION-STREAM 3_10. LAM-LAP-SYM)
;(DEFPROP WRITE-DISPATCH-RAM (FORCE-DISPATCH 2_10.) LAM-LAP-SYM)
(DEFPROP X-MULT-TC 1_12. LAM-LAP-SYM)
(DEFPROP Y-MULT-TC 1_13. LAM-LAP-SYM)

(DEFPROP HALT-CONS 1_59. LAM-LAP-SYM)	;for old times sake
(DEFPROP HALT-LAMBDA 1_59. LAM-LAP-SYM)

(DEFPROP I-LONG 1_56. LAM-LAP-SYM)

; "AUGMENTED" INSTRUCTIONS
(DEFPROP JUMP-OP-XCT-NEXT JUMP-INST LAM-LAP-SYM)
(DEFPROP JUMP-OP (PLUS JUMP-INST INHIBIT-XCT-NEXT-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT JUMP-ALWAYS) LAM-LAP-SYM)
(DEFPROP JUMP (PLUS JUMP-OP JUMP-ALWAYS) LAM-LAP-SYM)

(DEFPROP CALL-XCT-NEXT (PLUS JUMP-XCT-NEXT P-BIT) LAM-LAP-SYM) 
(DEFPROP CALL (PLUS JUMP P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-XCT-NEXT (PLUS JUMP-XCT-NEXT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ (PLUS JUMP R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-IF-BIT-SET (PLUS JUMP-OP JUMP-ON-BIT-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-IF-BIT-CLEAR (PLUS JUMP-IF-BIT-SET INVERT-JUMP-SENSE) LAM-LAP-SYM)
(DEFPROP JUMP-IF-BIT-SET-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT JUMP-ON-BIT-CONDITION)
	 LAM-LAP-SYM)
(DEFPROP JUMP-IF-BIT-CLEAR-XCT-NEXT (PLUS JUMP-IF-BIT-SET-XCT-NEXT INVERT-JUMP-SENSE)
	 LAM-LAP-SYM)

(DEFPROP CALL-IF-BIT-SET (PLUS JUMP-IF-BIT-SET P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-BIT-CLEAR (PLUS JUMP-IF-BIT-CLEAR P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-BIT-SET-XCT-NEXT (PLUS JUMP-IF-BIT-SET-XCT-NEXT P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-BIT-CLEAR-XCT-NEXT (PLUS JUMP-IF-BIT-CLEAR-XCT-NEXT P-BIT)
	 LAM-LAP-SYM)

(DEFPROP POPJ-IF-BIT-SET (PLUS JUMP-IF-BIT-SET R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-BIT-CLEAR (PLUS JUMP-IF-BIT-CLEAR R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-BIT-SET-XCT-NEXT (PLUS JUMP-IF-BIT-SET-XCT-NEXT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-BIT-CLEAR-XCT-NEXT (PLUS JUMP-IF-BIT-CLEAR-XCT-NEXT R-BIT)
	 LAM-LAP-SYM)

(DEFPROP JUMP-EQUAL (PLUS JUMP-OP JUMP-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-NOT-EQUAL (PLUS JUMP-OP JUMP-NOT-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-EQUAL-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT JUMP-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-NOT-EQUAL-XCT-NEXT 
			(PLUS JUMP-OP-XCT-NEXT JUMP-NOT-EQUAL-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-EQUAL (PLUS JUMP-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-NOT-EQUAL (PLUS JUMP-NOT-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-EQUAL-XCT-NEXT (PLUS JUMP-EQUAL-XCT-NEXT P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-NOT-EQUAL-XCT-NEXT (PLUS JUMP-NOT-EQUAL-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-EQUAL (PLUS JUMP-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-NOT-EQUAL (PLUS JUMP-NOT-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-EQUAL-XCT-NEXT (PLUS JUMP-EQUAL-XCT-NEXT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-NOT-EQUAL-XCT-NEXT (PLUS JUMP-NOT-EQUAL-XCT-NEXT R-BIT) LAM-LAP-SYM)


(DEFPROP JUMP-DATA-TYPE-EQUAL (PLUS JUMP-OP JUMP-DATA-TYPE-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-DATA-TYPE-NOT-EQUAL (PLUS JUMP-OP JUMP-DATA-TYPE-NOT-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-DATA-TYPE-EQUAL-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT
					     JUMP-DATA-TYPE-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-DATA-TYPE-NOT-EQUAL-XCT-NEXT 
			(PLUS JUMP-OP-XCT-NEXT JUMP-DATA-TYPE-NOT-EQUAL-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-DATA-TYPE-EQUAL (PLUS JUMP-DATA-TYPE-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-DATA-TYPE-NOT-EQUAL (PLUS JUMP-DATA-TYPE-NOT-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-DATA-TYPE-EQUAL-XCT-NEXT (PLUS JUMP-DATA-TYPE-EQUAL-XCT-NEXT P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-DATA-TYPE-NOT-EQUAL-XCT-NEXT (PLUS JUMP-DATA-TYPE-NOT-EQUAL-XCT-NEXT P-BIT)
	 LAM-LAP-SYM)

(DEFPROP POPJ-DATA-TYPE-EQUAL (PLUS JUMP-DATA-TYPE-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-DATA-TYPE-NOT-EQUAL (PLUS JUMP-DATA-TYPE-NOT-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-DATA-TYPE-EQUAL-XCT-NEXT (PLUS JUMP-DATA-TYPE-EQUAL-XCT-NEXT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-DATA-TYPE-NOT-EQUAL-XCT-NEXT (PLUS JUMP-DATA-TYPE-NOT-EQUAL-XCT-NEXT R-BIT)
	 LAM-LAP-SYM)

(DEFPROP JUMP-LESS-THAN (PLUS JUMP-OP JUMP-LESS-THAN-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-LESS-THAN-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT JUMP-LESS-THAN-CONDITION)
	 LAM-LAP-SYM)

(DEFPROP CALL-LESS-THAN (PLUS JUMP-LESS-THAN P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-LESS-THAN-XCT-NEXT (PLUS JUMP-LESS-THAN-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-LESS-THAN (PLUS JUMP-LESS-THAN R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-LESS-THAN-XCT-NEXT (PLUS JUMP-LESS-THAN-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-GREATER-THAN (PLUS JUMP-OP JUMP-GREATER-THAN-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-GREATER-THAN-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-GREATER-THAN-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-GREATER-THAN (PLUS JUMP-GREATER-THAN P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-GREATER-THAN-XCT-NEXT
	 (PLUS JUMP-GREATER-THAN-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-GREATER-THAN (PLUS JUMP-GREATER-THAN R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-GREATER-THAN-XCT-NEXT
	 (PLUS JUMP-GREATER-THAN-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-LESS (PLUS JUMP-OP JUMP-LESS-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-LESS-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT JUMP-LESS-CONDITION)
	 LAM-LAP-SYM)

(DEFPROP CALL-LESS (PLUS JUMP-LESS P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-LESS-XCT-NEXT (PLUS JUMP-LESS-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-LESS (PLUS JUMP-LESS R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-LESS-XCT-NEXT (PLUS JUMP-LESS-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-GREATER (PLUS JUMP-OP JUMP-GREATER-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-GREATER-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-GREATER-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-GREATER (PLUS JUMP-GREATER P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-GREATER-XCT-NEXT
	 (PLUS JUMP-GREATER-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-GREATER (PLUS JUMP-GREATER R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-GREATER-XCT-NEXT
	 (PLUS JUMP-GREATER-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-GREATER-OR-EQUAL
	 (PLUS JUMP-OP JUMP-GREATER-OR-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-GREATER-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-GREATER-OR-EQUAL-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-GREATER-OR-EQUAL (PLUS JUMP-GREATER-OR-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-GREATER-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-GREATER-OR-EQUAL-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-GREATER-OR-EQUAL (PLUS JUMP-GREATER-OR-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-GREATER-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-GREATER-OR-EQUAL-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-LESS-OR-EQUAL (PLUS JUMP-OP JUMP-LESS-OR-EQUAL-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-LESS-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-LESS-OR-EQUAL-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-LESS-OR-EQUAL (PLUS JUMP-LESS-OR-EQUAL P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-LESS-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-LESS-OR-EQUAL-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-LESS-OR-EQUAL (PLUS JUMP-LESS-OR-EQUAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-LESS-OR-EQUAL-XCT-NEXT
	 (PLUS JUMP-LESS-OR-EQUAL-XCT-NEXT R-BIT) LAM-LAP-SYM)


(DEFPROP JUMP-IF-PAGE-FAULT (PLUS JUMP-OP JUMP-ON-PAGE-FAULT-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-IF-PAGE-FAULT-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-ON-PAGE-FAULT-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-IF-PAGE-FAULT (PLUS JUMP-IF-PAGE-FAULT P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-PAGE-FAULT-XCT-NEXT
	 (PLUS JUMP-IF-PAGE-FAULT-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-IF-PAGE-FAULT (PLUS JUMP-IF-PAGE-FAULT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-PAGE-FAULT-XCT-NEXT
	 (PLUS JUMP-IF-PAGE-FAULT-XCT-NEXT R-BIT) LAM-LAP-SYM)

(DEFPROP JUMP-IF-PAGE-FAULT-OR-INTERRUPT (PLUS JUMP-OP JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-IF-PAGE-FAULT-OR-INTERRUPT-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-IF-PAGE-FAULT-OR-INTERRUPT (PLUS JUMP-IF-PAGE-FAULT-OR-INTERRUPT P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-PAGE-FAULT-OR-INTERRUPT-XCT-NEXT
	 (PLUS JUMP-IF-PAGE-FAULT-OR-INTERRUPT-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-IF-PAGE-FAULT-OR-INTERRUPT (PLUS JUMP-IF-PAGE-FAULT-OR-INTERRUPT R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-PAGE-FAULT-OR-INTERRUPT-XCT-NEXT
	 (PLUS JUMP-IF-PAGE-FAULT-OR-INTERRUPT-XCT-NEXT R-BIT) LAM-LAP-SYM)

;These really check for page fault, interrupt or sequence break,
;but that makes a hell of a name!
(DEFPROP JUMP-IF-SEQUENCE-BREAK (PLUS JUMP-OP JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-OR-SEQUENCE-BREAK-CONDITION) LAM-LAP-SYM)
(DEFPROP JUMP-IF-SEQUENCE-BREAK-XCT-NEXT
	 (PLUS JUMP-OP-XCT-NEXT JUMP-ON-PAGE-FAULT-OR-INTERRUPT-PENDING-OR-SEQUENCE-BREAK-CONDITION) LAM-LAP-SYM)

(DEFPROP CALL-IF-SEQUENCE-BREAK (PLUS JUMP-IF-SEQUENCE-BREAK P-BIT) LAM-LAP-SYM)
(DEFPROP CALL-IF-SEQUENCE-BREAK-XCT-NEXT
	 (PLUS JUMP-IF-SEQUENCE-BREAK-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-IF-SEQUENCE-BREAK (PLUS JUMP-IF-SEQUENCE-BREAK R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-IF-SEQUENCE-BREAK-XCT-NEXT
	 (PLUS JUMP-IF-SEQUENCE-BREAK-XCT-NEXT R-BIT) LAM-LAP-SYM)

;(DEFPROP WRITE-I-MEM (PLUS JUMP-OP P-BIT R-BIT JUMP-ALWAYS) LAM-LAP-SYM)

(DEFPROP JUMP-CONDITIONAL JUMP-OP LAM-LAP-SYM)	;DEFINED FOR CONVENIENCE
(DEFPROP JUMP-CONDITIONAL-XCT-NEXT JUMP-OP-XCT-NEXT LAM-LAP-SYM) ;LIKEWISE

(DEFPROP CALL-CONDITIONAL (PLUS JUMP-OP P-BIT) LAM-LAP-SYM)	;DEFINED FOR CONVIENENCE
(DEFPROP CALL-CONDITIONAL-XCT-NEXT (PLUS JUMP-OP-XCT-NEXT P-BIT) LAM-LAP-SYM)

(DEFPROP POPJ-CONDITIONAL (PLUS JUMP-CONDITIONAL R-BIT) LAM-LAP-SYM)
(DEFPROP POPJ-CONDITIONAL-XCT-NEXT (PLUS JUMP-CONDITIONAL-XCT-NEXT R-BIT) LAM-LAP-SYM)


(DEFPROP DISPATCH-CALL-XCT-NEXT (PLUS DISPATCH 0) LAM-LAP-SYM)
				;THIS SYM DEFINED FOR CONVIENCE, DISPATCH TABLE MUST
				;HAVE THE RIGHT THING TO MAKE THIS HAPPEN.

(DEFPROP DISPATCH-XCT-NEXT (PLUS DISPATCH 0) LAM-LAP-SYM)  ;LIKEWISE
(DEFPROP DISPATCH-CALL (PLUS DISPATCH 0) LAM-LAP-SYM)	;LIKEWISE
(DEFPROP DISPATCH-POPJ-XCT-NEXT (PLUS DISPATCH 0) LAM-LAP-SYM) ;DITTO

(DEFPROP POPJ-AFTER-NEXT 1_51. LAM-LAP-SYM)

(DEFPROP LDB BYTE-INST LAM-LAP-SYM)
(DEFPROP DPB (PLUS BYTE-INST MR-BIT) LAM-LAP-SYM)	;(LIKE PDP10 DPB)SR-BIT REVERSED
(DEFPROP SELECTIVE-DEPOSIT (PLUS (PLUS BYTE-INST	;(LIKE PDP1 DIP, DAP)
			  MR-BIT) SR-BIT) LAM-LAP-SYM)	;SR-BIT REVERSED

(DEFPROP NO-OP ALU-INST LAM-LAP-SYM)

(DEFPROP SETZ  (FIELD ALU-OP 00) LAM-LAP-SYM)
(DEFPROP AND   (FIELD ALU-OP 01) LAM-LAP-SYM)
(DEFPROP ANDCA (FIELD ALU-OP 02) LAM-LAP-SYM)
(DEFPROP SETM  (FIELD ALU-OP 03) LAM-LAP-SYM)
(DEFPROP ANDCM (FIELD ALU-OP 04) LAM-LAP-SYM)
(DEFPROP SETA  (FIELD ALU-OP 05) LAM-LAP-SYM)
(DEFPROP XOR   (FIELD ALU-OP 06) LAM-LAP-SYM)
(DEFPROP IOR   (FIELD ALU-OP 07) LAM-LAP-SYM)
(DEFPROP ANDCB (FIELD ALU-OP 10) LAM-LAP-SYM)
(DEFPROP EQV   (FIELD ALU-OP 11) LAM-LAP-SYM)
(DEFPROP SETCA (FIELD ALU-OP 12) LAM-LAP-SYM)
(DEFPROP ORCA  (FIELD ALU-OP 13) LAM-LAP-SYM)
(DEFPROP SETCM (FIELD ALU-OP 14) LAM-LAP-SYM)
(DEFPROP ORCM  (FIELD ALU-OP 15) LAM-LAP-SYM)
(DEFPROP ORCB  (FIELD ALU-OP 16) LAM-LAP-SYM)
(DEFPROP SETO  (FIELD ALU-OP 17) LAM-LAP-SYM)

(DEFPROP ADD   (FIELD ALU-OP 31) LAM-LAP-SYM)
(DEFPROP SUB   (PLUS (FIELD ALU-OP 26) ALU-CARRY-IN-ONE) LAM-LAP-SYM)
(DEFPROP SUB-M+1 (FIELD ALU-OP 26) LAM-LAP-SYM)
(DEFPROP M+M   (FIELD ALU-OP 37) LAM-LAP-SYM)
(DEFPROP M+1   (PLUS (FIELD ALU-OP 34) ALU-CARRY-IN-ONE) LAM-LAP-SYM)
(DEFPROP M-A-1 (FIELD ALU-OP 26) LAM-LAP-SYM)
(DEFPROP M+A+1 (PLUS (FIELD ALU-OP 31) ALU-CARRY-IN-ONE) LAM-LAP-SYM)
(DEFPROP M+M+1 (PLUS (FIELD ALU-OP 37) ALU-CARRY-IN-ONE) LAM-LAP-SYM)


(DEFPROP MULTIPLY-STEP (PLUS (PLUS (FIELD ALU-OP 20) SHIFT-Q-RIGHT)
			 OUTPUT-SELECTOR-RIGHTSHIFT-1) LAM-LAP-SYM)
(DEFPROP MULTIPLY-LAST-STEP (PLUS (PLUS (FIELD ALU-OP 21) SHIFT-Q-RIGHT)
			OUTPUT-SELECTOR-RIGHTSHIFT-1) LAM-LAP-SYM)  ;dexter is this right?
(DEFPROP DIVIDE-FIRST-STEP  (PLUS (FIELD SLOW-DESTINATION 1) ;to allow divisor sign to load
				  (PLUS (PLUS (FIELD ALU-OP 22) SHIFT-Q-LEFT)
					OUTPUT-SELECTOR-LEFTSHIFT-1)) LAM-LAP-SYM)
(DEFPROP DIVIDE-STEP (PLUS (PLUS (FIELD ALU-OP 23) SHIFT-Q-LEFT)
			 OUTPUT-SELECTOR-LEFTSHIFT-1) LAM-LAP-SYM)
(DEFPROP DIVIDE-LAST-STEP (PLUS (FIELD ALU-OP 23) SHIFT-Q-LEFT) LAM-LAP-SYM)
(DEFPROP DIVIDE-REMAINDER-CORRECTION-STEP (FIELD ALU-OP 24) LAM-LAP-SYM)

; FUNCTION SOURCES
(DEFPROP READ-I-ARG 
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 10))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-PNTR-AND-DATA
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 11))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP PDL-BUFFER-POINTER (OR (SOURCE-P (FIELD FUNCTION-SOURCE 32))
			        (FIELD FUNCTION-DESTINATION 13)) LAM-LAP-SYM)

(DEFPROP PDL-BUFFER-INDEX (OR (SOURCE-P (FIELD FUNCTION-SOURCE 30))
		 	      (FIELD FUNCTION-DESTINATION 53)) LAM-LAP-SYM)

(DEFPROP C-PDL-BUFFER-INDEX 
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 37))
		    (FIELD FUNCTION-DESTINATION 12)) LAM-LAP-SYM)

(DEFPROP Q-R (OR (SOURCE-P (FIELD FUNCTION-SOURCE 31))
	         (FORCE-ALU 3)) LAM-LAP-SYM)

(DEFPROP READ-MEMORY-DATA (OR (SOURCE-P (FIELD FUNCTION-SOURCE 61))
			      (ERROR)) LAM-LAP-SYM)

(DEFPROP LOCATION-COUNTER (OR (SOURCE-P (FIELD FUNCTION-SOURCE 26))
			      (FIELD FUNCTION-DESTINATION 1)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-PNTR-AND-DATA-POP
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 12))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-POINTER (OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 11)
						 (BYTE-FIELD 8 24.)))
				 (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-POINTER-POP (OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 12)
						     (BYTE-FIELD 8 24.)))
				     (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-DATA (OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 11)
					      (BYTE-FIELD 20. 0)))
			      (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-PC-DATA (OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 11)
					      (BYTE-FIELD 16. 0)))
			      (ERROR)) LAM-LAP-SYM)
(DEFPROP MICRO-STACK-DATA-POP
		(OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 12)
				    (BYTE-FIELD 20. 0)))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-PC-DATA-POP
		(OR (SOURCE-P (PLUS (FIELD FUNCTION-SOURCE 12)
				    (BYTE-FIELD 16. 0)))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP C-PDL-BUFFER-POINTER 
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 76))
		    (FIELD FUNCTION-DESTINATION 10)) LAM-LAP-SYM)

(DEFPROP C-PDL-BUFFER-POINTER-POP
		(OR (SOURCE-P (FIELD FUNCTION-SOURCE 36))
		    (ERROR)) LAM-LAP-SYM)

(DEFPROP INTERRUPT-POINTER (OR (SOURCE-P (FIELD FUNCTION-SOURCE 0))
			       (ERROR)) LAM-LAP-SYM)

(DEFPROP MACRO-IR-DISPLACEMENT (OR (SOURCE-P (FIELD FUNCTION-SOURCE 1))
				   (ERROR)) LAM-LAP-SYM)	;low 6 bits of macro IR

(DEFPROP MACRO-IR (OR (SOURCE-P (FIELD FUNCTION-SOURCE 3))
		      (ERROR)) LAM-LAP-SYM)		;16 bits of current macroinstruction

(DEFPROP STAT-COUNTER (OR (SOURCE-P (FIELD FUNCTION-SOURCE 2))
			  (FIELD FUNCTION-DESTINATION 44)) LAM-LAP-SYM)

(DEFPROP STAT-COUNTER-AUX (OR (SOURCE-P (FIELD FUNCTION-SOURCE 42))
			      (FIELD FUNCTION-DESTINATION 4)) LAM-LAP-SYM)

  ;THE MACRO-IR-DECODE IS A "SLOW" SOURCE BECAUSE A RAM MUST ACCESS DURING THE 
  ; SOURCE CYCLE, THEN COME OVER THE BACKPLANE.
(DEFPROP MACRO-IR-DECODE (OR (SOURCE-P (PLUS I-LONG (FIELD FUNCTION-SOURCE 4)))
			     (PLUS (FIELD SLOW-DESTINATION 1)
				   (FIELD FUNCTION-DESTINATION 5))) LAM-LAP-SYM)

(DEFPROP MACRO-IR-DECODE-MISC-ENABLE
	 (OR (SOURCE-P (PLUS I-LONG (FIELD FUNCTION-SOURCE 44)))
	     (ERROR)) LAM-LAP-SYM)

(DEFPROP SPY-REG (OR (SOURCE-P (FIELD FUNCTION-SOURCE 5))
		     (ERROR)) LAM-LAP-SYM)

(DEFPROP L1-MAP (OR (SOURCE-P
		      (logior clobbers-mem-subr (FIELD FUNCTION-SOURCE 23)))
		    (PLUS (FIELD SLOW-DESTINATION 1)
			  (FIELD FUNCTION-DESTINATION 23)
			  (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP L2-MAP-CONTROL (OR (SOURCE-P
			      (logior clobbers-mem-subr (FIELD FUNCTION-SOURCE 24)))
			    (PLUS (FIELD SLOW-DESTINATION 1)
				  (FIELD FUNCTION-DESTINATION 24)
				  (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP L2-MAP-PHYSICAL-PAGE (OR (SOURCE-P
				    (logior clobbers-mem-subr (FIELD FUNCTION-SOURCE 25)))
				  (PLUS (FIELD SLOW-DESTINATION 1)
					(FIELD FUNCTION-DESTINATION 64)
					(FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

;cram-map dest 26, functional source?  HOWEVER, THIS HAS PROBLEMS.. HAVE TO DO A WRITE
; -LIKE OPERATION TO GET THE RIGHT THING IN THE PC ON A READ.
(DEFPROP CRAM-ADR-MAP (OR (SOURCE-P (FIELD FUNCTION-SOURCE 13))
			  (PLUS (FIELD SLOW-DESTINATION 1)
				(FIELD FUNCTION-DESTINATION 26))) LAM-LAP-SYM)

(DEFPROP CRAM-HIGH (OR (SOURCE-P (ERROR))
		       (PLUS (FIELD SLOW-DESTINATION 1)
			     (FIELD FUNCTION-DESTINATION 6))) LAM-LAP-SYM)

(DEFPROP CRAM-LOW (OR (SOURCE-P (ERROR))
		      (PLUS (FIELD SLOW-DESTINATION 1)
			    (FIELD FUNCTION-DESTINATION 7))) LAM-LAP-SYM)

  ;DUE TO VARIOUS LOSSAGE, MULTIPLIER IS A "SLOW" SOURCE.
(DEFPROP MULTIPLIER (OR (SOURCE-P (PLUS I-LONG (FIELD FUNCTION-SOURCE 46)))
			(FIELD FUNCTION-DESTINATION 37)) LAM-LAP-SYM)

(DEFPROP MULTIPLIER-FT (OR (SOURCE-P (PLUS I-LONG (FIELD FUNCTION-SOURCE 6)))
			   (ERROR)) LAM-LAP-SYM)

;FUNCTION-DESTINATIONS

(DEFPROP INTERRUPT-CLEAR (OR (SOURCE-P (ERROR))
			     (FIELD FUNCTION-DESTINATION 41)) LAM-LAP-SYM)

(DEFPROP RG-MODE (OR (SOURCE-P (FIELD FUNCTION-SOURCE 7))
		     (FIELD FUNCTION-DESTINATION 42)) LAM-LAP-SYM)

(DEFPROP DP-MODE (OR (SOURCE-P (FIELD FUNCTION-SOURCE 35))
		     (FIELD FUNCTION-DESTINATION 2)) LAM-LAP-SYM)

;WRITE-MEMORY-DATA AND MD ARE SYNONYMS.  WRITE-MEMORY-DATA WILL GO
; AWAY EVENTUALLY
(DEFPROP WRITE-MEMORY-DATA 
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 61))
	     (PLUS (FIELD FUNCTION-DESTINATION 30)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP MD  
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 61))
	     (PLUS (FIELD FUNCTION-DESTINATION 30)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP WRITE-MEMORY-DATA-START-WRITE 
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 32)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP WRITE-MEMORY-DATA-START-WRITE-FORCE
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 72)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP MD-START-WRITE 
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 32)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP MD-START-WRITE-FORCE
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 72)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP VMA (OR (SOURCE-P (FIELD FUNCTION-SOURCE 22))
		 (PLUS (FIELD FUNCTION-DESTINATION 20)
		       (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP VMA-START-READ (OR (SOURCE-P (ERROR))
			    (PLUS (FIELD FUNCTION-DESTINATION 21)
				  (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP VMA-START-READ-FORCE
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 61)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP VMA-START-WRITE (OR (SOURCE-P (ERROR))
			     (PLUS (FIELD FUNCTION-DESTINATION 22)
				   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

(DEFPROP VMA-START-WRITE-FORCE
	 (OR (SOURCE-P (ERROR))
	     (PLUS (FIELD FUNCTION-DESTINATION 62)
		   (FIELD CLOBBERS-MEM-SUBR 1))) LAM-LAP-SYM)

;10 C-PDL-BUFFER-POINTER

(DEFPROP C-PDL-BUFFER-POINTER-PUSH 
		(OR (SOURCE-P (ERROR))
		    (FIELD FUNCTION-DESTINATION 11)) LAM-LAP-SYM)

(DEFPROP MICRO-STACK-DATA-PUSH 
		(OR (SOURCE-P (ERROR))
		    (FIELD FUNCTION-DESTINATION 15)) LAM-LAP-SYM)

(DEFPROP OA-REG-LOW (OR (SOURCE-P (ERROR))
			(FIELD FUNCTION-DESTINATION 16)) LAM-LAP-SYM)

(DEFPROP OA-REG-HIGH (OR (SOURCE-P (ERROR))
			 (FIELD FUNCTION-DESTINATION 17)) LAM-LAP-SYM)
(DEFPROP OA-REG-HI (OR (SOURCE-P (ERROR))
		       (FIELD FUNCTION-DESTINATION 17)) LAM-LAP-SYM)

;New names for some things:  pdl-buffer

(DEFPROP PDL-PUSH
	 (OR (SOURCE-P (ERROR))
	     (FIELD FUNCTION-DESTINATION 11)) LAM-LAP-SYM)

(DEFPROP PDL-POP
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 36))
	     (ERROR)) LAM-LAP-SYM)

(DEFPROP PDL-POINTER
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 32))
	     (FIELD FUNCTION-DESTINATION 13)) LAM-LAP-SYM)

(DEFPROP PDL-INDEX
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 30))
	     (FIELD FUNCTION-DESTINATION 53)) LAM-LAP-SYM)

(DEFPROP PDL-TOP
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 76))
	     (FIELD FUNCTION-DESTINATION 10)) LAM-LAP-SYM)

(DEFPROP PDL-POINTER-INDIRECT
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 76))
	     (FIELD FUNCTION-DESTINATION 10)) LAM-LAP-SYM)

(DEFPROP PDL-INDEX-INDIRECT
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 37))
	     (FIELD FUNCTION-DESTINATION 12)) LAM-LAP-SYM)

(DEFPROP C-PDL-INDEX-INC (OR (SOURCE-P (ERROR))
			     (FIELD FUNCTION-DESTINATION 33)) LAM-LAP-SYM)

(DEFPROP C-PDL-INDEX-DEC (OR (SOURCE-P (ERROR))
			     (FIELD FUNCTION-DESTINATION 36)) LAM-LAP-SYM)


;Other things

(DEFPROP I-ARG 
	 (OR (SOURCE-P (FIELD FUNCTION-SOURCE 10))
	     (ERROR)) LAM-LAP-SYM)

;(DEFPROP INSTRUCTION-FETCH (FORCE-DISPATCH 1_24.) LAM-LAP-SYM)
(DEFPROP PUSH-OWN-ADDRESS (FORCE-DISPATCH 1_26.) LAM-LAP-SYM)

; MAP2C-4 IS REALLY FROM THE GC-WRITE-LOGIC, NOT DIRECTLY THE L2MAP, THESE DAYS.
; ALL THESE GUYS HAVE CLOBBERS-MEM-SUBR SET TO ASSURE MAP IS BEING DRIVEN FROM MD
;  (IF PACKET READ WAS IN PROGRESS YOU COULD LOSE EVEN THO YOU HAVE YOUR DATA).
(DEFPROP DISPATCH-ON-MAP2C-4 (PLUS CLOBBERS-MEM-SUBR (FORCE-DISPATCH 1_28.)) LAM-LAP-SYM)
(DEFPROP DISPATCH-ON-MAP2C-5 (PLUS CLOBBERS-MEM-SUBR (FORCE-DISPATCH 1_29.)) LAM-LAP-SYM)
;**kludge** the following are so CADR definitions will win...
(DEFPROP DISPATCH-ON-MAP-18 (PLUS CLOBBERS-MEM-SUBR (FORCE-DISPATCH 1_28.)) LAM-LAP-SYM)
(DEFPROP DISPATCH-ON-MAP-19 (PLUS CLOBBERS-MEM-SUBR (FORCE-DISPATCH 1_29.)) LAM-LAP-SYM)







