(FILECREATED "21-Jun-85 17:35:14" {ERIS}<LISPCORE>SOURCES>CLISP.;14
 37798  

      changes to:  (VARS CLISPCOMS LEFT.ARROW)

      previous date: "19-Mar-85 12:51:34" {ERIS}<LISPCORE>SOURCES>CLISP.;13)


(* Copyright (c) 1982, 1983, 1984, 1985 by Xerox Corporation. All rights reserved. The following 
program was created in 1982  but has not been published within the meaning of the copyright law, is 
furnished under license, and may not be used, copied and/or disclosed except in accordance with the 
terms of said license.)

(PRETTYCOMPRINT CLISPCOMS)

(RPAQQ CLISPCOMS
 [[INITVARS (NOFIXFNSLST0)
			    (NOFIXVARSLST0)
			    (NOSPELLFLG)
			    (LPARKEY 9)
			    (RPARKEY 0)
			    (WTFIXCHCONLST (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL 
						       NIL NIL NIL NIL NIL NIL NIL NIL)))
			    (WTFIXCHCONLST1 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL 
							NIL NIL NIL NIL NIL NIL NIL NIL]
	(USERMACROS FIX8 FIX9)
	(ADDVARS (DWIMUSERFORMS)
		 (LAMBDASPLST LAMBDA NLAMBDA)
		 (OKREEVALST AND OR PROGN SAVESETQ CAR CDR ADD1 SUB1 CONS LIST EQ EQUAL PRINT PRIN1 
			     APPEND NEQ NOT NULL)
		 (NOFIXFNSLST)
		 (NOFIXVARSLST))
	(ADDVARS (GLOBALVARS)
		 (LOCALVARS)
		 (SPECVARS)
		 (NLAMA)
		 (NLAML)
		 (LAMA)
		 (LAMS))
	(P (MOVD? (QUOTE NILL)
		  (QUOTE FREEVARS)))
	(PROP FILEDEF BREAKDOWN CALLS CLISPRECORD SETUPHASHARRAY MAKEMATCH)
	(PROP CLISPTYPE ')
	[E (SETQQ CLISPCHARS
		  (↑ * / + - = ← : ' ~ +- ~= < > @ ! ← ↑))
	   (CLISPDEC (QUOTE (STANDARD MIXED]
	(VARS (CLISPFLG T)
	      (CLISPHELPFLG T)
	      (TREATASCLISPFLG)
	      (DWIMESSGAG)
	      CLISPINFIXSPLST
	      (CLISPCHARS (QUOTE (↑ * / + - = ← : ' ~ +- ~= < > @ !)))
	      (CLISPCHARRAY (MAKEBITTABLE CLISPCHARS))
	      [LEFT.ARROWS.BITTABLE (MAKEBITTABLE (QUOTE (← ←]
	      LEFT.ARROW DECLWORDS CLISPISWORDSPLST (CLISPLASTSUB (CONS))
	      (CHECKCARATOMFLG)
	      (CLISPARITHOPLST (QUOTE (+ - * / +- LT GT lt gt GEQ LEQ GE LE geq leq ge le)))
	      (CLISPARITHCLASSLST (QUOTE (INTEGER FIXED MIXED FLOATING)))
	      (DWIMINMACROSFLG T))
	(IFPROP (CLISPTYPE LISPFN UNARYOP CLISPCLASS CLISPCLASSDEF CLISPNEG CLISPBRACKET)
		↑ ↑ * / + - = ← ← : ' ~ +- ~= < > @ !)
	(IFPROP (CLISPTYPE LISPFN UNARYOP CLISPINFIX CLISPCLASS CLISPCLASSDEF CLISPNEG BROADSCOPE)
		FLOATING FAST FFETCHFIELD FETCHFIELD REPLACEFIELD FREPLACEFIELD /REPLACEFIELD 
		/LISTPUT /LISTPUT1 /MAPCON /MAPCONC /NCONC /NCONC1 /PUT /PUTASSOC /PUTHASH /PUTPROP 
		/RPLACA /RPLACD /RPLNODE /RPLNODE2 /SETA ASSOC CLISPIFY FASSOC FIXED FLAST FMEMB FNTH 
		FRPLACA FRPLACD FRPLNODE FRPLNODE2 INTEGER LAST LISTPUT LISTPUT1 MAPCON MAPCONC MEMB 
		MIXED NCONC NCONC1 NTH PUT PUTASSOC PUTHASH PUTPROP RPLACA RPLACD RPLNODE RPLNODE2 
		SETA STANDARD UNDOABLE)
	(IFPROP (CLISPTYPE LISPFN UNARYOP CLISPINFIX CLISPCLASS CLISPCLASSDEF CLISPNEG BROADSCOPE)
		LT lt GT gt LE le GE ge LEQ leq GEQ geq EQ NEQ EQP EQUAL EQUALS NOT AND OR and or NOR 
		nor MEMBER SETQ IPLUS IMINUS IDIFFERENCE ITIMES IQUOTIENT ILESSP IGREATERP FPLUS 
		FMINUS FDIFFERENCE FTIMES FQUOTIENT FGTP PLUS MINUS DIFFERENCE TIMES QUOTIENT LESSP 
		GREATERP EXPT -> =>)
	(PROP SETFN ELT SETA)
	(VARS (DWIMIFYFLG (QUOTE EVAL))
	      (DWIMCHECK#ARGSFLG T)
	      (DWIMCHECKPROGLABELSFLG T)
	      (COMPILEUSERFN (QUOTE COMPILEUSERFN))
	      (#CLISPARRAY 250)
	      (RECORDHASHFLG T)
	      (CLISPTRANFLG (QUOTE CLISP% ))
	      (CLISPRETRANFLG))
	(ADDVARS (DWIMEQUIVLST))
	(USERMACROS DW !DW CLISP: NOCLISP PPT)
	(PROP CLISPWORD AND OR and or ! !! CLISP clisp MATCH match)
	(VARS CLISPIFWORDSPLST (CLISPIFTRANFLG T))
	(PROP CLISPWORD IF THEN ELSE ELSEIF if then else elseif)
	(VARS (CLISPI.S.GAG))
	(ADDVARS (I.S.OPRLST ALWAYS AS BIND BY COLLECT COUNT DECLARE DECLARE: DO EACHTIME FCOLLECT 
			     FINALLY FIND FIRST FOR FROM IN INSIDE ISTHERE JOIN LARGEST NEVER OLD ON 
			     ORIGINAL REPEATUNTIL REPEATWHILE SMALLEST SUCHTHAT SUM THEREIS THRU TO 
			     UNLESS UNTIL WHEN WHERE WHILE always as bind by collect count declare 
			     declare: do eachtime fcollect finally find first for from in inside 
			     isthere join largest never old on original repeatuntil repeatwhile 
			     smallest suchthat sum thereis thru to unless until when where while)
		 (CLISPFORWORDSPLST ALWAYS AS BIND BY COLLECT COUNT DO EACHTIME FINALLY FIRST FOR 
				    FROM IN INSIDE JOIN LARGEST NEVER OLD ON REPEATUNTIL REPEATWHILE 
				    SMALLEST SUCHTHAT SUM THEREIS TO UNLESS UNTIL WHEN WHERE WHILE)
		 (DURATIONCLISPWORDS (TIMERUNITS timerUnits timerunits)
				     (USINGBOX usingBox usingbox)
				     (USINGTIMER usingTimer usingtimer)
				     (FORDURATION forDuration forduration DURING during)
				     (RESOURCENAME resourceName resourcename)
				     (UNTILDATE untilDate untildate)))
	(PROP CLISPWORD * (PROGN I.S.OPRLST))
	(IFPROP I.S.OPR * (PROGN I.S.OPRLST))
	[VARS (CLISPDUMMYFORVARS (QUOTE ($$TEM0 $$TEM1 $$TEM2 $$TEM3 $$TEM4 $$TEM5 $$TEM6]
	(IFPROP (CLISPWORD \DURATIONTRAN)
		*
		(APPLY (QUOTE APPEND)
		       DURATIONCLISPWORDS))
	(FILEPKGCOMS I.S.OPRS)
	(FNS DUMPI.S.OPRS GETDEF.I.S.OPR)
	(ADDVARS * (LIST (CONS (QUOTE SYSLOCALVARS)
			       CLISPDUMMYFORVARS)
			 (CONS (QUOTE INVISIBLEVARS)
			       CLISPDUMMYFORVARS)))
	(ADDVARS (SYSLOCALVARS $$VAL $$TEM $$LST1 $$LST2 $$LST3 $$LST4 $$LST5 $$LST6 $$END $$EXTREME)
		 (INVISIBLEVARS $$VAL $$END $$TEM $$LST1 $$LST2 $$LST3 $$LST4 $$LST5 $$LST6 $$EXTREME)
		 )
	[P (PUTPROP (QUOTE CLISP% )
		    (QUOTE MACRO)
		    (QUOTE (X (CAR X]
	(RESOURCES \ForDurationOfBox)
	(* currently there are four possible entries for this property, EVAL, BINDS, LABELS, PROGN, 
	   or a list containg any or all of these. EVAL is used to indicate thatan nlambda evaluates 
	   its arguments. EVAL affects DWIMIFY and CLISPIFY: neither will touch an nlambda thatdoes 
	   not have this property. BINDS tells clispify and dwimify that cadr of the form is a list 
	   of variabes being bound, a la prog. PROGN says that only the last top level expression is 
	   being used for value. This affects the way OR's and AND's are clispifed for example. 
	   Finally, LABELS indicates that top level atoms in this expression are not being evaluated. 
	   this tells clispify not to create atoms out of lists atthe top level. LABELS also implies 
	   that none of the top level expressions are being ued for value. For example, FOR has info 
	   property just BINDS,
	   (EVAL is unnecssary since FOR is not a function and its dwimifying and clispifying 
		 affected by its clispword propety)
	   , whereas PROG has (BINDS EVAL and LABLELS)
	   , and LAMBDA has (EVAL BINDS PROGN))
	(PROP INFO PROG PROG* RESETVARS RESETBUFS RESETLST ADV-PROG ADV-SETQ AND ARG COND ERSETQ 
	      NLSETQ OR PROG1 PROG2 PROGN RESETFORM RESETSAVE RESETVAR RPAQ RPTQ FRPTQ SAVESETQ SETN 
	      SETQ UNDONLSETQ XNLSETQ SETARG LET LET*)
	(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS (ADDVARS (NLAMA DUMPI.S.OPRS)
									      (NLAML)
									      (LAMA])

(RPAQ? NOFIXFNSLST0
 )

(RPAQ? NOFIXVARSLST0
 )

(RPAQ? NOSPELLFLG
 )

(RPAQ? LPARKEY
 9)

(RPAQ? RPARKEY
 0)

(RPAQ? WTFIXCHCONLST
 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL 
				 NIL NIL)))

(RPAQ? WTFIXCHCONLST1
 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL 
				  NIL NIL)))

(ADDTOVAR EDITMACROS
 (FIX8 NIL (FIX8))
		     (FIX8 (X N)
			   (BIND (E (SETQ #1 (EDITFPAT (QUOTE X)))
				    T)
				 (IF (LISTP (##))
				     (1))
				 (COMS (SPLIT89 LPARKEY N))
				 (I F LPARKEY T)
				 (1)
				 (LI 1)
				 (IF (TAILP (CAR L)
					    (CADR L))
				     (!0)
				     NIL)
				 (LPQ [IF (OR (NULL #1)
					      (NOT (EDIT4E #1 (## 1]
				      UP
				      (RO 1)
				      !0)))
		     (FIX9 NIL (FIX9))
		     (FIX9 (X N)
			   (BIND (E (SETQ #1 (EDITFPAT (QUOTE X)))
				    T)
				 (IF (NOT (ATOM (##)))
				     (1))
				 (COMS (SPLIT89 RPARKEY N))
				 (I F RPARKEY T)
				 (E [SETQ #2 (ADD1 (LENGTH (CAR L]
				    T)
				 !0 MARK (LPQ [IF (OR (NULL #1)
						      (NOT (EDIT4E #1 (## 1]
					      UP
					      (E (SETQ #3 (LENGTH (CAR L)))
						 T)
					      (I RI 1 (MINUS #2))
					      (E (SETQ #2 #3)
						 T)
					      1 !0)
				 ←←
				 (DELETE NX))))

(ADDTOVAR DWIMUSERFORMS
 )

(ADDTOVAR LAMBDASPLST
 LAMBDA NLAMBDA)

(ADDTOVAR OKREEVALST
 AND OR PROGN SAVESETQ CAR CDR ADD1 SUB1 CONS LIST EQ EQUAL PRINT PRIN1 APPEND 
			 NEQ NOT NULL)

(ADDTOVAR NOFIXFNSLST
 )

(ADDTOVAR NOFIXVARSLST
 )

(ADDTOVAR GLOBALVARS
 )

(ADDTOVAR LOCALVARS
 )

(ADDTOVAR SPECVARS
 )

(ADDTOVAR NLAMA
 )

(ADDTOVAR NLAML
 )

(ADDTOVAR LAMA
 )

(ADDTOVAR LAMS
 )
(MOVD? (QUOTE NILL)
       (QUOTE FREEVARS))

(PUTPROPS BREAKDOWN FILEDEF
 BRKDWN)

(PUTPROPS CALLS FILEDEF
 MSANALYZE)

(PUTPROPS CLISPRECORD FILEDEF
 RECORD)

(PUTPROPS SETUPHASHARRAY FILEDEF
 (RECORD SETUPHASHARRAY))

(PUTPROPS MAKEMATCH FILEDEF
 MATCH)

(PUTPROPS ' CLISPTYPE
 15)

(RPAQQ CLISPFLG
 T)

(RPAQQ CLISPHELPFLG
 T)

(RPAQQ TREATASCLISPFLG
 NIL)

(RPAQQ DWIMESSGAG
 NIL)

(RPAQQ CLISPINFIXSPLST
 NIL)

(RPAQQ CLISPCHARS
 (↑ * / + - = ← : ' ~ +- ~= < > @ !))

(RPAQ CLISPCHARRAY
 (MAKEBITTABLE CLISPCHARS))

(RPAQ LEFT.ARROWS.BITTABLE
 (MAKEBITTABLE (QUOTE (← ←))))

(RPAQQ LEFT.ARROW
 ←)

(RPAQQ DECLWORDS
 (FLOATING FAST FFETCHFIELD FETCHFIELD REPLACEFIELD FREPLACEFIELD /REPLACEFIELD 
			   /LISTPUT /LISTPUT1 /MAPCON /MAPCONC /NCONC /NCONC1 /PUT /PUTASSOC /PUTHASH 
			   /PUTPROP /RPLACA /RPLACD /RPLNODE /RPLNODE2 /SETA ASSOC CLISPIFY FASSOC 
			   FIXED FLAST FMEMB FNTH FRPLACA FRPLACD FRPLNODE FRPLNODE2 INTEGER LAST 
			   LISTPUT LISTPUT1 MAPCON MAPCONC MEMB MIXED NCONC NCONC1 NTH PUT PUTASSOC 
			   PUTHASH PUTPROP RPLACA RPLACD RPLNODE RPLNODE2 SETA STANDARD UNDOABLE))

(RPAQQ CLISPISWORDSPLST
 NIL)

(RPAQ CLISPLASTSUB
 (CONS))

(RPAQQ CHECKCARATOMFLG
 NIL)

(RPAQQ CLISPARITHOPLST
 (+ - * / +- LT GT lt gt GEQ LEQ GE LE geq leq ge le))

(RPAQQ CLISPARITHCLASSLST
 (INTEGER FIXED MIXED FLOATING))

(RPAQQ DWIMINMACROSFLG
 T)

(PUTPROPS ↑ CLISPTYPE
 6)

(PUTPROPS ↑ CLISPTYPE
 6)

(PUTPROPS * CLISPTYPE
 4)

(PUTPROPS / CLISPTYPE
 4)

(PUTPROPS + CLISPTYPE
 2)

(PUTPROPS - CLISPTYPE
 7)

(PUTPROPS = CLISPTYPE
 -20)

(PUTPROPS ← CLISPTYPE
 (8 . -12))

(PUTPROPS ← CLISPTYPE
 (8 . -12))

(PUTPROPS : CLISPTYPE
 (14 . 13))

(PUTPROPS ' CLISPTYPE
 15)

(PUTPROPS ~ CLISPTYPE
 7)

(PUTPROPS +- CLISPTYPE
 2)

(PUTPROPS < CLISPTYPE
 BRACKET)

(PUTPROPS > CLISPTYPE
 BRACKET)

(PUTPROPS ↑ LISPFN
 EXPT)

(PUTPROPS ↑ LISPFN
 EXPT)

(PUTPROPS * LISPFN
 TIMES)

(PUTPROPS / LISPFN
 QUOTIENT)

(PUTPROPS + LISPFN
 PLUS)

(PUTPROPS - LISPFN
 MINUS)

(PUTPROPS = LISPFN
 EQ)

(PUTPROPS ← LISPFN
 SETQ)

(PUTPROPS ← LISPFN
 SETQ)

(PUTPROPS ' LISPFN
 QUOTE)

(PUTPROPS ~ LISPFN
 NOT)

(PUTPROPS +- LISPFN
 DIFFERENCE)

(PUTPROPS - UNARYOP
 T)

(PUTPROPS ' UNARYOP
 T)

(PUTPROPS ~ UNARYOP
 T)

(PUTPROPS < UNARYOP
 T)

(PUTPROPS > UNARYOP
 T)

(PUTPROPS * CLISPCLASS
 *)

(PUTPROPS / CLISPCLASS
 /)

(PUTPROPS + CLISPCLASS
 +)

(PUTPROPS - CLISPCLASS
 -)

(PUTPROPS +- CLISPCLASS
 +-)

(PUTPROPS * CLISPCLASSDEF
 (ARITH ITIMES FTIMES TIMES))

(PUTPROPS / CLISPCLASSDEF
 (ARITH IQUOTIENT FQUOTIENT QUOTIENT))

(PUTPROPS + CLISPCLASSDEF
 (ARITH IPLUS FPLUS PLUS))

(PUTPROPS - CLISPCLASSDEF
 (ARITH IMINUS FMINUS MINUS))

(PUTPROPS +- CLISPCLASSDEF
 (ARITH IDIFFERENCE FDIFFERENCE DIFFERENCE))

(PUTPROPS = CLISPNEG
 ~=)

(PUTPROPS < CLISPBRACKET
 (< > SEPARATOR ! DWIMIFY CLISPANGLEBRACKETS CLISPIFY SHRIEKIFY))

(PUTPROPS > CLISPBRACKET
 (< > SEPARATOR ! DWIMIFY CLISPANGLEBRACKETS CLISPIFY SHRIEKIFY))

(PUTPROPS FMEMB CLISPTYPE
 -20)

(PUTPROPS MEMB CLISPTYPE
 -20)

(PUTPROPS FETCHFIELD LISPFN
 FETCHFIELD)

(PUTPROPS REPLACEFIELD LISPFN
 REPLACEFIELD)

(PUTPROPS FREPLACEFIELD LISPFN
 FREPLACEFIELD)

(PUTPROPS ASSOC LISPFN
 ASSOC)

(PUTPROPS LAST LISPFN
 LAST)

(PUTPROPS LISTPUT LISPFN
 LISTPUT)

(PUTPROPS LISTPUT1 LISPFN
 LISTPUT1)

(PUTPROPS MAPCON LISPFN
 MAPCON)

(PUTPROPS MAPCONC LISPFN
 MAPCONC)

(PUTPROPS MEMB LISPFN
 MEMB)

(PUTPROPS NCONC LISPFN
 NCONC)

(PUTPROPS NCONC1 LISPFN
 NCONC1)

(PUTPROPS NTH LISPFN
 NTH)

(PUTPROPS PUT LISPFN
 PUT)

(PUTPROPS PUTASSOC LISPFN
 PUTASSOC)

(PUTPROPS PUTHASH LISPFN
 PUTHASH)

(PUTPROPS PUTPROP LISPFN
 PUTPROP)

(PUTPROPS RPLACA LISPFN
 RPLACA)

(PUTPROPS RPLACD LISPFN
 RPLACD)

(PUTPROPS RPLNODE LISPFN
 RPLNODE)

(PUTPROPS RPLNODE2 LISPFN
 RPLNODE2)

(PUTPROPS SETA LISPFN
 SETA)

(PUTPROPS FLOATING CLISPCLASS
 (ARITH . 2))

(PUTPROPS FAST CLISPCLASS
 (ACCESS . 3))

(PUTPROPS FFETCHFIELD CLISPCLASS
 FETCHFIELD)

(PUTPROPS FETCHFIELD CLISPCLASS
 FETCHFIELD)

(PUTPROPS REPLACEFIELD CLISPCLASS
 REPLACEFIELD)

(PUTPROPS FREPLACEFIELD CLISPCLASS
 REPLACEFIELD)

(PUTPROPS /REPLACEFIELD CLISPCLASS
 REPLACEFIELD)

(PUTPROPS /LISTPUT CLISPCLASS
 LISTPUT)

(PUTPROPS /MAPCON CLISPCLASS
 MAPCON)

(PUTPROPS /MAPCONC CLISPCLASS
 MAPCONC)

(PUTPROPS /NCONC CLISPCLASS
 NCONC)

(PUTPROPS /NCONC1 CLISPCLASS
 NCONC1)

(PUTPROPS /PUT CLISPCLASS
 PUT)

(PUTPROPS /PUTASSOC CLISPCLASS
 PUTASSOC)

(PUTPROPS /PUTHASH CLISPCLASS
 PUTHASH)

(PUTPROPS /PUTPROP CLISPCLASS
 PUTPROP)

(PUTPROPS /RPLACA CLISPCLASS
 RPLACA)

(PUTPROPS /RPLACD CLISPCLASS
 RPLACD)

(PUTPROPS /RPLNODE CLISPCLASS
 RPLNODE)

(PUTPROPS /RPLNODE2 CLISPCLASS
 RPLNODE2)

(PUTPROPS /SETA CLISPCLASS
 SETA)

(PUTPROPS ASSOC CLISPCLASS
 ASSOC)

(PUTPROPS FASSOC CLISPCLASS
 ASSOC)

(PUTPROPS FIXED CLISPCLASS
 (ARITH . 1))

(PUTPROPS FLAST CLISPCLASS
 LAST)

(PUTPROPS FMEMB CLISPCLASS
 MEMB)

(PUTPROPS FNTH CLISPCLASS
 NTH)

(PUTPROPS FRPLACA CLISPCLASS
 RPLACA)

(PUTPROPS FRPLACD CLISPCLASS
 RPLACD)

(PUTPROPS FRPLNODE CLISPCLASS
 RPLNODE)

(PUTPROPS FRPLNODE2 CLISPCLASS
 RPLNODE2)

(PUTPROPS INTEGER CLISPCLASS
 (ARITH . 1))

(PUTPROPS LAST CLISPCLASS
 LAST)

(PUTPROPS LISTPUT CLISPCLASS
 LISTPUT)

(PUTPROPS LISTPUT1 CLISPCLASS
 LISTPUT1)

(PUTPROPS MAPCON CLISPCLASS
 MAPCON)

(PUTPROPS MAPCONC CLISPCLASS
 MAPCONC)

(PUTPROPS MEMB CLISPCLASS
 MEMB)

(PUTPROPS MIXED CLISPCLASS
 (ARITH . 3))

(PUTPROPS NCONC CLISPCLASS
 NCONC)

(PUTPROPS NCONC1 CLISPCLASS
 NCONC1)

(PUTPROPS NTH CLISPCLASS
 NTH)

(PUTPROPS PUT CLISPCLASS
 PUT)

(PUTPROPS PUTASSOC CLISPCLASS
 PUTASSOC)

(PUTPROPS PUTHASH CLISPCLASS
 PUTHASH)

(PUTPROPS PUTPROP CLISPCLASS
 PUTPROP)

(PUTPROPS RPLACA CLISPCLASS
 RPLACA)

(PUTPROPS RPLACD CLISPCLASS
 RPLACD)

(PUTPROPS RPLNODE CLISPCLASS
 RPLNODE)

(PUTPROPS RPLNODE2 CLISPCLASS
 RPLNODE2)

(PUTPROPS SETA CLISPCLASS
 SETA)

(PUTPROPS STANDARD CLISPCLASS
 (ACCESS . 1))

(PUTPROPS UNDOABLE CLISPCLASS
 (ACCESS . 2))

(PUTPROPS FETCHFIELD CLISPCLASSDEF
 (ACCESS FETCHFIELD NIL FFETCHFIELD))

(PUTPROPS REPLACEFIELD CLISPCLASSDEF
 (ACCESS REPLACEFIELD /REPLACEFIELD FREPLACEFIELD))

(PUTPROPS ASSOC CLISPCLASSDEF
 (ACCESS ASSOC NIL FASSOC))

(PUTPROPS LAST CLISPCLASSDEF
 (ACCESS LAST NIL FLAST))

(PUTPROPS LISTPUT CLISPCLASSDEF
 (ACCESS LISTPUT /LISTPUT))

(PUTPROPS LISTPUT1 CLISPCLASSDEF
 (ACCESS LISTPUT1 /LISTPUT1))

(PUTPROPS MAPCON CLISPCLASSDEF
 (ACCESS MAPCON /MAPCON))

(PUTPROPS MAPCONC CLISPCLASSDEF
 (ACCESS MAPCONC /MAPCONC))

(PUTPROPS MEMB CLISPCLASSDEF
 (ACCESS MEMB NIL FMEMB))

(PUTPROPS NCONC CLISPCLASSDEF
 (ACCESS NCONC /NCONC))

(PUTPROPS NCONC1 CLISPCLASSDEF
 (ACCESS NCONC1 /NCONC1))

(PUTPROPS NTH CLISPCLASSDEF
 (ACCESS NTH NIL FNTH))

(PUTPROPS PUT CLISPCLASSDEF
 (ACCESS PUT /PUT))

(PUTPROPS PUTASSOC CLISPCLASSDEF
 (ACCESS PUTASSOC /PUTASSOC))

(PUTPROPS PUTHASH CLISPCLASSDEF
 (ACCESS PUTHASH /PUTHASH))

(PUTPROPS PUTPROP CLISPCLASSDEF
 (ACCESS PUTPROP /PUTPROP))

(PUTPROPS RPLACA CLISPCLASSDEF
 (ACCESS RPLACA /RPLACA FRPLACA))

(PUTPROPS RPLACD CLISPCLASSDEF
 (ACCESS RPLACD /RPLACD FRPLACD))

(PUTPROPS RPLNODE CLISPCLASSDEF
 (ACCESS RPLNODE /RPLNODE FRPLNODE))

(PUTPROPS RPLNODE2 CLISPCLASSDEF
 (ACCESS RPLNODE2 /RPLNODE2 FRPLNODE2))

(PUTPROPS SETA CLISPCLASSDEF
 (ACCESS SETA /SETA))

(PUTPROPS FMEMB CLISPNEG
 ~FMEMB)

(PUTPROPS MEMB CLISPNEG
 ~MEMB)

(PUTPROPS FMEMB BROADSCOPE
 T)

(PUTPROPS MEMB BROADSCOPE
 T)

(PUTPROPS LT CLISPTYPE
 -20)

(PUTPROPS lt CLISPTYPE
 -20)

(PUTPROPS GT CLISPTYPE
 -20)

(PUTPROPS gt CLISPTYPE
 -20)

(PUTPROPS LE CLISPTYPE
 -20)

(PUTPROPS le CLISPTYPE
 -20)

(PUTPROPS GE CLISPTYPE
 -20)

(PUTPROPS ge CLISPTYPE
 -20)

(PUTPROPS LEQ CLISPTYPE
 -20)

(PUTPROPS leq CLISPTYPE
 -20)

(PUTPROPS GEQ CLISPTYPE
 -20)

(PUTPROPS geq CLISPTYPE
 -20)

(PUTPROPS EQ CLISPTYPE
 -20)

(PUTPROPS NEQ CLISPTYPE
 -20)

(PUTPROPS EQP CLISPTYPE
 -20)

(PUTPROPS EQUAL CLISPTYPE
 -20)

(PUTPROPS EQUALS CLISPTYPE
 -20)

(PUTPROPS AND CLISPTYPE
 -25)

(PUTPROPS OR CLISPTYPE
 -26)

(PUTPROPS and CLISPTYPE
 -25)

(PUTPROPS or CLISPTYPE
 -26)

(PUTPROPS NOR CLISPTYPE
 -25)

(PUTPROPS nor CLISPTYPE
 -25)

(PUTPROPS MEMBER CLISPTYPE
 -20)

(PUTPROPS ILESSP CLISPTYPE
 -20)

(PUTPROPS IGREATERP CLISPTYPE
 -20)

(PUTPROPS FGTP CLISPTYPE
 -20)

(PUTPROPS MINUS CLISPTYPE
 8)

(PUTPROPS LESSP CLISPTYPE
 -20)

(PUTPROPS GREATERP CLISPTYPE
 -20)

(PUTPROPS -> CLISPTYPE
 7)

(PUTPROPS => CLISPTYPE
 7)

(PUTPROPS LT LISPFN
 LESSP)

(PUTPROPS lt LISPFN
 LESSP)

(PUTPROPS GT LISPFN
 GREATERP)

(PUTPROPS gt LISPFN
 GREATERP)

(PUTPROPS LE LISPFN
 LEQ)

(PUTPROPS le LISPFN
 LEQ)

(PUTPROPS GE LISPFN
 GEQ)

(PUTPROPS ge LISPFN
 GEQ)

(PUTPROPS LEQ LISPFN
 LEQ)

(PUTPROPS leq LISPFN
 LEQ)

(PUTPROPS GEQ LISPFN
 GEQ)

(PUTPROPS geq LISPFN
 GEQ)

(PUTPROPS EQUALS LISPFN
 EQUAL)

(PUTPROPS AND LISPFN
 AND)

(PUTPROPS OR LISPFN
 OR)

(PUTPROPS and LISPFN
 AND)

(PUTPROPS or LISPFN
 OR)

(PUTPROPS NOR LISPFN
 AND)

(PUTPROPS nor LISPFN
 AND)

(PUTPROPS NOT UNARYOP
 T)

(PUTPROPS MINUS UNARYOP
 T)

(PUTPROPS LEQ CLISPINFIX
 le)

(PUTPROPS GEQ CLISPINFIX
 ge)

(PUTPROPS EQ CLISPINFIX
 =)

(PUTPROPS NOT CLISPINFIX
 ~)

(PUTPROPS AND CLISPINFIX
 and)

(PUTPROPS OR CLISPINFIX
 or)

(PUTPROPS SETQ CLISPINFIX
 ←)

(PUTPROPS IPLUS CLISPINFIX
 +)

(PUTPROPS IMINUS CLISPINFIX
 -)

(PUTPROPS IDIFFERENCE CLISPINFIX
 +-)

(PUTPROPS ITIMES CLISPINFIX
 *)

(PUTPROPS IQUOTIENT CLISPINFIX
 /)

(PUTPROPS ILESSP CLISPINFIX
 lt)

(PUTPROPS IGREATERP CLISPINFIX
 gt)

(PUTPROPS PLUS CLISPINFIX
 +)

(PUTPROPS MINUS CLISPINFIX
 -)

(PUTPROPS DIFFERENCE CLISPINFIX
 +-)

(PUTPROPS TIMES CLISPINFIX
 *)

(PUTPROPS QUOTIENT CLISPINFIX
 /)

(PUTPROPS LESSP CLISPINFIX
 lt)

(PUTPROPS GREATERP CLISPINFIX
 gt)

(PUTPROPS EXPT CLISPINFIX
 ↑)

(PUTPROPS LT CLISPCLASS
 LT)

(PUTPROPS lt CLISPCLASS
 LT)

(PUTPROPS GT CLISPCLASS
 GT)

(PUTPROPS gt CLISPCLASS
 GT)

(PUTPROPS LE CLISPCLASS
 LEQ)

(PUTPROPS le CLISPCLASS
 LEQ)

(PUTPROPS GE CLISPCLASS
 GEQ)

(PUTPROPS ge CLISPCLASS
 GEQ)

(PUTPROPS LEQ CLISPCLASS
 LEQ)

(PUTPROPS leq CLISPCLASS
 LEQ)

(PUTPROPS GEQ CLISPCLASS
 GEQ)

(PUTPROPS geq CLISPCLASS
 GEQ)

(PUTPROPS IPLUS CLISPCLASS
 +)

(PUTPROPS IMINUS CLISPCLASS
 -)

(PUTPROPS IDIFFERENCE CLISPCLASS
 +-)

(PUTPROPS ITIMES CLISPCLASS
 *)

(PUTPROPS IQUOTIENT CLISPCLASS
 /)

(PUTPROPS ILESSP CLISPCLASS
 LT)

(PUTPROPS IGREATERP CLISPCLASS
 GT)

(PUTPROPS FPLUS CLISPCLASS
 +)

(PUTPROPS FMINUS CLISPCLASS
 -)

(PUTPROPS FDIFFERENCE CLISPCLASS
 +-)

(PUTPROPS FTIMES CLISPCLASS
 *)

(PUTPROPS FQUOTIENT CLISPCLASS
 /)

(PUTPROPS FGTP CLISPCLASS
 GT)

(PUTPROPS PLUS CLISPCLASS
 +)

(PUTPROPS MINUS CLISPCLASS
 -)

(PUTPROPS DIFFERENCE CLISPCLASS
 +-)

(PUTPROPS TIMES CLISPCLASS
 *)

(PUTPROPS QUOTIENT CLISPCLASS
 /)

(PUTPROPS LESSP CLISPCLASS
 LT)

(PUTPROPS GREATERP CLISPCLASS
 GT)

(PUTPROPS LT CLISPCLASSDEF
 (ARITH ILESSP LESSP LESSP))

(PUTPROPS GT CLISPCLASSDEF
 (ARITH IGREATERP FGTP GREATERP))

(PUTPROPS LE CLISPCLASSDEF
 (ARITH ILEQ LEQ LEQ))

(PUTPROPS GE CLISPCLASSDEF
 (ARITH IGEQ GEQ GEQ))

(PUTPROPS LEQ CLISPCLASSDEF
 (ARITH ILEQ LEQ LEQ))

(PUTPROPS GEQ CLISPCLASSDEF
 (ARITH IGEQ GEQ GEQ))

(PUTPROPS LT CLISPNEG
 GEQ)

(PUTPROPS GT CLISPNEG
 LEQ)

(PUTPROPS EQUALS CLISPNEG
 ~EQUAL)

(PUTPROPS MEMBER CLISPNEG
 ~MEMBER)

(PUTPROPS LT BROADSCOPE
 T)

(PUTPROPS lt BROADSCOPE
 T)

(PUTPROPS GT BROADSCOPE
 T)

(PUTPROPS gt BROADSCOPE
 T)

(PUTPROPS LE BROADSCOPE
 T)

(PUTPROPS le BROADSCOPE
 T)

(PUTPROPS GE BROADSCOPE
 T)

(PUTPROPS ge BROADSCOPE
 T)

(PUTPROPS LEQ BROADSCOPE
 T)

(PUTPROPS leq BROADSCOPE
 T)

(PUTPROPS GEQ BROADSCOPE
 T)

(PUTPROPS geq BROADSCOPE
 T)

(PUTPROPS EQ BROADSCOPE
 T)

(PUTPROPS NEQ BROADSCOPE
 T)

(PUTPROPS EQP BROADSCOPE
 T)

(PUTPROPS EQUAL BROADSCOPE
 T)

(PUTPROPS EQUALS BROADSCOPE
 T)

(PUTPROPS NOT BROADSCOPE
 T)

(PUTPROPS AND BROADSCOPE
 T)

(PUTPROPS OR BROADSCOPE
 T)

(PUTPROPS and BROADSCOPE
 T)

(PUTPROPS or BROADSCOPE
 T)

(PUTPROPS NOR BROADSCOPE
 T)

(PUTPROPS nor BROADSCOPE
 T)

(PUTPROPS MEMBER BROADSCOPE
 T)

(PUTPROPS ILESSP BROADSCOPE
 T)

(PUTPROPS IGREATERP BROADSCOPE
 T)

(PUTPROPS FGTP BROADSCOPE
 T)

(PUTPROPS LESSP BROADSCOPE
 T)

(PUTPROPS GREATERP BROADSCOPE
 T)

(PUTPROPS ELT SETFN
 SETA)

(PUTPROPS SETA SETFN
 (ELT))

(RPAQQ DWIMIFYFLG
 EVAL)

(RPAQQ DWIMCHECK#ARGSFLG
 T)

(RPAQQ DWIMCHECKPROGLABELSFLG
 T)

(RPAQQ COMPILEUSERFN
 COMPILEUSERFN)

(RPAQQ #CLISPARRAY
 250)

(RPAQQ RECORDHASHFLG
 T)

(RPAQQ CLISPTRANFLG
 CLISP% )

(RPAQQ CLISPRETRANFLG
 NIL)

(ADDTOVAR DWIMEQUIVLST
 )

(ADDTOVAR EDITMACROS
 (CLISP: NIL (BIND (E (COND ((SETQ #1 (AND CLISPARRAY (GETHASH (##)
										   CLISPARRAY)))
						 (SETQQ COM CLISP:)
						 (EDITE #1))
						(T (PRIN1 (QUOTE "not translated.
")
							  T)))
					  T)))
		     (NOCLISP COMS (RESETVAR CLISPTRANFLG NIL . COMS))
		     (NOCLISP NIL (NOCLISP TTY:))
		     (!DW NIL (RESETVAR CLISPRETRANFLG T DW))
		     (PPT NIL (RESETVAR PRETTYTRANFLG T PP))
		     (DW NIL (BIND (E (PROGN (SETQ #1 (##))
					     (AND (CDR L)
						  (## !0 (E (SETQ #2 L)
							    T)))
					     (AND [SETQ #3 (DWIMIFY #1 T (OR #2 (QUOTE (NIL]
						  EDITCHANGES
						  (RPLACA (CDR EDITCHANGES)
							  T)))
				      T)
				   (IF (NLISTP #1)
				       ((I : #3)
					(IF (LISTP #3)
					    (1)
					    NIL))
				       NIL))))

(ADDTOVAR EDITCOMSA
 PPT DW !DW CLISP:)

(PUTPROPS AND CLISPWORD
 T)

(PUTPROPS OR CLISPWORD
 T)

(PUTPROPS and CLISPWORD
 T)

(PUTPROPS or CLISPWORD
 T)

(PUTPROPS ! CLISPWORD
 T)

(PUTPROPS !! CLISPWORD
 T)

(PUTPROPS CLISP CLISPWORD
 (PREFIXFN . clisp))

(PUTPROPS clisp CLISPWORD
 (PREFIXFN . clisp))

(PUTPROPS MATCH CLISPWORD
 (MATCHWORD . match))

(PUTPROPS match CLISPWORD
 (MATCHWORD . match))

(RPAQQ CLISPIFWORDSPLST
 (THEN ELSE ELSEIF IF))

(RPAQQ CLISPIFTRANFLG
 T)

(PUTPROPS IF CLISPWORD
 (IFWORD . if))

(PUTPROPS THEN CLISPWORD
 (IFWORD . then))

(PUTPROPS ELSE CLISPWORD
 (IFWORD . else))

(PUTPROPS ELSEIF CLISPWORD
 (IFWORD . elseif))

(PUTPROPS if CLISPWORD
 (IFWORD . if))

(PUTPROPS then CLISPWORD
 (IFWORD . then))

(PUTPROPS else CLISPWORD
 (IFWORD . else))

(PUTPROPS elseif CLISPWORD
 (IFWORD . elseif))

(RPAQQ CLISPI.S.GAG
 NIL)

(ADDTOVAR I.S.OPRLST
 ALWAYS AS BIND BY COLLECT COUNT DECLARE DECLARE: DO EACHTIME FCOLLECT FINALLY 
			    FIND FIRST FOR FROM IN INSIDE ISTHERE JOIN LARGEST NEVER OLD ON ORIGINAL 
			    REPEATUNTIL REPEATWHILE SMALLEST SUCHTHAT SUM THEREIS THRU TO UNLESS 
			    UNTIL WHEN WHERE WHILE always as bind by collect count declare declare: 
			    do eachtime fcollect finally find first for from in inside isthere join 
			    largest never old on original repeatuntil repeatwhile smallest suchthat 
			    sum thereis thru to unless until when where while)

(ADDTOVAR CLISPFORWORDSPLST
 ALWAYS AS BIND BY COLLECT COUNT DO EACHTIME FINALLY FIRST FOR FROM IN 
				   INSIDE JOIN LARGEST NEVER OLD ON REPEATUNTIL REPEATWHILE SMALLEST 
				   SUCHTHAT SUM THEREIS TO UNLESS UNTIL WHEN WHERE WHILE)

(ADDTOVAR DURATIONCLISPWORDS
 (TIMERUNITS timerUnits timerunits)
			     (USINGBOX usingBox usingbox)
			     (USINGTIMER usingTimer usingtimer)
			     (FORDURATION forDuration forduration DURING during)
			     (RESOURCENAME resourceName resourcename)
			     (UNTILDATE untilDate untildate))

(PUTPROPS ALWAYS CLISPWORD
 (FORWORD . always))

(PUTPROPS AS CLISPWORD
 (FORWORD . as))

(PUTPROPS BIND CLISPWORD
 (FORWORD . bind))

(PUTPROPS BY CLISPWORD
 (FORWORD . by))

(PUTPROPS COLLECT CLISPWORD
 (FORWORD . collect))

(PUTPROPS COUNT CLISPWORD
 (FORWORD . count))

(PUTPROPS DECLARE CLISPWORD
 (FORWORD . declare))

(PUTPROPS DECLARE: CLISPWORD
 (FORWORD declare: DECLARE))

(PUTPROPS DO CLISPWORD
 (FORWORD . do))

(PUTPROPS EACHTIME CLISPWORD
 (FORWORD . eachtime))

(PUTPROPS FCOLLECT CLISPWORD
 (FORWORD . fcollect))

(PUTPROPS FINALLY CLISPWORD
 (FORWORD . finally))

(PUTPROPS FIND CLISPWORD
 (FORWORD find FOR))

(PUTPROPS FIRST CLISPWORD
 (FORWORD . first))

(PUTPROPS FOR CLISPWORD
 (FORWORD . for))

(PUTPROPS FROM CLISPWORD
 (FORWORD . from))

(PUTPROPS IN CLISPWORD
 (FORWORD . in))

(PUTPROPS INSIDE CLISPWORD
 (FORWORD . inside))

(PUTPROPS ISTHERE CLISPWORD
 (FORWORD isthere THEREIS))

(PUTPROPS JOIN CLISPWORD
 (FORWORD . join))

(PUTPROPS LARGEST CLISPWORD
 (FORWORD . largest))

(PUTPROPS NEVER CLISPWORD
 (FORWORD . never))

(PUTPROPS OLD CLISPWORD
 (FORWORD . old))

(PUTPROPS ON CLISPWORD
 (FORWORD . on))

(PUTPROPS ORIGINAL CLISPWORD
 (FORWORD . original))

(PUTPROPS REPEATUNTIL CLISPWORD
 (FORWORD . repeatuntil))

(PUTPROPS REPEATWHILE CLISPWORD
 (FORWORD . repeatwhile))

(PUTPROPS SMALLEST CLISPWORD
 (FORWORD . smallest))

(PUTPROPS SUCHTHAT CLISPWORD
 (FORWORD suchthat THEREIS))

(PUTPROPS SUM CLISPWORD
 (FORWORD . sum))

(PUTPROPS THEREIS CLISPWORD
 (FORWORD . thereis))

(PUTPROPS THRU CLISPWORD
 (FORWORD thru TO))

(PUTPROPS TO CLISPWORD
 (FORWORD . to))

(PUTPROPS UNLESS CLISPWORD
 (FORWORD . unless))

(PUTPROPS UNTIL CLISPWORD
 (FORWORD . until))

(PUTPROPS WHEN CLISPWORD
 (FORWORD . when))

(PUTPROPS WHERE CLISPWORD
 (FORWORD where WHEN))

(PUTPROPS WHILE CLISPWORD
 (FORWORD . while))

(PUTPROPS always CLISPWORD
 (FORWORD . always))

(PUTPROPS as CLISPWORD
 (FORWORD . as))

(PUTPROPS bind CLISPWORD
 (FORWORD . bind))

(PUTPROPS by CLISPWORD
 (FORWORD . by))

(PUTPROPS collect CLISPWORD
 (FORWORD . collect))

(PUTPROPS count CLISPWORD
 (FORWORD . count))

(PUTPROPS declare CLISPWORD
 (FORWORD . declare))

(PUTPROPS declare: CLISPWORD
 (FORWORD declare: DECLARE))

(PUTPROPS do CLISPWORD
 (FORWORD . do))

(PUTPROPS eachtime CLISPWORD
 (FORWORD . eachtime))

(PUTPROPS fcollect CLISPWORD
 (FORWORD . fcollect))

(PUTPROPS finally CLISPWORD
 (FORWORD . finally))

(PUTPROPS find CLISPWORD
 (FORWORD find FOR))

(PUTPROPS first CLISPWORD
 (FORWORD . first))

(PUTPROPS for CLISPWORD
 (FORWORD . for))

(PUTPROPS from CLISPWORD
 (FORWORD . from))

(PUTPROPS in CLISPWORD
 (FORWORD . in))

(PUTPROPS inside CLISPWORD
 (FORWORD . inside))

(PUTPROPS isthere CLISPWORD
 (FORWORD isthere thereis))

(PUTPROPS join CLISPWORD
 (FORWORD . join))

(PUTPROPS largest CLISPWORD
 (FORWORD . largest))

(PUTPROPS never CLISPWORD
 (FORWORD . never))

(PUTPROPS old CLISPWORD
 (FORWORD . old))

(PUTPROPS on CLISPWORD
 (FORWORD . on))

(PUTPROPS original CLISPWORD
 (FORWORD . original))

(PUTPROPS repeatuntil CLISPWORD
 (FORWORD . repeatuntil))

(PUTPROPS repeatwhile CLISPWORD
 (FORWORD . repeatwhile))

(PUTPROPS smallest CLISPWORD
 (FORWORD . smallest))

(PUTPROPS suchthat CLISPWORD
 (FORWORD suchthat THEREIS))

(PUTPROPS sum CLISPWORD
 (FORWORD . sum))

(PUTPROPS thereis CLISPWORD
 (FORWORD . thereis))

(PUTPROPS thru CLISPWORD
 (FORWORD thru TO))

(PUTPROPS to CLISPWORD
 (FORWORD . to))

(PUTPROPS unless CLISPWORD
 (FORWORD . unless))

(PUTPROPS until CLISPWORD
 (FORWORD . until))

(PUTPROPS when CLISPWORD
 (FORWORD . when))

(PUTPROPS where CLISPWORD
 (FORWORD where WHEN))

(PUTPROPS while CLISPWORD
 (FORWORD . while))

(PUTPROPS OUTOF CLISPWORD
 (FORWORD . outof))

(PUTPROPS outof CLISPWORD
 (FORWORD . outof))

(PUTPROPS INFILES CLISPWORD
 (FORWORD . infiles))

(PUTPROPS infiles CLISPWORD
 (FORWORD . infiles))

(PUTPROPS always I.S.OPR
 ((COND ((NULL BODY)
				 (SETQ $$VAL NIL)
				 (GO $$OUT)))
			  BIND
			  (SETQ $$VAL T)))

(PUTPROPS collect I.S.OPR
 ((SETQ $$VAL (NCONC1 $$VAL BODY))))

(PUTPROPS count I.S.OPR
 ((AND BODY (SETQ $$VAL (ADD1 $$VAL)))
			 BIND
			 ($$VAL ← 0)))

(PUTPROPS do I.S.OPR
 (BODY))

(PUTPROPS fcollect I.S.OPR
 [(= SUBPAIR (QUOTE (VAR1 VAR2))
			       (LIST (GETDUMMYVAR T)
				     (GETDUMMYVAR T))
			       (QUOTE (PROGN (SETQ VAR1 BODY)
					     (COND [VAR2 (FRPLACD VAR2 (SETQ VAR2 (LIST VAR1]
						   (T (SETQ $$VAL (SETQ VAR2 (LIST VAR1])

(PUTPROPS inside I.S.OPR
 [NIL = SUBST (GETDUMMYVAR)
			      (QUOTE VAR)
			      (QUOTE (bind (VAR ← BODY)
					   eachtime
					   (COND ((NULL VAR)
						  (GO $$OUT))
						 ((NLISTP VAR)
						  (SETQ I.V. VAR)
						  (SETQ VAR NIL))
						 (T (SETQ I.V. (CAR VAR))
						    (SETQ VAR (CDR VAR])

(PUTPROPS join I.S.OPR
 ((SETQ $$VAL (NCONC $$VAL BODY))))

(PUTPROPS largest I.S.OPR
 [NIL = SUBST (GETDUMMYVAR)
			       (QUOTE $$TEMP)
			       (QUOTE (BIND $$EXTREME $$TEMP DO (SETQ $$TEMP BODY)
					    (COND ((OR (NULL $$EXTREME)
						       (GREATERP $$TEMP $$EXTREME))
						   (SETQ $$EXTREME $$TEMP)
						   (SETQ $$VAL I.V.])

(PUTPROPS never I.S.OPR
 ((COND (BODY (SETQ $$VAL NIL)
				     (GO $$OUT)))
			 BIND
			 ($$VAL ← T)))

(PUTPROPS old I.S.OPR
 MODIFIER)

(PUTPROPS smallest I.S.OPR
 [NIL = SUBST (GETDUMMYVAR)
				(QUOTE $$TEMP)
				(QUOTE (BIND $$EXTREME $$TEMP DO (SETQ $$TEMP BODY)
					     (COND ((OR (NULL $$EXTREME)
							(LESSP $$TEMP $$EXTREME))
						    (SETQ $$EXTREME $$TEMP)
						    (SETQ $$VAL I.V.])

(PUTPROPS sum I.S.OPR
 ((SETQ $$VAL (PLUS $$VAL BODY))
		       BIND
		       ($$VAL ← 0)))

(PUTPROPS thereis I.S.OPR
 [(COND (BODY (SETQ $$VAL (OR I.V. T))
				       (GO $$OUT])

(PUTPROPS outof I.S.OPR
 [NIL = SUBST (GENSYM)
			     (QUOTE GENVAR)
			     (QUOTE (BIND GENVAR ← (GENERATOR BODY)
					  EACHTIME
					  (COND ((EQ (SETQ I.V. (GENERATE GENVAR))
						     GENVAR)
						 (GO $$OUT)))
					  FINALLY
					  (RELSTK (CDR GENVAR])

(PUTPROPS infiles I.S.OPR
 [NIL = SUBST (GENSYM)
			       (QUOTE GENVAR)
			       (QUOTE (BIND GENVAR ← (\GENERATEFILES BODY NIL (QUOTE (SORT)))
					    EACHTIME
					    (PROGN (OR (SETQ I.V. (\GENERATENEXTFILE GENVAR))
						       (GO $$OUT))
						   (IF (LISTP I.V.)
						       THEN
						       (SETQ I.V. (CONCATCODES I.V.])

(RPAQQ CLISPDUMMYFORVARS
 ($$TEM0 $$TEM1 $$TEM2 $$TEM3 $$TEM4 $$TEM5 $$TEM6))

(PUTPROPS TIMERUNITS CLISPWORD
 (FORWORD . timerUnits))

(PUTPROPS timerUnits CLISPWORD
 (FORWORD . timerUnits))

(PUTPROPS timerunits CLISPWORD
 (FORWORD . timerUnits))

(PUTPROPS USINGBOX CLISPWORD
 (FORWORD . usingBox))

(PUTPROPS usingBox CLISPWORD
 (FORWORD . usingBox))

(PUTPROPS usingbox CLISPWORD
 (FORWORD . usingBox))

(PUTPROPS USINGTIMER CLISPWORD
 (FORWORD . usingTimer))

(PUTPROPS usingTimer CLISPWORD
 (FORWORD . usingTimer))

(PUTPROPS usingtimer CLISPWORD
 (FORWORD . usingTimer))

(PUTPROPS FORDURATION CLISPWORD
 (FORWORD . forDuration))

(PUTPROPS forDuration CLISPWORD
 (FORWORD . forDuration))

(PUTPROPS forduration CLISPWORD
 (FORWORD . forDuration))

(PUTPROPS DURING CLISPWORD
 (FORWORD . during))

(PUTPROPS during CLISPWORD
 (FORWORD . during))

(PUTPROPS RESOURCENAME CLISPWORD
 (FORWORD . resourceName))

(PUTPROPS resourceName CLISPWORD
 (FORWORD . resourceName))

(PUTPROPS resourcename CLISPWORD
 (FORWORD . resourceName))

(PUTPROPS UNTILDATE CLISPWORD
 (FORWORD . untildate))

(PUTPROPS untilDate CLISPWORD
 (FORWORD . untilDate))

(PUTPROPS untildate CLISPWORD
 (FORWORD . untildate))

(PUTPROPS timerUnits \DURATIONTRAN
 T)

(PUTPROPS usingBox \DURATIONTRAN
 T)

(PUTPROPS usingTimer \DURATIONTRAN
 T)

(PUTPROPS forDuration \DURATIONTRAN
 T)

(PUTPROPS during \DURATIONTRAN
 T)

(PUTPROPS resourceName \DURATIONTRAN
 T)

(PUTPROPS untilDate \DURATIONTRAN
 T)

(PUTPROPS untildate \DURATIONTRAN
 T)
(PUTDEF (QUOTE I.S.OPRS) (QUOTE FILEPKGCOMS) (QUOTE ((COM MACRO [X (DECLARE: EVAL@COMPILE
									     (P * (DUMPI.S.OPRS . X]
							  CONTENTS NILL)
						     (TYPE DESCRIPTION "i.s. operators" WHENCHANGED
							   (CLEARCLISPARRAY)
							   GETDEF GETDEF.I.S.OPR))))
(DEFINEQ

(DUMPI.S.OPRS

  [NLAMBDA X                                                 (* lmm "14-Aug-84 18:34")

                                                             (* Dump I.S.OPRS definitions.

							     -

							     redefined to dump out same case as given)

    (for Y in X collect (OR (GETDEF.I.S.OPR
 Y)
			    (PROG1 NIL (LISPXPRINT (LIST (QUOTE I.S.OPR)
							 Y
							 (QUOTE not)
							 (QUOTE defined))
						   T T])

(GETDEF.I.S.OPR

  [LAMBDA (Y)                                                (* lmm "14-Aug-84 18:34")

    (PROG (TEM BODY EVALFLG)
          (RETURN
	    (CONS (QUOTE I.S.OPR)
		  (CONS (KWOTE Y)
			(OR [AND [SETQ TEM (LISTP (GETPROP Y (QUOTE CLISPWORD]
				 (EQ (CAR TEM)
				     (QUOTE FORWORD))
				 (COND
				   [[AND (NLISTP (CDR TEM))
					 (SETQ BODY (GETPROP (CDR TEM)
							     (QUOTE I.S.OPR]
				     (COND
				       [(LISTP BODY)
					 (CONS [KWOTE (COND
							((EQ (CAR (LISTP (CAR BODY)))
							     (QUOTE =))
							  (SETQ EVALFLG T)
							  (CDAR BODY))
							(T (CAR BODY]
					       (COND
						 ((EQ (CADR BODY)
						      (QUOTE =))
						   (LIST (KWOTE (CDDR BODY))
							 T))
						 [(CDR BODY)
						   (COND
						     (EVALFLG (SHOULDNT)))
                                                             (* somehow there was an = in front of the i.s.type and 

							     not in front of the others. this shouldnt happen)

						   (LIST (KWOTE (CDR BODY]
						 (EVALFLG (QUOTE (NIL T]
				       (T (LIST (KWOTE BODY]
				   ((AND (LISTP (CDR TEM))
					 (CADDR TEM))
				     (LIST (KWOTE (CADDR TEM]
			    (RETURN])
)

(ADDTOVAR SYSLOCALVARS
 $$TEM0 $$TEM1 $$TEM2 $$TEM3 $$TEM4 $$TEM5 $$TEM6)

(ADDTOVAR INVISIBLEVARS
 $$TEM0 $$TEM1 $$TEM2 $$TEM3 $$TEM4 $$TEM5 $$TEM6)

(ADDTOVAR SYSLOCALVARS
 $$VAL $$TEM $$LST1 $$LST2 $$LST3 $$LST4 $$LST5 $$LST6 $$END $$EXTREME)

(ADDTOVAR INVISIBLEVARS
 $$VAL $$END $$TEM $$LST1 $$LST2 $$LST3 $$LST4 $$LST5 $$LST6 $$EXTREME)
[PUTPROP (QUOTE CLISP% )
	 (QUOTE MACRO)
	 (QUOTE (X (CAR X]
(DECLARE: EVAL@COMPILE 
[PUTDEF (QUOTE \ForDurationOfBox)
	(QUOTE RESOURCES)
	(QUOTE (NEW (\TIMER.MAKETIMER]
)



(* currently there are four possible entries for this property, EVAL, BINDS, LABELS, PROGN, or 
a list containg any or all of these. EVAL is used to indicate thatan nlambda evaluates its 
arguments. EVAL affects DWIMIFY and CLISPIFY: neither will touch an nlambda thatdoes not have 
this property. BINDS tells clispify and dwimify that cadr of the form is a list of variabes 
being bound, a la prog. PROGN says that only the last top level expression is being used for 
value. This affects the way OR's and AND's are clispifed for example. Finally, LABELS indicates
 that top level atoms in this expression are not being evaluated. this tells clispify not to 
create atoms out of lists atthe top level. LABELS also implies that none of the top level 
expressions are being ued for value. For example, FOR has info property just BINDS, (EVAL is 
unnecssary since FOR is not a function and its dwimifying and clispifying affected by its 
clispword propety) , whereas PROG has (BINDS EVAL and LABLELS) , and LAMBDA has (EVAL BINDS 
PROGN))



(PUTPROPS PROG INFO
 (EVAL BINDS LABELS))

(PUTPROPS PROG* INFO
 (EVAL BINDS LABELS))

(PUTPROPS RESETVARS INFO
 (EVAL BINDS LABELS))

(PUTPROPS RESETBUFS INFO
 EVAL)

(PUTPROPS RESETLST INFO
 (EVAL PROGN))

(PUTPROPS ADV-PROG INFO
 (EVAL BINDS LABELS))

(PUTPROPS ADV-SETQ INFO
 EVAL)

(PUTPROPS AND INFO
 EVAL)

(PUTPROPS ARG INFO
 EVAL)

(PUTPROPS COND INFO
 EVAL)

(PUTPROPS ERSETQ INFO
 EVAL)

(PUTPROPS NLSETQ INFO
 EVAL)

(PUTPROPS OR INFO
 EVAL)

(PUTPROPS PROG1 INFO
 EVAL)

(PUTPROPS PROG2 INFO
 EVAL)

(PUTPROPS PROGN INFO
 (EVAL PROGN))

(PUTPROPS RESETFORM INFO
 EVAL)

(PUTPROPS RESETSAVE INFO
 EVAL)

(PUTPROPS RESETVAR INFO
 EVAL)

(PUTPROPS RPAQ INFO
 EVAL)

(PUTPROPS RPTQ INFO
 EVAL)

(PUTPROPS FRPTQ INFO
 EVAL)

(PUTPROPS SAVESETQ INFO
 EVAL)

(PUTPROPS SETN INFO
 EVAL)

(PUTPROPS SETQ INFO
 EVAL)

(PUTPROPS UNDONLSETQ INFO
 EVAL)

(PUTPROPS XNLSETQ INFO
 EVAL)

(PUTPROPS SETARG INFO
 EVAL)

(PUTPROPS LET INFO
 (BINDS EVAL))

(PUTPROPS LET* INFO
 (BINDS EVAL))
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS 

(ADDTOVAR NLAMA
 DUMPI.S.OPRS)

(ADDTOVAR NLAML
 )

(ADDTOVAR LAMA
 )
)
(PUTPROPS CLISP COPYRIGHT ("Xerox Corporation" T 1982 1983 1984 1985))
(DECLARE: DONTCOPY
  (FILEMAP (NIL (33273 34911 (DUMPI.S.OPRS 33283 . 33735) (GETDEF.I.S.OPR 33737 . 34909)))))
STOP