;;; -*- Mode:LISP; Base:8; Readtable:T -*-

;	** (c) Copyright 1980 Massachusetts Institute of Technology **
;;; This file contains all the definitions for the machine instruction set
;;; and some other stuff needed by the compiler.


;;; This section contains various information regarding the misc. instructions
;;; on the Lisp Machine.  Every entry is of the form:
;;; (DEFMIC <name> <opcode> <arglist> <lisp-function-p> <no-QINTCMP>)
;;;   <name> is the name of the instruction.  If the Lisp function name
;;; 		is different from the instruction name, this is a cons
;;;		of the function name and the instruction name (e.g. (CAR . M-CAR))
;;;   <opcode> is the number which appears in the macro-instruction.
;;;   <arglist> is a list resembling a lambda-list for the Lisp function
;;;             corresponding to the instruction.  & keywords not allowed.
;;;   <lisp-function-p> should be either T or NIL.  If T, then there
;;;             will be a Lisp function defined in the initial Lisp
;;;             environment (available in the interpreter) corresponding
;;;             to the instruction.
;;;   <no-QINTCMP> is OPTIONAL.  If it is not present it is taken to be NIL.
;;;             If it is non-NIL, then no QINTCMP property will be created
;;;             for the symbol.  Otherwise the QINTCMP property is created from
;;;             the length of <arglist>.  The QINTCMP property permits the
;;;		compiler to compile calls to this function as a misc instruction.

;240 241 FREE
(DEFMIC (CAR . M-CAR) 242 (X) cl:T cl:T)
(DEFMIC (CDR . M-CDR) 243 (X) cl:T cl:T)
(DEFMIC (CAAR . M-CAAR) 244 (X) cl:T cl:T)
(DEFMIC (CADR . M-CADR) 245 (X) cl:T cl:T)
(DEFMIC (CDAR . M-CDAR) 246 (X) cl:T cl:T)
(DEFMIC (CDDR . M-CDDR) 247 (X) cl:T cl:T)
(DEFMIC CAAAR 250 (X) cl:T)
(DEFMIC CAADR 251 (X) cl:T)
(DEFMIC CADAR 252 (X) cl:T)
(DEFMIC CADDR 253 (X) cl:T)
(DEFMIC CDAAR 254 (X) cl:T)
(DEFMIC CDADR 255 (X) cl:T)
(DEFMIC CDDAR 256 (X) cl:T)
(DEFMIC CDDDR 257 (X) cl:T)
(DEFMIC CAAAAR 260 (X) cl:T)
(DEFMIC CAAADR 261 (X) cl:T)
(DEFMIC CAADAR 262 (X) cl:T)
(DEFMIC CAADDR 263 (X) cl:T)
(DEFMIC CADAAR 264 (X) cl:T)
(DEFMIC CADADR 265 (X) cl:T)
(DEFMIC CADDAR 266 (X) cl:T)
(DEFMIC CADDDR 267 (X) cl:T)
(DEFMIC CDAAAR 270 (X) cl:T)
(DEFMIC CDAADR 271 (X) cl:T)
(DEFMIC CDADAR 272 (X) cl:T)
(DEFMIC CDADDR 273 (X) cl:T)
(DEFMIC CDDAAR 274 (X) cl:T)
(DEFMIC CDDADR 275 (X) cl:T)
(DEFMIC CDDDAR 276 (X) cl:T)
(DEFMIC CDDDDR 277 (X) cl:T)

(DEFMIC %LOAD-FROM-HIGHER-CONTEXT 300 (ENVPTR) cl:T)
(DEFMIC %LOCATE-IN-HIGHER-CONTEXT 301 (ENVPTR) cl:T)
(DEFMIC %STORE-IN-HIGHER-CONTEXT 302 (VALUE ENVPTR) cl:T)
(DEFMIC %DATA-TYPE 303 (X) cl:T)
(DEFMIC %POINTER 304 (X) cl:T)
(DEFMIC %MAKE-REST-ARG-SAFE 305 () cl:T)
(DEFMIC %PERMIT-TAIL-RECURSION 306 () cl:NIL cl:T)
(DEFMIC INTERNAL-FLOAT 307 (NUMBER) cl:NIL)
(DEFMIC %MAKE-POINTER 310 (DTP ADDRESS) cl:T)
(DEFMIC %SPREAD 311 (LIST) cl:NIL cl:T)
(DEFMIC %P-STORE-CONTENTS 312 (POINTER VALUE) cl:T)
(DEFMIC %LOGLDB 313 (PPSS WORD) cl:T)		;These don't complain about loading/clobbering
(DEFMIC %LOGDPB 314 (VALUE PPSS WORD) cl:T)	; sign bit. Result is always a fixnum
(DEFMIC LDB 315 (PPSS WORD) cl:T)
(DEFMIC DPB 316 (VALUE PPSS WORD) cl:T)
(DEFMIC %P-STORE-TAG-AND-POINTER 317 (POINTER MISC-FIELDS POINTER-FIELD) cl:T)

