;;; -*- Mode: Lisp; Package: USER; Syntax: Common-Lisp; Base: 10 -*- ;;;; (IN-PACKAGE "USER") ; Creation date: April 4, 2000 11:16:11 ; Created as: /stage/ftp/pub/boyer/pc-nqthm/pc-nqthm-1992/examples/mg/c-predefined1.lisp ; Associated file: /stage/ftp/pub/boyer/pc-nqthm/pc-nqthm-1992/examples/mg/c-predefined1.lib (EVAL-WHEN (LOAD EVAL COMPILE) (CHK-BASE-AND-PACKAGE-1992 10 *PACKAGE*)) (COND ((NOT (EQUAL LIB-DATE 1000404111611)) (ERROR1 (QUOTE (PROGN |Attempt| |to| |load| |the| |wrong| |.lisp| |or| |compiled| |file| EXCL |the| |variable| LIB-DATE |has| |the| |value| (!PPR LIB-DATE NIL) |,| |but| |the| |date| |in| |the| |.lisp| |or| |compiled| |file| |is| (!PPR DATE NIL) |.|)) (LIST (CONS (QUOTE LIB-DATE) LIB-DATE) (CONS (QUOTE DATE) 1000404111611)) (QUOTE HARD)))) (DEFUN *1*GREATERP (*3*X *3*Y) (*1*LESSP *3*Y *3*X)) (DEFUN *1*LEQ (*3*X *3*Y) (*1*NOT (*1*LESSP *3*Y *3*X))) (DEFUN *1*GEQ (*3*X *3*Y) (*1*NOT (*1*LESSP *3*X *3*Y))) (DEFUN *1*MEMBER (*3*X *3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*FALSE)) ((EQUAL *3*X (*1*CAR *3*LST)) (QUOTE *1*TRUE)) (T (*1*MEMBER *3*X (*1*CDR *3*LST))))) (DEFUN *1*IFF (*3*P *3*Q) (COND ((NOT (EQ *3*P *1*F)) (COND ((NOT (EQ *3*Q *1*F)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) ((NOT (EQ *3*Q *1*F)) (QUOTE *1*FALSE)) (T (QUOTE *1*TRUE)))) (DEFUN *1*LEX2 (*3*L1 *3*L2) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*OR (*1*LESSP (SETQ *2*TEMP2 (*1*CAR *3*L1)) (SETQ *2*TEMP1 (*1*CAR *3*L2))) (*1*AND (COND ((EQUAL *2*TEMP2 *2*TEMP1) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*LESSP (*1*CAR (*1*CDR *3*L1)) (*1*CAR (*1*CDR *3*L2))))))) (DEFUN *1*LEX3 (*3*L1 *3*L2) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*OR (*1*LESSP (SETQ *2*TEMP2 (*1*CAR *3*L1)) (SETQ *2*TEMP1 (*1*CAR *3*L2))) (*1*AND (COND ((EQUAL *2*TEMP2 *2*TEMP1) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*LEX2 (*1*CDR *3*L1) (*1*CDR *3*L2)))))) (DEFUN *1*LENGTH (*3*LST) (COND ((AND (CONSP *3*LST) (NOT (EQ (CAR *3*LST) (QUOTE *1*QUOTE)))) (*1*ADD1 (*1*LENGTH (CDR *3*LST)))) (T (QUOTE 0)))) (DEFUN *1*SUBSETP (*3*X *3*Y) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*MEMBER (*1*CAR *3*X) *3*Y) *1*F)) (*1*SUBSETP (*1*CDR *3*X) *3*Y)) (T (QUOTE *1*FALSE)))) (DEFUN *1*LAST (*3*L) (COND ((AND (CONSP *3*L) (NOT (EQ (CAR *3*L) (QUOTE *1*QUOTE)))) (COND ((AND (CONSP (CDR *3*L)) (NOT (EQ (CAR (CDR *3*L)) (QUOTE *1*QUOTE)))) (*1*LAST (CDR *3*L))) (T *3*L))) (T *3*L))) (DEFUN *1*LOOKUP (*3*X *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*CAR *3*ALIST))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQUAL *3*X (*1*CAR *2*TEMP1)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) *1*F)) (*1*CDR *2*TEMP1)) (T (*1*LOOKUP *3*X (*1*CDR *3*ALIST)))))) (DEFUN *1*EVAL$ (*3*FLG *3*X *3*A) (LET ((REDUCE-TERM-CLOCK (1- REDUCE-TERM-CLOCK))) (COND ((INT= 0 REDUCE-TERM-CLOCK) (IPRINC (QUOTE EVAL$) COMMENT-WINDOW) (IPRINC (QUOTE | aborted. |) COMMENT-WINDOW) (THROW (QUOTE REDUCE-TERM) (QUOTE *1*FAILED))) (T (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((EQ *3*FLG (QUOTE LIST)) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (QUOTE NIL)) (T (CONS (*1*EVAL$ (QUOTE *1*TRUE) (*1*CAR *3*X) *3*A) (*1*EVAL$ (QUOTE LIST) (*1*CDR *3*X) *3*A))))) ((NOT (EQ (*1*LITATOM *3*X) *1*F)) (*1*LOOKUP *3*X *3*A)) ((NOT (EQ (*1*NLISTP *3*X) *1*F)) *3*X) ((EQ (SETQ *2*TEMP1 (*1*CAR *3*X)) (QUOTE QUOTE)) (*1*CAR (*1*CDR *3*X))) (T (*1*APPLY$ *2*TEMP1 (*1*EVAL$ (QUOTE LIST) (*1*CDR *3*X) *3*A))))))))) (DEFUN *1*IDENTITY (*3*X) *3*X) (DEFUN *1*NAME (*3*EXP) (*1*CAR *3*EXP)) (DEFUN *1*ASSOC (*3*X *3*Y) (COND ((AND (CONSP *3*Y) (NOT (EQ (CAR *3*Y) (QUOTE *1*QUOTE)))) (COND ((EQUAL *3*X (*1*CAR (CAR *3*Y))) (CAR *3*Y)) (T (*1*ASSOC *3*X (CDR *3*Y))))) (T (QUOTE *1*FALSE)))) (DEFUN *1*VALUE (*3*NAME *3*ALIST) (*1*CDR (*1*ASSOC *3*NAME *3*ALIST))) (DEFUN *1*MAX (*3*X *3*Y) (COND ((NOT (EQ (*1*LESSP *3*X *3*Y) *1*F)) *3*Y) (T *3*X))) (DEFUN *1*APPEND (*3*X *3*Y) (COND ((AND (CONSP *3*X) (NOT (EQ (CAR *3*X) (QUOTE *1*QUOTE)))) (CONS (CAR *3*X) (*1*APPEND (CDR *3*X) *3*Y))) (T *3*Y))) (DEFUN *1*PLISTP (*3*X) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (COND ((EQ *3*X (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*PLISTP (*1*CDR *3*X))))) (DEFUN *1*LENGTH-PLISTP (*3*LST *3*N) (*1*AND (*1*PLISTP *3*LST) (COND ((EQUAL (*1*LENGTH *3*LST) *3*N) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*REVERSE (*3*X) (COND ((AND (CONSP *3*X) (NOT (EQ (CAR *3*X) (QUOTE *1*QUOTE)))) (*1*APPEND (*1*REVERSE (CDR *3*X)) (CONS (CAR *3*X) (QUOTE NIL)))) (T (QUOTE NIL)))) (DEFUN *1*SUBSET (*3*X *3*Y) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*MEMBER (*1*CAR *3*X) *3*Y) (*1*SUBSET (*1*CDR *3*X) *3*Y))))) (DEFUN *1*LISTCARS (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE NIL)) (T (CONS (*1*CAR (*1*CAR *3*LST)) (*1*LISTCARS (*1*CDR *3*LST)))))) (DEFUN *1*NO-DUPLICATES (*3*LST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*MEMBER (*1*CAR *3*LST) (SETQ *2*TEMP1 (*1*CDR *3*LST))) *1*F)) (QUOTE *1*FALSE)) (T (*1*NO-DUPLICATES *2*TEMP1))))) (DEFUN *1*ALL-CARS-UNIQUE (*3*LST) (*1*NO-DUPLICATES (*1*LISTCARS *3*LST))) (DEFUN *1*EXP (*3*X *3*Y) (COND ((NOT (EQ (*1*ZEROP *3*Y) *1*F)) (QUOTE 1)) (T (*1*TIMES *3*X (*1*EXP *3*X (*1*SUB1 *3*Y)))))) (DEFUN *1*INTEGERP (*3*X) (*1*OR (*1*AND (*1*NEGATIVEP *3*X) (*1*NOT (COND ((EQUAL (*1*NEGATIVE-GUTS *3*X) (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (*1*NUMBERP *3*X))) (DEFUN *1*ILESSP (*3*X *3*Y) (LET NIL (COND ((NOT (EQ (*1*NEGATIVEP *3*X) *1*F)) (COND ((NOT (EQ (*1*NEGATIVEP *3*Y) *1*F)) (*1*LESSP (*1*NEGATIVE-GUTS *3*Y) (*1*NEGATIVE-GUTS *3*X))) (T (QUOTE *1*TRUE)))) ((NOT (EQ (*1*NEGATIVEP *3*Y) *1*F)) (QUOTE *1*FALSE)) (T (*1*LESSP *3*X *3*Y))))) (DEFUN *1*IPLUS (*3*I *3*J) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NEGATIVEP *3*I) *1*F)) (COND ((NOT (EQ (*1*NEGATIVEP *3*J) *1*F)) (*1*MINUS (*1*PLUS (*1*NEGATIVE-GUTS *3*I) (*1*NEGATIVE-GUTS *3*J)))) ((NOT (EQ (*1*LESSP *3*J (SETQ *2*TEMP2 (*1*NEGATIVE-GUTS *3*I))) *1*F)) (*1*MINUS (*1*DIFFERENCE *2*TEMP2 *3*J))) (T (*1*DIFFERENCE *3*J *2*TEMP2)))) ((NOT (EQ (*1*NEGATIVEP *3*J) *1*F)) (COND ((NOT (EQ (*1*LESSP *3*I (SETQ *2*TEMP1 (*1*NEGATIVE-GUTS *3*J))) *1*F)) (*1*MINUS (*1*DIFFERENCE *2*TEMP1 *3*I))) (T (*1*DIFFERENCE *3*I *2*TEMP1)))) (T (*1*PLUS *3*I *3*J))))) (DEFUN *1*INEGATE (*3*I) (COND ((NOT (EQ (*1*NEGATIVEP *3*I) *1*F)) (*1*NEGATIVE-GUTS *3*I)) ((NOT (EQ (*1*ZEROP *3*I) *1*F)) (QUOTE 0)) (T (*1*MINUS *3*I)))) (DEFUN *1*IDIFFERENCE (*3*I *3*J) (*1*IPLUS *3*I (*1*INEGATE *3*J))) (DEFUN *1*ILEQ (*3*X *3*Y) (*1*NOT (*1*ILESSP *3*Y *3*X))) (DEFUN *1*NTH (*3*X *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) *3*X) (T (*1*NTH (*1*CDR *3*X) (*1*SUB1 *3*N))))) (DEFUN *1*INDEX (*3*Y *3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE 0)) ((EQUAL *3*Y (*1*CAR *3*LST)) (QUOTE 1)) (T (*1*ADD1 (*1*INDEX *3*Y (*1*CDR *3*LST)))))) (DEFUN *1*GET (*3*N *3*LST) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (*1*CAR *3*LST)) (T (*1*GET (*1*SUB1 *3*N) (*1*CDR *3*LST))))) (DEFUN *1*PUT (*3*VAL *3*N *3*LST) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (COND ((AND (CONSP *3*LST) (NOT (EQ (CAR *3*LST) (QUOTE *1*QUOTE)))) (CONS *3*VAL (CDR *3*LST))) (T (CONS *3*VAL (QUOTE NIL))))) (T (CONS (*1*CAR *3*LST) (*1*PUT *3*VAL (*1*SUB1 *3*N) (*1*CDR *3*LST)))))) (DEFUN *1*PUT-ASSOC (*3*VAL *3*NAME *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) *3*ALIST) ((EQUAL *3*NAME (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*ALIST)))) (CONS (CONS *3*NAME *3*VAL) (*1*CDR *3*ALIST))) (T (CONS *2*TEMP1 (*1*PUT-ASSOC *3*VAL *3*NAME (*1*CDR *3*ALIST))))))) (DEFUN *1*DEFINEDP (*3*NAME *3*ALIST) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE *1*FALSE)) ((EQUAL *3*NAME (*1*CAR (*1*CAR *3*ALIST))) (QUOTE *1*TRUE)) (T (*1*DEFINEDP *3*NAME (*1*CDR *3*ALIST))))) (DEFUN *1*RESTRICT (*3*ALIST *3*NAMES) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*MEMBER (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*ALIST))) *3*NAMES) *1*F)) (CONS *2*TEMP1 (*1*RESTRICT (*1*CDR *3*ALIST) *3*NAMES))) (T (*1*RESTRICT (*1*CDR *3*ALIST) *3*NAMES))))) (DEFUN *1*RESTRICTION-INDUCTION-HINT (*3*ALIST *3*NAMES1 *3*NAMES2) (LET NIL (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*MEMBER (*1*CAR (*1*CAR *3*ALIST)) *3*NAMES1) *1*F)) (*1*RESTRICTION-INDUCTION-HINT (*1*CDR *3*ALIST) (*1*CDR *3*NAMES1) *3*NAMES2)) (T (*1*RESTRICTION-INDUCTION-HINT (*1*CDR *3*ALIST) *3*NAMES1 (*1*CDR *3*NAMES2)))))) (DEFUN *1*DOUBLE-CDR-INDUCTION (*3*X *3*Y) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (QUOTE *1*TRUE)) (T (*1*DOUBLE-CDR-INDUCTION (*1*CDR *3*X) (*1*CDR *3*Y))))) (DEFUN *1*SIGNATURES-MATCH (*3*ALIST1 *3*ALIST2) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST1) *1*F)) (COND ((EQ *3*ALIST2 (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (COND ((EQUAL (*1*CAR (SETQ *2*TEMP2 (*1*CAR *3*ALIST1))) (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*ALIST2)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((EQUAL (*1*CAR (*1*CDR *2*TEMP2)) (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*SIGNATURES-MATCH (*1*CDR *3*ALIST1) (*1*CDR *3*ALIST2)))))))) (DEFUN *1*SIGNATURE (*3*MG-VARS-LIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*MG-VARS-LIST) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*MG-VARS-LIST))) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (*1*SIGNATURE (*1*CDR *3*MG-VARS-LIST))))))) (DEFUN *1*ONE-WAY-DISJOINT (*3*LST1 *3*LST2) (COND ((NOT (EQ (*1*NLISTP *3*LST1) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*NOT (*1*MEMBER (*1*CAR *3*LST1) *3*LST2)) (*1*ONE-WAY-DISJOINT (*1*CDR *3*LST1) *3*LST2))))) (DEFUN *1*DISJOINT (*3*LST1 *3*LST2) (*1*AND (*1*ONE-WAY-DISJOINT *3*LST1 *3*LST2) (*1*ONE-WAY-DISJOINT *3*LST2 *3*LST1))) (DEFUN *1*COND-SUBSETP (*3*LST1 *3*LST2) (COND ((NOT (EQ (*1*NLISTP *3*LST1) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*MEMBER (*1*CAR *3*LST1) (CONS (QUOTE LEAVE) (CONS (QUOTE ROUTINEERROR) *3*LST2))) (*1*COND-SUBSETP (*1*CDR *3*LST1) *3*LST2))))) (DEFUN *1*P-STATEP (X) (COND ((AND (CONSP X) (EQ (CAR X) *1*SHELL-QUOTE-MARK) (EQ (CADR X) (QUOTE P-STATE))) *1*T) (T *1*F))) (DEFUN *1*P-PC (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR X)))) (T (*1*ZERO)))) (DEFUN *1*P-CTRL-STK (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR X))))) (T (*1*ZERO)))) (DEFUN *1*P-TEMP-STK (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR X)))))) (T (*1*ZERO)))) (DEFUN *1*P-PROG-SEGMENT (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR X))))))) (T (*1*ZERO)))) (DEFUN *1*P-DATA-SEGMENT (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR (CDR X)))))))) (T (*1*ZERO)))) (DEFUN *1*P-MAX-CTRL-STK-SIZE (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR (CDR (CDR X))))))))) (T (*1*ZERO)))) (DEFUN *1*P-MAX-TEMP-STK-SIZE (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR X)))))))))) (T (*1*ZERO)))) (DEFUN *1*P-WORD-SIZE (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR X))))))))))) (T (*1*ZERO)))) (DEFUN *1*P-PSW (X) (COND ((EQ (*1*P-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR (CDR X)))))))))))) (T (*1*ZERO)))) (DEFUN *1*P-STATE (P-PC P-CTRL-STK P-TEMP-STK P-PROG-SEGMENT P-DATA-SEGMENT P-MAX-CTRL-STK-SIZE P-MAX-TEMP-STK-SIZE P-WORD-SIZE P-PSW) (LIST *1*SHELL-QUOTE-MARK (QUOTE P-STATE) P-PC P-CTRL-STK P-TEMP-STK P-PROG-SEGMENT P-DATA-SEGMENT P-MAX-CTRL-STK-SIZE P-MAX-TEMP-STK-SIZE P-WORD-SIZE P-PSW)) (DEFUN *1*P-HALT (*3*P *3*PSW) (*1*P-STATE (*1*P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*P-TEMP-STK *3*P) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) *3*PSW)) (DEFUN *1*DEFINITION (*3*NAME *3*ALIST) (*1*ASSOC *3*NAME *3*ALIST)) (DEFUN *1*PUT-VALUE (*3*VAL *3*NAME *3*ALIST) (*1*PUT-ASSOC *3*VAL *3*NAME *3*ALIST)) (DEFUN *1*FORMAL-VARS (*3*D) (*1*CAR (*1*CDR *3*D))) (DEFUN *1*TEMP-VAR-DCLS (*3*D) (*1*CAR (*1*CDR (*1*CDR *3*D)))) (DEFUN *1*PROGRAM-BODY (*3*D) (*1*CDR (*1*CDR (*1*CDR *3*D)))) (DEFUN *1*ADP-NAME (*3*ADP) (*1*CAR *3*ADP)) (DEFUN *1*ADP-OFFSET (*3*ADP) (*1*CDR *3*ADP)) (DEFUN *1*ADPP (*3*X *3*SEGMENT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP *3*X) (NOT (EQ (CAR *3*X) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*NUMBERP (SETQ *2*TEMP2 (*1*ADP-OFFSET *3*X))) (*1*AND (*1*DEFINEDP (SETQ *2*TEMP1 (*1*ADP-NAME *3*X)) *3*SEGMENT) (*1*LESSP *2*TEMP2 (*1*LENGTH (*1*VALUE *2*TEMP1 *3*SEGMENT)))))))) (DEFUN *1*PCPP (*3*X *3*SEGMENT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP *3*X) (NOT (EQ (CAR *3*X) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*NUMBERP (SETQ *2*TEMP2 (*1*ADP-OFFSET *3*X))) (*1*AND (*1*DEFINEDP (SETQ *2*TEMP1 (*1*ADP-NAME *3*X)) *3*SEGMENT) (*1*LESSP *2*TEMP2 (*1*LENGTH (*1*PROGRAM-BODY (*1*DEFINITION *2*TEMP1 *3*SEGMENT))))))))) (DEFUN *1*ADD-ADP (*3*ADP *3*N) (CONS (*1*ADP-NAME *3*ADP) (*1*PLUS (*1*ADP-OFFSET *3*ADP) *3*N))) (DEFUN *1*ADD1-ADP (*3*ADP) (*1*ADD-ADP *3*ADP (QUOTE 1))) (DEFUN *1*SUB-ADP (*3*ADP *3*N) (CONS (*1*ADP-NAME *3*ADP) (*1*DIFFERENCE (*1*ADP-OFFSET *3*ADP) *3*N))) (DEFUN *1*FETCH-ADP (*3*ADP *3*SEGMENT) (*1*GET (*1*ADP-OFFSET *3*ADP) (*1*VALUE (*1*ADP-NAME *3*ADP) *3*SEGMENT))) (DEFUN *1*DEPOSIT-ADP (*3*VAL *3*ADP *3*SEGMENT) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*PUT-VALUE (*1*PUT *3*VAL (*1*ADP-OFFSET *3*ADP) (*1*VALUE (SETQ *2*TEMP1 (*1*ADP-NAME *3*ADP)) *3*SEGMENT)) *2*TEMP1 *3*SEGMENT))) (DEFUN *1*RGET (*3*N *3*LST) (*1*GET (*1*SUB1 (*1*DIFFERENCE (*1*LENGTH *3*LST) *3*N)) *3*LST)) (DEFUN *1*RPUT (*3*VAL *3*N *3*LST) (*1*PUT *3*VAL (*1*SUB1 (*1*DIFFERENCE (*1*LENGTH *3*LST) *3*N)) *3*LST)) (DEFUN *1*TAG (*3*TYPE *3*OBJ) (CONS *3*TYPE (CONS *3*OBJ (QUOTE NIL)))) (DEFUN *1*TYPE (*3*CONST) (*1*CAR *3*CONST)) (DEFUN *1*UNTAG (*3*CONST) (*1*CAR (*1*CDR *3*CONST))) (DEFUN *1*AREA-NAME (*3*X) (*1*ADP-NAME (*1*UNTAG *3*X))) (DEFUN *1*OFFSET (*3*X) (*1*ADP-OFFSET (*1*UNTAG *3*X))) (DEFUN *1*ADD-ADDR (*3*ADDR *3*N) (*1*TAG (*1*TYPE *3*ADDR) (*1*ADD-ADP (*1*UNTAG *3*ADDR) *3*N))) (DEFUN *1*ADD1-ADDR (*3*ADDR) (*1*ADD-ADDR *3*ADDR (QUOTE 1))) (DEFUN *1*SUB-ADDR (*3*ADDR *3*N) (*1*TAG (*1*TYPE *3*ADDR) (*1*SUB-ADP (*1*UNTAG *3*ADDR) *3*N))) (DEFUN *1*SUB1-ADDR (*3*ADDR) (*1*SUB-ADDR *3*ADDR (QUOTE 1))) (DEFUN *1*FETCH (*3*ADDR *3*SEGMENT) (*1*FETCH-ADP (*1*UNTAG *3*ADDR) *3*SEGMENT)) (DEFUN *1*DEPOSIT (*3*VAL *3*ADDR *3*SEGMENT) (*1*DEPOSIT-ADP *3*VAL (*1*UNTAG *3*ADDR) *3*SEGMENT)) (DEFUN *1*ADD1-NAT (*3*NAT) (*1*TAG (QUOTE NAT) (*1*ADD1 (*1*UNTAG *3*NAT)))) (DEFUN *1*BOOLEANP (*3*X) (*1*OR (COND ((EQ *3*X (QUOTE T)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQ *3*X (QUOTE F)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*BOOL (*3*X) (*1*TAG (QUOTE BOOL) (COND ((NOT (EQ *3*X *1*F)) (QUOTE T)) (T (QUOTE F))))) (DEFUN *1*OR-BOOL (*3*X *3*Y) (COND ((EQ *3*X (QUOTE F)) *3*Y) (T (QUOTE T)))) (DEFUN *1*AND-BOOL (*3*X *3*Y) (COND ((EQ *3*X (QUOTE F)) (QUOTE F)) (T *3*Y))) (DEFUN *1*NOT-BOOL (*3*X) (COND ((EQ *3*X (QUOTE F)) (QUOTE T)) (T (QUOTE F)))) (DEFUN *1*SMALL-NATURALP (*3*I *3*WORD-SIZE) (*1*AND (*1*NUMBERP *3*I) (*1*LESSP *3*I (*1*EXP (QUOTE 2) *3*WORD-SIZE)))) (DEFUN *1*BOOL-TO-NAT (*3*FLG) (COND ((EQ *3*FLG (QUOTE F)) (QUOTE 0)) (T (QUOTE 1)))) (DEFUN *1*SMALL-INTEGERP (*3*I *3*WORD-SIZE) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*INTEGERP *3*I) (*1*AND (*1*NOT (*1*ILESSP *3*I (*1*MINUS (SETQ *2*TEMP1 (*1*EXP (QUOTE 2) (*1*SUB1 *3*WORD-SIZE)))))) (*1*ILESSP *3*I *2*TEMP1))))) (DEFUN *1*FIX-SMALL-INTEGER (*3*I *3*WORD-SIZE) (LET NIL (COND ((NOT (EQ (*1*SMALL-INTEGERP *3*I *3*WORD-SIZE) *1*F)) *3*I) ((NOT (EQ (*1*NEGATIVEP *3*I) *1*F)) (*1*IPLUS *3*I (*1*EXP (QUOTE 2) *3*WORD-SIZE))) (T (*1*IPLUS *3*I (*1*MINUS (*1*EXP (QUOTE 2) *3*WORD-SIZE))))))) (DEFUN *1*PUSH (*3*X *3*STK) (CONS *3*X *3*STK)) (DEFUN *1*TOP (*3*STK) (*1*CAR *3*STK)) (DEFUN *1*POP (*3*STK) (*1*CDR *3*STK)) (DEFUN *1*POPN (*3*N *3*X) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) *3*X) (T (*1*POPN (*1*SUB1 *3*N) (*1*CDR *3*X))))) (DEFUN *1*TOP1 (*3*STK) (*1*TOP (*1*POP *3*STK))) (DEFUN *1*TOP2 (*3*STK) (*1*TOP (*1*POP (*1*POP *3*STK)))) (DEFUN *1*LABELLEDP (*3*X) (COND ((EQ (*1*CAR *3*X) (QUOTE DL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*UNLABEL (*3*X) (COND ((NOT (EQ (*1*LABELLEDP *3*X) *1*F)) (*1*CAR (*1*CDR (*1*CDR (*1*CDR *3*X))))) (T *3*X))) (DEFUN *1*FIND-LABELP (*3*X *3*LST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*FALSE)) ((NOT (EQ (*1*AND (*1*LABELLEDP (SETQ *2*TEMP1 (*1*CAR *3*LST))) (COND ((EQUAL *3*X (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) *1*F)) (QUOTE *1*TRUE)) (T (*1*FIND-LABELP *3*X (*1*CDR *3*LST)))))) (DEFUN *1*FIND-LABEL (*3*X *3*LST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE 0)) ((NOT (EQ (*1*AND (*1*LABELLEDP (SETQ *2*TEMP1 (*1*CAR *3*LST))) (COND ((EQUAL *3*X (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) *1*F)) (QUOTE 0)) (T (*1*ADD1 (*1*FIND-LABEL *3*X (*1*CDR *3*LST))))))) (DEFUN *1*PC (*3*LABEL *3*PROGRAM) (*1*TAG (QUOTE PC) (CONS (*1*CAR *3*PROGRAM) (*1*FIND-LABEL *3*LABEL (*1*PROGRAM-BODY *3*PROGRAM))))) (DEFUN *1*P-OBJECTP (*3*X *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP *3*X) (NOT (EQ (CAR *3*X) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((EQ (*1*CDR (*1*CDR *3*X)) (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQ (SETQ *2*TEMP1 (*1*TYPE *3*X)) (QUOTE NAT)) (*1*SMALL-NATURALP (*1*UNTAG *3*X) (*1*P-WORD-SIZE *3*P))) ((EQ *2*TEMP1 (QUOTE INT)) (*1*SMALL-INTEGERP (*1*UNTAG *3*X) (*1*P-WORD-SIZE *3*P))) ((EQ *2*TEMP1 (QUOTE BOOL)) (*1*BOOLEANP (*1*UNTAG *3*X))) ((EQ *2*TEMP1 (QUOTE ADDR)) (*1*ADPP (*1*UNTAG *3*X) (*1*P-DATA-SEGMENT *3*P))) ((EQ *2*TEMP1 (QUOTE PC)) (*1*PCPP (*1*UNTAG *3*X) (*1*P-PROG-SEGMENT *3*P))) ((EQ *2*TEMP1 (QUOTE SUBR)) (*1*DEFINEDP (*1*UNTAG *3*X) (*1*P-PROG-SEGMENT *3*P))) (T (QUOTE *1*FALSE))))))) (DEFUN *1*P-OBJECTP-TYPE (*3*TYPE *3*X *3*P) (*1*AND (COND ((EQUAL (*1*TYPE *3*X) *3*TYPE) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*P-OBJECTP *3*X *3*P))) (DEFUN *1*ADD1-P-PC (*3*P) (*1*ADD1-ADDR (*1*P-PC *3*P))) (DEFUN *1*P-CURRENT-PROGRAM (*3*P) (*1*DEFINITION (*1*AREA-NAME (*1*P-PC *3*P)) (*1*P-PROG-SEGMENT *3*P))) (DEFUN *1*P-CURRENT-INSTRUCTION (*3*P) (*1*UNLABEL (*1*GET (*1*OFFSET (*1*P-PC *3*P)) (*1*PROGRAM-BODY (*1*P-CURRENT-PROGRAM *3*P))))) (DEFUN *1*P-FRAME (*3*BINDINGS *3*RET-PC) (CONS *3*BINDINGS (CONS *3*RET-PC (QUOTE NIL)))) (DEFUN *1*BINDINGS (*3*FRAME) (*1*CAR *3*FRAME)) (DEFUN *1*RET-PC (*3*FRAME) (*1*CAR (*1*CDR *3*FRAME))) (DEFUN *1*P-FRAME-SIZE (*3*FRAME) (*1*PLUS (QUOTE 2) (*1*LENGTH (*1*BINDINGS *3*FRAME)))) (DEFUN *1*P-CTRL-STK-SIZE (*3*CTRL-STK) (COND ((NOT (EQ (*1*NLISTP *3*CTRL-STK) *1*F)) (QUOTE 0)) (T (*1*PLUS (*1*P-FRAME-SIZE (*1*TOP *3*CTRL-STK)) (*1*P-CTRL-STK-SIZE (*1*CDR *3*CTRL-STK)))))) (DEFUN *1*LOCAL-VAR-VALUE (*3*VAR *3*CTRL-STK) (*1*VALUE *3*VAR (*1*BINDINGS (*1*TOP *3*CTRL-STK)))) (DEFUN *1*SET-LOCAL-VAR-VALUE (*3*VAL *3*VAR *3*CTRL-STK) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*PUSH (*1*P-FRAME (*1*PUT-VALUE *3*VAL *3*VAR (*1*BINDINGS (SETQ *2*TEMP1 (*1*TOP *3*CTRL-STK)))) (*1*RET-PC *2*TEMP1)) (*1*POP *3*CTRL-STK)))) (DEFUN *1*FIRST-N (*3*N *3*X) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE NIL)) (T (CONS (*1*CAR *3*X) (*1*FIRST-N (*1*SUB1 *3*N) (*1*CDR *3*X)))))) (DEFUN *1*PAIRLIST (*3*LST1 *3*LST2) (COND ((NOT (EQ (*1*NLISTP *3*LST1) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR *3*LST1) (*1*CAR *3*LST2)) (*1*PAIRLIST (*1*CDR *3*LST1) (*1*CDR *3*LST2)))))) (DEFUN *1*PAIR-FORMAL-VARS-WITH-ACTUALS (*3*FORMAL-VARS *3*TEMP-STK) (*1*PAIRLIST *3*FORMAL-VARS (*1*REVERSE (*1*FIRST-N (*1*LENGTH *3*FORMAL-VARS) *3*TEMP-STK)))) (DEFUN *1*PAIR-TEMPS-WITH-INITIAL-VALUES (*3*TEMP-VAR-DCLS) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*TEMP-VAR-DCLS) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*TEMP-VAR-DCLS))) (*1*CAR (*1*CDR *2*TEMP1))) (*1*PAIR-TEMPS-WITH-INITIAL-VALUES (*1*CDR *3*TEMP-VAR-DCLS))))))) (DEFUN *1*MAKE-P-CALL-FRAME (*3*FORMAL-VARS *3*TEMP-STK *3*TEMP-VAR-DCLS *3*RET-PC) (*1*P-FRAME (*1*APPEND (*1*PAIR-FORMAL-VARS-WITH-ACTUALS *3*FORMAL-VARS *3*TEMP-STK) (*1*PAIR-TEMPS-WITH-INITIAL-VALUES *3*TEMP-VAR-DCLS)) *3*RET-PC)) (DEFUN *1*P-CALL-OKP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*AND (*1*NOT (*1*LESSP (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-CTRL-STK-SIZE (*1*PUSH (*1*MAKE-P-CALL-FRAME (SETQ *2*TEMP3 (*1*FORMAL-VARS (SETQ *2*TEMP2 (*1*DEFINITION (*1*CAR (*1*CDR *3*INS)) (*1*P-PROG-SEGMENT *3*P))))) (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)) (*1*TEMP-VAR-DCLS *2*TEMP2) (*1*ADD1-ADDR (*1*P-PC *3*P))) (*1*P-CTRL-STK *3*P))))) (*1*NOT (*1*LESSP (*1*LENGTH *2*TEMP1) (*1*LENGTH *2*TEMP3)))))) (DEFUN *1*P-CALL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (*1*P-STATE (*1*TAG (QUOTE PC) (CONS (SETQ *2*TEMP5 (*1*CAR (*1*CDR *3*INS))) (QUOTE 0))) (*1*PUSH (*1*MAKE-P-CALL-FRAME (SETQ *2*TEMP4 (*1*FORMAL-VARS (SETQ *2*TEMP3 (*1*DEFINITION *2*TEMP5 (SETQ *2*TEMP2 (*1*P-PROG-SEGMENT *3*P)))))) (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)) (*1*TEMP-VAR-DCLS *2*TEMP3) (*1*ADD1-ADDR (*1*P-PC *3*P))) (*1*P-CTRL-STK *3*P)) (*1*POPN (*1*LENGTH *2*TEMP4) *2*TEMP1) *2*TEMP2 (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-RET-OKP (*3*INS *3*P) (PROGN *3*INS *3*P (QUOTE *1*TRUE))) (DEFUN *1*P-RET-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*POP (SETQ *2*TEMP1 (*1*P-CTRL-STK *3*P))))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (*1*P-STATE (*1*RET-PC (*1*TOP *2*TEMP1)) *2*TEMP2 (*1*P-TEMP-STK *3*P) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))) (T (*1*P-HALT *3*P (QUOTE HALT))))))) (DEFUN *1*P-PUSH-CONSTANT-OKP (*3*INS *3*P) (PROGN *3*INS (*1*LESSP (*1*LENGTH (*1*P-TEMP-STK *3*P)) (*1*P-MAX-TEMP-STK-SIZE *3*P)))) (DEFUN *1*UNABBREVIATE-CONSTANT (*3*C *3*P) (COND ((EQ *3*C (QUOTE PC)) (*1*ADD1-P-PC *3*P)) ((NOT (EQ (*1*NLISTP *3*C) *1*F)) (*1*PC *3*C (*1*P-CURRENT-PROGRAM *3*P))) (T *3*C))) (DEFUN *1*P-PUSH-CONSTANT-STEP (*3*INS *3*P) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*UNABBREVIATE-CONSTANT (*1*CAR (*1*CDR *3*INS)) *3*P) (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))) (DEFUN *1*P-PUSH-LOCAL-OKP (*3*INS *3*P) (PROGN *3*INS (*1*LESSP (*1*LENGTH (*1*P-TEMP-STK *3*P)) (*1*P-MAX-TEMP-STK-SIZE *3*P)))) (DEFUN *1*P-PUSH-LOCAL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (SETQ *2*TEMP1 (*1*P-CTRL-STK *3*P)) (*1*PUSH (*1*LOCAL-VAR-VALUE (*1*CAR (*1*CDR *3*INS)) *2*TEMP1) (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-PUSH-GLOBAL-OKP (*3*INS *3*P) (PROGN *3*INS (*1*LESSP (*1*LENGTH (*1*P-TEMP-STK *3*P)) (*1*P-MAX-TEMP-STK-SIZE *3*P)))) (DEFUN *1*P-PUSH-GLOBAL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*FETCH (*1*TAG (QUOTE ADDR) (CONS (*1*CAR (*1*CDR *3*INS)) (QUOTE 0))) (SETQ *2*TEMP1 (*1*P-DATA-SEGMENT *3*P))) (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) *2*TEMP1 (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-PUSH-TEMP-STK-INDEX-OKP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LESSP (SETQ *2*TEMP1 (*1*LENGTH (*1*P-TEMP-STK *3*P))) (*1*P-MAX-TEMP-STK-SIZE *3*P)) (*1*LESSP (*1*CAR (*1*CDR *3*INS)) *2*TEMP1)))) (DEFUN *1*P-PUSH-TEMP-STK-INDEX-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE NAT) (*1*SUB1 (*1*DIFFERENCE (*1*LENGTH (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (*1*CAR (*1*CDR *3*INS))))) *2*TEMP1) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-POP-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (DEFUN *1*P-POP-STEP (*3*INS *3*P) (PROGN *3*INS (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*POP (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-POP*-OKP (*3*INS *3*P) (*1*NOT (*1*LESSP (*1*LENGTH (*1*P-TEMP-STK *3*P)) (*1*CAR (*1*CDR *3*INS))))) (DEFUN *1*P-POP*-STEP (*3*INS *3*P) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*POPN (*1*CAR (*1*CDR *3*INS)) (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))) (DEFUN *1*P-POP-LOCAL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (DEFUN *1*P-POP-LOCAL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*SET-LOCAL-VAR-VALUE (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (*1*CAR (*1*CDR *3*INS)) (*1*P-CTRL-STK *3*P)) (*1*POP *2*TEMP1) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-POP-GLOBAL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (DEFUN *1*P-POP-GLOBAL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*POP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (*1*P-PROG-SEGMENT *3*P) (*1*DEPOSIT (*1*TOP *2*TEMP1) (*1*TAG (QUOTE ADDR) (CONS (*1*CAR (*1*CDR *3*INS)) (QUOTE 0))) (*1*P-DATA-SEGMENT *3*P)) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-FETCH-TEMP-STK-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP2)) *3*P) (*1*LESSP (*1*UNTAG *2*TEMP1) (*1*LENGTH *2*TEMP2))))))) (DEFUN *1*P-FETCH-TEMP-STK-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*RGET (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) *2*TEMP1) (*1*POP *2*TEMP1)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-DEPOSIT-TEMP-STK-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*POP *2*TEMP3))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP3)) *3*P) (*1*LESSP (*1*UNTAG *2*TEMP1) (*1*LENGTH (*1*POP *2*TEMP2))))))))) (DEFUN *1*P-DEPOSIT-TEMP-STK-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*RPUT (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (*1*UNTAG (*1*TOP *2*TEMP1)) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-JUMP-OKP (*3*INS *3*P) (PROGN *3*INS *3*P (QUOTE *1*TRUE))) (DEFUN *1*P-JUMP-STEP (*3*INS *3*P) (*1*P-STATE (*1*PC (*1*CAR (*1*CDR *3*INS)) (*1*P-CURRENT-PROGRAM *3*P)) (*1*P-CTRL-STK *3*P) (*1*P-TEMP-STK *3*P) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))) (DEFUN *1*P-JUMP-CASE-OKP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP2)) *3*P) (*1*LESSP (*1*UNTAG *2*TEMP1) (*1*LENGTH (*1*CDR *3*INS))))))) (DEFUN *1*P-JUMP-CASE-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*PC (*1*GET (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*CDR *3*INS)) (*1*P-CURRENT-PROGRAM *3*P)) (*1*P-CTRL-STK *3*P) (*1*POP *2*TEMP1) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-SET-LOCAL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (DEFUN *1*P-SET-LOCAL-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*SET-LOCAL-VAR-VALUE (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (*1*CAR (*1*CDR *3*INS)) (*1*P-CTRL-STK *3*P)) *2*TEMP1 (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-TEST-AND-JUMP-OKP (*3*INS *3*TYPE *3*TEST *3*P) (PROGN *3*INS *3*TEST (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*P-OBJECTP-TYPE *3*TYPE (*1*TOP *2*TEMP1) *3*P))))) (DEFUN *1*P-TEST-AND-JUMP-STEP (*3*TEST *3*LAB *3*P) (LET NIL (COND ((NOT (EQ *3*TEST *1*F)) (*1*P-STATE (*1*PC *3*LAB (*1*P-CURRENT-PROGRAM *3*P)) (*1*P-CTRL-STK *3*P) (*1*POP (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))) (T (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*POP (*1*P-TEMP-STK *3*P)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))))) (DEFUN *1*P-TEST-NATP (*3*FLG *3*X) (LET NIL (COND ((EQ *3*FLG (QUOTE ZERO)) (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*NOT (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))))) (DEFUN *1*P-TEST-NAT-AND-JUMP-OKP (*3*INS *3*P) (*1*P-TEST-AND-JUMP-OKP *3*INS (QUOTE NAT) (*1*P-TEST-NATP (*1*CAR (*1*CDR *3*INS)) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) *3*P)) (DEFUN *1*P-TEST-NAT-AND-JUMP-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-TEST-AND-JUMP-STEP (*1*P-TEST-NATP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*INS))) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) (*1*CAR (*1*CDR *2*TEMP1)) *3*P))) (DEFUN *1*P-TEST-INTP (*3*FLG *3*X) (LET NIL (COND ((EQ *3*FLG (QUOTE ZERO)) (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) ((EQ *3*FLG (QUOTE NOT-ZERO)) (*1*NOT (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) ((EQ *3*FLG (QUOTE NEG)) (*1*NEGATIVEP *3*X)) ((EQ *3*FLG (QUOTE NOT-NEG)) (*1*NOT (*1*NEGATIVEP *3*X))) ((EQ *3*FLG (QUOTE POS)) (*1*AND (*1*NUMBERP *3*X) (*1*NOT (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (T (*1*OR (COND ((EQUAL *3*X (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*NEGATIVEP *3*X)))))) (DEFUN *1*P-TEST-INT-AND-JUMP-OKP (*3*INS *3*P) (*1*P-TEST-AND-JUMP-OKP *3*INS (QUOTE INT) (*1*P-TEST-INTP (*1*CAR (*1*CDR *3*INS)) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) *3*P)) (DEFUN *1*P-TEST-INT-AND-JUMP-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-TEST-AND-JUMP-STEP (*1*P-TEST-INTP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*INS))) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) (*1*CAR (*1*CDR *2*TEMP1)) *3*P))) (DEFUN *1*P-TEST-BOOLP (*3*FLG *3*X) (COND ((EQ *3*FLG (QUOTE T)) (COND ((EQ *3*X (QUOTE T)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) ((EQ *3*X (QUOTE F)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*P-TEST-BOOL-AND-JUMP-OKP (*3*INS *3*P) (*1*P-TEST-AND-JUMP-OKP *3*INS (QUOTE BOOL) (*1*P-TEST-BOOLP (*1*CAR (*1*CDR *3*INS)) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) *3*P)) (DEFUN *1*P-TEST-BOOL-AND-JUMP-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-TEST-AND-JUMP-STEP (*1*P-TEST-BOOLP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*INS))) (*1*UNTAG (*1*TOP (*1*P-TEMP-STK *3*P)))) (*1*CAR (*1*CDR *2*TEMP1)) *3*P))) (DEFUN *1*P-NO-OP-OKP (*3*INS *3*P) (PROGN *3*INS *3*P (QUOTE *1*TRUE))) (DEFUN *1*P-NO-OP-STEP (*3*INS *3*P) (PROGN *3*INS (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*P-TEMP-STK *3*P) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN)))) (DEFUN *1*P-EQ-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQUAL (*1*TYPE (*1*TOP *2*TEMP2)) (*1*TYPE (*1*TOP1 *2*TEMP2))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))))) (DEFUN *1*P-EQ-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*BOOL (COND ((EQUAL (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-ADD-INT-WITH-CARRY-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*POP *2*TEMP3))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP *2*TEMP3) *3*P) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP1 *2*TEMP3) *3*P) (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP2 *2*TEMP3) *3*P))))))))) (DEFUN *1*P-ADD-INT-WITH-CARRY-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE INT) (*1*FIX-SMALL-INTEGER (SETQ *2*TEMP3 (*1*IPLUS (*1*BOOL-TO-NAT (*1*UNTAG (*1*TOP2 (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))))) (*1*IPLUS (*1*UNTAG (*1*TOP1 *2*TEMP2)) (*1*UNTAG (*1*TOP *2*TEMP2))))) (SETQ *2*TEMP1 (*1*P-WORD-SIZE *3*P)))) (*1*PUSH (*1*BOOL (*1*NOT (*1*SMALL-INTEGERP *2*TEMP3 *2*TEMP1))) (*1*POP (*1*POP (*1*POP *2*TEMP2))))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) *2*TEMP1 (QUOTE RUN))))) (DEFUN *1*P-SUB-INT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP4 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP4) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*POP *2*TEMP4))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (SETQ *2*TEMP2 (*1*TOP *2*TEMP4)) *3*P) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (SETQ *2*TEMP1 (*1*TOP1 *2*TEMP4)) *3*P) (*1*SMALL-INTEGERP (*1*IDIFFERENCE (*1*UNTAG *2*TEMP1) (*1*UNTAG *2*TEMP2)) (*1*P-WORD-SIZE *3*P))))))))) (DEFUN *1*P-SUB-INT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE INT) (*1*IDIFFERENCE (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-SUB-INT-WITH-CARRY-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*POP *2*TEMP3))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP *2*TEMP3) *3*P) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP1 *2*TEMP3) *3*P) (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP2 *2*TEMP3) *3*P))))))))) (DEFUN *1*P-SUB-INT-WITH-CARRY-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE INT) (*1*FIX-SMALL-INTEGER (SETQ *2*TEMP3 (*1*IDIFFERENCE (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P)))) (*1*IPLUS (*1*UNTAG (*1*TOP *2*TEMP2)) (*1*BOOL-TO-NAT (*1*UNTAG (*1*TOP2 *2*TEMP2)))))) (SETQ *2*TEMP1 (*1*P-WORD-SIZE *3*P)))) (*1*PUSH (*1*BOOL (*1*NOT (*1*SMALL-INTEGERP *2*TEMP3 *2*TEMP1))) (*1*POP (*1*POP (*1*POP *2*TEMP2))))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) *2*TEMP1 (QUOTE RUN))))) (DEFUN *1*P-NEG-INT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP2)) *3*P) (*1*SMALL-INTEGERP (*1*INEGATE (*1*UNTAG *2*TEMP1)) (*1*P-WORD-SIZE *3*P))))))) (DEFUN *1*P-NEG-INT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE INT) (*1*INEGATE (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))))) (*1*POP *2*TEMP1)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-LT-INT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP *2*TEMP2) *3*P) (*1*P-OBJECTP-TYPE (QUOTE INT) (*1*TOP1 *2*TEMP2) *3*P))))))) (DEFUN *1*P-LT-INT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*BOOL (*1*ILESSP (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-INT-TO-NAT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE INT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP2)) *3*P) (*1*NOT (*1*NEGATIVEP (*1*UNTAG *2*TEMP1)))))))) (DEFUN *1*P-INT-TO-NAT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE NAT) (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))))) (*1*POP *2*TEMP1)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-ADD-NAT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP4 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP4) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*POP *2*TEMP4))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP2 (*1*TOP *2*TEMP4)) *3*P) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP1 *2*TEMP4)) *3*P) (*1*SMALL-NATURALP (*1*PLUS (*1*UNTAG *2*TEMP1) (*1*UNTAG *2*TEMP2)) (*1*P-WORD-SIZE *3*P))))))))) (DEFUN *1*P-ADD-NAT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE NAT) (*1*PLUS (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-SUB-NAT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP4 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP4) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP3 (*1*POP *2*TEMP4))) (NOT (EQ (CAR *2*TEMP3) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP2 (*1*TOP *2*TEMP4)) *3*P) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP1 *2*TEMP4)) *3*P) (*1*NOT (*1*LESSP (*1*UNTAG *2*TEMP1) (*1*UNTAG *2*TEMP2)))))))))) (DEFUN *1*P-SUB-NAT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE NAT) (*1*DIFFERENCE (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-SUB1-NAT-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE NAT) (SETQ *2*TEMP1 (*1*TOP *2*TEMP2)) *3*P) (*1*NOT (*1*ZEROP (*1*UNTAG *2*TEMP1)))))))) (DEFUN *1*P-SUB1-NAT-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE NAT) (*1*SUB1 (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))))) (*1*POP *2*TEMP1)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-OR-BOOL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP *2*TEMP2) *3*P) (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP1 *2*TEMP2) *3*P))))))) (DEFUN *1*P-OR-BOOL-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE BOOL) (*1*OR-BOOL (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-AND-BOOL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP2 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP2) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*POP *2*TEMP2))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP *2*TEMP2) *3*P) (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP1 *2*TEMP2) *3*P))))))) (DEFUN *1*P-AND-BOOL-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE BOOL) (*1*AND-BOOL (*1*UNTAG (*1*TOP1 (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))) (*1*UNTAG (*1*TOP *2*TEMP1)))) (*1*POP (*1*POP *2*TEMP1))) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*P-NOT-BOOL-OKP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (COND ((AND (CONSP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P))) (NOT (EQ (CAR *2*TEMP1) (QUOTE *1*QUOTE)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*P-OBJECTP-TYPE (QUOTE BOOL) (*1*TOP *2*TEMP1) *3*P))))) (DEFUN *1*P-NOT-BOOL-STEP (*3*INS *3*P) (PROGN *3*INS (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*P-STATE (*1*ADD1-P-PC *3*P) (*1*P-CTRL-STK *3*P) (*1*PUSH (*1*TAG (QUOTE BOOL) (*1*NOT-BOOL (*1*UNTAG (*1*TOP (SETQ *2*TEMP1 (*1*P-TEMP-STK *3*P)))))) (*1*POP *2*TEMP1)) (*1*P-PROG-SEGMENT *3*P) (*1*P-DATA-SEGMENT *3*P) (*1*P-MAX-CTRL-STK-SIZE *3*P) (*1*P-MAX-TEMP-STK-SIZE *3*P) (*1*P-WORD-SIZE *3*P) (QUOTE RUN))))) (DEFUN *1*X-Y-ERROR-MSG (*3*X *3*Y) (PROGN *3*X (*1*PACK (*1*APPEND (*1*UNPACK (QUOTE ILLEGAL-)) (*1*APPEND (*1*UNPACK *3*Y) (*1*CDR (*1*UNPACK (QUOTE G-INSTRUCTION)))))))) (DEFUN *1*P-INS-OKP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP1 (*1*CAR *3*INS)) (QUOTE CALL)) (*1*P-CALL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE RET)) (*1*P-RET-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-CONSTANT)) (*1*P-PUSH-CONSTANT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-LOCAL)) (*1*P-PUSH-LOCAL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-GLOBAL)) (*1*P-PUSH-GLOBAL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-TEMP-STK-INDEX)) (*1*P-PUSH-TEMP-STK-INDEX-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP)) (*1*P-POP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP*)) (*1*P-POP*-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP-LOCAL)) (*1*P-POP-LOCAL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP-GLOBAL)) (*1*P-POP-GLOBAL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE FETCH-TEMP-STK)) (*1*P-FETCH-TEMP-STK-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE DEPOSIT-TEMP-STK)) (*1*P-DEPOSIT-TEMP-STK-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE JUMP)) (*1*P-JUMP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE JUMP-CASE)) (*1*P-JUMP-CASE-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SET-LOCAL)) (*1*P-SET-LOCAL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-NAT-AND-JUMP)) (*1*P-TEST-NAT-AND-JUMP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-INT-AND-JUMP)) (*1*P-TEST-INT-AND-JUMP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-BOOL-AND-JUMP)) (*1*P-TEST-BOOL-AND-JUMP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NO-OP)) (*1*P-NO-OP-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE EQ)) (*1*P-EQ-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE ADD-INT-WITH-CARRY)) (*1*P-ADD-INT-WITH-CARRY-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-INT)) (*1*P-SUB-INT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-INT-WITH-CARRY)) (*1*P-SUB-INT-WITH-CARRY-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NEG-INT)) (*1*P-NEG-INT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE LT-INT)) (*1*P-LT-INT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE INT-TO-NAT)) (*1*P-INT-TO-NAT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE ADD-NAT)) (*1*P-ADD-NAT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-NAT)) (*1*P-SUB-NAT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB1-NAT)) (*1*P-SUB1-NAT-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE OR-BOOL)) (*1*P-OR-BOOL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE AND-BOOL)) (*1*P-AND-BOOL-OKP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NOT-BOOL)) (*1*P-NOT-BOOL-OKP *3*INS *3*P)) (T (QUOTE *1*FALSE))))) (DEFUN *1*P-INS-STEP (*3*INS *3*P) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP1 (*1*CAR *3*INS)) (QUOTE CALL)) (*1*P-CALL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE RET)) (*1*P-RET-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-CONSTANT)) (*1*P-PUSH-CONSTANT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-LOCAL)) (*1*P-PUSH-LOCAL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-GLOBAL)) (*1*P-PUSH-GLOBAL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE PUSH-TEMP-STK-INDEX)) (*1*P-PUSH-TEMP-STK-INDEX-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP)) (*1*P-POP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP*)) (*1*P-POP*-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP-LOCAL)) (*1*P-POP-LOCAL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE POP-GLOBAL)) (*1*P-POP-GLOBAL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE FETCH-TEMP-STK)) (*1*P-FETCH-TEMP-STK-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE DEPOSIT-TEMP-STK)) (*1*P-DEPOSIT-TEMP-STK-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE JUMP)) (*1*P-JUMP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE JUMP-CASE)) (*1*P-JUMP-CASE-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SET-LOCAL)) (*1*P-SET-LOCAL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-NAT-AND-JUMP)) (*1*P-TEST-NAT-AND-JUMP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-INT-AND-JUMP)) (*1*P-TEST-INT-AND-JUMP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE TEST-BOOL-AND-JUMP)) (*1*P-TEST-BOOL-AND-JUMP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NO-OP)) (*1*P-NO-OP-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE EQ)) (*1*P-EQ-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE ADD-INT-WITH-CARRY)) (*1*P-ADD-INT-WITH-CARRY-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-INT)) (*1*P-SUB-INT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-INT-WITH-CARRY)) (*1*P-SUB-INT-WITH-CARRY-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NEG-INT)) (*1*P-NEG-INT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE LT-INT)) (*1*P-LT-INT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE INT-TO-NAT)) (*1*P-INT-TO-NAT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE ADD-NAT)) (*1*P-ADD-NAT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB-NAT)) (*1*P-SUB-NAT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE SUB1-NAT)) (*1*P-SUB1-NAT-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE OR-BOOL)) (*1*P-OR-BOOL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE AND-BOOL)) (*1*P-AND-BOOL-STEP *3*INS *3*P)) ((EQ *2*TEMP1 (QUOTE NOT-BOOL)) (*1*P-NOT-BOOL-STEP *3*INS *3*P)) (T (*1*P-HALT *3*P (QUOTE RUN)))))) (DEFUN *1*P-STEP1 (*3*INS *3*P) (COND ((NOT (EQ (*1*P-INS-OKP *3*INS *3*P) *1*F)) (*1*P-INS-STEP *3*INS *3*P)) (T (*1*P-HALT *3*P (*1*X-Y-ERROR-MSG (QUOTE P) (*1*CAR *3*INS)))))) (DEFUN *1*P-STEP (*3*P) (COND ((EQ (*1*P-PSW *3*P) (QUOTE RUN)) (*1*P-STEP1 (*1*P-CURRENT-INSTRUCTION *3*P) *3*P)) (T *3*P))) (DEFUN *1*P (*3*P *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) *3*P) (T (*1*P (*1*P-STEP *3*P) (*1*SUB1 *3*N))))) (DEFUN *1*LOOP-BODY (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*PROG2-LEFT-BRANCH (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*PROG2-RIGHT-BRANCH (*3*STMT) (*1*CAR (*1*CDR (*1*CDR *3*STMT)))) (DEFUN *1*SIGNALLED-CONDITION (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*IF-CONDITION (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*IF-TRUE-BRANCH (*3*STMT) (*1*CAR (*1*CDR (*1*CDR *3*STMT)))) (DEFUN *1*IF-FALSE-BRANCH (*3*STMT) (*1*CAR (*1*CDR (*1*CDR (*1*CDR *3*STMT))))) (DEFUN *1*BEGIN-BODY (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*WHEN-LABELS (*3*STMT) (*1*CAR (*1*CDR (*1*CDR *3*STMT)))) (DEFUN *1*WHEN-HANDLER (*3*STMT) (*1*CAR (*1*CDR (*1*CDR (*1*CDR *3*STMT))))) (DEFUN *1*CALL-NAME (*3*STMT) (*1*CAR (*1*CDR *3*STMT))) (DEFUN *1*CALL-ACTUALS (*3*STMT) (*1*CAR (*1*CDR (*1*CDR *3*STMT)))) (DEFUN *1*CALL-CONDS (*3*STMT) (*1*CAR (*1*CDR (*1*CDR (*1*CDR *3*STMT))))) (DEFUN *1*FORMAL-TYPE (*3*EXP) (*1*CAR (*1*CDR *3*EXP))) (DEFUN *1*FORMAL-INITIAL-VALUE (*3*LOCAL) (*1*CAR (*1*CDR (*1*CDR *3*LOCAL)))) (DEFUN *1*PREDEFINED-PROCEDURE-LIST NIL (QUOTE (MG-SIMPLE-VARIABLE-ASSIGNMENT MG-SIMPLE-CONSTANT-ASSIGNMENT MG-SIMPLE-VARIABLE-EQ MG-SIMPLE-CONSTANT-EQ MG-INTEGER-LE MG-INTEGER-UNARY-MINUS MG-INTEGER-ADD MG-INTEGER-SUBTRACT MG-BOOLEAN-OR MG-BOOLEAN-AND MG-BOOLEAN-NOT MG-INDEX-ARRAY MG-ARRAY-ELEMENT-ASSIGNMENT))) (DEFUN *1*PREDEFINED-PROCP (*3*NAME) (*1*MEMBER *3*NAME (*1*PREDEFINED-PROCEDURE-LIST))) (DEFUN *1*USER-DEFINED-PROCP (*3*NAME *3*PROC-LIST) (*1*AND (*1*NOT (*1*MEMBER *3*NAME (*1*PREDEFINED-PROCEDURE-LIST))) (*1*DEFINEDP *3*NAME *3*PROC-LIST))) (DEFUN *1*DEFINED-PROCP (*3*NAME *3*PROC-LIST) (*1*OR (*1*PREDEFINED-PROCP *3*NAME) (*1*USER-DEFINED-PROCP *3*NAME *3*PROC-LIST))) (DEFUN *1*FETCH-DEF (*3*NAME *3*PROC-LIST) (*1*ASSOC *3*NAME *3*PROC-LIST)) (DEFUN *1*FETCH-CALLED-DEF (*3*STMT *3*PROC-LIST) (*1*FETCH-DEF (*1*CALL-NAME *3*STMT) *3*PROC-LIST)) (DEFUN *1*DEF-NAME (*3*DEF) (*1*CAR *3*DEF)) (DEFUN *1*DEF-FORMALS (*3*DEF) (*1*CAR (*1*CDR *3*DEF))) (DEFUN *1*DEF-CONDS (*3*DEF) (*1*CAR (*1*CDR (*1*CDR *3*DEF)))) (DEFUN *1*DEF-LOCALS (*3*DEF) (*1*CAR (*1*CDR (*1*CDR (*1*CDR *3*DEF))))) (DEFUN *1*DEF-COND-LOCALS (*3*DEF) (*1*CAR (*1*CDR (*1*CDR (*1*CDR (*1*CDR *3*DEF)))))) (DEFUN *1*DEF-BODY (*3*DEF) (*1*CAR (*1*CDR (*1*CDR (*1*CDR (*1*CDR (*1*CDR *3*DEF))))))) (DEFUN *1*ARRAY-ELEMTYPE (*3*TYPE) (*1*CAR (*1*CDR *3*TYPE))) (DEFUN *1*ARRAY-LENGTH (*3*TYPE) (*1*CAR (*1*CDR (*1*CDR *3*TYPE)))) (DEFUN *1*RESERVED-NAMES-LIST NIL (QUOTE (LEAVE NORMAL ROUTINEERROR))) (DEFUN *1*RESERVED-WORD (*3*WD) (*1*MEMBER *3*WD (*1*RESERVED-NAMES-LIST))) (DEFUN *1*OK-MG-NAMEP (*3*IDENT) (*1*AND (*1*LITATOM *3*IDENT) (*1*AND (*1*NOT (*1*MEMBER (QUOTE 45) (*1*UNPACK *3*IDENT))) (*1*NOT (*1*RESERVED-WORD *3*IDENT))))) (DEFUN *1*MG-WORD-SIZE NIL (QUOTE 32)) (DEFUN *1*MG-MAX-CTRL-STK-SIZE NIL (PROGN (THROW (QUOTE REDUCE-TERM) (QUOTE *1*FAILED)))) (DEFUN *1*MG-MAX-TEMP-STK-SIZE NIL (PROGN (THROW (QUOTE REDUCE-TERM) (QUOTE *1*FAILED)))) (DEFUN *1*MAXINT NIL (*1*SUB1 (*1*EXP (QUOTE 2) (*1*SUB1 (*1*MG-WORD-SIZE))))) (DEFUN *1*MININT NIL (*1*MINUS (*1*EXP (QUOTE 2) (*1*SUB1 (*1*MG-WORD-SIZE))))) (DEFUN *1*INT-LITERALP (*3*EXP) (*1*AND (COND ((EQ (*1*CAR *3*EXP) (QUOTE INT-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*LENGTH-PLISTP *3*EXP (QUOTE 2)) (*1*SMALL-INTEGERP (*1*CAR (*1*CDR *3*EXP)) (*1*MG-WORD-SIZE))))) (DEFUN *1*BOOLEAN-LITERALP (*3*EXP) (*1*AND (COND ((EQ (*1*CAR *3*EXP) (QUOTE BOOLEAN-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*LENGTH-PLISTP *3*EXP (QUOTE 2)) (*1*MEMBER (*1*CAR (*1*CDR *3*EXP)) (QUOTE (TRUE-MG FALSE-MG)))))) (DEFUN *1*CHARACTER-LITERALP (*3*EXP) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (COND ((EQ (*1*CAR *3*EXP) (QUOTE CHARACTER-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*LENGTH-PLISTP *3*EXP (QUOTE 2)) (*1*AND (*1*NUMBERP (SETQ *2*TEMP1 (*1*CAR (*1*CDR *3*EXP)))) (COND ((NOT (EQ (*1*LESSP (QUOTE 127) *2*TEMP1) *1*F)) (QUOTE *1*FALSE)) (T (QUOTE *1*TRUE)))))))) (DEFUN *1*SIMPLE-MG-TYPE-REFP (*3*TYPREF) (*1*MEMBER *3*TYPREF (QUOTE (INT-MG BOOLEAN-MG CHARACTER-MG)))) (DEFUN *1*ARRAY-MG-TYPE-REFP (*3*TYPREF) (*1*AND (*1*LENGTH-PLISTP *3*TYPREF (QUOTE 3)) (*1*AND (COND ((EQ (*1*CAR *3*TYPREF) (QUOTE ARRAY-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*SIMPLE-MG-TYPE-REFP (*1*ARRAY-ELEMTYPE *3*TYPREF)) (*1*NOT (*1*ZEROP (*1*ARRAY-LENGTH *3*TYPREF))))))) (DEFUN *1*MG-TYPE-REFP (*3*TYPREF) (*1*OR (*1*SIMPLE-MG-TYPE-REFP *3*TYPREF) (*1*ARRAY-MG-TYPE-REFP *3*TYPREF))) (DEFUN *1*SIMPLE-TYPED-LITERALP (*3*LIT *3*TYPE) (COND ((EQ *3*TYPE (QUOTE INT-MG)) (*1*INT-LITERALP *3*LIT)) ((EQ *3*TYPE (QUOTE BOOLEAN-MG)) (*1*BOOLEAN-LITERALP *3*LIT)) ((EQ *3*TYPE (QUOTE CHARACTER-MG)) (*1*CHARACTER-LITERALP *3*LIT)) (T (QUOTE *1*FALSE)))) (DEFUN *1*SIMPLE-TYPED-LITERAL-PLISTP (*3*LST *3*TYPE) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*SIMPLE-TYPED-LITERALP (*1*CAR *3*LST) *3*TYPE) (*1*SIMPLE-TYPED-LITERAL-PLISTP (*1*CDR *3*LST) *3*TYPE))))) (DEFUN *1*ARRAY-LITERALP (*3*EXP *3*LENGTH *3*ELEMTYPE) (*1*AND (*1*SIMPLE-TYPED-LITERAL-PLISTP *3*EXP *3*ELEMTYPE) (COND ((EQUAL (*1*LENGTH *3*EXP) *3*LENGTH) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*OK-MG-ARRAY-VALUE (*3*EXP *3*TYPE) (*1*ARRAY-LITERALP *3*EXP (*1*ARRAY-LENGTH *3*TYPE) (*1*ARRAY-ELEMTYPE *3*TYPE))) (DEFUN *1*OK-MG-VALUEP (*3*EXP *3*TYPE) (COND ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP *3*TYPE) *1*F)) (*1*SIMPLE-TYPED-LITERALP *3*EXP *3*TYPE)) ((NOT (EQ (*1*ARRAY-MG-TYPE-REFP *3*TYPE) *1*F)) (*1*OK-MG-ARRAY-VALUE *3*EXP *3*TYPE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*M-TYPE (*3*X) (*1*CAR (*1*CDR *3*X))) (DEFUN *1*GET-M-TYPE (*3*NAME *3*ALIST) (*1*M-TYPE (*1*ASSOC *3*NAME *3*ALIST))) (DEFUN *1*HAS-ARRAY-TYPE (*3*NAME *3*ALIST) (COND ((EQ (*1*CAR (*1*GET-M-TYPE *3*NAME *3*ALIST)) (QUOTE ARRAY-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*MG-NAME-ALIST-ELEMENTP (*3*X) (*1*AND (*1*OK-MG-NAMEP (*1*CAR *3*X)) (*1*MG-TYPE-REFP (*1*M-TYPE *3*X)))) (DEFUN *1*MG-NAME-ALISTP (*3*ALIST) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (COND ((EQ *3*ALIST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*MG-NAME-ALIST-ELEMENTP (*1*CAR *3*ALIST)) (*1*MG-NAME-ALISTP (*1*CDR *3*ALIST)))))) (DEFUN *1*IDENTIFIERP (*3*NAME) (*1*OK-MG-NAMEP *3*NAME)) (DEFUN *1*DEFINED-IDENTIFIERP (*3*NAME *3*ALIST) (*1*AND (*1*IDENTIFIERP *3*NAME) (*1*DEFINEDP *3*NAME *3*ALIST))) (DEFUN *1*BOOLEAN-IDENTIFIERP (*3*NAME *3*ALIST) (*1*AND (*1*IDENTIFIERP *3*NAME) (COND ((EQ (*1*GET-M-TYPE *3*NAME *3*ALIST) (QUOTE BOOLEAN-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*INT-IDENTIFIERP (*3*NAME *3*ALIST) (*1*AND (*1*IDENTIFIERP *3*NAME) (COND ((EQ (*1*GET-M-TYPE *3*NAME *3*ALIST) (QUOTE INT-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*CHARACTER-IDENTIFIERP (*3*NAME *3*ALIST) (*1*AND (*1*IDENTIFIERP *3*NAME) (COND ((EQ (*1*GET-M-TYPE *3*NAME *3*ALIST) (QUOTE CHARACTER-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*ARRAY-IDENTIFIERP (*3*NAME *3*ALIST) (*1*AND (*1*DEFINED-IDENTIFIERP *3*NAME *3*ALIST) (*1*HAS-ARRAY-TYPE *3*NAME *3*ALIST))) (DEFUN *1*SIMPLE-IDENTIFIERP (*3*NAME *3*ALIST) (*1*OR (*1*BOOLEAN-IDENTIFIERP *3*NAME *3*ALIST) (*1*OR (*1*INT-IDENTIFIERP *3*NAME *3*ALIST) (*1*CHARACTER-IDENTIFIERP *3*NAME *3*ALIST)))) (DEFUN *1*SIMPLE-TYPED-IDENTIFIERP (*3*IDENT *3*TYPE *3*ALIST) (COND ((EQ *3*TYPE (QUOTE INT-MG)) (*1*INT-IDENTIFIERP *3*IDENT *3*ALIST)) ((EQ *3*TYPE (QUOTE BOOLEAN-MG)) (*1*BOOLEAN-IDENTIFIERP *3*IDENT *3*ALIST)) ((EQ *3*TYPE (QUOTE CHARACTER-MG)) (*1*CHARACTER-IDENTIFIERP *3*IDENT *3*ALIST)) (T (QUOTE *1*FALSE)))) (DEFUN *1*IDENTIFIER-PLISTP (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*IDENTIFIERP (*1*CAR *3*LST)) (*1*IDENTIFIER-PLISTP (*1*CDR *3*LST)))))) (DEFUN *1*COND-IDENTIFIERP (*3*X *3*COND-LIST) (*1*OR (COND ((EQ *3*X (QUOTE ROUTINEERROR)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*IDENTIFIERP *3*X) (*1*MEMBER *3*X *3*COND-LIST)))) (DEFUN *1*COND-IDENTIFIER-PLISTP (*3*LST *3*COND-LIST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*COND-IDENTIFIERP (*1*CAR *3*LST) *3*COND-LIST) (*1*COND-IDENTIFIER-PLISTP (*1*CDR *3*LST) *3*COND-LIST))))) (DEFUN *1*NONEMPTY-COND-IDENTIFIER-PLISTP (*3*LST *3*COND-LIST) (*1*AND (*1*COND-IDENTIFIER-PLISTP *3*LST *3*COND-LIST) (*1*NOT (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))) (DEFUN *1*OK-CONDITION (*3*EXP *3*COND-LIST) (*1*OR (COND ((EQ *3*EXP (QUOTE ROUTINEERROR)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*OR (*1*OK-MG-NAMEP *3*EXP) (COND ((EQ *3*EXP (QUOTE LEAVE)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (*1*MEMBER *3*EXP *3*COND-LIST)))) (DEFUN *1*OK-ACTUAL-PARAMS-LIST (*3*LST *3*ALIST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*DEFINED-IDENTIFIERP (*1*CAR *3*LST) *3*ALIST) (*1*OK-ACTUAL-PARAMS-LIST (*1*CDR *3*LST) *3*ALIST))))) (DEFUN *1*OK-IDENTIFIER-ACTUAL (*3*ACTUAL *3*FORMAL *3*ALIST) (*1*AND (*1*IDENTIFIERP *3*ACTUAL) (COND ((EQUAL (*1*GET-M-TYPE *3*ACTUAL *3*ALIST) (*1*FORMAL-TYPE *3*FORMAL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*DATA-PARAMS-MATCH (*3*ACTUAL *3*FORMAL *3*ALIST) (*1*OK-IDENTIFIER-ACTUAL *3*ACTUAL *3*FORMAL *3*ALIST)) (DEFUN *1*DATA-PARAM-LISTS-MATCH (*3*ACTUALS *3*FORMALS *3*ALIST) (COND ((NOT (EQ (*1*OR (*1*NLISTP *3*ACTUALS) (*1*NLISTP *3*FORMALS)) *1*F)) (*1*AND (COND ((EQ *3*FORMALS (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQ *3*ACTUALS (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (T (*1*AND (*1*DATA-PARAMS-MATCH (*1*CAR *3*ACTUALS) (*1*CAR *3*FORMALS) *3*ALIST) (*1*DATA-PARAM-LISTS-MATCH (*1*CDR *3*ACTUALS) (*1*CDR *3*FORMALS) *3*ALIST))))) (DEFUN *1*COND-PARAMS-MATCH (*3*COND-ACTUALS *3*CONDS) (COND ((EQUAL (*1*LENGTH *3*COND-ACTUALS) (*1*LENGTH *3*CONDS)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*OK-MG-SIMPLE-VARIABLE-ASSIGNMENT-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 2)) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP2 (*1*CAR *3*ARGS)) *3*ALIST) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP1 (*1*CAR (*1*CDR *3*ARGS))) *3*ALIST) (COND ((EQUAL (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP2 *3*ALIST))) (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP1 *3*ALIST)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))))))) (DEFUN *1*OK-MG-SIMPLE-CONSTANT-ASSIGNMENT-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 2)) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP1 (*1*CAR *3*ARGS)) *3*ALIST) (*1*SIMPLE-TYPED-LITERALP (*1*CAR (*1*CDR *3*ARGS)) (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP1 *3*ALIST)))))))) (DEFUN *1*OK-MG-SIMPLE-VARIABLE-EQ-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP3 (*1*CAR (SETQ *2*TEMP2 (*1*CDR *3*ARGS)))) *3*ALIST) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP1 (*1*CAR (*1*CDR *2*TEMP2))) *3*ALIST) (COND ((EQUAL (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP3 *3*ALIST))) (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP1 *3*ALIST)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))))))) (DEFUN *1*OK-MG-SIMPLE-CONSTANT-EQ-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*SIMPLE-IDENTIFIERP (SETQ *2*TEMP2 (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS)))) *3*ALIST) (*1*SIMPLE-TYPED-LITERALP (*1*CAR (*1*CDR *2*TEMP1)) (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP2 *3*ALIST))))))))) (DEFUN *1*OK-MG-INTEGER-LE-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS))) *3*ALIST) (*1*INT-IDENTIFIERP (*1*CAR (*1*CDR *2*TEMP1)) *3*ALIST)))))) (DEFUN *1*OK-MG-INTEGER-UNARY-MINUS-ARGS (*3*ARGS *3*ALIST) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 2)) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*INT-IDENTIFIERP (*1*CAR (*1*CDR *3*ARGS)) *3*ALIST)))) (DEFUN *1*OK-MG-INTEGER-ADD-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS))) *3*ALIST) (*1*INT-IDENTIFIERP (*1*CAR (*1*CDR *2*TEMP1)) *3*ALIST)))))) (DEFUN *1*OK-MG-INTEGER-SUBTRACT-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS))) *3*ALIST) (*1*INT-IDENTIFIERP (*1*CAR (*1*CDR *2*TEMP1)) *3*ALIST)))))) (DEFUN *1*OK-MG-BOOLEAN-OR-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS))) *3*ALIST) (*1*BOOLEAN-IDENTIFIERP (*1*CAR (*1*CDR *2*TEMP1)) *3*ALIST)))))) (DEFUN *1*OK-MG-BOOLEAN-AND-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 3)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR (SETQ *2*TEMP1 (*1*CDR *3*ARGS))) *3*ALIST) (*1*BOOLEAN-IDENTIFIERP (*1*CAR (*1*CDR *2*TEMP1)) *3*ALIST)))))) (DEFUN *1*OK-MG-BOOLEAN-NOT-ARGS (*3*ARGS *3*ALIST) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 2)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*CAR *3*ARGS) *3*ALIST) (*1*BOOLEAN-IDENTIFIERP (*1*CAR (*1*CDR *3*ARGS)) *3*ALIST)))) (DEFUN *1*OK-MG-INDEX-ARRAY-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 4)) (*1*AND (*1*ARRAY-IDENTIFIERP (SETQ *2*TEMP5 (*1*CAR (SETQ *2*TEMP4 (*1*CDR *3*ARGS)))) *3*ALIST) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR (SETQ *2*TEMP3 (*1*CDR *2*TEMP4))) *3*ALIST) (*1*AND (*1*SIMPLE-TYPED-IDENTIFIERP (*1*CAR *3*ARGS) (*1*ARRAY-ELEMTYPE (SETQ *2*TEMP2 (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP5 *3*ALIST))))) *3*ALIST) (*1*AND (COND ((EQUAL (SETQ *2*TEMP1 (*1*CAR (*1*CDR *2*TEMP3))) (*1*ARRAY-LENGTH *2*TEMP2)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*LESSP *2*TEMP1 (*1*MAXINT))))))))) (DEFUN *1*OK-MG-ARRAY-ELEMENT-ASSIGNMENT-ARGS (*3*ARGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*ARGS (QUOTE 4)) (*1*AND (*1*ARRAY-IDENTIFIERP (SETQ *2*TEMP5 (*1*CAR *3*ARGS)) *3*ALIST) (*1*AND (*1*INT-IDENTIFIERP (*1*CAR (SETQ *2*TEMP4 (*1*CDR *3*ARGS))) *3*ALIST) (*1*AND (COND ((EQUAL (SETQ *2*TEMP3 (*1*CAR (*1*CDR (SETQ *2*TEMP2 (*1*CDR *2*TEMP4))))) (*1*ARRAY-LENGTH (SETQ *2*TEMP1 (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP5 *3*ALIST)))))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*LESSP *2*TEMP3 (*1*MAXINT)) (*1*SIMPLE-TYPED-IDENTIFIERP (*1*CAR *2*TEMP2) (*1*ARRAY-ELEMTYPE *2*TEMP1) *3*ALIST)))))))) (DEFUN *1*OK-PREDEFINED-PROC-ARGS (*3*NAME *3*ARGS *3*ALIST) (COND ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (*1*OK-MG-SIMPLE-VARIABLE-ASSIGNMENT-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (*1*OK-MG-SIMPLE-CONSTANT-ASSIGNMENT-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-EQ)) (*1*OK-MG-SIMPLE-VARIABLE-EQ-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-EQ)) (*1*OK-MG-SIMPLE-CONSTANT-EQ-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-INTEGER-LE)) (*1*OK-MG-INTEGER-LE-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-INTEGER-UNARY-MINUS)) (*1*OK-MG-INTEGER-UNARY-MINUS-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-INTEGER-ADD)) (*1*OK-MG-INTEGER-ADD-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-INTEGER-SUBTRACT)) (*1*OK-MG-INTEGER-SUBTRACT-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-OR)) (*1*OK-MG-BOOLEAN-OR-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-AND)) (*1*OK-MG-BOOLEAN-AND-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-NOT)) (*1*OK-MG-BOOLEAN-NOT-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-INDEX-ARRAY)) (*1*OK-MG-INDEX-ARRAY-ARGS *3*ARGS *3*ALIST)) ((EQ *3*NAME (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (*1*OK-MG-ARRAY-ELEMENT-ASSIGNMENT-ARGS *3*ARGS *3*ALIST)) (T (QUOTE *1*FALSE)))) (DEFUN *1*OK-PREDEFINED-PROC-CALL (*3*STMT *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 3)) (*1*AND (*1*PREDEFINED-PROCP (SETQ *2*TEMP1 (*1*CALL-NAME *3*STMT))) (*1*OK-PREDEFINED-PROC-ARGS *2*TEMP1 (*1*CALL-ACTUALS *3*STMT) *3*ALIST))))) (DEFUN *1*OK-PROC-CALL (*3*STMT *3*R-COND-LIST *3*ALIST *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 4)) (*1*AND (*1*IDENTIFIERP (SETQ *2*TEMP4 (*1*CALL-NAME *3*STMT))) (*1*AND (*1*USER-DEFINED-PROCP *2*TEMP4 *3*PROC-LIST) (*1*AND (*1*OK-ACTUAL-PARAMS-LIST (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT)) *3*ALIST) (*1*AND (*1*NO-DUPLICATES *2*TEMP3) (*1*AND (*1*DATA-PARAM-LISTS-MATCH *2*TEMP3 (*1*DEF-FORMALS (SETQ *2*TEMP2 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) *3*ALIST) (*1*AND (*1*COND-IDENTIFIER-PLISTP (SETQ *2*TEMP1 (*1*CALL-CONDS *3*STMT)) *3*R-COND-LIST) (*1*COND-PARAMS-MATCH *2*TEMP1 (*1*DEF-CONDS *2*TEMP2))))))))))) (DEFUN *1*OK-MG-STATEMENT (*3*STMT *3*R-COND-LIST *3*ALIST *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP2 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (COND ((EQ (*1*CDR *3*STMT) (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) ((EQ *2*TEMP2 (QUOTE SIGNAL-MG)) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 2)) (*1*OK-CONDITION (*1*SIGNALLED-CONDITION *3*STMT) *3*R-COND-LIST))) ((EQ *2*TEMP2 (QUOTE PROG2-MG)) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 3)) (*1*AND (*1*OK-MG-STATEMENT (*1*PROG2-LEFT-BRANCH *3*STMT) *3*R-COND-LIST *3*ALIST *3*PROC-LIST) (*1*OK-MG-STATEMENT (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*R-COND-LIST *3*ALIST *3*PROC-LIST)))) ((EQ *2*TEMP2 (QUOTE LOOP-MG)) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 2)) (*1*OK-MG-STATEMENT (*1*LOOP-BODY *3*STMT) (CONS (QUOTE LEAVE) *3*R-COND-LIST) *3*ALIST *3*PROC-LIST))) ((EQ *2*TEMP2 (QUOTE IF-MG)) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 4)) (*1*AND (*1*BOOLEAN-IDENTIFIERP (*1*IF-CONDITION *3*STMT) *3*ALIST) (*1*AND (*1*OK-MG-STATEMENT (*1*IF-TRUE-BRANCH *3*STMT) *3*R-COND-LIST *3*ALIST *3*PROC-LIST) (*1*OK-MG-STATEMENT (*1*IF-FALSE-BRANCH *3*STMT) *3*R-COND-LIST *3*ALIST *3*PROC-LIST))))) ((EQ *2*TEMP2 (QUOTE BEGIN-MG)) (*1*AND (*1*LENGTH-PLISTP *3*STMT (QUOTE 4)) (*1*AND (*1*OK-MG-STATEMENT (*1*BEGIN-BODY *3*STMT) (*1*APPEND (SETQ *2*TEMP1 (*1*WHEN-LABELS *3*STMT)) *3*R-COND-LIST) *3*ALIST *3*PROC-LIST) (*1*AND (*1*NONEMPTY-COND-IDENTIFIER-PLISTP *2*TEMP1 *3*R-COND-LIST) (*1*OK-MG-STATEMENT (*1*WHEN-HANDLER *3*STMT) *3*R-COND-LIST *3*ALIST *3*PROC-LIST))))) ((EQ *2*TEMP2 (QUOTE PROC-CALL-MG)) (*1*OK-PROC-CALL *3*STMT *3*R-COND-LIST *3*ALIST *3*PROC-LIST)) ((EQ *2*TEMP2 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*OK-PREDEFINED-PROC-CALL *3*STMT *3*ALIST)) (T (QUOTE *1*FALSE))))) (DEFUN *1*OK-MG-FORMAL-DATA-PARAM (*3*EXP) (*1*AND (*1*LENGTH-PLISTP *3*EXP (QUOTE 2)) (*1*AND (*1*OK-MG-NAMEP (*1*CAR *3*EXP)) (*1*MG-TYPE-REFP (*1*FORMAL-TYPE *3*EXP))))) (DEFUN *1*OK-MG-FORMAL-DATA-PARAMS-PLISTP (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*OK-MG-FORMAL-DATA-PARAM (*1*CAR *3*LST)) (*1*OK-MG-FORMAL-DATA-PARAMS-PLISTP (*1*CDR *3*LST)))))) (DEFUN *1*OK-MG-LOCAL-DATA-DECL (*3*EXP) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*EXP (QUOTE 3)) (*1*AND (*1*OK-MG-NAMEP (*1*CAR *3*EXP)) (*1*AND (*1*MG-TYPE-REFP (SETQ *2*TEMP1 (*1*FORMAL-TYPE *3*EXP))) (*1*OK-MG-VALUEP (*1*FORMAL-INITIAL-VALUE *3*EXP) *2*TEMP1)))))) (DEFUN *1*OK-MG-LOCAL-DATA-PLISTP (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*OK-MG-LOCAL-DATA-DECL (*1*CAR *3*LST)) (*1*OK-MG-LOCAL-DATA-PLISTP (*1*CDR *3*LST)))))) (DEFUN *1*MAKE-COND-LIST (*3*DEF) (*1*APPEND (*1*DEF-CONDS *3*DEF) (*1*DEF-COND-LOCALS *3*DEF))) (DEFUN *1*MAKE-ALIST-FROM-FORMALS (*3*LST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*NAME (SETQ *2*TEMP1 (*1*CAR *3*LST))) (CONS (*1*FORMAL-TYPE *2*TEMP1) (QUOTE NIL))) (*1*MAKE-ALIST-FROM-FORMALS (*1*CDR *3*LST))))))) (DEFUN *1*MAKE-NAME-ALIST (*3*DEF) (*1*APPEND (*1*MAKE-ALIST-FROM-FORMALS (*1*DEF-FORMALS *3*DEF)) (*1*MAKE-ALIST-FROM-FORMALS (*1*DEF-LOCALS *3*DEF)))) (DEFUN *1*COLLECT-LOCAL-NAMES (*3*DEF) (*1*APPEND (*1*LISTCARS (*1*DEF-FORMALS *3*DEF)) (*1*LISTCARS (*1*DEF-LOCALS *3*DEF)))) (DEFUN *1*OK-MG-DEF (*3*DEF *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*DEF (QUOTE 6)) (*1*AND (*1*OK-MG-NAMEP (*1*DEF-NAME *3*DEF)) (*1*AND (*1*OK-MG-FORMAL-DATA-PARAMS-PLISTP (*1*DEF-FORMALS *3*DEF)) (*1*AND (*1*IDENTIFIER-PLISTP (SETQ *2*TEMP2 (*1*DEF-CONDS *3*DEF))) (*1*AND (*1*OK-MG-LOCAL-DATA-PLISTP (*1*DEF-LOCALS *3*DEF)) (*1*AND (*1*IDENTIFIER-PLISTP (SETQ *2*TEMP1 (*1*DEF-COND-LOCALS *3*DEF))) (*1*AND (*1*NO-DUPLICATES (*1*COLLECT-LOCAL-NAMES *3*DEF)) (*1*AND (*1*LESSP (*1*PLUS (*1*LENGTH *2*TEMP2) (*1*LENGTH *2*TEMP1)) (*1*SUB1 (*1*SUB1 (*1*SUB1 (*1*EXP (QUOTE 2) (*1*MG-WORD-SIZE)))))) (*1*OK-MG-STATEMENT (*1*DEF-BODY *3*DEF) (*1*MAKE-COND-LIST *3*DEF) (*1*MAKE-NAME-ALIST *3*DEF) *3*PROC-LIST))))))))))) (DEFUN *1*OK-MG-DEF-PLISTP1 (*3*LST1 *3*LST2) (COND ((NOT (EQ (*1*NLISTP *3*LST1) *1*F)) (COND ((EQ *3*LST1 (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*OK-MG-DEF (*1*CAR *3*LST1) *3*LST2) (*1*OK-MG-DEF-PLISTP1 (*1*CDR *3*LST1) *3*LST2))))) (DEFUN *1*OK-MG-DEF-PLISTP (*3*PROC-LIST) (*1*OK-MG-DEF-PLISTP1 *3*PROC-LIST *3*PROC-LIST)) (DEFUN *1*MG-STATEP (X) (COND ((AND (CONSP X) (EQ (CAR X) *1*SHELL-QUOTE-MARK) (EQ (CADR X) (QUOTE MG-STATE))) *1*T) (T *1*F))) (DEFUN *1*CC (X) (COND ((EQ (*1*MG-STATEP X) *1*T) (CAR (CDR (CDR X)))) (T (*1*FALSE)))) (DEFUN *1*MG-ALIST (X) (COND ((EQ (*1*MG-STATEP X) *1*T) (CAR (CDR (CDR (CDR X))))) (T (*1*FALSE)))) (DEFUN *1*MG-PSW (X) (COND ((EQ (*1*MG-STATEP X) *1*T) (CAR (CDR (CDR (CDR (CDR X)))))) (T (*1*FALSE)))) (DEFUN *1*MG-STATE (CC MG-ALIST MG-PSW) (LIST *1*SHELL-QUOTE-MARK (QUOTE MG-STATE) CC MG-ALIST MG-PSW)) (DEFUN *1*RESOURCE-ERRORP (*3*MG-STATE) (*1*NOT (COND ((EQ (*1*MG-PSW *3*MG-STATE) (QUOTE RUN)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*SIGNAL-SYSTEM-ERROR (*3*MG-STATE *3*ERROR) (*1*MG-STATE (*1*CC *3*MG-STATE) (*1*MG-ALIST *3*MG-STATE) *3*ERROR)) (DEFUN *1*NORMAL (*3*MG-STATE) (COND ((EQ (*1*CC *3*MG-STATE) (QUOTE NORMAL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*M-VALUE (*3*X) (*1*CAR (*1*CDR (*1*CDR *3*X)))) (DEFUN *1*GET-M-VALUE (*3*NAME *3*ALIST) (*1*M-VALUE (*1*ASSOC *3*NAME *3*ALIST))) (DEFUN *1*MG-ALIST-ELEMENTP (*3*X) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*X (QUOTE 3)) (*1*AND (*1*OK-MG-NAMEP (*1*CAR *3*X)) (*1*AND (*1*MG-TYPE-REFP (SETQ *2*TEMP1 (*1*M-TYPE *3*X))) (*1*OK-MG-VALUEP (*1*M-VALUE *3*X) *2*TEMP1)))))) (DEFUN *1*MG-ALISTP (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*MG-ALIST-ELEMENTP (*1*CAR *3*LST)) (*1*MG-ALISTP (*1*CDR *3*LST)))))) (DEFUN *1*OK-CC (*3*C *3*COND-LIST) (*1*AND (*1*LITATOM *3*C) (*1*OR (*1*MEMBER *3*C (QUOTE (NORMAL ROUTINEERROR))) (*1*MEMBER *3*C *3*COND-LIST)))) (DEFUN *1*OK-MG-STATEP (*3*MG-STATE *3*COND-LIST) (*1*AND (*1*OK-CC (*1*CC *3*MG-STATE) *3*COND-LIST) (*1*MG-ALISTP (*1*MG-ALIST *3*MG-STATE)))) (DEFUN *1*SET-CONDITION (*3*MG-STATE *3*CONDITION-NAME) (*1*MG-STATE *3*CONDITION-NAME (*1*MG-ALIST *3*MG-STATE) (*1*MG-PSW *3*MG-STATE))) (DEFUN *1*REMOVE-LEAVE (*3*MG-STATE) (COND ((EQ (*1*CC *3*MG-STATE) (QUOTE LEAVE)) (*1*SET-CONDITION *3*MG-STATE (QUOTE NORMAL))) (T *3*MG-STATE))) (DEFUN *1*MG-EXPRESSION-FALSEP (*3*EXP *3*MG-STATE) (COND ((EQUAL (*1*GET-M-VALUE *3*EXP (*1*MG-ALIST *3*MG-STATE)) (QUOTE (BOOLEAN-MG FALSE-MG))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (DEFUN *1*CONVERT-CONDITION1 (*3*COND *3*FORMALS *3*ACTUALS) (COND ((NOT (EQ (*1*NLISTP *3*FORMALS) *1*F)) (QUOTE ROUTINEERROR)) ((EQUAL *3*COND (*1*CAR *3*FORMALS)) (*1*CAR *3*ACTUALS)) (T (*1*CONVERT-CONDITION1 *3*COND (*1*CDR *3*FORMALS) (*1*CDR *3*ACTUALS))))) (DEFUN *1*CONVERT-CONDITION (*3*COND *3*FORMALS *3*ACTUALS) (COND ((NOT (EQ (*1*MEMBER *3*COND (QUOTE (NORMAL ROUTINEERROR))) *1*F)) *3*COND) (T (*1*CONVERT-CONDITION1 *3*COND *3*FORMALS *3*ACTUALS)))) (DEFUN *1*SET-ALIST-VALUE (*3*NAME *3*VAL *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE NIL)) ((EQUAL (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*ALIST))) *3*NAME) (CONS (CONS *3*NAME (CONS (*1*M-TYPE *2*TEMP1) (CONS *3*VAL (*1*CDR (*1*CDR (*1*CDR *2*TEMP1)))))) (*1*CDR *3*ALIST))) (T (CONS *2*TEMP1 (*1*SET-ALIST-VALUE *3*NAME *3*VAL (*1*CDR *3*ALIST))))))) (DEFUN *1*COPY-OUT-PARAMS (*3*FORMALS *3*ACTUALS *3*NEW-VAR-ALIST *3*OLD-VAR-ALIST) (COND ((NOT (EQ (*1*NLISTP *3*FORMALS) *1*F)) *3*OLD-VAR-ALIST) (T (*1*COPY-OUT-PARAMS (*1*CDR *3*FORMALS) (*1*CDR *3*ACTUALS) *3*NEW-VAR-ALIST (*1*SET-ALIST-VALUE (*1*CAR *3*ACTUALS) (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (*1*CAR *3*FORMALS)) *3*NEW-VAR-ALIST)))) *3*OLD-VAR-ALIST))))) (DEFUN *1*MAP-CALL-EFFECTS (*3*NEW-STATE *3*DEF *3*STMT *3*OLD-STATE) (*1*MG-STATE (*1*CONVERT-CONDITION (*1*CC *3*NEW-STATE) (*1*DEF-CONDS *3*DEF) (*1*CALL-CONDS *3*STMT)) (*1*COPY-OUT-PARAMS (*1*DEF-FORMALS *3*DEF) (*1*CALL-ACTUALS *3*STMT) (*1*MG-ALIST *3*NEW-STATE) (*1*MG-ALIST *3*OLD-STATE)) (*1*MG-PSW *3*NEW-STATE))) (DEFUN *1*MAKE-CALL-PARAM-ALIST (*3*FORMALS *3*ACTUALS *3*MG-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*FORMALS) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*FORMALS))) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (CONS (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR *3*ACTUALS) *3*MG-ALIST)))) (QUOTE NIL)))) (*1*MAKE-CALL-PARAM-ALIST (*1*CDR *3*FORMALS) (*1*CDR *3*ACTUALS) *3*MG-ALIST)))))) (DEFUN *1*MAKE-CALL-VAR-ALIST (*3*MG-ALIST *3*STMT *3*DEF) (*1*APPEND (*1*MAKE-CALL-PARAM-ALIST (*1*DEF-FORMALS *3*DEF) (*1*CALL-ACTUALS *3*STMT) *3*MG-ALIST) (*1*DEF-LOCALS *3*DEF))) (DEFUN *1*MAKE-CALL-ENVIRONMENT (*3*MG-STATE *3*STMT *3*DEF) (*1*MG-STATE (QUOTE NORMAL) (*1*MAKE-CALL-VAR-ALIST (*1*MG-ALIST *3*MG-STATE) *3*STMT *3*DEF) (*1*MG-PSW *3*MG-STATE))) (DEFUN *1*MG-BOOL (*3*X) (*1*TAG (QUOTE BOOLEAN-MG) (COND ((NOT (EQ *3*X *1*F)) (QUOTE TRUE-MG)) (T (QUOTE FALSE-MG))))) (DEFUN *1*MG-OR-BOOL (*3*X *3*Y) (COND ((EQ *3*X (QUOTE FALSE-MG)) *3*Y) (T (QUOTE TRUE-MG)))) (DEFUN *1*MG-AND-BOOL (*3*X *3*Y) (COND ((EQ *3*X (QUOTE FALSE-MG)) (QUOTE FALSE-MG)) (T *3*Y))) (DEFUN *1*MG-NOT-BOOL (*3*X) (COND ((EQ *3*X (QUOTE FALSE-MG)) (QUOTE TRUE-MG)) (T (QUOTE FALSE-MG)))) (DEFUN *1*FETCH-ARRAY-ELEMENT (*3*A *3*I *3*ALIST) (*1*GET *3*I (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC *3*A *3*ALIST)))))) (DEFUN *1*PUT-ARRAY-ELEMENT (*3*A *3*I *3*VAL *3*ALIST) (*1*PUT *3*VAL *3*I (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC *3*A *3*ALIST)))))) (DEFUN *1*MG-MEANING-MG-SIMPLE-VARIABLE-ASSIGNMENT (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-SIMPLE-CONSTANT-ASSIGNMENT (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP1 (*1*CALL-ACTUALS *3*STMT))) (*1*CAR (*1*CDR *2*TEMP1)) (*1*MG-ALIST *3*MG-STATE)) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-SIMPLE-VARIABLE-EQ (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (*1*MG-BOOL (COND ((EQUAL (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) *2*TEMP1))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-SIMPLE-CONSTANT-EQ (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (*1*MG-BOOL (COND ((EQUAL (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*CAR (*1*CDR *2*TEMP2)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-INTEGER-LE (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (*1*MG-BOOL (*1*ILEQ (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) *2*TEMP1)))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-INTEGER-UNARY-MINUS (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (COND ((NOT (EQ (*1*SMALL-INTEGERP (SETQ *2*TEMP3 (*1*INEGATE (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT)))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))))) (*1*MG-WORD-SIZE)) *1*F)) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR *2*TEMP2) (*1*TAG (QUOTE INT-MG) *2*TEMP3) *2*TEMP1) (*1*MG-PSW *3*MG-STATE))) (T (*1*SET-CONDITION *3*MG-STATE (QUOTE ROUTINEERROR)))))) (DEFUN *1*MG-MEANING-MG-INTEGER-ADD (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (COND ((NOT (EQ (*1*SMALL-INTEGERP (SETQ *2*TEMP4 (*1*IPLUS (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CDR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP3)) *2*TEMP1)))) (*1*MG-WORD-SIZE)) *1*F)) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR *2*TEMP2) (*1*TAG (QUOTE INT-MG) *2*TEMP4) *2*TEMP1) (*1*MG-PSW *3*MG-STATE))) (T (*1*SET-CONDITION *3*MG-STATE (QUOTE ROUTINEERROR)))))) (DEFUN *1*MG-MEANING-MG-INTEGER-SUBTRACT (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (COND ((NOT (EQ (*1*SMALL-INTEGERP (SETQ *2*TEMP4 (*1*IDIFFERENCE (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CDR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP3)) *2*TEMP1)))) (*1*MG-WORD-SIZE)) *1*F)) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR *2*TEMP2) (*1*TAG (QUOTE INT-MG) *2*TEMP4) *2*TEMP1) (*1*MG-PSW *3*MG-STATE))) (T (*1*SET-CONDITION *3*MG-STATE (QUOTE ROUTINEERROR)))))) (DEFUN *1*MG-MEANING-MG-BOOLEAN-OR (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (*1*TAG (QUOTE BOOLEAN-MG) (*1*MG-OR-BOOL (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) *2*TEMP1)))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-BOOLEAN-AND (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (*1*TAG (QUOTE BOOLEAN-MG) (*1*MG-AND-BOOL (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))) (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) *2*TEMP1)))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-BOOLEAN-NOT (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (*1*TAG (QUOTE BOOLEAN-MG) (*1*MG-NOT-BOOL (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP2)) (SETQ *2*TEMP1 (*1*MG-ALIST *3*MG-STATE)))))) *2*TEMP1) (*1*MG-PSW *3*MG-STATE)))) (DEFUN *1*MG-MEANING-MG-INDEX-ARRAY (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (COND ((NOT (EQ (*1*AND (*1*NUMBERP (SETQ *2*TEMP5 (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (*1*CDR (SETQ *2*TEMP4 (*1*CDR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT)))))) (SETQ *2*TEMP2 (*1*MG-ALIST *3*MG-STATE)))))) (*1*LESSP *2*TEMP5 (*1*ARRAY-LENGTH (*1*GET-M-TYPE (SETQ *2*TEMP1 (*1*CAR *2*TEMP4)) *2*TEMP2)))) *1*F)) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE (*1*CAR *2*TEMP3) (*1*FETCH-ARRAY-ELEMENT *2*TEMP1 *2*TEMP5 *2*TEMP2) *2*TEMP2) (*1*MG-PSW *3*MG-STATE))) (T (*1*SET-CONDITION *3*MG-STATE (QUOTE ROUTINEERROR)))))) (DEFUN *1*MG-MEANING-MG-ARRAY-ELEMENT-ASSIGNMENT (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (COND ((NOT (EQ (*1*AND (*1*NUMBERP (SETQ *2*TEMP5 (*1*UNTAG (*1*GET-M-VALUE (*1*CAR (SETQ *2*TEMP4 (*1*CDR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))))) (SETQ *2*TEMP2 (*1*MG-ALIST *3*MG-STATE)))))) (*1*LESSP *2*TEMP5 (*1*ARRAY-LENGTH (*1*GET-M-TYPE (SETQ *2*TEMP1 (*1*CAR *2*TEMP3)) *2*TEMP2)))) *1*F)) (*1*MG-STATE (QUOTE NORMAL) (*1*SET-ALIST-VALUE *2*TEMP1 (*1*PUT-ARRAY-ELEMENT *2*TEMP1 *2*TEMP5 (*1*GET-M-VALUE (*1*CAR (*1*CDR *2*TEMP4)) *2*TEMP2) *2*TEMP2) *2*TEMP2) (*1*MG-PSW *3*MG-STATE))) (T (*1*SET-CONDITION *3*MG-STATE (QUOTE ROUTINEERROR)))))) (DEFUN *1*MG-MEANING-PREDEFINED-PROC-CALL (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP1 (*1*CALL-NAME *3*STMT)) (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (*1*MG-MEANING-MG-SIMPLE-VARIABLE-ASSIGNMENT *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (*1*MG-MEANING-MG-SIMPLE-CONSTANT-ASSIGNMENT *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-VARIABLE-EQ)) (*1*MG-MEANING-MG-SIMPLE-VARIABLE-EQ *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-CONSTANT-EQ)) (*1*MG-MEANING-MG-SIMPLE-CONSTANT-EQ *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-LE)) (*1*MG-MEANING-MG-INTEGER-LE *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-UNARY-MINUS)) (*1*MG-MEANING-MG-INTEGER-UNARY-MINUS *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-ADD)) (*1*MG-MEANING-MG-INTEGER-ADD *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-SUBTRACT)) (*1*MG-MEANING-MG-INTEGER-SUBTRACT *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-OR)) (*1*MG-MEANING-MG-BOOLEAN-OR *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-AND)) (*1*MG-MEANING-MG-BOOLEAN-AND *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-NOT)) (*1*MG-MEANING-MG-BOOLEAN-NOT *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-INDEX-ARRAY)) (*1*MG-MEANING-MG-INDEX-ARRAY *3*STMT *3*MG-STATE)) ((EQ *2*TEMP1 (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (*1*MG-MEANING-MG-ARRAY-ELEMENT-ASSIGNMENT *3*STMT *3*MG-STATE)) (T *3*MG-STATE)))) (DEFUN *1*MG-MEANING (*3*STMT *3*PROC-LIST *3*MG-STATE *3*N) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X))) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (*1*SIGNAL-SYSTEM-ERROR *3*MG-STATE (QUOTE TIMED-OUT))) ((NOT (EQ (*1*NOT (*1*NORMAL *3*MG-STATE)) *1*F)) *3*MG-STATE) ((EQ (SETQ *2*TEMP4 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) *3*MG-STATE) ((EQ *2*TEMP4 (QUOTE SIGNAL-MG)) (*1*SET-CONDITION *3*MG-STATE (*1*SIGNALLED-CONDITION *3*STMT))) ((EQ *2*TEMP4 (QUOTE PROG2-MG)) (*1*MG-MEANING (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST (*1*MG-MEANING (*1*PROG2-LEFT-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP3 (*1*SUB1 *3*N))) *2*TEMP3)) ((EQ *2*TEMP4 (QUOTE LOOP-MG)) (*1*REMOVE-LEAVE (*1*MG-MEANING *3*STMT *3*PROC-LIST (*1*MG-MEANING (*1*LOOP-BODY *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP3 (*1*SUB1 *3*N))) *2*TEMP3))) ((EQ *2*TEMP4 (QUOTE IF-MG)) (COND ((NOT (EQ (*1*MG-EXPRESSION-FALSEP (*1*IF-CONDITION *3*STMT) *3*MG-STATE) *1*F)) (*1*MG-MEANING (*1*IF-FALSE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (*1*SUB1 *3*N))) (T (*1*MG-MEANING (*1*IF-TRUE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (*1*SUB1 *3*N))))) ((EQ *2*TEMP4 (QUOTE BEGIN-MG)) (COND ((NOT (EQ (*1*MEMBER (*1*CC (SETQ *2*TEMP2 (*1*MG-MEANING (*1*BEGIN-BODY *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP3 (*1*SUB1 *3*N))))) (*1*WHEN-LABELS *3*STMT)) *1*F)) (*1*MG-MEANING (*1*WHEN-HANDLER *3*STMT) *3*PROC-LIST (*1*SET-CONDITION *2*TEMP2 (QUOTE NORMAL)) *2*TEMP3)) (T *2*TEMP2))) ((EQ *2*TEMP4 (QUOTE PROC-CALL-MG)) (*1*MAP-CALL-EFFECTS (*1*MG-MEANING (*1*DEF-BODY (SETQ *2*TEMP1 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) *3*PROC-LIST (*1*MAKE-CALL-ENVIRONMENT *3*MG-STATE *3*STMT *2*TEMP1) (*1*SUB1 *3*N)) *2*TEMP1 *3*STMT *3*MG-STATE)) ((EQ *2*TEMP4 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*MG-MEANING-PREDEFINED-PROC-CALL *3*STMT *3*MG-STATE)) (T *3*MG-STATE)))) (DEFUN *1*DATA-LENGTH (*3*LOCALS) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE 0)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP1 (*1*CAR (*1*CDR (*1*CAR *3*LOCALS))))) *1*F)) (*1*ADD1 (*1*DATA-LENGTH (*1*CDR *3*LOCALS)))) (T (*1*PLUS (*1*ARRAY-LENGTH *2*TEMP1) (*1*DATA-LENGTH (*1*CDR *3*LOCALS))))))) (DEFUN *1*PREDEFINED-PROC-CALL-TEMP-STK-REQUIREMENT (*3*NAME) (COND ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-EQ)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-EQ)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INTEGER-LE)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INTEGER-UNARY-MINUS)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-INTEGER-ADD)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INTEGER-SUBTRACT)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-OR)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-AND)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-NOT)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-INDEX-ARRAY)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (QUOTE 4)) (T (QUOTE 0)))) (DEFUN *1*PREDEFINED-PROC-CALL-BINDINGS-COUNT (*3*NAME) (COND ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (QUOTE 2)) ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-EQ)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-EQ)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INTEGER-LE)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INTEGER-UNARY-MINUS)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-INTEGER-ADD)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-INTEGER-SUBTRACT)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-OR)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-AND)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-NOT)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INDEX-ARRAY)) (QUOTE 5)) ((EQ *3*NAME (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (QUOTE 5)) (T (QUOTE 0)))) (DEFUN *1*PREDEFINED-PROC-CALL-P-FRAME-SIZE (*3*NAME) (*1*ADD1 (*1*ADD1 (*1*PREDEFINED-PROC-CALL-BINDINGS-COUNT *3*NAME)))) (DEFUN *1*T-SIZE (*3*X) (*1*CAR *3*X)) (DEFUN *1*C-SIZE (*3*X) (*1*CAR (*1*CDR *3*X))) (DEFUN *1*TEMP-STK-REQUIREMENTS (*3*STMT *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP2 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE SIGNAL-MG)) (QUOTE 1)) ((EQ *2*TEMP2 (QUOTE PROG2-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE LOOP-MG)) (QUOTE 1)) ((EQ *2*TEMP2 (QUOTE IF-MG)) (QUOTE 1)) ((EQ *2*TEMP2 (QUOTE BEGIN-MG)) (QUOTE 1)) ((EQ *2*TEMP2 (QUOTE PROC-CALL-MG)) (*1*MAX (*1*PLUS (*1*DATA-LENGTH (SETQ *2*TEMP1 (*1*DEF-LOCALS (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST)))) (*1*PLUS (*1*LENGTH *2*TEMP1) (*1*LENGTH (*1*CALL-ACTUALS *3*STMT)))) (QUOTE 1))) ((EQ *2*TEMP2 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*PREDEFINED-PROC-CALL-TEMP-STK-REQUIREMENT (*1*CALL-NAME *3*STMT))) (T (QUOTE 0))))) (DEFUN *1*CTRL-STK-REQUIREMENTS (*3*STMT *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP2 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE SIGNAL-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE PROG2-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE LOOP-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE IF-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE BEGIN-MG)) (QUOTE 0)) ((EQ *2*TEMP2 (QUOTE PROC-CALL-MG)) (*1*PLUS (QUOTE 2) (*1*PLUS (*1*LENGTH (*1*DEF-LOCALS (SETQ *2*TEMP1 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST)))) (*1*LENGTH (*1*DEF-FORMALS *2*TEMP1))))) ((EQ *2*TEMP2 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*PREDEFINED-PROC-CALL-P-FRAME-SIZE (*1*CALL-NAME *3*STMT))) (T (QUOTE 0))))) (DEFUN *1*RESOURCES-INADEQUATEP (*3*STMT *3*PROC-LIST *3*SIZE-PAIR) (*1*OR (*1*NOT (*1*LESSP (*1*TEMP-STK-REQUIREMENTS *3*STMT *3*PROC-LIST) (*1*DIFFERENCE (*1*MG-MAX-TEMP-STK-SIZE) (*1*T-SIZE *3*SIZE-PAIR)))) (*1*NOT (*1*LESSP (*1*CTRL-STK-REQUIREMENTS *3*STMT *3*PROC-LIST) (*1*DIFFERENCE (*1*MG-MAX-CTRL-STK-SIZE) (*1*C-SIZE *3*SIZE-PAIR)))))) (DEFUN *1*MG-MEANING-R (*3*STMT *3*PROC-LIST *3*MG-STATE *3*N *3*SIZES) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X))) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (*1*SIGNAL-SYSTEM-ERROR *3*MG-STATE (QUOTE TIMED-OUT))) ((NOT (EQ (*1*NOT (*1*NORMAL *3*MG-STATE)) *1*F)) *3*MG-STATE) ((NOT (EQ (*1*RESOURCES-INADEQUATEP *3*STMT *3*PROC-LIST *3*SIZES) *1*F)) (*1*SIGNAL-SYSTEM-ERROR *3*MG-STATE (QUOTE RESOURCE-ERROR))) ((EQ (SETQ *2*TEMP5 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) *3*MG-STATE) ((EQ *2*TEMP5 (QUOTE SIGNAL-MG)) (*1*SET-CONDITION *3*MG-STATE (*1*SIGNALLED-CONDITION *3*STMT))) ((EQ *2*TEMP5 (QUOTE PROG2-MG)) (*1*MG-MEANING-R (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST (*1*MG-MEANING-R (*1*PROG2-LEFT-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*SIZES) *2*TEMP4 *3*SIZES)) ((EQ *2*TEMP5 (QUOTE LOOP-MG)) (*1*REMOVE-LEAVE (*1*MG-MEANING-R *3*STMT *3*PROC-LIST (*1*MG-MEANING-R (*1*LOOP-BODY *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*SIZES) *2*TEMP4 *3*SIZES))) ((EQ *2*TEMP5 (QUOTE IF-MG)) (COND ((NOT (EQ (*1*MG-EXPRESSION-FALSEP (*1*IF-CONDITION *3*STMT) *3*MG-STATE) *1*F)) (*1*MG-MEANING-R (*1*IF-FALSE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (*1*SUB1 *3*N) *3*SIZES)) (T (*1*MG-MEANING-R (*1*IF-TRUE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (*1*SUB1 *3*N) *3*SIZES)))) ((EQ *2*TEMP5 (QUOTE BEGIN-MG)) (COND ((NOT (EQ (*1*MEMBER (*1*CC (SETQ *2*TEMP3 (*1*MG-MEANING-R (*1*BEGIN-BODY *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*SIZES))) (*1*WHEN-LABELS *3*STMT)) *1*F)) (*1*MG-MEANING-R (*1*WHEN-HANDLER *3*STMT) *3*PROC-LIST (*1*SET-CONDITION *2*TEMP3 (QUOTE NORMAL)) *2*TEMP4 *3*SIZES)) (T *2*TEMP3))) ((EQ *2*TEMP5 (QUOTE PROC-CALL-MG)) (*1*MAP-CALL-EFFECTS (*1*MG-MEANING-R (*1*DEF-BODY (SETQ *2*TEMP2 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) *3*PROC-LIST (*1*MAKE-CALL-ENVIRONMENT *3*MG-STATE *3*STMT *2*TEMP2) (*1*SUB1 *3*N) (CONS (*1*PLUS (*1*T-SIZE *3*SIZES) (*1*DATA-LENGTH (SETQ *2*TEMP1 (*1*DEF-LOCALS *2*TEMP2)))) (CONS (*1*PLUS (*1*C-SIZE *3*SIZES) (*1*PLUS (QUOTE 2) (*1*PLUS (*1*LENGTH *2*TEMP1) (*1*LENGTH (*1*DEF-FORMALS *2*TEMP2))))) (QUOTE NIL)))) *2*TEMP2 *3*STMT *3*MG-STATE)) ((EQ *2*TEMP5 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*MG-MEANING-PREDEFINED-PROC-CALL *3*STMT *3*MG-STATE)) (T *3*MG-STATE)))) (DEFUN *1*MEANING-INDUCTION-HINT0 (*3*STMT *3*PROC-LIST *3*MG-STATE *3*N *3*SIZES1 *3*SIZES2) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X)) (*2*TEMP7 (QUOTE *1*X)) (*2*TEMP8 (QUOTE *1*X)) (*2*TEMP9 (QUOTE *1*X))) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*RESOURCES-INADEQUATEP *3*STMT *3*PROC-LIST *3*SIZES1) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*NOT (*1*NORMAL *3*MG-STATE)) *1*F)) (QUOTE *1*TRUE)) ((EQ (SETQ *2*TEMP9 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP9 (QUOTE SIGNAL-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP9 (QUOTE PROG2-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT0 (SETQ *2*TEMP8 (*1*PROG2-LEFT-BRANCH *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP7 (*1*SUB1 *3*N)) *3*SIZES1 *3*SIZES2) (*1*MEANING-INDUCTION-HINT0 (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST (*1*MG-MEANING-R *2*TEMP8 *3*PROC-LIST *3*MG-STATE *2*TEMP7 *3*SIZES1) *2*TEMP7 *3*SIZES1 *3*SIZES2))) ((EQ *2*TEMP9 (QUOTE LOOP-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT0 (SETQ *2*TEMP6 (*1*LOOP-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP7 (*1*SUB1 *3*N)) *3*SIZES1 *3*SIZES2) (*1*MEANING-INDUCTION-HINT0 *3*STMT *3*PROC-LIST (*1*MG-MEANING-R *2*TEMP6 *3*PROC-LIST *3*MG-STATE *2*TEMP7 *3*SIZES1) *2*TEMP7 *3*SIZES1 *3*SIZES2))) ((EQ *2*TEMP9 (QUOTE IF-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT0 (*1*IF-FALSE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP7 (*1*SUB1 *3*N)) *3*SIZES1 *3*SIZES2) (*1*MEANING-INDUCTION-HINT0 (*1*IF-TRUE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE *2*TEMP7 *3*SIZES1 *3*SIZES2))) ((EQ *2*TEMP9 (QUOTE BEGIN-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT0 (SETQ *2*TEMP5 (*1*BEGIN-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP7 (*1*SUB1 *3*N)) *3*SIZES1 *3*SIZES2) (*1*MEANING-INDUCTION-HINT0 (*1*WHEN-HANDLER *3*STMT) *3*PROC-LIST (*1*SET-CONDITION (*1*MG-MEANING-R *2*TEMP5 *3*PROC-LIST *3*MG-STATE *2*TEMP7 *3*SIZES1) (QUOTE NORMAL)) *2*TEMP7 *3*SIZES1 *3*SIZES2))) ((EQ *2*TEMP9 (QUOTE PROC-CALL-MG)) (*1*MEANING-INDUCTION-HINT0 (*1*DEF-BODY (SETQ *2*TEMP4 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) *3*PROC-LIST (*1*MAKE-CALL-ENVIRONMENT *3*MG-STATE *3*STMT *2*TEMP4) (*1*SUB1 *3*N) (CONS (*1*PLUS (*1*T-SIZE *3*SIZES1) (SETQ *2*TEMP3 (*1*DATA-LENGTH (SETQ *2*TEMP2 (*1*DEF-LOCALS *2*TEMP4))))) (CONS (*1*PLUS (*1*C-SIZE *3*SIZES1) (SETQ *2*TEMP1 (*1*PLUS (QUOTE 2) (*1*PLUS (*1*LENGTH *2*TEMP2) (*1*LENGTH (*1*DEF-FORMALS *2*TEMP4)))))) (QUOTE NIL))) (CONS (*1*PLUS (*1*T-SIZE *3*SIZES2) *2*TEMP3) (CONS (*1*PLUS (*1*C-SIZE *3*SIZES2) *2*TEMP1) (QUOTE NIL))))) ((EQ *2*TEMP9 (QUOTE PREDEFINED-PROC-CALL-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*FORMAL-TYPES-PRESERVED (*3*FORMALS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*FORMALS) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*DEFINEDP (SETQ *2*TEMP2 (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*FORMALS)))) *3*ALIST) (*1*AND (COND ((EQUAL (*1*CAR (*1*CDR *2*TEMP1)) (*1*CAR (*1*CDR (*1*ASSOC *2*TEMP2 *3*ALIST)))) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*FORMAL-TYPES-PRESERVED (*1*CDR *3*FORMALS) *3*ALIST))))))) (DEFUN *1*MEANING-INDUCTION-HINT (*3*STMT *3*PROC-LIST *3*MG-STATE *3*N *3*NAME-ALIST *3*R-COND-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X))) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*NOT (*1*NORMAL *3*MG-STATE)) *1*F)) (QUOTE *1*TRUE)) ((EQ (SETQ *2*TEMP6 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP6 (QUOTE SIGNAL-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP6 (QUOTE PROG2-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT (SETQ *2*TEMP5 (*1*PROG2-LEFT-BRANCH *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*NAME-ALIST *3*R-COND-LIST) (*1*MEANING-INDUCTION-HINT (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST (*1*MG-MEANING *2*TEMP5 *3*PROC-LIST *3*MG-STATE *2*TEMP4) *2*TEMP4 *3*NAME-ALIST *3*R-COND-LIST))) ((EQ *2*TEMP6 (QUOTE LOOP-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT (SETQ *2*TEMP3 (*1*LOOP-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*NAME-ALIST (CONS (QUOTE LEAVE) *3*R-COND-LIST)) (*1*MEANING-INDUCTION-HINT *3*STMT *3*PROC-LIST (*1*MG-MEANING *2*TEMP3 *3*PROC-LIST *3*MG-STATE *2*TEMP4) *2*TEMP4 *3*NAME-ALIST *3*R-COND-LIST))) ((EQ *2*TEMP6 (QUOTE IF-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT (*1*IF-FALSE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*NAME-ALIST *3*R-COND-LIST) (*1*MEANING-INDUCTION-HINT (*1*IF-TRUE-BRANCH *3*STMT) *3*PROC-LIST *3*MG-STATE *2*TEMP4 *3*NAME-ALIST *3*R-COND-LIST))) ((EQ *2*TEMP6 (QUOTE BEGIN-MG)) (*1*AND (*1*MEANING-INDUCTION-HINT (SETQ *2*TEMP2 (*1*BEGIN-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP4 (*1*SUB1 *3*N)) *3*NAME-ALIST (*1*APPEND (*1*WHEN-LABELS *3*STMT) *3*R-COND-LIST)) (*1*MEANING-INDUCTION-HINT (*1*WHEN-HANDLER *3*STMT) *3*PROC-LIST (*1*SET-CONDITION (*1*MG-MEANING *2*TEMP2 *3*PROC-LIST *3*MG-STATE *2*TEMP4) (QUOTE NORMAL)) *2*TEMP4 *3*NAME-ALIST *3*R-COND-LIST))) ((EQ *2*TEMP6 (QUOTE PROC-CALL-MG)) (*1*MEANING-INDUCTION-HINT (*1*DEF-BODY (SETQ *2*TEMP1 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) *3*PROC-LIST (*1*MAKE-CALL-ENVIRONMENT *3*MG-STATE *3*STMT *2*TEMP1) (*1*SUB1 *3*N) (*1*MAKE-NAME-ALIST *2*TEMP1) (*1*MAKE-COND-LIST *2*TEMP1))) ((EQ *2*TEMP6 (QUOTE PREDEFINED-PROC-CALL-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*MG-TO-P-SIMPLE-LITERAL (*3*LIT) (LET NIL (COND ((NOT (EQ (*1*INT-LITERALP *3*LIT) *1*F)) (CONS (QUOTE INT) (CONS (*1*CAR (*1*CDR *3*LIT)) (QUOTE NIL)))) ((NOT (EQ (*1*BOOLEAN-LITERALP *3*LIT) *1*F)) (COND ((EQ (*1*CAR (*1*CDR *3*LIT)) (QUOTE FALSE-MG)) (QUOTE (BOOL F))) (T (QUOTE (BOOL T))))) ((NOT (EQ (*1*CHARACTER-LITERALP *3*LIT) *1*F)) (CONS (QUOTE INT) (CONS (*1*CAR (*1*CDR *3*LIT)) (QUOTE NIL)))) (T (QUOTE 0))))) (DEFUN *1*MG-TO-P-SIMPLE-LITERAL-LIST (*3*LST) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE NIL)) (T (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR *3*LST)) (*1*MG-TO-P-SIMPLE-LITERAL-LIST (*1*CDR *3*LST)))))) (DEFUN *1*P-TO-MG-SIMPLE-LITERAL (*3*LIT *3*TYPESPEC) (LET NIL (COND ((EQ *3*TYPESPEC (QUOTE INT-MG)) (CONS (QUOTE INT-MG) (CONS (*1*CAR (*1*CDR *3*LIT)) (QUOTE NIL)))) ((EQ *3*TYPESPEC (QUOTE BOOLEAN-MG)) (CONS (QUOTE BOOLEAN-MG) (CONS (COND ((EQ (*1*CAR (*1*CDR *3*LIT)) (QUOTE F)) (QUOTE FALSE-MG)) (T (QUOTE TRUE-MG))) (QUOTE NIL)))) (T (CONS (QUOTE CHARACTER-MG) (CONS (*1*CAR (*1*CDR *3*LIT)) (QUOTE NIL))))))) (DEFUN *1*P-TO-MG-SIMPLE-LITERAL-LIST (*3*LST *3*TYPESPEC) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE NIL)) (T (CONS (*1*P-TO-MG-SIMPLE-LITERAL (*1*CAR *3*LST) *3*TYPESPEC) (*1*P-TO-MG-SIMPLE-LITERAL-LIST (*1*CDR *3*LST) *3*TYPESPEC))))) (DEFUN *1*CONDITION-INDEX (*3*COND *3*COND-LIST) (COND ((EQ *3*COND (QUOTE LEAVE)) (QUOTE 0)) ((EQ *3*COND (QUOTE ROUTINEERROR)) (QUOTE 1)) ((EQ *3*COND (QUOTE NORMAL)) (QUOTE 2)) (T (*1*ADD1 (*1*ADD1 (*1*INDEX *3*COND *3*COND-LIST)))))) (DEFUN *1*MG-COND-TO-P-NAT (*3*C *3*COND-LIST) (CONS (QUOTE NAT) (CONS (*1*CONDITION-INDEX *3*C *3*COND-LIST) (QUOTE NIL)))) (DEFUN *1*P-NAT-TO-MG-COND (*3*P-NAT *3*COND-LIST) (COND ((EQUAL *3*P-NAT (QUOTE (NAT 0))) (QUOTE LEAVE)) ((EQUAL *3*P-NAT (QUOTE (NAT 1))) (QUOTE ROUTINEERROR)) ((EQUAL *3*P-NAT (QUOTE (NAT 2))) (QUOTE NORMAL)) (T (*1*CAR (*1*NTH *3*COND-LIST (*1*SUB1 (*1*SUB1 (*1*SUB1 (*1*CAR (*1*CDR *3*P-NAT)))))))))) (DEFUN *1*DEPOSIT-TEMP (*3*VAL *3*NAT *3*TEMP-STK) (*1*RPUT *3*VAL (*1*UNTAG *3*NAT) *3*TEMP-STK)) (DEFUN *1*FETCH-TEMP (*3*NAT *3*TEMP-STK) (*1*RGET (*1*UNTAG *3*NAT) *3*TEMP-STK)) (DEFUN *1*FETCH-N-TEMP-STK-ELEMENTS (*3*TEMP-STK *3*NAT *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE NIL)) (T (CONS (*1*FETCH-TEMP *3*NAT *3*TEMP-STK) (*1*FETCH-N-TEMP-STK-ELEMENTS *3*TEMP-STK (*1*ADD1-NAT *3*NAT) (*1*SUB1 *3*N)))))) (DEFUN *1*DEPOSIT-ARRAY-VALUE (*3*LIT-LIST *3*NAT *3*TEMP-STK) (COND ((NOT (EQ (*1*NLISTP *3*LIT-LIST) *1*F)) *3*TEMP-STK) (T (*1*DEPOSIT-ARRAY-VALUE (*1*CDR *3*LIT-LIST) (*1*ADD1-NAT *3*NAT) (*1*DEPOSIT-TEMP (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR *3*LIT-LIST)) *3*NAT *3*TEMP-STK))))) (DEFUN *1*DEPOSIT-ALIST-VALUE (*3*MG-ALIST-ELEMENT *3*BINDINGS *3*TEMP-STK) (LET NIL (COND ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (*1*M-TYPE *3*MG-ALIST-ELEMENT)) *1*F)) (*1*DEPOSIT-TEMP (*1*MG-TO-P-SIMPLE-LITERAL (*1*M-VALUE *3*MG-ALIST-ELEMENT)) (*1*CDR (*1*ASSOC (*1*CAR *3*MG-ALIST-ELEMENT) *3*BINDINGS)) *3*TEMP-STK)) (T (*1*DEPOSIT-ARRAY-VALUE (*1*M-VALUE *3*MG-ALIST-ELEMENT) (*1*CDR (*1*ASSOC (*1*CAR *3*MG-ALIST-ELEMENT) *3*BINDINGS)) *3*TEMP-STK))))) (DEFUN *1*MAP-DOWN-VALUES (*3*MG-ALIST *3*BINDINGS *3*TEMP-STK) (COND ((NOT (EQ (*1*NLISTP *3*MG-ALIST) *1*F)) *3*TEMP-STK) (T (*1*MAP-DOWN-VALUES (*1*CDR *3*MG-ALIST) *3*BINDINGS (*1*DEPOSIT-ALIST-VALUE (*1*CAR *3*MG-ALIST) *3*BINDINGS *3*TEMP-STK))))) (DEFUN *1*OK-TEMP-STK-INDEX (*3*NAT *3*TEMP-STK) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*NAT (QUOTE 2)) (*1*AND (COND ((EQ (*1*TYPE *3*NAT) (QUOTE NAT)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*NUMBERP (SETQ *2*TEMP1 (*1*UNTAG *3*NAT))) (*1*LESSP *2*TEMP1 (*1*LENGTH *3*TEMP-STK))))))) (DEFUN *1*OK-TEMP-STK-ARRAY-INDEX (*3*NAT *3*TEMP-STK *3*LNGTH) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*AND (*1*LENGTH-PLISTP *3*NAT (QUOTE 2)) (*1*AND (COND ((EQ (*1*TYPE *3*NAT) (QUOTE NAT)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*AND (*1*NUMBERP (SETQ *2*TEMP1 (*1*UNTAG *3*NAT))) (*1*LESSP (*1*PLUS *2*TEMP1 (*1*SUB1 *3*LNGTH)) (*1*LENGTH *3*TEMP-STK))))))) (DEFUN *1*MG-VAR-OK-IN-P-STATE (*3*MG-VAR *3*BINDINGS *3*TEMP-STK) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (*1*AND (*1*DEFINEDP (SETQ *2*TEMP2 (*1*CAR *3*MG-VAR)) *3*BINDINGS) (COND ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP1 (*1*M-TYPE *3*MG-VAR))) *1*F)) (*1*OK-TEMP-STK-INDEX (*1*CDR (*1*ASSOC *2*TEMP2 *3*BINDINGS)) *3*TEMP-STK)) (T (*1*OK-TEMP-STK-ARRAY-INDEX (*1*CDR (*1*ASSOC *2*TEMP2 *3*BINDINGS)) *3*TEMP-STK (*1*ARRAY-LENGTH *2*TEMP1))))))) (DEFUN *1*MG-VARS-LIST-OK-IN-P-STATE (*3*MG-VARS *3*BINDINGS *3*TEMP-STK) (COND ((NOT (EQ (*1*NLISTP *3*MG-VARS) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*MG-VAR-OK-IN-P-STATE (*1*CAR *3*MG-VARS) *3*BINDINGS *3*TEMP-STK) (*1*MG-VARS-LIST-OK-IN-P-STATE (*1*CDR *3*MG-VARS) *3*BINDINGS *3*TEMP-STK))))) (DEFUN *1*N-SUCCESSIVE-POINTERS (*3*NAT *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE NIL)) (T (CONS (*1*UNTAG *3*NAT) (*1*N-SUCCESSIVE-POINTERS (*1*ADD1-NAT *3*NAT) (*1*SUB1 *3*N)))))) (DEFUN *1*COLLECT-POINTERS (*3*BINDINGS *3*ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ALIST) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP2 (*1*CAR (*1*CDR (SETQ *2*TEMP1 (*1*CAR *3*ALIST)))))) *1*F)) (CONS (*1*UNTAG (*1*CDR (*1*ASSOC (*1*CAR *2*TEMP1) *3*BINDINGS))) (*1*COLLECT-POINTERS *3*BINDINGS (*1*CDR *3*ALIST)))) (T (*1*APPEND (*1*N-SUCCESSIVE-POINTERS (*1*CDR (*1*ASSOC (*1*CAR *2*TEMP1) *3*BINDINGS)) (*1*ARRAY-LENGTH *2*TEMP2)) (*1*COLLECT-POINTERS *3*BINDINGS (*1*CDR *3*ALIST))))))) (DEFUN *1*NO-P-ALIASING (*3*BINDINGS *3*ALIST) (*1*NO-DUPLICATES (*1*COLLECT-POINTERS *3*BINDINGS *3*ALIST))) (DEFUN *1*DOUBLE-CDR-INDUCTION2 (*3*X *3*Y *3*NAT) (COND ((NOT (EQ (*1*NLISTP *3*X) *1*F)) (QUOTE *1*TRUE)) (T (*1*DOUBLE-CDR-INDUCTION2 (*1*CDR *3*X) (*1*CDR *3*Y) (*1*ADD1-NAT *3*NAT))))) (DEFUN *1*RGET-ARRAY-MAPPING-INDUCTION-HINT (*3*VALUE *3*INDEX *3*NAT *3*TEMP-STK) (COND ((NOT (EQ (*1*NLISTP *3*VALUE) *1*F)) (QUOTE *1*TRUE)) ((NOT (EQ (*1*ZEROP *3*INDEX) *1*F)) (QUOTE *1*TRUE)) (T (*1*RGET-ARRAY-MAPPING-INDUCTION-HINT (*1*CDR *3*VALUE) (*1*SUB1 *3*INDEX) (*1*ADD1-NAT *3*NAT) (*1*DEPOSIT-TEMP (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR *3*VALUE)) *3*NAT *3*TEMP-STK))))) (DEFUN *1*ASCENDING-LOCAL-ADDRESS-SEQUENCE (*3*LOCALS *3*N) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP1 (*1*FORMAL-TYPE (*1*CAR *3*LOCALS)))) *1*F)) (CONS (*1*TAG (QUOTE NAT) *3*N) (*1*ASCENDING-LOCAL-ADDRESS-SEQUENCE (*1*CDR *3*LOCALS) (*1*ADD1 *3*N)))) (T (CONS (*1*TAG (QUOTE NAT) *3*N) (*1*ASCENDING-LOCAL-ADDRESS-SEQUENCE (*1*CDR *3*LOCALS) (*1*PLUS (*1*ARRAY-LENGTH *2*TEMP1) *3*N))))))) (DEFUN *1*ALL-POINTERS-SMALLER (*3*LST *3*N) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (*1*LESSP (*1*CAR *3*LST) *3*N) (*1*ALL-POINTERS-SMALLER (*1*CDR *3*LST) *3*N))))) (DEFUN *1*ALL-POINTERS-BIGGER (*3*LST *3*N) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*TRUE)) (T (*1*AND (COND ((NOT (EQ (*1*LESSP (*1*CAR *3*LST) *3*N) *1*F)) (QUOTE *1*FALSE)) (T (QUOTE *1*TRUE))) (*1*ALL-POINTERS-BIGGER (*1*CDR *3*LST) *3*N))))) (DEFUN *1*SUCCESSIVE-POINTERS-BIGGER-INDUCTION-HINT (*3*NAT *3*N *3*M) (COND ((NOT (EQ (*1*ZEROP *3*M) *1*F)) (QUOTE *1*TRUE)) (T (*1*SUCCESSIVE-POINTERS-BIGGER-INDUCTION-HINT (*1*ADD1-NAT *3*NAT) (*1*ADD1 *3*N) (*1*SUB1 *3*M))))) (DEFUN *1*MAP-UP-VARS-LIST-ARRAY (*3*P-VAR *3*TEMP-STK *3*VAR-SIGNATURE) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (*1*CAR *3*VAR-SIGNATURE) (CONS (SETQ *2*TEMP1 (*1*CAR (*1*CDR *3*VAR-SIGNATURE))) (CONS (*1*P-TO-MG-SIMPLE-LITERAL-LIST (*1*FETCH-N-TEMP-STK-ELEMENTS *3*TEMP-STK (*1*CDR *3*P-VAR) (*1*ARRAY-LENGTH *2*TEMP1)) (*1*ARRAY-ELEMTYPE *2*TEMP1)) (QUOTE NIL)))))) (DEFUN *1*MAP-UP-VARS-LIST-SIMPLE-ELEMENT (*3*P-VAR *3*TEMP-STK *3*VAR-SIGNATURE) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (*1*CAR *3*VAR-SIGNATURE) (CONS (SETQ *2*TEMP1 (*1*CAR (*1*CDR *3*VAR-SIGNATURE))) (CONS (*1*P-TO-MG-SIMPLE-LITERAL (*1*FETCH-TEMP (*1*CDR *3*P-VAR) *3*TEMP-STK) *2*TEMP1) (QUOTE NIL)))))) (DEFUN *1*MAP-UP-VARS-LIST-ELEMENT (*3*P-VAR *3*TEMP-STK *3*VAR-SIGNATURE) (COND ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (*1*CAR (*1*CDR *3*VAR-SIGNATURE))) *1*F)) (*1*MAP-UP-VARS-LIST-SIMPLE-ELEMENT *3*P-VAR *3*TEMP-STK *3*VAR-SIGNATURE)) (T (*1*MAP-UP-VARS-LIST-ARRAY *3*P-VAR *3*TEMP-STK *3*VAR-SIGNATURE)))) (DEFUN *1*MAP-UP-VARS-LIST (*3*P-VARS *3*TEMP-STK *3*SIGNATURE) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*SIGNATURE) *1*F)) (QUOTE NIL)) (T (CONS (*1*MAP-UP-VARS-LIST-ELEMENT (*1*ASSOC (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*SIGNATURE))) *3*P-VARS) *3*TEMP-STK *2*TEMP1) (*1*MAP-UP-VARS-LIST *3*P-VARS *3*TEMP-STK (*1*CDR *3*SIGNATURE))))))) (DEFUN *1*PITON-CC (*3*P) (*1*FETCH-ADP (QUOTE (C-C . 0)) (*1*P-DATA-SEGMENT *3*P))) (DEFUN *1*MAP-UP (*3*P-STATE *3*MG-SIGNATURE *3*COND-LIST) (*1*MG-STATE (*1*P-NAT-TO-MG-COND (*1*PITON-CC *3*P-STATE) *3*COND-LIST) (*1*MAP-UP-VARS-LIST (*1*BINDINGS (*1*TOP (*1*P-CTRL-STK *3*P-STATE))) (*1*P-TEMP-STK *3*P-STATE) *3*MG-SIGNATURE) (QUOTE RUN))) (DEFUN *1*FETCH-TEMP-STK-ELEMENTS-INDUCTION-HINT (*3*VALUE *3*TEMP-STK *3*NAT *3*N) (COND ((NOT (EQ (*1*NLISTP *3*VALUE) *1*F)) (QUOTE *1*TRUE)) (T (*1*FETCH-TEMP-STK-ELEMENTS-INDUCTION-HINT (*1*CDR *3*VALUE) *3*TEMP-STK (*1*ADD1-NAT *3*NAT) (*1*SUB1 *3*N))))) (DEFUN *1*DEPOSIT-ARRAY-VALUE-SAME-VALUE-INDUCTION-HINT (*3*ARRAY-VALUE *3*TEMP-STK) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ARRAY-VALUE) *1*F)) (QUOTE *1*TRUE)) (T (*1*DEPOSIT-ARRAY-VALUE-SAME-VALUE-INDUCTION-HINT (*1*CDR *3*ARRAY-VALUE) (*1*DEPOSIT-TEMP (SETQ *2*TEMP1 (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR *3*ARRAY-VALUE))) (*1*TAG (QUOTE NAT) (*1*LENGTH *3*TEMP-STK)) (CONS *2*TEMP1 *3*TEMP-STK))))))) (DEFUN *1*MG-TO-P-LOCAL-VALUES (*3*LOCALS) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (*1*CAR (SETQ *2*TEMP1 (*1*CDR (*1*CAR *3*LOCALS))))) *1*F)) (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR (*1*CDR *2*TEMP1))) (*1*MG-TO-P-LOCAL-VALUES (*1*CDR *3*LOCALS)))) (T (*1*APPEND (*1*MG-TO-P-SIMPLE-LITERAL-LIST (*1*CAR (*1*CDR *2*TEMP1))) (*1*MG-TO-P-LOCAL-VALUES (*1*CDR *3*LOCALS))))))) (DEFUN *1*MAP-CALL-FORMALS (*3*FORMALS *3*ACTUALS *3*BINDINGS) (COND ((NOT (EQ (*1*NLISTP *3*FORMALS) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR (*1*CAR *3*FORMALS)) (*1*CDR (*1*ASSOC (*1*CAR *3*ACTUALS) *3*BINDINGS))) (*1*MAP-CALL-FORMALS (*1*CDR *3*FORMALS) (*1*CDR *3*ACTUALS) *3*BINDINGS))))) (DEFUN *1*MAP-CALL-LOCALS (*3*LOCALS *3*N) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP2 (*1*CAR (*1*CDR (SETQ *2*TEMP1 (*1*CAR *3*LOCALS)))))) *1*F)) (CONS (CONS (*1*CAR *2*TEMP1) (*1*TAG (QUOTE NAT) *3*N)) (*1*MAP-CALL-LOCALS (*1*CDR *3*LOCALS) (*1*ADD1 *3*N)))) (T (CONS (CONS (*1*CAR *2*TEMP1) (*1*TAG (QUOTE NAT) *3*N)) (*1*MAP-CALL-LOCALS (*1*CDR *3*LOCALS) (*1*PLUS (*1*ARRAY-LENGTH *2*TEMP2) *3*N))))))) (DEFUN *1*MAKE-FRAME-ALIST (*3*DEF *3*STMT *3*CTRL-STK *3*TEMP-STK) (*1*APPEND (*1*MAP-CALL-LOCALS (*1*DEF-LOCALS *3*DEF) (*1*LENGTH *3*TEMP-STK)) (*1*MAP-CALL-FORMALS (*1*DEF-FORMALS *3*DEF) (*1*CALL-ACTUALS *3*STMT) (*1*BINDINGS (*1*TOP *3*CTRL-STK))))) (DEFUN *1*MG-ACTUALS-TO-P-ACTUALS (*3*MG-ACTUALS *3*BINDINGS) (COND ((NOT (EQ (*1*NLISTP *3*MG-ACTUALS) *1*F)) (QUOTE NIL)) (T (CONS (*1*CDR (*1*ASSOC (*1*CAR *3*MG-ACTUALS) *3*BINDINGS)) (*1*MG-ACTUALS-TO-P-ACTUALS (*1*CDR *3*MG-ACTUALS) *3*BINDINGS))))) (DEFUN *1*CINFOP (X) (COND ((AND (CONSP X) (EQ (CAR X) *1*SHELL-QUOTE-MARK) (EQ (CADR X) (QUOTE MAKE-CINFO))) *1*T) (T *1*F))) (DEFUN *1*CODE (X) (COND ((EQ (*1*CINFOP X) *1*T) (CAR (CDR (CDR X)))) (T (*1*ZERO)))) (DEFUN *1*LABEL-ALIST (X) (COND ((EQ (*1*CINFOP X) *1*T) (CAR (CDR (CDR (CDR X))))) (T (*1*ZERO)))) (DEFUN *1*LABEL-CNT (X) (COND ((EQ (*1*CINFOP X) *1*T) (CAR (CDR (CDR (CDR (CDR X)))))) (T (*1*ZERO)))) (DEFUN *1*MAKE-CINFO (CODE LABEL-ALIST LABEL-CNT) (LIST *1*SHELL-QUOTE-MARK (QUOTE MAKE-CINFO) CODE LABEL-ALIST (IF (OR (EQ *1*T (*1*NUMBERP LABEL-CNT))) LABEL-CNT (*1*ZERO)))) (DEFUN *1*NULLIFY (*3*CINFO) (*1*MAKE-CINFO (QUOTE NIL) (*1*LABEL-ALIST *3*CINFO) (*1*LABEL-CNT *3*CINFO))) (DEFUN *1*ADD-CODE (*3*CINFO *3*CODE) (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) *3*CODE) (*1*LABEL-ALIST *3*CINFO) (*1*LABEL-CNT *3*CINFO))) (DEFUN *1*DISCARD-LABEL (*3*CINFO) (*1*MAKE-CINFO (*1*CODE *3*CINFO) (*1*CDR (*1*LABEL-ALIST *3*CINFO)) (*1*LABEL-CNT *3*CINFO))) (DEFUN *1*SET-LABEL-ALIST (*3*CINFO *3*NEW-LABEL-ALIST) (*1*MAKE-CINFO (*1*CODE *3*CINFO) *3*NEW-LABEL-ALIST (*1*LABEL-CNT *3*CINFO))) (DEFUN *1*FETCH-LABEL (*3*CONDITION *3*LABEL-ALIST) (*1*CDR (*1*ASSOC *3*CONDITION *3*LABEL-ALIST))) (DEFUN *1*OK-CINFOP (*3*CINFO) (*1*PLISTP (*1*CODE *3*CINFO))) (DEFUN *1*MAKE-LABEL-ALIST (*3*NAME-LIST *3*LABEL) (COND ((NOT (EQ (*1*NLISTP *3*NAME-LIST) *1*F)) (QUOTE NIL)) (T (CONS (CONS (*1*CAR *3*NAME-LIST) *3*LABEL) (*1*MAKE-LABEL-ALIST (*1*CDR *3*NAME-LIST) *3*LABEL))))) (DEFUN *1*PUSH-LOCAL-ARRAY-VALUES-CODE (*3*ARRAY-VALUE) (COND ((NOT (EQ (*1*NLISTP *3*ARRAY-VALUE) *1*F)) (QUOTE NIL)) (T (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR *3*ARRAY-VALUE)) (QUOTE NIL))) (*1*PUSH-LOCAL-ARRAY-VALUES-CODE (*1*CDR *3*ARRAY-VALUE)))))) (DEFUN *1*PUSH-LOCALS-VALUES-CODE (*3*LOCALS) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (*1*CAR (SETQ *2*TEMP1 (*1*CDR (*1*CAR *3*LOCALS))))) *1*F)) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE NIL))) (*1*PUSH-LOCALS-VALUES-CODE (*1*CDR *3*LOCALS)))) (T (*1*APPEND (*1*PUSH-LOCAL-ARRAY-VALUES-CODE (*1*CAR (*1*CDR *2*TEMP1))) (*1*PUSH-LOCALS-VALUES-CODE (*1*CDR *3*LOCALS))))))) (DEFUN *1*PUSH-LOCALS-ADDRESSES-CODE (*3*LOCALS *3*N) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LOCALS) *1*F)) (QUOTE NIL)) ((NOT (EQ (*1*SIMPLE-MG-TYPE-REFP (SETQ *2*TEMP1 (*1*CAR (*1*CDR (*1*CAR *3*LOCALS))))) *1*F)) (CONS (CONS (QUOTE PUSH-TEMP-STK-INDEX) (CONS *3*N (QUOTE NIL))) (*1*PUSH-LOCALS-ADDRESSES-CODE (*1*CDR *3*LOCALS) *3*N))) (T (CONS (CONS (QUOTE PUSH-TEMP-STK-INDEX) (CONS *3*N (QUOTE NIL))) (*1*PUSH-LOCALS-ADDRESSES-CODE (*1*CDR *3*LOCALS) (*1*ADD1 (*1*DIFFERENCE *3*N (*1*ARRAY-LENGTH *2*TEMP1))))))))) (DEFUN *1*PUSH-ACTUALS-CODE (*3*ACTUALS) (COND ((NOT (EQ (*1*NLISTP *3*ACTUALS) *1*F)) (QUOTE NIL)) (T (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR *3*ACTUALS) (QUOTE NIL))) (*1*PUSH-ACTUALS-CODE (*1*CDR *3*ACTUALS)))))) (DEFUN *1*PUSH-PARAMETERS-CODE (*3*LOCALS *3*ACTUALS) (*1*APPEND (*1*PUSH-LOCALS-VALUES-CODE *3*LOCALS) (*1*APPEND (*1*PUSH-LOCALS-ADDRESSES-CODE *3*LOCALS (*1*SUB1 (*1*DATA-LENGTH *3*LOCALS))) (*1*PUSH-ACTUALS-CODE *3*ACTUALS)))) (DEFUN *1*COND-CASE-JUMP-LABEL-LIST (*3*LC *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE NIL)) (T (CONS *3*LC (*1*COND-CASE-JUMP-LABEL-LIST (*1*ADD1 *3*LC) (*1*SUB1 *3*N)))))) (DEFUN *1*INDEX-COND-CASE-INDUCTION-HINT (*3*I *3*J *3*K) (COND ((NOT (EQ (*1*ZEROP *3*K) *1*F)) (QUOTE *1*TRUE)) (T (*1*INDEX-COND-CASE-INDUCTION-HINT (*1*SUB1 *3*I) (*1*ADD1 *3*J) (*1*SUB1 *3*K))))) (DEFUN *1*COND-CONVERSION (*3*ACTUAL-CONDS *3*LC *3*COND-LIST *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*ACTUAL-CONDS) *1*F)) (QUOTE NIL)) (T (CONS (CONS (QUOTE DL) (CONS *3*LC (CONS (QUOTE NIL) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-COND-TO-P-NAT (SETQ *2*TEMP1 (*1*CAR *3*ACTUAL-CONDS)) *3*COND-LIST) (QUOTE NIL))) (QUOTE NIL))))) (CONS (QUOTE (POP-GLOBAL C-C)) (CONS (CONS (QUOTE JUMP) (CONS (*1*FETCH-LABEL *2*TEMP1 *3*LABEL-ALIST) (QUOTE NIL))) (*1*COND-CONVERSION (*1*CDR *3*ACTUAL-CONDS) (*1*ADD1 *3*LC) *3*COND-LIST *3*LABEL-ALIST)))))))) (DEFUN *1*LABEL-CNT-LIST (*3*LC *3*N) (COND ((NOT (EQ (*1*ZEROP *3*N) *1*F)) (QUOTE NIL)) (T (CONS *3*LC (*1*LABEL-CNT-LIST *3*LC (*1*SUB1 *3*N)))))) (DEFUN *1*CONDITION-MAP-CODE (*3*ACTUAL-CONDS *3*LC *3*COND-LIST *3*LABEL-ALIST *3*PROC-LOCALS-LNGTH) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*APPEND (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (*1*APPEND (CONS (QUOTE JUMP-CASE) (CONS *3*LC (CONS *3*LC (*1*COND-CASE-JUMP-LABEL-LIST (SETQ *2*TEMP1 (*1*ADD1 *3*LC)) (*1*ADD1 (*1*LENGTH *3*ACTUAL-CONDS)))))) (*1*LABEL-CNT-LIST *3*LC *3*PROC-LOCALS-LNGTH)) (CONS (CONS (QUOTE DL) (CONS *3*LC (QUOTE (NIL (PUSH-CONSTANT (NAT 1)))))) (CONS (QUOTE (POP-GLOBAL C-C)) (CONS (CONS (QUOTE JUMP) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL))) (QUOTE NIL)))))) (*1*APPEND (*1*COND-CONVERSION *3*ACTUAL-CONDS (*1*ADD1 *2*TEMP1) *3*COND-LIST *3*LABEL-ALIST) (CONS (CONS (QUOTE DL) (CONS *2*TEMP1 (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))))) (DEFUN *1*PROC-CALL-CODE (*3*CINFO *3*STMT *3*COND-LIST *3*LOCALS *3*COND-LOCALS-LNGTH) (*1*APPEND (*1*PUSH-PARAMETERS-CODE *3*LOCALS (*1*CALL-ACTUALS *3*STMT)) (CONS (CONS (QUOTE CALL) (CONS (*1*CALL-NAME *3*STMT) (QUOTE NIL))) (*1*CONDITION-MAP-CODE (*1*CALL-CONDS *3*STMT) (*1*LABEL-CNT *3*CINFO) *3*COND-LIST (*1*LABEL-ALIST *3*CINFO) *3*COND-LOCALS-LNGTH)))) (DEFUN *1*MG-SIMPLE-VARIABLE-ASSIGNMENT-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-SIMPLE-VARIABLE-ASSIGNMENT))))))) (DEFUN *1*MG-SIMPLE-CONSTANT-ASSIGNMENT-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE NIL))) (QUOTE ((CALL MG-SIMPLE-CONSTANT-ASSIGNMENT))))))) (DEFUN *1*MG-SIMPLE-VARIABLE-EQ-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-SIMPLE-VARIABLE-EQ)))))))) (DEFUN *1*MG-SIMPLE-CONSTANT-EQ-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-TO-P-SIMPLE-LITERAL (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE NIL))) (QUOTE ((CALL MG-SIMPLE-CONSTANT-EQ)))))))) (DEFUN *1*MG-INTEGER-LE-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-INTEGER-LE)))))))) (DEFUN *1*MG-INTEGER-UNARY-MINUS-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (CONS (QUOTE (CALL MG-INTEGER-UNARY-MINUS)) (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (QUOTE (SUB1-NAT)) (CONS (CONS (QUOTE TEST-NAT-AND-JUMP) (CONS (QUOTE ZERO) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL)))) (QUOTE NIL))))))))) (DEFUN *1*MG-INTEGER-ADD-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (CONS (QUOTE (CALL MG-INTEGER-ADD)) (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (QUOTE (SUB1-NAT)) (CONS (CONS (QUOTE TEST-NAT-AND-JUMP) (CONS (QUOTE ZERO) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL)))) (QUOTE NIL)))))))))) (DEFUN *1*MG-INTEGER-SUBTRACT-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (CONS (QUOTE (CALL MG-INTEGER-SUBTRACT)) (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (QUOTE (SUB1-NAT)) (CONS (CONS (QUOTE TEST-NAT-AND-JUMP) (CONS (QUOTE ZERO) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL)))) (QUOTE NIL)))))))))) (DEFUN *1*MG-BOOLEAN-OR-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-BOOLEAN-OR)))))))) (DEFUN *1*MG-BOOLEAN-AND-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-BOOLEAN-AND)))))))) (DEFUN *1*MG-BOOLEAN-NOT-CALL-SEQUENCE (*3*STMT) (LET ((*2*TEMP1 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (QUOTE NIL))) (QUOTE ((CALL MG-BOOLEAN-NOT))))))) (DEFUN *1*MG-INDEX-ARRAY-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*TAG (QUOTE INT) (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE NIL))) (CONS (QUOTE (CALL MG-INDEX-ARRAY)) (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (QUOTE (SUB1-NAT)) (CONS (CONS (QUOTE TEST-NAT-AND-JUMP) (CONS (QUOTE ZERO) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL)))) (QUOTE NIL))))))))))) (DEFUN *1*MG-ARRAY-ELEMENT-ASSIGNMENT-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP3 (*1*CALL-ACTUALS *3*STMT))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP2 (*1*CDR *2*TEMP3))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*CAR (SETQ *2*TEMP1 (*1*CDR *2*TEMP2))) (QUOTE NIL))) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*TAG (QUOTE INT) (*1*CAR (*1*CDR *2*TEMP1))) (QUOTE NIL))) (CONS (QUOTE (CALL MG-ARRAY-ELEMENT-ASSIGNMENT)) (CONS (QUOTE (PUSH-GLOBAL C-C)) (CONS (QUOTE (SUB1-NAT)) (CONS (CONS (QUOTE TEST-NAT-AND-JUMP) (CONS (QUOTE ZERO) (CONS (*1*FETCH-LABEL (QUOTE ROUTINEERROR) *3*LABEL-ALIST) (QUOTE NIL)))) (QUOTE NIL))))))))))) (DEFUN *1*PREDEFINED-PROC-CALL-SEQUENCE (*3*STMT *3*LABEL-ALIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP1 (*1*CALL-NAME *3*STMT)) (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (*1*MG-SIMPLE-VARIABLE-ASSIGNMENT-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (*1*MG-SIMPLE-CONSTANT-ASSIGNMENT-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-VARIABLE-EQ)) (*1*MG-SIMPLE-VARIABLE-EQ-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-SIMPLE-CONSTANT-EQ)) (*1*MG-SIMPLE-CONSTANT-EQ-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-LE)) (*1*MG-INTEGER-LE-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-UNARY-MINUS)) (*1*MG-INTEGER-UNARY-MINUS-CALL-SEQUENCE *3*STMT *3*LABEL-ALIST)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-ADD)) (*1*MG-INTEGER-ADD-CALL-SEQUENCE *3*STMT *3*LABEL-ALIST)) ((EQ *2*TEMP1 (QUOTE MG-INTEGER-SUBTRACT)) (*1*MG-INTEGER-SUBTRACT-CALL-SEQUENCE *3*STMT *3*LABEL-ALIST)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-OR)) (*1*MG-BOOLEAN-OR-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-AND)) (*1*MG-BOOLEAN-AND-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-BOOLEAN-NOT)) (*1*MG-BOOLEAN-NOT-CALL-SEQUENCE *3*STMT)) ((EQ *2*TEMP1 (QUOTE MG-INDEX-ARRAY)) (*1*MG-INDEX-ARRAY-CALL-SEQUENCE *3*STMT *3*LABEL-ALIST)) ((EQ *2*TEMP1 (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (*1*MG-ARRAY-ELEMENT-ASSIGNMENT-CALL-SEQUENCE *3*STMT *3*LABEL-ALIST)) (T (QUOTE NIL))))) (DEFUN *1*MG-SIMPLE-VARIABLE-ASSIGNMENT-TRANSLATION NIL (QUOTE (MG-SIMPLE-VARIABLE-ASSIGNMENT (DEST SOURCE) NIL (PUSH-LOCAL SOURCE) (FETCH-TEMP-STK) (PUSH-LOCAL DEST) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-SIMPLE-CONSTANT-ASSIGNMENT-TRANSLATION NIL (QUOTE (MG-SIMPLE-CONSTANT-ASSIGNMENT (DEST SOURCE) NIL (PUSH-LOCAL SOURCE) (PUSH-LOCAL DEST) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-SIMPLE-VARIABLE-EQ-TRANSLATION NIL (QUOTE (MG-SIMPLE-VARIABLE-EQ (ANS X Y) NIL (PUSH-LOCAL X) (FETCH-TEMP-STK) (PUSH-LOCAL Y) (FETCH-TEMP-STK) (EQ) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-SIMPLE-CONSTANT-EQ-TRANSLATION NIL (QUOTE (MG-SIMPLE-CONSTANT-EQ (ANS X Y) NIL (PUSH-LOCAL X) (FETCH-TEMP-STK) (PUSH-LOCAL Y) (EQ) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-INTEGER-LE-TRANSLATION NIL (QUOTE (MG-INTEGER-LE (ANS X Y) NIL (PUSH-LOCAL Y) (FETCH-TEMP-STK) (PUSH-LOCAL X) (FETCH-TEMP-STK) (LT-INT) (NOT-BOOL) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-INTEGER-UNARY-MINUS-TRANSLATION NIL (QUOTE (MG-INTEGER-UNARY-MINUS (ANS X) ((MIN-INT (INT -2147483648)) (TEMP-X (INT 0))) (PUSH-LOCAL X) (FETCH-TEMP-STK) (SET-LOCAL TEMP-X) (PUSH-LOCAL MIN-INT) (EQ) (TEST-BOOL-AND-JUMP F 0) (PUSH-CONSTANT (NAT 1)) (POP-GLOBAL C-C) (JUMP 1) (DL 0 NIL (PUSH-LOCAL TEMP-X)) (NEG-INT) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (DL 1 NIL (RET))))) (DEFUN *1*MG-INTEGER-ADD-TRANSLATION NIL (QUOTE (MG-INTEGER-ADD (ANS Y Z) ((T1 (INT 0))) (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL Y) (FETCH-TEMP-STK) (PUSH-LOCAL Z) (FETCH-TEMP-STK) (ADD-INT-WITH-CARRY) (POP-LOCAL T1) (TEST-BOOL-AND-JUMP T 0) (PUSH-LOCAL T1) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (JUMP 1) (DL 0 NIL (PUSH-CONSTANT (NAT 1))) (POP-GLOBAL C-C) (DL 1 NIL (RET))))) (DEFUN *1*MG-INTEGER-SUBTRACT-TRANSLATION NIL (QUOTE (MG-INTEGER-SUBTRACT (ANS Y Z) ((T1 (INT 0))) (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL Y) (FETCH-TEMP-STK) (PUSH-LOCAL Z) (FETCH-TEMP-STK) (SUB-INT-WITH-CARRY) (POP-LOCAL T1) (TEST-BOOL-AND-JUMP T 0) (PUSH-LOCAL T1) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (JUMP 1) (DL 0 NIL (PUSH-CONSTANT (NAT 1))) (POP-GLOBAL C-C) (DL 1 NIL (RET))))) (DEFUN *1*MG-BOOLEAN-OR-TRANSLATION NIL (QUOTE (MG-BOOLEAN-OR (ANS B1 B2) NIL (PUSH-LOCAL B1) (FETCH-TEMP-STK) (PUSH-LOCAL B2) (FETCH-TEMP-STK) (OR-BOOL) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-BOOLEAN-AND-TRANSLATION NIL (QUOTE (MG-BOOLEAN-AND (ANS B1 B2) NIL (PUSH-LOCAL B1) (FETCH-TEMP-STK) (PUSH-LOCAL B2) (FETCH-TEMP-STK) (AND-BOOL) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-BOOLEAN-NOT-TRANSLATION NIL (QUOTE (MG-BOOLEAN-NOT (ANS B1) NIL (PUSH-LOCAL B1) (FETCH-TEMP-STK) (NOT-BOOL) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (RET)))) (DEFUN *1*MG-INDEX-ARRAY-TRANSLATION NIL (QUOTE (MG-INDEX-ARRAY (ANS A I ARRAY-SIZE) ((TEMP-I (NAT 0))) (PUSH-LOCAL I) (FETCH-TEMP-STK) (SET-LOCAL TEMP-I) (TEST-INT-AND-JUMP NEG 0) (PUSH-LOCAL ARRAY-SIZE) (PUSH-LOCAL TEMP-I) (SUB-INT) (TEST-INT-AND-JUMP NOT-POS 0) (PUSH-LOCAL A) (PUSH-LOCAL TEMP-I) (INT-TO-NAT) (ADD-NAT) (FETCH-TEMP-STK) (PUSH-LOCAL ANS) (DEPOSIT-TEMP-STK) (JUMP 1) (DL 0 NIL (PUSH-CONSTANT (NAT 1))) (POP-GLOBAL C-C) (DL 1 NIL (RET))))) (DEFUN *1*MG-ARRAY-ELEMENT-ASSIGNMENT-TRANSLATION NIL (QUOTE (MG-ARRAY-ELEMENT-ASSIGNMENT (A I VALUE ARRAY-SIZE) ((TEMP-I (NAT 0))) (PUSH-LOCAL I) (FETCH-TEMP-STK) (SET-LOCAL TEMP-I) (TEST-INT-AND-JUMP NEG 0) (PUSH-LOCAL ARRAY-SIZE) (PUSH-LOCAL TEMP-I) (SUB-INT) (TEST-INT-AND-JUMP NOT-POS 0) (PUSH-LOCAL VALUE) (FETCH-TEMP-STK) (PUSH-LOCAL A) (PUSH-LOCAL TEMP-I) (INT-TO-NAT) (ADD-NAT) (DEPOSIT-TEMP-STK) (JUMP 1) (DL 0 NIL (PUSH-CONSTANT (NAT 1))) (POP-GLOBAL C-C) (DL 1 NIL (RET))))) (DEFUN *1*PREDEFINED-PROCEDURE-TRANSLATIONS-LIST NIL (CONS (*1*MG-SIMPLE-VARIABLE-ASSIGNMENT-TRANSLATION) (CONS (*1*MG-SIMPLE-CONSTANT-ASSIGNMENT-TRANSLATION) (CONS (*1*MG-SIMPLE-VARIABLE-EQ-TRANSLATION) (CONS (*1*MG-SIMPLE-CONSTANT-EQ-TRANSLATION) (CONS (*1*MG-INTEGER-LE-TRANSLATION) (CONS (*1*MG-INTEGER-UNARY-MINUS-TRANSLATION) (CONS (*1*MG-INTEGER-ADD-TRANSLATION) (CONS (*1*MG-INTEGER-SUBTRACT-TRANSLATION) (CONS (*1*MG-BOOLEAN-OR-TRANSLATION) (CONS (*1*MG-BOOLEAN-AND-TRANSLATION) (CONS (*1*MG-BOOLEAN-NOT-TRANSLATION) (CONS (*1*MG-INDEX-ARRAY-TRANSLATION) (CONS (*1*MG-ARRAY-ELEMENT-ASSIGNMENT-TRANSLATION) (QUOTE NIL))))))))))))))) (DEFUN *1*TRANSLATE (*3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP6 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) *3*CINFO) ((EQ *2*TEMP6 (QUOTE SIGNAL-MG)) (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) (CONS (CONS (QUOTE PUSH-CONSTANT) (CONS (*1*MG-COND-TO-P-NAT (SETQ *2*TEMP5 (*1*SIGNALLED-CONDITION *3*STMT)) *3*COND-LIST) (QUOTE NIL))) (CONS (QUOTE (POP-GLOBAL C-C)) (CONS (CONS (QUOTE JUMP) (CONS (*1*FETCH-LABEL *2*TEMP5 (SETQ *2*TEMP4 (*1*LABEL-ALIST *3*CINFO))) (QUOTE NIL))) (QUOTE NIL))))) *2*TEMP4 (*1*LABEL-CNT *3*CINFO))) ((EQ *2*TEMP6 (QUOTE PROG2-MG)) (*1*TRANSLATE (*1*TRANSLATE *3*CINFO *3*COND-LIST (*1*PROG2-LEFT-BRANCH *3*STMT) *3*PROC-LIST) *3*COND-LIST (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST)) ((EQ *2*TEMP6 (QUOTE LOOP-MG)) (*1*DISCARD-LABEL (*1*ADD-CODE (*1*TRANSLATE (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) (CONS (CONS (QUOTE DL) (CONS (SETQ *2*TEMP3 (*1*LABEL-CNT *3*CINFO)) (QUOTE (NIL (NO-OP))))) (QUOTE NIL))) (CONS (CONS (QUOTE LEAVE) (SETQ *2*TEMP2 (*1*ADD1 *2*TEMP3))) (*1*LABEL-ALIST *3*CINFO)) (*1*ADD1 *2*TEMP2)) *3*COND-LIST (*1*LOOP-BODY *3*STMT) *3*PROC-LIST) (CONS (CONS (QUOTE JUMP) (CONS *2*TEMP3 (QUOTE NIL))) (CONS (CONS (QUOTE DL) (CONS *2*TEMP2 (QUOTE (NIL (PUSH-CONSTANT (NAT 2)))))) (QUOTE ((POP-GLOBAL C-C)))))))) ((EQ *2*TEMP6 (QUOTE IF-MG)) (*1*ADD-CODE (*1*TRANSLATE (*1*ADD-CODE (*1*TRANSLATE (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*IF-CONDITION *3*STMT) (QUOTE NIL))) (CONS (QUOTE (FETCH-TEMP-STK)) (CONS (CONS (QUOTE TEST-BOOL-AND-JUMP) (CONS (QUOTE FALSE) (CONS (SETQ *2*TEMP3 (*1*LABEL-CNT *3*CINFO)) (QUOTE NIL)))) (QUOTE NIL))))) (*1*LABEL-ALIST *3*CINFO) (*1*ADD1 (SETQ *2*TEMP2 (*1*ADD1 *2*TEMP3)))) *3*COND-LIST (*1*IF-TRUE-BRANCH *3*STMT) *3*PROC-LIST) (CONS (CONS (QUOTE JUMP) (CONS *2*TEMP2 (QUOTE NIL))) (CONS (CONS (QUOTE DL) (CONS *2*TEMP3 (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))) *3*COND-LIST (*1*IF-FALSE-BRANCH *3*STMT) *3*PROC-LIST) (CONS (CONS (QUOTE DL) (CONS *2*TEMP2 (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))) ((EQ *2*TEMP6 (QUOTE BEGIN-MG)) (*1*ADD-CODE (*1*TRANSLATE (*1*ADD-CODE (*1*SET-LABEL-ALIST (*1*TRANSLATE (*1*MAKE-CINFO (*1*CODE *3*CINFO) (*1*APPEND (*1*MAKE-LABEL-ALIST (*1*WHEN-LABELS *3*STMT) (SETQ *2*TEMP3 (*1*LABEL-CNT *3*CINFO))) (SETQ *2*TEMP4 (*1*LABEL-ALIST *3*CINFO))) (*1*ADD1 (SETQ *2*TEMP2 (*1*ADD1 *2*TEMP3)))) *3*COND-LIST (*1*BEGIN-BODY *3*STMT) *3*PROC-LIST) *2*TEMP4) (CONS (CONS (QUOTE JUMP) (CONS *2*TEMP2 (QUOTE NIL))) (CONS (CONS (QUOTE DL) (CONS *2*TEMP3 (QUOTE (NIL (PUSH-CONSTANT (NAT 2)))))) (QUOTE ((POP-GLOBAL C-C)))))) *3*COND-LIST (*1*WHEN-HANDLER *3*STMT) *3*PROC-LIST) (CONS (CONS (QUOTE DL) (CONS *2*TEMP2 (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))) ((EQ *2*TEMP6 (QUOTE PROC-CALL-MG)) (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) (*1*PROC-CALL-CODE *3*CINFO *3*STMT *3*COND-LIST (*1*DEF-LOCALS (SETQ *2*TEMP1 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))) (*1*LENGTH (*1*DEF-COND-LOCALS *2*TEMP1)))) (*1*LABEL-ALIST *3*CINFO) (*1*PLUS (*1*LABEL-CNT *3*CINFO) (*1*ADD1 (*1*ADD1 (*1*LENGTH (*1*CALL-CONDS *3*STMT))))))) ((EQ *2*TEMP6 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*ADD-CODE *3*CINFO (*1*PREDEFINED-PROC-CALL-SEQUENCE *3*STMT (*1*LABEL-ALIST *3*CINFO)))) (T *3*CINFO)))) (DEFUN *1*TRANSLATE-DEF-BODY (*3*PROC-DEF *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (*1*ADD-CODE (*1*TRANSLATE (*1*MAKE-CINFO (QUOTE NIL) (CONS (QUOTE (ROUTINEERROR . 0)) (*1*MAKE-LABEL-ALIST (SETQ *2*TEMP1 (*1*MAKE-COND-LIST *3*PROC-DEF)) (QUOTE 0))) (QUOTE 1)) *2*TEMP1 (*1*DEF-BODY *3*PROC-DEF) *3*PROC-LIST) (CONS (QUOTE (DL 0 NIL (NO-OP))) (CONS (CONS (QUOTE POP*) (CONS (*1*DATA-LENGTH (*1*DEF-LOCALS *3*PROC-DEF)) (QUOTE NIL))) (QUOTE ((RET)))))))) (DEFUN *1*TRANSLATE-DEF (*3*DEF *3*PROC-LIST) (*1*APPEND (CONS (*1*DEF-NAME *3*DEF) (CONS (*1*APPEND (*1*LISTCARS (*1*DEF-LOCALS *3*DEF)) (*1*LISTCARS (*1*DEF-FORMALS *3*DEF))) (QUOTE (NIL)))) (*1*CODE (*1*TRANSLATE-DEF-BODY *3*DEF *3*PROC-LIST)))) (DEFUN *1*TRANSLATE-PROC-LIST1 (*3*PROC-LIST1 *3*PROC-LIST2) (COND ((NOT (EQ (*1*NLISTP *3*PROC-LIST1) *1*F)) (QUOTE NIL)) (T (CONS (*1*TRANSLATE-DEF (*1*CAR *3*PROC-LIST1) *3*PROC-LIST2) (*1*TRANSLATE-PROC-LIST1 (*1*CDR *3*PROC-LIST1) *3*PROC-LIST2))))) (DEFUN *1*TRANSLATE-PROC-LIST (*3*PROC-LIST) (*1*APPEND (*1*PREDEFINED-PROCEDURE-TRANSLATIONS-LIST) (*1*TRANSLATE-PROC-LIST1 *3*PROC-LIST *3*PROC-LIST))) (DEFUN *1*NEARLY-EQUAL-CINFOS (*3*X *3*Y) (*1*AND (COND ((EQUAL (*1*LABEL-ALIST *3*X) (*1*LABEL-ALIST *3*Y)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (COND ((EQUAL (*1*LABEL-CNT *3*X) (*1*LABEL-CNT *3*Y)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*NULLIFY-INDUCTION-HINT (*3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X)) (*2*TEMP7 (QUOTE *1*X)) (*2*TEMP8 (QUOTE *1*X)) (*2*TEMP9 (QUOTE *1*X)) (*2*TEMP10 (QUOTE *1*X)) (*2*TEMP11 (QUOTE *1*X)) (*2*TEMP12 (QUOTE *1*X)) (*2*TEMP13 (QUOTE *1*X)) (*2*TEMP14 (QUOTE *1*X)) (*2*TEMP15 (QUOTE *1*X)) (*2*TEMP16 (QUOTE *1*X)) (*2*TEMP17 (QUOTE *1*X)) (*2*TEMP18 (QUOTE *1*X)) (*2*TEMP19 (QUOTE *1*X)) (*2*TEMP20 (QUOTE *1*X)) (*2*TEMP21 (QUOTE *1*X)) (*2*TEMP22 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP22 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP22 (QUOTE SIGNAL-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP22 (QUOTE PROG2-MG)) (*1*AND (*1*NULLIFY-INDUCTION-HINT *3*CINFO *3*COND-LIST (SETQ *2*TEMP21 (*1*PROG2-LEFT-BRANCH *3*STMT)) *3*PROC-LIST) (*1*AND (*1*NULLIFY-INDUCTION-HINT (*1*TRANSLATE *3*CINFO *3*COND-LIST *2*TEMP21 *3*PROC-LIST) *3*COND-LIST (SETQ *2*TEMP20 (*1*PROG2-RIGHT-BRANCH *3*STMT)) *3*PROC-LIST) (*1*NULLIFY-INDUCTION-HINT (*1*TRANSLATE (*1*NULLIFY *3*CINFO) *3*COND-LIST *2*TEMP21 *3*PROC-LIST) *3*COND-LIST *2*TEMP20 *3*PROC-LIST)))) ((EQ *2*TEMP22 (QUOTE LOOP-MG)) (*1*AND (*1*NULLIFY-INDUCTION-HINT (*1*MAKE-CINFO (*1*APPEND (*1*CODE *3*CINFO) (SETQ *2*TEMP18 (CONS (CONS (QUOTE DL) (CONS (SETQ *2*TEMP17 (*1*LABEL-CNT *3*CINFO)) (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))) (SETQ *2*TEMP16 (CONS (CONS (QUOTE LEAVE) (SETQ *2*TEMP15 (*1*ADD1 *2*TEMP17))) (SETQ *2*TEMP14 (*1*LABEL-ALIST *3*CINFO)))) (SETQ *2*TEMP13 (*1*ADD1 *2*TEMP15))) *3*COND-LIST (SETQ *2*TEMP12 (*1*LOOP-BODY *3*STMT)) *3*PROC-LIST) (*1*NULLIFY-INDUCTION-HINT (*1*MAKE-CINFO *2*TEMP18 *2*TEMP16 *2*TEMP13) *3*COND-LIST *2*TEMP12 *3*PROC-LIST))) ((EQ *2*TEMP22 (QUOTE IF-MG)) (*1*AND (*1*NULLIFY-INDUCTION-HINT (SETQ *2*TEMP11 (*1*MAKE-CINFO (SETQ *2*TEMP10 (CONS (CONS (QUOTE PUSH-LOCAL) (CONS (*1*IF-CONDITION *3*STMT) (QUOTE NIL))) (CONS (QUOTE (FETCH-TEMP-STK)) (CONS (CONS (QUOTE TEST-BOOL-AND-JUMP) (CONS (QUOTE FALSE) (CONS (SETQ *2*TEMP17 (*1*LABEL-CNT *3*CINFO)) (QUOTE NIL)))) (QUOTE NIL))))) (SETQ *2*TEMP14 (*1*LABEL-ALIST *3*CINFO)) (SETQ *2*TEMP13 (*1*ADD1 (SETQ *2*TEMP15 (*1*ADD1 *2*TEMP17)))))) *3*COND-LIST (SETQ *2*TEMP9 (*1*IF-TRUE-BRANCH *3*STMT)) *3*PROC-LIST) (*1*AND (*1*NULLIFY-INDUCTION-HINT (SETQ *2*TEMP8 (*1*MAKE-CINFO (*1*APPEND (SETQ *2*TEMP19 (*1*CODE *3*CINFO)) *2*TEMP10) *2*TEMP14 *2*TEMP13)) *3*COND-LIST *2*TEMP9 *3*PROC-LIST) (*1*AND (*1*NULLIFY-INDUCTION-HINT (*1*ADD-CODE (*1*TRANSLATE *2*TEMP8 *3*COND-LIST *2*TEMP9 *3*PROC-LIST) (SETQ *2*TEMP7 (CONS (SETQ *2*TEMP6 (CONS (QUOTE JUMP) (CONS *2*TEMP15 (QUOTE NIL)))) (SETQ *2*TEMP18 (CONS (CONS (QUOTE DL) (CONS *2*TEMP17 (QUOTE (NIL (NO-OP))))) (QUOTE NIL)))))) *3*COND-LIST (SETQ *2*TEMP5 (*1*IF-FALSE-BRANCH *3*STMT)) *3*PROC-LIST) (*1*NULLIFY-INDUCTION-HINT (*1*ADD-CODE (*1*TRANSLATE *2*TEMP11 *3*COND-LIST *2*TEMP9 *3*PROC-LIST) *2*TEMP7) *3*COND-LIST *2*TEMP5 *3*PROC-LIST))))) ((EQ *2*TEMP22 (QUOTE BEGIN-MG)) (*1*AND (*1*NULLIFY-INDUCTION-HINT (*1*ADD-CODE (*1*SET-LABEL-ALIST (*1*TRANSLATE (SETQ *2*TEMP4 (*1*MAKE-CINFO (SETQ *2*TEMP19 (*1*CODE *3*CINFO)) (*1*APPEND (*1*MAKE-LABEL-ALIST (*1*WHEN-LABELS *3*STMT) (SETQ *2*TEMP17 (*1*LABEL-CNT *3*CINFO))) (SETQ *2*TEMP14 (*1*LABEL-ALIST *3*CINFO))) (SETQ *2*TEMP13 (*1*ADD1 (SETQ *2*TEMP15 (*1*ADD1 *2*TEMP17)))))) *3*COND-LIST (SETQ *2*TEMP3 (*1*BEGIN-BODY *3*STMT)) *3*PROC-LIST) *2*TEMP14) (SETQ *2*TEMP2 (CONS (SETQ *2*TEMP6 (CONS (QUOTE JUMP) (CONS *2*TEMP15 (QUOTE NIL)))) (CONS (CONS (QUOTE DL) (CONS *2*TEMP17 (QUOTE (NIL (PUSH-CONSTANT (NAT 2)))))) (QUOTE ((POP-GLOBAL C-C))))))) *3*COND-LIST (SETQ *2*TEMP1 (*1*WHEN-HANDLER *3*STMT)) *3*PROC-LIST) (*1*AND (*1*NULLIFY-INDUCTION-HINT *2*TEMP4 *3*COND-LIST *2*TEMP3 *3*PROC-LIST) (*1*NULLIFY-INDUCTION-HINT (*1*ADD-CODE (*1*SET-LABEL-ALIST (*1*TRANSLATE (*1*NULLIFY *2*TEMP4) *3*COND-LIST *2*TEMP3 *3*PROC-LIST) *2*TEMP14) *2*TEMP2) *3*COND-LIST *2*TEMP1 *3*PROC-LIST)))) ((EQ *2*TEMP22 (QUOTE PROC-CALL-MG)) (QUOTE *1*TRUE)) ((EQ *2*TEMP22 (QUOTE PREDEFINED-PROC-CALL-MG)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))))) (DEFUN *1*COLLECT-LABELS (*3*CODELIST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*CODELIST) *1*F)) (QUOTE NIL)) ((EQ (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*CODELIST))) (QUOTE DL)) (CONS (*1*CAR (*1*CDR *2*TEMP1)) (*1*COLLECT-LABELS (*1*CDR *3*CODELIST)))) (T (*1*COLLECT-LABELS (*1*CDR *3*CODELIST)))))) (DEFUN *1*ALL-LABELS-UNIQUE (*3*CODELIST) (*1*NO-DUPLICATES (*1*COLLECT-LABELS *3*CODELIST))) (DEFUN *1*LABEL-HOLE-BIG-ENOUGH (*3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST *3*Y) (*1*ALL-LABELS-UNIQUE (*1*APPEND (*1*CODE (*1*TRANSLATE *3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST)) *3*Y))) (DEFUN *1*OK-COND-LIST (*3*LST) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (COND ((EQ *3*LST (QUOTE NIL)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE)))) (T (*1*AND (*1*OR (*1*OK-MG-NAMEP (SETQ *2*TEMP1 (*1*CAR *3*LST))) (*1*MEMBER *2*TEMP1 (QUOTE (LEAVE ROUTINEERROR)))) (*1*OK-COND-LIST (*1*CDR *3*LST))))))) (DEFUN *1*OK-TRANSLATION-PARAMETERS (*3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST *3*Y) (*1*AND (*1*OK-CINFOP *3*CINFO) (*1*AND (*1*OK-COND-LIST *3*COND-LIST) (*1*LABEL-HOLE-BIG-ENOUGH *3*CINFO *3*COND-LIST *3*STMT *3*PROC-LIST *3*Y)))) (DEFUN *1*LABEL-CNT-BIG-ENOUGH (*3*LC *3*CODE) (LET ((*2*TEMP1 (QUOTE *1*X))) (COND ((NOT (EQ (*1*NLISTP *3*CODE) *1*F)) (QUOTE *1*TRUE)) ((EQ (*1*CAR (SETQ *2*TEMP1 (*1*CAR *3*CODE))) (QUOTE DL)) (*1*AND (*1*LESSP (*1*CAR (*1*CDR *2*TEMP1)) *3*LC) (*1*LABEL-CNT-BIG-ENOUGH *3*LC (*1*CDR *3*CODE)))) (T (*1*LABEL-CNT-BIG-ENOUGH *3*LC (*1*CDR *3*CODE)))))) (DEFUN *1*COND-CONVERSION-INDUCTION-HINT (*3*LST *3*N) (COND ((NOT (EQ (*1*NLISTP *3*LST) *1*F)) (QUOTE *1*TRUE)) (T (*1*COND-CONVERSION-INDUCTION-HINT (*1*CDR *3*LST) (*1*ADD1 *3*N))))) (DEFUN *1*CLOCK-PREDEFINED-PROC-CALL-SEQUENCE (*3*NAME) (COND ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-SIMPLE-VARIABLE-EQ)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-SIMPLE-CONSTANT-EQ)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-INTEGER-LE)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-INTEGER-UNARY-MINUS)) (QUOTE 6)) ((EQ *3*NAME (QUOTE MG-INTEGER-ADD)) (QUOTE 7)) ((EQ *3*NAME (QUOTE MG-INTEGER-SUBTRACT)) (QUOTE 7)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-OR)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-AND)) (QUOTE 4)) ((EQ *3*NAME (QUOTE MG-BOOLEAN-NOT)) (QUOTE 3)) ((EQ *3*NAME (QUOTE MG-INDEX-ARRAY)) (QUOTE 8)) ((EQ *3*NAME (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (QUOTE 8)) (T (QUOTE 0)))) (DEFUN *1*CLOCK-PREDEFINED-PROC-CALL-BODY-TRANSLATION (*3*STMT *3*MG-STATE) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X)) (*2*TEMP7 (QUOTE *1*X)) (*2*TEMP8 (QUOTE *1*X)) (*2*TEMP9 (QUOTE *1*X)) (*2*TEMP10 (QUOTE *1*X)) (*2*TEMP11 (QUOTE *1*X))) (COND ((EQ (SETQ *2*TEMP11 (*1*CALL-NAME *3*STMT)) (QUOTE MG-SIMPLE-VARIABLE-ASSIGNMENT)) (QUOTE 5)) ((EQ *2*TEMP11 (QUOTE MG-SIMPLE-CONSTANT-ASSIGNMENT)) (QUOTE 4)) ((EQ *2*TEMP11 (QUOTE MG-SIMPLE-VARIABLE-EQ)) (QUOTE 8)) ((EQ *2*TEMP11 (QUOTE MG-SIMPLE-CONSTANT-EQ)) (QUOTE 7)) ((EQ *2*TEMP11 (QUOTE MG-INTEGER-LE)) (QUOTE 9)) ((EQ *2*TEMP11 (QUOTE MG-INTEGER-UNARY-MINUS)) (COND ((NOT (EQ (*1*SMALL-INTEGERP (*1*INEGATE (*1*UNTAG (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (*1*CDR (*1*CALL-ACTUALS *3*STMT))) (*1*MG-ALIST *3*MG-STATE))))))) (*1*MG-WORD-SIZE)) *1*F)) (QUOTE 11)) (T (QUOTE 10)))) ((EQ *2*TEMP11 (QUOTE MG-INTEGER-ADD)) (COND ((NOT (EQ (*1*SMALL-INTEGERP (*1*IPLUS (*1*UNTAG (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (SETQ *2*TEMP9 (*1*CDR (*1*CALL-ACTUALS *3*STMT)))) (SETQ *2*TEMP8 (*1*MG-ALIST *3*MG-STATE))))))) (*1*UNTAG (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (*1*CDR *2*TEMP9)) *2*TEMP8)))))) (*1*MG-WORD-SIZE)) *1*F)) (QUOTE 13)) (T (QUOTE 11)))) ((EQ *2*TEMP11 (QUOTE MG-INTEGER-SUBTRACT)) (COND ((NOT (EQ (*1*SMALL-INTEGERP (*1*IDIFFERENCE (*1*UNTAG (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (SETQ *2*TEMP9 (*1*CDR (*1*CALL-ACTUALS *3*STMT)))) (SETQ *2*TEMP8 (*1*MG-ALIST *3*MG-STATE))))))) (*1*UNTAG (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (*1*CDR *2*TEMP9)) *2*TEMP8)))))) (*1*MG-WORD-SIZE)) *1*F)) (QUOTE 13)) (T (QUOTE 11)))) ((EQ *2*TEMP11 (QUOTE MG-BOOLEAN-OR)) (QUOTE 8)) ((EQ *2*TEMP11 (QUOTE MG-BOOLEAN-AND)) (QUOTE 8)) ((EQ *2*TEMP11 (QUOTE MG-BOOLEAN-NOT)) (QUOTE 6)) ((EQ *2*TEMP11 (QUOTE MG-INDEX-ARRAY)) (COND ((NOT (EQ (*1*NEGATIVEP (SETQ *2*TEMP5 (*1*CAR (*1*CDR (SETQ *2*TEMP7 (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (SETQ *2*TEMP6 (*1*CDR (SETQ *2*TEMP9 (*1*CDR (*1*CALL-ACTUALS *3*STMT)))))) (SETQ *2*TEMP8 (*1*MG-ALIST *3*MG-STATE))))))))))) *1*F)) (QUOTE 7)) ((NOT (EQ (*1*OR (COND ((EQUAL (SETQ *2*TEMP4 (*1*IDIFFERENCE (SETQ *2*TEMP3 (*1*CAR (*1*CDR *2*TEMP6))) *2*TEMP5)) (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*NEGATIVEP *2*TEMP4)) *1*F)) (QUOTE 11)) (T (QUOTE 17)))) ((EQ *2*TEMP11 (QUOTE MG-ARRAY-ELEMENT-ASSIGNMENT)) (COND ((NOT (EQ (*1*NEGATIVEP (SETQ *2*TEMP2 (*1*CAR (*1*CDR (SETQ *2*TEMP10 (*1*CAR (*1*CDR (*1*CDR (*1*ASSOC (*1*CAR (SETQ *2*TEMP9 (*1*CDR (*1*CALL-ACTUALS *3*STMT)))) (SETQ *2*TEMP8 (*1*MG-ALIST *3*MG-STATE))))))))))) *1*F)) (QUOTE 7)) ((NOT (EQ (*1*OR (COND ((EQUAL (SETQ *2*TEMP1 (*1*IDIFFERENCE (SETQ *2*TEMP3 (*1*CAR (*1*CDR (SETQ *2*TEMP6 (*1*CDR *2*TEMP9))))) *2*TEMP2)) (QUOTE 0)) (QUOTE *1*TRUE)) (T (QUOTE *1*FALSE))) (*1*NEGATIVEP *2*TEMP1)) *1*F)) (QUOTE 11)) (T (QUOTE 17)))) (T (QUOTE 0))))) (DEFUN *1*PREDEFINED-PROC-CALL-CLOCK (*3*STMT *3*MG-STATE) (*1*PLUS (*1*CLOCK-PREDEFINED-PROC-CALL-SEQUENCE (*1*CALL-NAME *3*STMT)) (*1*CLOCK-PREDEFINED-PROC-CALL-BODY-TRANSLATION *3*STMT *3*MG-STATE))) (DEFUN *1*CLOCK (*3*STMT *3*PROC-LIST *3*MG-STATE *3*N) (LET ((*2*TEMP1 (QUOTE *1*X)) (*2*TEMP2 (QUOTE *1*X)) (*2*TEMP3 (QUOTE *1*X)) (*2*TEMP4 (QUOTE *1*X)) (*2*TEMP5 (QUOTE *1*X)) (*2*TEMP6 (QUOTE *1*X)) (*2*TEMP7 (QUOTE *1*X)) (*2*TEMP8 (QUOTE *1*X)) (*2*TEMP9 (QUOTE *1*X)) (*2*TEMP10 (QUOTE *1*X)) (*2*TEMP11 (QUOTE *1*X)) (*2*TEMP12 (QUOTE *1*X)) (*2*TEMP13 (QUOTE *1*X)) (*2*TEMP14 (QUOTE *1*X)) (*2*TEMP15 (QUOTE *1*X))) (COND ((NOT (EQ (*1*OR (*1*ZEROP *3*N) (*1*NOT (*1*NORMAL *3*MG-STATE))) *1*F)) (QUOTE 0)) ((EQ (SETQ *2*TEMP15 (*1*CAR *3*STMT)) (QUOTE NO-OP-MG)) (QUOTE 0)) ((EQ *2*TEMP15 (QUOTE SIGNAL-MG)) (QUOTE 3)) ((EQ *2*TEMP15 (QUOTE PROG2-MG)) (*1*PLUS (*1*CLOCK (SETQ *2*TEMP14 (*1*PROG2-LEFT-BRANCH *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP13 (*1*SUB1 *3*N))) (*1*CLOCK (*1*PROG2-RIGHT-BRANCH *3*STMT) *3*PROC-LIST (*1*MG-MEANING *2*TEMP14 *3*PROC-LIST *3*MG-STATE *2*TEMP13) *2*TEMP13))) ((EQ *2*TEMP15 (QUOTE LOOP-MG)) (COND ((NOT (EQ (*1*NOT (*1*NORMAL (SETQ *2*TEMP12 (*1*MG-MEANING (SETQ *2*TEMP11 (*1*LOOP-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP13 (*1*SUB1 *3*N)))))) *1*F)) (COND ((EQ (*1*CC *2*TEMP12) (QUOTE LEAVE)) (*1*PLUS (QUOTE 3) (*1*CLOCK *2*TEMP11 *3*PROC-LIST *3*MG-STATE *2*TEMP13))) (T (*1*ADD1 (*1*CLOCK *2*TEMP11 *3*PROC-LIST *3*MG-STATE *2*TEMP13))))) (T (*1*ADD1 (*1*PLUS (*1*ADD1 (*1*CLOCK *2*TEMP11 *3*PROC-LIST *3*MG-STATE *2*TEMP13)) (*1*CLOCK *3*STMT *3*PROC-LIST *2*TEMP12 *2*TEMP13)))))) ((EQ *2*TEMP15 (QUOTE IF-MG)) (COND ((NOT (EQ (*1*MG-EXPRESSION-FALSEP (*1*IF-CONDITION *3*STMT) *3*MG-STATE) *1*F)) (COND ((NOT (EQ (*1*NORMAL (*1*MG-MEANING (SETQ *2*TEMP10 (*1*IF-FALSE-BRANCH *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP13 (*1*SUB1 *3*N)))) *1*F)) (*1*PLUS (QUOTE 5) (*1*CLOCK *2*TEMP10 *3*PROC-LIST *3*MG-STATE *2*TEMP13))) (T (*1*PLUS (QUOTE 4) (*1*CLOCK *2*TEMP10 *3*PROC-LIST *3*MG-STATE *2*TEMP13))))) ((NOT (EQ (*1*NORMAL (*1*MG-MEANING (SETQ *2*TEMP9 (*1*IF-TRUE-BRANCH *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP13 (*1*SUB1 *3*N)))) *1*F)) (*1*PLUS (QUOTE 5) (*1*CLOCK *2*TEMP9 *3*PROC-LIST *3*MG-STATE *2*TEMP13))) (T (*1*PLUS (QUOTE 3) (*1*CLOCK *2*TEMP9 *3*PROC-LIST *3*MG-STATE *2*TEMP13))))) ((EQ *2*TEMP15 (QUOTE BEGIN-MG)) (COND ((NOT (EQ (*1*MEMBER (*1*CC (SETQ *2*TEMP8 (*1*MG-MEANING (SETQ *2*TEMP7 (*1*BEGIN-BODY *3*STMT)) *3*PROC-LIST *3*MG-STATE (SETQ *2*TEMP13 (*1*SUB1 *3*N))))) (*1*WHEN-LABELS *3*STMT)) *1*F)) (COND ((NOT (EQ (*1*NORMAL (*1*MG-MEANING (SETQ *2*TEMP6 (*1*WHEN-HANDLER *3*STMT)) *3*PROC-LIST (SETQ *2*TEMP5 (*1*SET-CONDITION *2*TEMP8 (QUOTE NORMAL))) *2*TEMP13)) *1*F)) (*1*PLUS (*1*CLOCK *2*TEMP7 *3*PROC-LIST *3*MG-STATE *2*TEMP13) (*1*PLUS (QUOTE 3) (*1*CLOCK *2*TEMP6 *3*PROC-LIST *2*TEMP5 *2*TEMP13)))) (T (*1*PLUS (*1*CLOCK *2*TEMP7 *3*PROC-LIST *3*MG-STATE *2*TEMP13) (*1*PLUS (QUOTE 2) (*1*CLOCK *2*TEMP6 *3*PROC-LIST *2*TEMP5 *2*TEMP13)))))) ((NOT (EQ (*1*NORMAL *2*TEMP8) *1*F)) (*1*PLUS (QUOTE 2) (*1*CLOCK *2*TEMP7 *3*PROC-LIST *3*MG-STATE *2*TEMP13))) (T (*1*CLOCK *2*TEMP7 *3*PROC-LIST *3*MG-STATE *2*TEMP13)))) ((EQ *2*TEMP15 (QUOTE PROC-CALL-MG)) (*1*PLUS (*1*DATA-LENGTH (SETQ *2*TEMP4 (*1*DEF-LOCALS (SETQ *2*TEMP3 (*1*FETCH-CALLED-DEF *3*STMT *3*PROC-LIST))))) (*1*PLUS (*1*LENGTH *2*TEMP4) (*1*PLUS (*1*LENGTH (*1*CALL-ACTUALS *3*STMT)) (*1*PLUS (QUOTE 1) (*1*PLUS (*1*CLOCK (SETQ *2*TEMP2 (*1*DEF-BODY *2*TEMP3)) *3*PROC-LIST (SETQ *2*TEMP1 (*1*MAKE-CALL-ENVIRONMENT *3*MG-STATE *3*STMT *2*TEMP3)) (SETQ *2*TEMP13 (*1*SUB1 *3*N))) (*1*PLUS (QUOTE 5) (COND ((NOT (EQ (*1*NORMAL (*1*MG-MEANING *2*TEMP2 *3*PROC-LIST *2*TEMP1 *2*TEMP13)) *1*F)) (QUOTE 1)) (T (QUOTE 3)))))))))) ((EQ *2*TEMP15 (QUOTE PREDEFINED-PROC-CALL-MG)) (*1*PREDEFINED-PROC-CALL-CLOCK *3*STMT *3*MG-STATE)) (T (QUOTE 0))))) (DEFUN *1*MAP-DOWN (*3*MG-STATE *3*PROC-LIST *3*CTRL-STK *3*TEMP-STK *3*ADDR *3*COND-LIST) (*1*P-STATE *3*ADDR *3*CTRL-STK (*1*MAP-DOWN-VALUES (*1*MG-ALIST *3*MG-STATE) (*1*BINDINGS (*1*TOP *3*CTRL-STK)) *3*TEMP-STK) (*1*TRANSLATE-PROC-LIST *3*PROC-LIST) (CONS (CONS (QUOTE C-C) (CONS (*1*MG-COND-TO-P-NAT (*1*CC *3*MG-STATE) *3*COND-LIST) (QUOTE NIL))) (QUOTE NIL)) (*1*MG-MAX-CTRL-STK-SIZE) (*1*MG-MAX-TEMP-STK-SIZE) (*1*MG-WORD-SIZE) (QUOTE RUN)))