(DEFMIC INTERNAL-GET-2 320 (SYMBOL PROPERTY) cl:NIL)
(DEFMIC GETL 321 (SYMBOL PROPERTY-NAME-LIST) cl:T)
(DEFMIC ASSQ 322 (X ALIST) cl:T)
(DEFMIC LAST 323 (LIST) cl:T)
(DEFMIC LENGTH 324 (LIST-OR-ARRAY) cl:T)
(DEFMIC 1+ 325 (N) cl:T)
(DEFMIC 1- 326 (N) cl:T)
(DEFMIC RPLACA 327 (CONS NEW-CAR) cl:T)
(DEFMIC RPLACD 330 (CONS NEW-CDR) cl:T)
(DEFMIC ZEROP 331 (NUMBER) cl:T)
(DEFMIC SET 332 (SYMBOL VALUE) cl:T)
(DEFMIC INTEGERP 333 (X) cl:T)
(DEFMIC (FIXP . INTEGERP) 333 (X) cl:T)
(DEFMIC FLOATP 334 (X) cl:T)
(DEFMIC EQUAL 335 (X Y) cl:T)
(DEFMIC %SET-SELF-MAPPING-TABLE 336 (MAPPING-TABLE) cl:T)
(DEFMIC PDL-WORD 337 (N) cl:NIL cl:T)
(DEFMIC FALSE 340 () cl:T)
(DEFMIC TRUE 341 () cl:T)
(DEFMIC NOT 342 (X) cl:T)
(DEFMIC (NULL . NOT) 342 (X) cl:T)
(DEFMIC ATOM 343 (X) cl:T)
(DEFMIC ODDP 344 (NUMBER) cl:NIL)
(DEFMIC EVENP 345 (NUMBER) cl:NIL)
(DEFMIC %HALT 346 () cl:T)
(DEFMIC GET-PNAME 347 (SYMBOL) cl:T)
(DEFMIC (SYMBOL-NAME . GET-PNAME) 347 (SYMBOL) cl:T)
(DEFMIC LSH 350 (N NBITS) cl:T)
(DEFMIC ROT 351 (N NBITS) cl:T)
(DEFMIC *BOOLE 352 (FN ARG1 ARG2) cl:T)
(DEFMIC NUMBERP 353 (X) cl:T)
(DEFMIC PLUSP 354 (NUMBER) cl:T)
(DEFMIC MINUSP 355 (NUMBER) cl:T)
(DEFMIC |\\| 356 (X Y) cl:T)
(DEFMIC MINUS 357 (NUMBER) cl:T)
(DEFMIC %SXHASH-STRING 360 (STRING CHARACTER-MASK) cl:T)
(DEFMIC VALUE-CELL-LOCATION 361 (SYMBOL) cl:T)
(DEFMIC FUNCTION-CELL-LOCATION 362 (SYMBOL) cl:T)
(DEFMIC PROPERTY-CELL-LOCATION 363 (SYMBOL) cl:T)
(DEFMIC NCONS 364 (CAR) cl:T)
(DEFMIC NCONS-IN-AREA 365 (CAR AREA) cl:T)
(DEFMIC CONS 366 (CAR CDR) cl:T)
(DEFMIC CONS-IN-AREA 367 (CAR CDR AREA) cl:T)
(DEFMIC XCONS 370 (CDR CAR) cl:T)
(DEFMIC XCONS-IN-AREA 371 (CDR CAR AREA) cl:T)
(DEFMIC %SPREAD-N 372 (LIST N) cl:NIL)
(DEFMIC SYMEVAL 373 (SYMBOL) cl:T)
(DEFMIC (SYMBOL-VALUE . SYMEVAL) 373 (SYMBOL) cl:T)
(DEFMIC POP-M-FROM-UNDER-N 374 (NUM-POPS NUM-TO-KEEP) cl:NIL)
(DEFMIC GET-LEXICAL-VALUE-CELL 375 (ENV-LIST SYMBOL-CELL-LOCATION) cl:T)
(DEFMIC %CALL-MULT-VALUE 376 () cl:NIL cl:T)
(DEFMIC %CALL0-MULT-VALUE 377 () cl:NIL cl:T)
(DEFMIC %RETURN-2 400 () cl:NIL cl:T)
(DEFMIC %RETURN-3 401 () cl:NIL cl:T)
(DEFMIC %RETURN-N 402 () cl:NIL cl:T)
(DEFMIC RETURN-NEXT-VALUE 403 (VALUE) cl:NIL)
(DEFMIC RETURN-LIST 404 (VALUES) cl:NIL cl:T)
(DEFMIC UNBIND-TO-INDEX-UNDER-N 405 (N) cl:NIL)
(DEFMIC %BIND 406 (POINTER VALUE) cl:NIL)
(DEFMIC (BIND . %BIND) 406 (POINTER VALUE) cl:NIL)
;; 407 unused
(DEFMIC MEMQ 410 (X LIST) cl:T)
(DEFMIC (INTERNAL-< . M-<) 411 (NUM1 NUM2) cl:T)
(DEFMIC (INTERNAL-> . M->) 412 (NUM1 NUM2) cl:T)
(DEFMIC (INTERNAL-= . M-=) 413 (NUM1 NUM2) cl:T)
(DEFMIC INTERNAL-CHAR-EQUAL 414 (CH1 CH2) cl:T)
(DEFMIC %STRING-SEARCH-CHAR 415 (CHAR STRING START END) cl:T)
(DEFMIC %STRING-EQUAL 416 (STRING1 INDEX1 STRING2 INDEX2 COUNT) cl:T)
(DEFMIC NTH 417 (N LIST) cl:T)
(DEFMIC NTHCDR 420 (N LIST) cl:T)
(DEFMIC (*PLUS . M-+) 421 (NUM1 NUM2) cl:T)
(DEFMIC (*DIF . M--) 422 (NUM1 NUM2) cl:T)
(DEFMIC (*TIMES . M-*) 423 (NUM1 NUM2) cl:T)
(DEFMIC (*QUO . M-//) 424 (NUM1 NUM2) cl:T)
(DEFMIC (*LOGAND . M-LOGAND) 425 (NUM1 NUM2) cl:T)
(DEFMIC (*LOGXOR . M-LOGXOR) 426 (NUM1 NUM2) cl:T)
(DEFMIC (*LOGIOR . M-LOGIOR) 427 (NUM1 NUM2) cl:T)
(DEFMIC ARRAY-LEADER 430 (ARRAY INDEX) cl:T)
(DEFMIC STORE-ARRAY-LEADER 431 (VALUE ARRAY INDEX) cl:T)
(DEFMIC GET-LIST-POINTER-INTO-ARRAY 432 (ARRAY) cl:T)
(DEFMIC ARRAY-PUSH 433 (ARRAY VALUE) cl:T)
(DEFMIC INTERNAL-APPLY 434 (FN ARGS) cl:NIL)	;was APPLY with NO-QINTCMP
(DEFMIC %MAKE-LIST 435 (INITIAL-VALUE AREA LENGTH) cl:T)
(DEFMIC LIST 436 (&REST ELEMENTS) cl:T cl:T)
(DEFMIC LIST* 437 (FIRST &REST ELEMENTS) cl:T cl:T)	;(&REST ELEMENTS LAST)
(DEFMIC LIST-IN-AREA 440 (AREA &REST ELEMENTS) cl:T cl:T)
(DEFMIC LIST*-IN-AREA 441 (AREA FIRST &REST ELEMENTS) cl:T cl:T)   ;(AREA &REST ELEMENTS LAST)
(DEFMIC LOCATE-IN-INSTANCE 442 (INSTANCE SYMBOL) cl:T)
(DEFMIC %P-CDR-CODE 443 (POINTER) cl:T)
(DEFMIC %P-DATA-TYPE 444 (POINTER) cl:T)
(DEFMIC %P-POINTER 445 (POINTER) cl:T)
(DEFMIC %PAGE-TRACE 446 (TABLE) cl:T)
(DEFMIC THROW-N 447 (TAG &REST VALUES-AND-COUNT) cl:NIL cl:T)
(DEFMIC %P-STORE-CDR-CODE 450 (POINTER CDR-CODE) cl:T)
(DEFMIC %P-STORE-DATA-TYPE 451 (POINTER DATA-TYPE) cl:T)
(DEFMIC %P-STORE-POINTER 452 (POINTER POINTER-TO-STORE) cl:T)
(DEFMIC FLOAT-EXPONENT 453 (FLONUM) cl:T)
(DEFMIC FLOAT-FRACTION 454 (FLONUM) cl:T)
(DEFMIC SCALE-FLOAT 455 (FLONUM INTEGER) cl:T)
(DEFMIC %CATCH-OPEN 456 () cl:NIL cl:T)
(DEFMIC %CATCH-OPEN-MV 457 () cl:NIL cl:T)
(DEFMIC INTERNAL-FLOOR-1 460 (DIVIDEND DIVISOR) cl:NIL cl:T)
;;; due to lossage, this INTERNAL-FLOOR-1 is pretty weird.
;;; does not store in its destination.  Instead, destination field decodes:
;;;  0 => FLOOR, 1 => CEIL, 2 => TRUNC, 3 => ROUND

(DEFMIC %DIV 461 (DIVIDEND DIVISOR) cl:T)
(DEFMIC %FEXPR-CALL 462 () cl:NIL cl:T)
(DEFMIC %FEXPR-CALL-MV 463 () cl:NIL cl:T)
(DEFMIC %FEXPR-CALL-MV-LIST 464 () cl:NIL cl:T)
(DEFMIC %CATCH-OPEN-MV-LIST 465 () cl:NIL cl:T)
(DEFMIC *CATCH 466 (TAG &REST FORMS) cl:T cl:T)
(DEFMIC (CATCH . *CATCH) 466 (TAG &REST FORMS) cl:T cl:T)
(DEFMIC %BLT 467 (FROM-ADDRESS TO-ADDRESS COUNT INCREMENT) cl:T)
(DEFMIC *THROW 470 (TAG VALUE) cl:NIL cl:T)
(DEFMIC (THROW . *THROW) 470 (TAG VALUE) cl:NIL cl:T) 
(DEFMIC %XBUS-WRITE-SYNC 471 (IO-ADDR WORD DELAY SYNC-LOC SYNC-MASK SYNC-VAL) cl:T)
(DEFMIC %P-LDB 472 (PPSS POINTER) cl:T)
(DEFMIC %P-DPB 473 (VALUE PPSS POINTER) cl:T)
(DEFMIC MASK-FIELD 474 (PPSS FIXNUM) cl:T)
(DEFMIC %P-MASK-FIELD 475  (PPSS POINTER) cl:T)
(DEFMIC DEPOSIT-FIELD 476 (VALUE PPSS FIXNUM) cl:T)
(DEFMIC %P-DEPOSIT-FIELD 477 (VALUE PPSS POINTER) cl:T)
(DEFMIC COPY-ARRAY-CONTENTS 500 (FROM TO) cl:T)
(DEFMIC COPY-ARRAY-CONTENTS-AND-LEADER 501 (FROM TO) cl:T)
(DEFMIC %FUNCTION-INSIDE-SELF 502 () cl:T)
(DEFMIC ARRAY-HAS-LEADER-P 503 (ARRAY) cl:T)
(DEFMIC COPY-ARRAY-PORTION 504 (FROM-ARRAY FROM-START FROM-END TO-ARRAY TO-START TO-END) cl:T)
(DEFMIC FIND-POSITION-IN-LIST 505 (ELEMENT LIST) cl:T)
(DEFMIC %GET-SELF-MAPPING-TABLE 506 (METHOD-FLAVOR-NAME) cl:T)
(DEFMIC G-L-P 507 (ARRAY) cl:T)
(DEFMIC INTERNAL-FLOOR-2 510 (DIVIDEND DIVISOR) cl:NIL cl:T)
;;; takes two args on stack, two values also to stack.
;;; destination of this one also weird. See INTERNAL-FLOOR-1.
(DEFMIC EQL 511 (X Y) cl:T)
(DEFMIC AR-1 512 (ARRAY SUB) cl:T)
(DEFMIC AR-2 513 (ARRAY SUB1 SUB2) cl:T)
(DEFMIC AR-3 514 (ARRAY SUB1 SUB2 SUB3) cl:T)
(DEFMIC AS-1 515 (VALUE ARRAY SUB) cl:T)
(DEFMIC AS-2 516 (VALUE ARRAY SUB1 SUB2) cl:T)
(DEFMIC AS-3 517 (VALUE ARRAY SUB1 SUB2 SUB3) cl:T)
(DEFMIC %INSTANCE-REF 520 (INSTANCE INDEX) cl:T)
(DEFMIC %INSTANCE-LOC 521 (INSTANCE INDEX) cl:T)
(DEFMIC %INSTANCE-SET 522 (VAL INSTANCE INDEX) cl:T)
(DEFMIC %BINDING-INSTANCES 523 (LIST-OF-SYMBOLS) cl:T)
(DEFMIC %EXTERNAL-VALUE-CELL 524 (SYMBOL) cl:T)
(DEFMIC %USING-BINDING-INSTANCES 525 (BINDING-INSTANCES) cl:T)
(DEFMIC %GC-CONS-WORK 526 (NQS) cl:T)
(DEFMIC %P-CONTENTS-OFFSET 527 (POINTER OFFSET) cl:T)
(DEFMIC %DISK-RESTORE 530 (PARTITION-HIGH-16-BITS LOW-16-BITS) cl:T)
(DEFMIC %DISK-SAVE 531 (MAIN-MEMORY-SIZE PARTITION-HIGH-16-BITS LOW-16-BITS) cl:T)
(DEFMIC %ARGS-INFO 532 (FUNCTION) cl:T)
(DEFMIC %OPEN-CALL-BLOCK 533 (FUNCTION ADI-PAIRS DESTINATION) cl:NIL)
(DEFMIC %PUSH 534 (X) cl:NIL)
(DEFMIC %ACTIVATE-OPEN-CALL-BLOCK 535 () cl:NIL)
(DEFMIC %ASSURE-PDL-ROOM 536 (ROOM) cl:NIL)
(DEFMIC STACK-GROUP-RETURN 537 (X) cl:T)
(DEFMIC AS-2-REVERSE 540 (VALUE ARRAY INDEX2 INDEX1) cl:T)
;Perhaps the next one should be flushed.
(DEFMIC %MAKE-STACK-LIST 541 (N) cl:NIL)
(DEFMIC STACK-GROUP-RESUME 542 (SG X) cl:T)
(DEFMIC %CALL-MULT-VALUE-LIST 543 () cl:NIL cl:T)
(DEFMIC %CALL0-MULT-VALUE-LIST 544 () cl:NIL cl:T)
(DEFMIC %GC-SCAV-RESET 545 (REGION) cl:T)
(DEFMIC %P-STORE-CONTENTS-OFFSET 546 (VALUE POINTER OFFSET) cl:T)
(DEFMIC %GC-FREE-REGION 547 (REGION) cl:T)
(DEFMIC %GC-FLIP 550 (REGION) cl:T)
(DEFMIC ARRAY-LENGTH 551 (ARRAY) cl:T)
(DEFMIC ARRAY-TOTAL-SIZE 551 (ARRAY) cl:T)
(DEFMIC ARRAY-ACTIVE-LENGTH 552 (ARRAY) cl:T)
(DEFMIC %COMPUTE-PAGE-HASH 553 (ADDR) cl:T)
(DEFMIC THROW-SPREAD 554 (TAG VALUE-LIST) cl:T)
(DEFMIC %UNIBUS-READ 555 (UNIBUS-ADDR) cl:T)
(DEFMIC %UNIBUS-WRITE 556 (UNIBUS-ADDR WORD) cl:T)
(DEFMIC %GC-SCAVENGE 557 (WORK-UNITS) cl:T)
(DEFMIC %CHAOS-WAKEUP 560 () cl:T)
(DEFMIC %AREA-NUMBER 561 (X) cl:T)
(DEFMIC *MAX 562 (NUM1 NUM2) cl:T)
(DEFMIC *MIN 563 (NUM1 NUM2) cl:T)
(DEFMIC CLOSURE 565 (SYMBOL-LIST FUNCTION) cl:T)
(DEFMIC AR-2-REVERSE 566 (ARRAY INDEX2 INDEX1) cl:T)
(DEFMIC LISTP 567 (X) cl:T)
(DEFMIC NLISTP 570 (X) cl:T)
(DEFMIC SYMBOLP 571 (X) cl:T)
(DEFMIC NSYMBOLP 572 (X) cl:T)
(DEFMIC ARRAYP 573 (X) cl:T)
(DEFMIC FBOUNDP 574 (SYMBOL) cl:T)
(DEFMIC STRINGP 575 (X) cl:T)
(DEFMIC BOUNDP 576 (SYMBOL) cl:T)
(DEFMIC INTERNAL-\\ 577 (NUM1 NUM2) cl:T)
(DEFMIC FSYMEVAL 600 (SYMBOL) cl:T)
(DEFMIC (SYMBOL-FUNCTION . FSYMEVAL) 600 (SYMBOL) cl:T)
(DEFMIC AP-1 601 (ARRAY SUB) cl:T)
(DEFMIC AP-2 602 (ARRAY SUB1 SUB2) cl:T)
(DEFMIC AP-3 603 (ARRAY SUB1 SUB2 SUB3) cl:T)
(DEFMIC AP-LEADER 604 (ARRAY INDEX) cl:T)
(DEFMIC %P-LDB-OFFSET 605 (PPSS POINTER OFFSET) cl:T)
(DEFMIC %P-DPB-OFFSET 606 (VALUE PPSS POINTER OFFSET) cl:T)
(DEFMIC %P-MASK-FIELD-OFFSET 607 (PPSS POINTER OFFSET) cl:T)
(DEFMIC %P-DEPOSIT-FIELD-OFFSET 610 (VALUE PPSS POINTER OFFSET) cl:T)
(DEFMIC %MULTIPLY-FRACTIONS 611 (NUM1 NUM2) cl:T)
(DEFMIC %DIVIDE-DOUBLE 612 (HIGH-DIVIDEND LOW-DIVIDEND DIVISOR) cl:T)
(DEFMIC %REMAINDER-DOUBLE 613 (HIGH-DIVIDEND LOW-DIVIDEND DIVISOR) cl:T)
(DEFMIC HAULONG 614 (INTEGER) cl:T)
(DEFMIC %ALLOCATE-AND-INITIALIZE 615 (RETURN-DTP HEADER-DTP HEADER WORD2 AREA NQS) cl:T)
(DEFMIC %ALLOCATE-AND-INITIALIZE-ARRAY 616 (HEADER INDEX-LENGTH LEADER-LENGTH AREA NQS) cl:T)
(DEFMIC %MAKE-POINTER-OFFSET 617 (NEW-DTP POINTER OFFSET) cl:T)
(DEFMIC ^ 620 (NUM EXPT) cl:T)
(DEFMIC %CHANGE-PAGE-STATUS 621 (VIRT-ADDR SWAP-STATUS ACCESS-AND-META) cl:T)
(DEFMIC %CREATE-PHYSICAL-PAGE 622 (PHYS-ADDR) cl:T)
(DEFMIC %DELETE-PHYSICAL-PAGE 623 (PHYS-ADDR) cl:T)
(DEFMIC %24-BIT-PLUS 624 (NUM1 NUM2) cl:T)
(DEFMIC %24-BIT-DIFFERENCE 625 (NUM1 NUM2) cl:T)
(DEFMIC %24-BIT-TIMES 626 (NUM1 NUM2) cl:T)
(DEFMIC ABS 627 (NUM) cl:T)
(DEFMIC %POINTER-DIFFERENCE 630 (PTR1 PTR2) cl:T)
(DEFMIC %P-CONTENTS-AS-LOCATIVE 631 (POINTER) cl:T)
(DEFMIC %P-CONTENTS-AS-LOCATIVE-OFFSET 632 (POINTER OFFSET) cl:T)
(DEFMIC (EQ . M-EQ) 633 (X Y) cl:T)
(DEFMIC %STORE-CONDITIONAL 634 (POINTER OLD NEW) cl:T)
(DEFMIC %STACK-FRAME-POINTER 635 () cl:T)
(DEFMIC *UNWIND-STACK 636 (TAG VALUE FRAME-COUNT ACTION) cl:T)
(DEFMIC %XBUS-READ 637 (IO-ADDR) cl:T)
(DEFMIC %XBUS-WRITE 640 (IO-ADDR WORD) cl:T)
(DEFMIC ELT 641 (SEQUENCE INDEX) cl:T)
(DEFMIC MOVE-PDL-TOP 642 cl:NIL cl:NIL cl:T)
(DEFMIC SHRINK-PDL-SAVE-TOP 643 (VALUE-TO-MOVE N-SLOTS) cl:NIL cl:T)
(DEFMIC SPECIAL-PDL-INDEX 644 cl:NIL cl:T)
(DEFMIC UNBIND-TO-INDEX 645 (SPECIAL-PDL-INDEX) cl:NIL cl:T)
(DEFMIC UNBIND-TO-INDEX-MOVE 646 (SPECIAL-PDL-INDEX VALUE-TO-MOVE) cl:NIL cl:T)
(DEFMIC FIX 647 (NUMBER) cl:T)
;; Changed in 95 to exist only for old code. -- now use INTERNAL-FLOAT
(DEFMIC FLOAT 650 (NUMBER OTHER) cl:NIL cl:T)
(DEFMIC SMALL-FLOAT 651 (NUMBER) cl:T)
(DEFMIC %FLOAT-DOUBLE 652 (LOW HIGH) cl:T)
(DEFMIC BIGNUM-TO-ARRAY 653 (BIGNUM BASE) cl:T)
(DEFMIC ARRAY-TO-BIGNUM 654 (ARRAY BASE SIGN) cl:T)
(DEFMIC %UNWIND-PROTECT-CONTINUE 655 (VALUE TAG COUNT ACTION) cl:NIL cl:T)
(DEFMIC %WRITE-INTERNAL-PROCESSOR-MEMORIES 656 (CODE ADR D-HI D-LOW) cl:T)
(DEFMIC %PAGE-STATUS 657 (PTR) cl:T)
(DEFMIC %REGION-NUMBER 660 (PTR) cl:T)
(DEFMIC %FIND-STRUCTURE-HEADER 661 (PTR) cl:T)
(DEFMIC %STRUCTURE-BOXED-SIZE 662 (PTR) cl:T)
(DEFMIC %STRUCTURE-TOTAL-SIZE 663 (PTR) cl:T)
(DEFMIC %MAKE-REGION 664 (BITS SIZE) cl:T)
(DEFMIC BITBLT 665 (ALU WIDTH HEIGHT FROM-ARRAY FROM-X FROM-Y TO-ARRAY TO-X TO-Y) cl:T)
(DEFMIC %DISK-OP 666 (RQB) cl:T)
(DEFMIC %PHYSICAL-ADDRESS 667 (PTR) cl:T)
(DEFMIC POP-OPEN-CALL 670 cl:NIL cl:NIL cl:T)
(DEFMIC %BEEP 671 (HALF-WAVELENGTH DURATION) cl:T)
(DEFMIC %FIND-STRUCTURE-LEADER 672 (PTR) cl:T)
(DEFMIC BPT 673 cl:NIL cl:T)
(DEFMIC %FINDCORE 674 () cl:T)
(DEFMIC %PAGE-IN 675 (PFN VPN) cl:T)
(DEFMIC ASH 676 (N NBITS) cl:T)
(DEFMIC %MAKE-EXPLICIT-STACK-LIST 677 (LENGTH) cl:NIL cl:T)
(DEFMIC %DRAW-CHAR 700 (FONT-ARRAY CHAR-CODE X-BITPOS Y-BITPOS ALU-FUNCTION SHEET) cl:T)
(DEFMIC %DRAW-RECTANGLE 701 (WIDTH HEIGHT X-BITPOS Y-BITPOS ALU-FUNCTION SHEET) cl:T)
(DEFMIC %DRAW-LINE 702 (X0 Y0 X Y ALU DRAW-END-POINT SHEET) cl:T)
(DEFMIC %DRAW-TRIANGLE 703 (X1 Y1 X2 Y2 X3 Y3 ALU SHEET) cl:T)
(DEFMIC %COLOR-TRANSFORM 704 (N17 N16 N15 N14 N13 N12 N11 N10 N7 N6 N5 N4 N3 N2 N1 N0
			      WIDTH HEIGHT ARRAY START-X START-Y) cl:T)
(DEFMIC %RECORD-EVENT 705 (DATA-4 DATA-3 DATA-2 DATA-1 STACK-LEVEL EVENT MUST-BE-4) cl:T)
(DEFMIC %AOS-TRIANGLE 706 (X1 Y1 X2 Y2 X3 Y3 INCREMENT SHEET) cl:T)
(DEFMIC %SET-MOUSE-SCREEN 707 (SHEET) cl:T)
(DEFMIC %OPEN-MOUSE-CURSOR 710 () cl:T)
(DEFMIC SETELT 711 (SEQUENCE INDEX VALUE) cl:T)
(DEFMIC %BLT-TYPED 712 (FROM-ADDRESS TO-ADDRESS COUNT INCREMENT) cl:T)
;(DEFMIC %ETHER-WAKEUP 711 (RESET-P) cl:T)
;(DEFMIC %CHECKSUM-PUP 712 (ART-16B-PUP START LENGTH) cl:T)
;(DEFMIC %DECODE-PUP 713 (ART-BYTE-PUP START LENGTH STATE SUPER-IMAGE-P) cl:T)
(DEFMIC AR-1-FORCE 714 (ARRAY INDEX) cl:T)
(DEFMIC AS-1-FORCE 715 (VALUE ARRAY INDEX) cl:T)
(DEFMIC AP-1-FORCE 716 (ARRAY INDEX) cl:T)
(DEFMIC AREF 717 (ARRAY &REST SUBSCRIPTS) cl:T cl:T)
(DEFMIC ASET 720 (VALUE ARRAY &REST SUBSCRIPTS) cl:T cl:T)
(DEFMIC ALOC 721 (ARRAY &REST SUBSCRIPTS) cl:T cl:T)

(DEFMIC EQUALP 722 (X Y) cl:T)
(DEFMIC %MAKE-EXPLICIT-STACK-LIST* 723 (LENGTH) cl:NIL cl:T)
(DEFMIC SETCAR 724 (CONS NEWCAR) cl:T)
(DEFMIC SETCDR 725 (CONS NEWCDR) cl:T)
(DEFMIC GET-LOCATION-OR-NIL 726 (SYMBOL PROPERTY) cl:T)
(DEFMIC %STRING-WIDTH 727 (TABLE OFFSET STRING START END STOP-WIDTH) cl:NIL)
(DEFMIC AR-1-CACHED-1 730 (ARRAY SUBSCRIPT) cl:T)
(DEFMIC AR-1-CACHED-2 731 (ARRAY SUBSCRIPT) cl:T)

(DEFMIC %MULTIBUS-READ-16 732 (MULTIBUS-BYTE-ADR) cl:T)
(DEFMIC %MULTIBUS-WRITE-16 733 (MULTIBUS-BYTE-ADR WORD) cl:T)
(DEFMIC %MULTIBUS-READ-8 734 (MULTIBUS-BYTE-ADR) cl:T)
(DEFMIC %MULTIBUS-WRITE-8 735 (MULTIBUS-BYTE-ADR WORD) cl:T)
(DEFMIC %MULTIBUS-READ-32 736 (MULTIBUS-BYTE-ADR) cl:T)
(DEFMIC %MULTIBUS-WRITE-32 737 (MULTIBUS-BYTE-ADR WORD) cl:T)

(DEFMIC SET-AR-1 740 (ARRAY SUBSCRIPT VALUE) cl:T)
(DEFMIC SET-AR-2 741 (ARRAY SUBSCRIPT1 SUBSCRIPT2 VALUE) cl:T)
(DEFMIC SET-AR-3 742 (ARRAY SUBSCRIPT1 SUBSCRIPT2 SUBSCRIPT3 VALUE) cl:T)
(DEFMIC SET-AR-1-FORCE 743 (ARRAY SUBSCRIPT VALUE) cl:T)
(DEFMIC SET-AREF 744 (ARRAY &REST SUBSCRIPTS-AND-VALUE) cl:T cl:T)
(DEFMIC SET-ARRAY-LEADER 745 (ARRAY INDEX VALUE) cl:T)
(DEFMIC SET-%INSTANCE-REF 746 (INSTANCE INDEX VALUE) cl:T)
(DEFMIC VECTOR-PUSH 747 (NEW-ELEMENT VECTOR) cl:T)
(DEFMIC ARRAY-HAS-FILL-POINTER-P 750 (ARRAY) cl:T)
(DEFMIC ARRAY-LEADER-LENGTH 751 (ARRAY) cl:T)
(DEFMIC ARRAY-RANK 752 (ARRAY) cl:T)
(DEFMIC ARRAY-DIMENSION 753 (ARRAY DIMENSION) cl:T)
(DEFMIC ARRAY-IN-BOUNDS-P 754 (ARRAY &REST SUBSCRIPTS) cl:T cl:T)
(DEFMIC ARRAY-ROW-MAJOR-INDEX 755 (ARRAY &REST SUBSCRIPTS) cl:T cl:T)

(DEFMIC RETURN-N-KEEP-CONTROL 756 (&REST VALUES N) cl:NIL cl:T)
(DEFMIC RETURN-SPREAD-KEEP-CONTROL 757 (VALUE-LIST) cl:NIL cl:T) 
(DEFMIC COMMON-LISP-LISTP 760 (OBJECT) cl:T)

(DEFMIC %NUBUS-READ 761 (NUBUS-SLOT SLOT-BYTE-ADR) cl:T)
				;SLOT is really the high 8 bits.
				;the "top F" can be supplied via slot, avoiding bignums.
(DEFMIC %NUBUS-WRITE 762 (NUBUS-SLOT SLOT-BYTE-ADR WORD) cl:T)
(DEFMIC %MICROSECOND-TIME 763 () cl:T)		; Returns 32 bits maybe as a bignum
(DEFMIC %FIXNUM-MICROSECOND-TIME 764 () cl:T)
(DEFMIC %IO-SPACE-READ 765 (IO-ADDR) cl:T)
				;32 bit read from HARDWARE-VIRTUAL-ADDRESS space.
				;actual ucode is identical to that for %XBUS-READ on CADR.
(DEFMIC %IO-SPACE-WRITE 766 (IO-ADDR WORD) cl:T) ;actual microcode is identical to %XBUS-WRITE
				;on CADR.
(DEFMIC %NUBUS-PHYSICAL-ADDRESS 767 (APPARENT-PHYSICAL-PAGE) cl:T)
				;arg is "apparent" physical page number (gotten, for example,
				;by shifting value from %PHYSICAL-ADDRESS).
				;value is 22 bit NUBUS page number.

(DEFMIC VECTORP 770 (OBJECT) cl:T)
(DEFMIC SIMPLE-VECTOR-P 771 (OBJECT) cl:T)
(DEFMIC SIMPLE-ARRAY-P 772 (OBJECT) cl:T)
(DEFMIC SIMPLE-STRING-P 773 (OBJECT) cl:T)
(DEFMIC BIT-VECTOR-P 774 (OBJECT) cl:T)
(DEFMIC SIMPLE-BIT-VECTOR-P 775 (OBJECT) cl:T)
(DEFMIC NAMED-STRUCTURE-P 776 (OBJECT) cl:T)
(DEFMIC NAMED-STRUCTURE-SYMBOL 776 (OBJECT) cl:T)
(DEFMIC TYPEP-STRUCTURE-OR-FLAVOR 777 (OBJECT TYPE) cl:T)
(DEFMIC FIXNUMP 1000 (OBJECT) cl:T)
(DEFMIC SMALL-FLOATP 1001 (OBJECT) cl:T)
(DEFMIC CHARACTERP 1002 (OBJECT) cl:T)

(DEFMIC CAR-SAFE 1003 (OBJECT) cl:T)
(DEFMIC CDR-SAFE 1004 (OBJECT) cl:T)
(DEFMIC CADR-SAFE 1005 (OBJECT) cl:T)
(DEFMIC CDDR-SAFE 1006 (OBJECT) cl:T)
(DEFMIC CDDDDR-SAFE 1007 (OBJECT) cl:T)
(DEFMIC NTHCDR-SAFE 1010 (N OBJECT) cl:T)
(DEFMIC NTH-SAFE 1011 (N OBJECT) cl:T)
(DEFMIC CARCDR 1012 (LIST) cl:NIL)
(DEFMIC ENDP 1013 (X) cl:T)
(DEFMIC CONSP-OR-POP 1014 (OBJECT) cl:NIL)
(DEFMIC INDICATORS-VALUE 1015 (OBJECT) cl:NIL cl:T)
(DEFMIC %POINTER-TIMES 1016 (POINTER1 POINTER2) cl:T)
(DEFMIC COMMON-LISP-AREF 1017 (ARRAY &REST INDICES) cl:T cl:T)
(DEFMIC COMMON-LISP-AR-1 1020 (ARRAY INDEX) cl:T)
(DEFMIC COMMON-LISP-AR-1-FORCE 1021 (ARRAY INDEX) cl:T)
(DEFMIC INTERNAL-GET-3 1022 (SYMBOL PROPERTY DEFAULT) cl:NIL cl:T)

(DEFMIC CHAR-INT 1023 (CHAR) cl:T)
(DEFMIC INT-CHAR 1024 (INTEGER) cl:T)
(DEFMIC ALPHA-CHAR-P 1025 (CHAR) cl:T)
(DEFMIC UPPER-CASE-P 1026 (CHAR) cl:T)
(DEFMIC ALPHANUMERICP 1027 (CHAR) cl:T)
(DEFMIC PACKAGE-CELL-LOCATION 1030 (SYMBOL) cl:T)
(DEFMIC MEMBER-EQL 1031 (ELT LIST) cl:T)
(DEFMIC RATIONALP 1032 (OBJECT) cl:T)
(DEFMIC RATIOP 1033 (OBJECT) cl:T)
(DEFMIC COMPLEXP 1034 (OBJECT) cl:T)
(DEFMIC %RATIO-CONS 1035 (NUMERATOR DENOMINATOR) cl:T)
(DEFMIC %COMPLEX-CONS 1036 (REALPART IMAGPART) cl:T)
(DEFMIC BOTH-CASE-P 1037 (CHAR) cl:T)
(DEFMIC CHAR-UPCASE 1040 (CHAR) cl:T)
(DEFMIC CHAR-DOWNCASE 1041 (CHAR) cl:T)
(DEFMIC LOWER-CASE-P 1042 (CHAR) cl:T)

(defmic %micro-paging 1100 (arg) cl:t)
(DEFMIC %PROCESSOR-SWITCHES 1101 (ARG) cl:T)
(DEFMIC %COLD-BOOT 1102 () cl:T)

(defmic %test-multiply-return-low 1103 (n1 n2) cl:t)	;these changed from sys 94 defs.
(defmic %test-multiply-return-high 1104 (n1 n2) cl:t)
(defmic %mult-16 1105 (n1 n2) cl:t)
(defmic %mult-32 1106 (n1 n2) cl:t)

(defmic %quart-transfer 1107 (quart-flags array n-blocks) cl:t)
;;; quart-flags bit0 0-> read, 1-> write. value is number blocks transferred
(defmic %nubus-read-8 1110 (nubus-slot slot-byte-adr) cl:t)
;;; SLOT is really the high 8 bits. The "top F" can be supplied via slot, avoiding bignums.
(defmic %nubus-write-8 1111 (nubus-slot slot-byte-adr word) cl:t)

(defmic %lambda-rg-quad-slot 1112 () cl:t)
(defmic %lambda-tv-quad-slot 1113 () cl:t)
(defmic %lambda-mouse-buttons 1114 () cl:t)
;;; CADR can read mouse buttons directly with %unibus-read.
;;; In LAMBDA, they live in A-mem so we need this.
(defmic %sys-conf-physical-page 1115 () cl:t)
(defmic %lambda-sdu-quad-slot 1116 () cl:t)

;;; FROM HERE TO 1777 FREE

;;;; Instructions and other symbols for LAP

(DEFPROP CALL 0 QLVAL) 

(DEFPROP CALL0 1000 QLVAL) 

(DEFPROP MOVE 2000 QLVAL) 

(DEFPROP CAR 3000 QLVAL) 

(DEFPROP CDR 4000 QLVAL) 

(DEFPROP CADR 5000 QLVAL) 

(DEFPROP CDDR 6000 QLVAL) 

(DEFPROP CDAR 7000 QLVAL) 

(DEFPROP CAAR 10000 QLVAL) 

;ND1
;(DEFPROP UNUSED 11000 QLVAL)			;Not used
(DEFPROP *PLUS 31000 QLVAL)			;These used to be called +, -, etc,
(DEFPROP *DIF 51000 QLVAL)			; but those are now n-arg, while these seven
(DEFPROP *TIMES 71000 QLVAL)			; are two-arguments-only (instructions).
(DEFPROP *QUO 111000 QLVAL) 
(DEFPROP *LOGAND 131000 QLVAL)
(DEFPROP *LOGXOR 151000 QLVAL)
(DEFPROP *LOGIOR 171000 QLVAL)

;ND2
(DEFPROP INTERNAL-= 12000 QLVAL) 
(DEFPROP INTERNAL-> 32000 QLVAL) 
(DEFPROP INTERNAL-< 52000 QLVAL) 
(DEFPROP EQ 72000 QLVAL)
;;; SETE CDR 112000
;;; SETE CDDR 132000
;;; SETE 1+ 152000
;;; SETE 1- 172000

;ND3
;;; 13000 unused, used to be BIND.
(DEFPROP BINDNIL 33000 QLVAL) 
(DEFPROP BINDPOP 53000 QLVAL) 
(DEFPROP SETNIL 73000 QLVAL) 
(DEFPROP SETZERO 113000 QLVAL) 
(DEFPROP PUSH-E 133000 QLVAL)
(DEFPROP MOVEM 153000 QLVAL) 
(DEFPROP POP 173000 QLVAL)

;BRANCH is 14

;MISC
(DEFPROP MISC 15000 QLVAL)
(DEFPROP MISC1 34000 QLVAL)			;MISC code 1000 turns into insn 35000,
						; by adding 34000

;; ND4
(DEFPROP STACK-CLOSURE-DISCONNECT 16000 QLVAL)
(DEFPROP STACK-CLOSURE-UNSHARE 36000 QLVAL)
(DEFPROP MAKE-STACK-CLOSURE 56000 QLVAL)
(DEFPROP PUSH-NUMBER 76000 QLVAL)
(DEFPROP STACK-CLOSURE-DISCONNECT-FIRST 116000 QLVAL)
(DEFPROP PUSH-CDR-IF-CAR-EQUAL 136000 QLVAL)
(DEFPROP PUSH-CDR-STORE-CAR-IF-CONS 156000 QLVAL)

;; AREFI
(DEFPROP AREFI 20000 QLVAL)
(DEFPROP AREFI-LEADER 20100 QLVAL)
(DEFPROP AREFI-INSTANCE 20200 QLVAL)
(DEFPROP AREFI-COMMON-LISP 20300 QLVAL)
(DEFPROP AREFI-SET 20400 QLVAL)
(DEFPROP AREFI-SET-LEADER 20500 QLVAL)
(DEFPROP AREFI-SET-INSTANCE 20600 QLVAL)
;; One unused code


;;; - MISCELLANEOUS FUNCTIONS -
(DEFPROP ASETI 100 QLVAL)
(DEFPROP ASETI-LEADER 120 QLVAL)
(DEFPROP ASETI-INSTANCE 140 QLVAL)

(DEFPROP UNBIND 200 QLVAL)
 (DEFMIC UNBIND-0 200 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-1 201 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-2 202 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-3 203 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-4 204 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-5 205 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-6 206 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-7 207 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-10 210 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-11 211 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-12 212 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-13 213 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-14 214 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-15 215 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-16 216 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC UNBIND-17 217 cl:NIL cl:NIL cl:T)	;FOR UCONS
(DEFPROP POPPDL 220 QLVAL)
 (DEFMIC POPPDL-0 220 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-1 221 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-2 222 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-3 223 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-4 224 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-5 225 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-6 226 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-7 227 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-10 230 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-11 231 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-12 232 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-13 233 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-14 234 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-15 235 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-16 236 cl:NIL cl:NIL cl:T)	;FOR UCONS
 (DEFMIC POPPDL-17 237 cl:NIL cl:NIL cl:T)	;FOR UCONS
;The rest of these come from the DEFMIC table above.

;;;Source address types

(DEFPROP FEF 0 QLVAL) 

(DEFPROP CONST-PAGE 400 QLVAL) 

(DEFPROP LOCBLOCK 500 QLVAL) 

(DEFPROP ARG 600 QLVAL) 

;OBSOLETE NAME
(DEFPROP LPDL 700 QLVAL) 

;Following word holds the actual source address
(DEFPROP EXTEND 776 QLVAL)

(DEFPROP PDL-POP 777 QLVAL)

;DESTINATIONS
(cl:defvar %%MACRO-DEST-FIELD 1602)

(DEFPROP D-IGNORE 0 QLVAL) 

(DEFPROP D-INDS 0 QLVAL) 

(DEFPROP D-PDL 40000 QLVAL)
(DEFPROP D-NEXT 40000 QLVAL) 

(DEFPROP D-RETURN 100000 QLVAL) 

(DEFPROP D-LAST 140000 QLVAL)

;Old values from when the dest field was 3 bits long.
;(DEFPROP D-PDL 20000 QLVAL)
;(DEFPROP D-NEXT 20000 QLVAL) 

;(DEFPROP D-PDL-NEW 40000 QLVAL)

;(DEFPROP D-LAST  60000 QLVAL) 

;(DEFPROP D-RETURN 100000 QLVAL) 

;(DEFPROP D-LAST-NEW 140000 QLVAL)


;(DEFPROP DEST-ARG-QTD 60000 QLVAL) 		;ADDED TO D-NEXT,D-LAST

;(DEFPROP D-NEXT-LIST 160000 QLVAL) 

;;; Properties for the micro-compiler

(DEFPROP M-CAR QMA LAST-ARG-IN-T-ENTRY)
(DEFPROP M-CDR QMD LAST-ARG-IN-T-ENTRY)
(DEFPROP M-CAAR QMAA LAST-ARG-IN-T-ENTRY)
(DEFPROP M-CADR QMAD LAST-ARG-IN-T-ENTRY)
(DEFPROP M-CDAR QMDA LAST-ARG-IN-T-ENTRY)
(DEFPROP M-CDDR QMDD LAST-ARG-IN-T-ENTRY)
(DEFPROP CAAAR QMAAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CAADR QMAAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CADAR QMADA LAST-ARG-IN-T-ENTRY)
(DEFPROP CADDR QMADD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDAAR QMDAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDADR QMDAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDAR QMDDA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDDR QMDDD LAST-ARG-IN-T-ENTRY)
(DEFPROP CAAAAR QMAAAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CAAADR QMAAAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CAADAR QMAADA LAST-ARG-IN-T-ENTRY)
(DEFPROP CAADDR QMAADD LAST-ARG-IN-T-ENTRY)
(DEFPROP CADAAR QMADAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CADADR QMADAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CADDAR QMADDA LAST-ARG-IN-T-ENTRY)
(DEFPROP CADDDR QMADDD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDAAAR QMDAAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDAADR QMDAAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDADAR QMDADA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDADDR QMDADD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDAAR QMDDAA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDADR QMDDAD LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDDAR QMDDDA LAST-ARG-IN-T-ENTRY)
(DEFPROP CDDDDR QMDDDD LAST-ARG-IN-T-ENTRY)

(DEFPROP M-+ XTCADD LAST-ARG-IN-T-ENTRY)	;CHECKS INPUT D.T. TO ASSURE FIXED
(DEFPROP M-- XTCSUB LAST-ARG-IN-T-ENTRY)
(DEFPROP M-* XTCMUL LAST-ARG-IN-T-ENTRY)
(DEFPROP M-// XTCDIV LAST-ARG-IN-T-ENTRY)
(DEFPROP M-LOGAND XTCAND LAST-ARG-IN-T-ENTRY)
(DEFPROP M-LOGXOR XTCXOR LAST-ARG-IN-T-ENTRY)
(DEFPROP M-LOGIOR XTCIOR LAST-ARG-IN-T-ENTRY)

;(DEFPROP XTCADD XTADD NO-TYPE-CHECKING-ENTRY)	;ONE ARG IN T, ONE ON PDL
;(DEFPROP XTCSUB XTSUB NO-TYPE-CHECKING-ENTRY)
;(DEFPROP XTCMUL XTMUL NO-TYPE-CHECKING-ENTRY)
;(DEFPROP XTCDIV XTDIV NO-TYPE-CHECKING-ENTRY)
;(DEFPROP XTCAND XTAND NO-TYPE-CHECKING-ENTRY)
;(DEFPROP XTCXOR XTXOR NO-TYPE-CHECKING-ENTRY)
;(DEFPROP XTCIOR XTIOR NO-TYPE-CHECKING-ENTRY)

;(DEFPROP M-+ XTADD UNBOXED-NUM-IN-T-ENTRY)	;THESE GUYS DONT REALLY CHECK ANYWAY
;(DEFPROP M-- XTSUB UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP M-* XTMUL UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP M-// XTDIV UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP M-LOGAND XTAND UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP M-LOGXOR XTXOR UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP M-LOGIOR XTIOR UNBOXED-NUM-IN-T-ENTRY)

;(DEFPROP M-+ XMADD NO-TYPE-CHECKING-ENTRY)	;THESE ARE A BIT FASTER
;(DEFPROP M-- XMSUB NO-TYPE-CHECKING-ENTRY)	;TAKE 2 ARGS ON PDL
;(DEFPROP M-* XMMUL NO-TYPE-CHECKING-ENTRY)
;(DEFPROP M-// XMDIV NO-TYPE-CHECKING-ENTRY)
;(DEFPROP M-LOGAND XMAND NO-TYPE-CHECKING-ENTRY)
;(DEFPROP M-LOGXOR XMXOR NO-TYPE-CHECKING-ENTRY)
;(DEFPROP M-LOGIOR XMIOR NO-TYPE-CHECKING-ENTRY)

;(DEFPROP ATOM XTATOM LAST-ARG-IN-T-ENTRY)
;(DEFPROP ZEROP XTZERO LAST-ARG-IN-T-ENTRY)
(DEFPROP NUMBERP XTNUMB LAST-ARG-IN-T-ENTRY)
(DEFPROP FIXP XTFIXP LAST-ARG-IN-T-ENTRY)
(DEFPROP FLOATP XTFLTP LAST-ARG-IN-T-ENTRY)
;(DEFPROP PLUSP XTPLUP LAST-ARG-IN-T-ENTRY)
;(DEFPROP MINUSP XTMNSP LAST-ARG-IN-T-ENTRY)
;(DEFPROP MINUS XTMNS LAST-ARG-IN-T-ENTRY)
;(DEFPROP 1+ XT1PLS LAST-ARG-IN-T-ENTRY)
;(DEFPROP 1- XT1MNS LAST-ARG-IN-T-ENTRY)
;(DEFPROP SYMEVAL XTSYME LAST-ARG-IN-T-ENTRY)
(DEFPROP LENGTH XTLENG LAST-ARG-IN-T-ENTRY)

;(DEFPROP ZEROP XBZERO UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP PLUSP XBPLUP UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP MINUSP XBMNSP UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP MINUS XBMNS UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP 1+ XB1PLS UNBOXED-NUM-IN-T-ENTRY)
;(DEFPROP 1- XB1MNS UNBOXED-NUM-IN-T-ENTRY)

;;; Certain MISC-instructions make assumptions about what destinations
;;; they are used with.  Some require D-IGNORE, because they assume that
;;; there is no return address on the micro-stack.  Some do not allow D-IGNORE,
;;; because they popj and start a memory cycle.  Some are really random.
(cl:DEFVAR MISC-INSTRUCTION-REQUIRED-DESTINATION-ALIST
	'((%ALLOCATE-AND-INITIALIZE D-PDL D-NEXT D-LAST D-RETURN)
	  (%ALLOCATE-AND-INITIALIZE-ARRAY D-PDL D-NEXT D-LAST D-RETURN)
	  (%SPREAD D-NEXT D-LAST)
	  (RETURN-LIST D-RETURN)
	  (%OPEN-CALL-BLOCK D-IGNORE D-INDS)
	  (%ACTIVATE-OPEN-CALL-BLOCK D-IGNORE D-INDS)
	  (%RETURN-2 D-IGNORE D-INDS)
	  (%RETURN-3 D-IGNORE D-INDS)
	  (%RETURN-N D-IGNORE D-INDS)
	  (%RETURN-NEXT-VALUE D-IGNORE D-INDS)))