gcl-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Gcl-devel] Re: 2.7.0 ACL2 2.9.4 mv chk-acceptable-defuns compilation bu


From: Camm Maguire
Subject: [Gcl-devel] Re: 2.7.0 ACL2 2.9.4 mv chk-acceptable-defuns compilation bug
Date: 14 Feb 2006 13:15:51 -0500
User-agent: Gnus/5.09 (Gnus v5.9.0) Emacs/21.2

Greetings!

OK this should be fixed now, though other-events.lisp still takes
quite a while to compile.  I wish I could understand what this new
feature is all about.  The basic issue was likely not so much a bug as
a poor algorithm, which is just mitigated at present.  We autodeclare
certain bindings to great benefit in execution performance, but the
current algorithm is exponential in the binding form nesting.  I.e.,
given a let, the compiler will process the binding forms and the body
once to see if a consistent type can be inferred, then if so, insert a
declare form and process the let for real.  A better solution
following a suggestion made by Paul Dietz would be to make a pass 0
through the whole function and build up a type lattice, and then do
some sort of linear program thereon to insert the declarations at all
levels all at once.  I'm still not really sure how to handle discrete
types in such a procedure.

Take care,

Robert Boyer <address@hidden> writes:

> Hi,  Camm!
> 
> I'm still stumped by what looks like a 2.7.0 compiler bug.  This is using:
> 
>   1.  Today's 2.7.0.
>   2.  Build with --enable-ansi
>   3.  Trying to use multiple values, a new feature of ACL2.
>   4.  Compiling the most recently released ACL2 2.9.4.
> 
> Below is the input I type to get to the problem.  Assuming you have around a
> large ansi gcl named "xg", you should be able to run the input as is,
> including getting and unpacking the newest ACL2.
> 
> Below that is a transcript showing me getting to the problem, using the
> input, and seeing the problem.
> 
> It would be very embarrassing to reveal how many hours I have been stumped by
> this problem!
> 
> Bob
> 
> -------------------------------------------------------------------------------
> 
> mkdir tmp
> cd tmp
> wget ftp://ftp.cs.utexas.edu/pub/moore/acl2/acl2-2.9.4.tar.gz
> tar zxf acl2-2.9.4.tar.gz
> cd acl2-sources
> make clean
> xg
> 
> 
> ; The following is input to GCL
> ; I am using using a huge, recent GCL 2.7.0, static, ANSI version of GCL
> (si::use-fast-links nil) ; so tracing will work
> (setq si:*notify-gbc* t) ; helps to tell we are running forever :)
> ; use multiple values
> (push :acl2-mv-as-values *features*)
> ; sneak around new ACL2 trick to prevent using ANSI 
> (push :CLTL2 *features*)
> (setq *features* (remove :ansi-cl *features*))
> 
> (trace (compiler::T1EXPR
>   :cond (and (consp si::arglist)
>              (consp (car si::arglist))
>              (eq (caar si::arglist) 'DEFUN)
>              (equal (symbol-name (cadr (car si::arglist)))
>                     (symbol-name 'CHK-ACCEPTABLE-DEFUNS)))
>   :entry (break)))
> 
> #+gcl
> (progn
>   ;; ALLOCATEs to speed compilation by reducing gc on the GCL,
>   ;; machine, virtual and physical address space we enjoy on elgin.
>   (progn
>     (si::set-hole-size 2000)
>     (si::allocate 'relocatable-blocks 170000 t)
>     (si::allocate 'contiguous-blocks 10000 t)
>     (si::allocate 'cons 100000 t)
>     (si::allocate 'sfun 10000 t)
>     (si::allocate 'array 30000 t)
>     (si::allocate 'fixnum 10000 t)
>     (si::allocate 'structure 10000 t)
>     (si::allocate 'symbol 10000 t)))
> (load "init.lisp")
> (acl2::compile-acl2)
> 
> ; will break at compiling chk-acceptable-defuns in defuns.lisp
> ; continuing from that :r never terminates (even after 12 hours)
> 
> -------------------------------------------------------------------------------
> 
> % mkdir tmp
> % cd tmp
> % wget ftp://ftp.cs.utexas.edu/pub/moore/acl2/acl2-2.9.4.tar.gz
> --15:33:46--  ftp://ftp.cs.utexas.edu/pub/moore/acl2/acl2-2.9.4.tar.gz
>            => `acl2-2.9.4.tar.gz'
> Resolving ftp.cs.utexas.edu... 128.83.120.155
> Connecting to ftp.cs.utexas.edu|128.83.120.155|:21... connected.
> Logging in as anonymous ... Logged in!
> ==> SYST ... done.    ==> PWD ... done.
> ==> TYPE I ... done.  ==> CWD /pub/moore/acl2 ... done.
> ==> PASV ... done.    ==> RETR acl2-2.9.4.tar.gz ... done.
> Length: 5,748,718 (5.5M) (unauthoritative)
> 
> 100%[====================================>] 5,748,718     11.02M/s            
>  
> 
> 15:33:47 (11.01 MB/s) - `acl2-2.9.4.tar.gz' saved [5748718]
> 
> % tar zxf acl2-2.9.4.tar.gz
> % cd acl2-sources
> % make clean
> rm -f *.o *#* *.c *.h *.data gazonk.* workxxx workyyy \
>   *.lbin *.sbin *.fasl *.wfasl *.fas *.lib *.sparcf *.ufsl *.x86f *.dfsl *.fn 
> acl2-status.txt \
>   *.log TMP* saved/*
> rm -f *~ */*~ */*/*~ */*/*/*~
> % xg
> GCL (GNU Common Lisp)  2.7.0 ANSI    Feb 13 2006 14:25:58
> Source License: LGPL(gcl,gmp,pargcl), GPL(unexec,bfd)
> Binary License:  GPL due to GPL'ed components: (BFD UNEXEC)
> Modifications of this banner must retain notice of a compatible license
> Dedicated to the memory of W. Schelter
> 
> Use (help) to get some basic information on how to use GCL.
> Temporary directory for compiler files set to /tmp/
> 
> >; The following is input to GCL
> ; I am using using a huge, recent GCL 2.7.0, static, ANSI version of GCL
> (si::use-fast-links nil) ; so tracing will work
> (setq si:*notify-gbc* t) ; helps to tell we are running forever :)
> 
> 
> NIL
> 
> >
> T
> 
> >(push :acl2-mv-as-values *features*)
> ; sneak around new ACL2 trick to prevent using ANSI 
> (push :CLTL2 *features*)
> (setq *features* (remove :ansi-cl *features*))
> 
> 
> (:ACL2-MV-AS-VALUES :COMPILER :NUMLIB :CLOS-CONDITIONS :PCL-STRUCTURES
>     :PORTABLE-COMMONLOOPS :PCL :TURBO-CLOSURE-ENV-SIZE :TURBO-CLOSURE
>     :SDEBUG :DEFPACKAGE :SETF :ANSI-CL :COMMON-LISP :GNU-LD :UNEXEC
>     :BFD :NATIVE-RELOC :TRUNCATE_USE_C :CLX-LITTLE-ENDIAN :BSD :GNU
>     :LINUX :I686 :SGC :IEEE-FLOATING-POINT :UNIX :GMP :GCL :AKCL
>     :COMMON :KCL)
> 
> >
> (:CLTL2 :ACL2-MV-AS-VALUES :COMPILER :NUMLIB :CLOS-CONDITIONS
>         :PCL-STRUCTURES :PORTABLE-COMMONLOOPS :PCL
>         :TURBO-CLOSURE-ENV-SIZE :TURBO-CLOSURE :SDEBUG :DEFPACKAGE
>         :SETF :ANSI-CL :COMMON-LISP :GNU-LD :UNEXEC :BFD :NATIVE-RELOC
>         :TRUNCATE_USE_C :CLX-LITTLE-ENDIAN :BSD :GNU :LINUX :I686 :SGC
>         :IEEE-FLOATING-POINT :UNIX :GMP :GCL :AKCL :COMMON :KCL)
> 
> >
> (:CLTL2 :ACL2-MV-AS-VALUES :COMPILER :NUMLIB :CLOS-CONDITIONS
>         :PCL-STRUCTURES :PORTABLE-COMMONLOOPS :PCL
>         :TURBO-CLOSURE-ENV-SIZE :TURBO-CLOSURE :SDEBUG :DEFPACKAGE
>         :SETF :COMMON-LISP :GNU-LD :UNEXEC :BFD :NATIVE-RELOC
>         :TRUNCATE_USE_C :CLX-LITTLE-ENDIAN :BSD :GNU :LINUX :I686 :SGC
>         :IEEE-FLOATING-POINT :UNIX :GMP :GCL :AKCL :COMMON :KCL)
> 
> >(trace (compiler::T1EXPR
>   :cond (and (consp si::arglist)
>              (consp (car si::arglist))
>              (eq (caar si::arglist) 'DEFUN)
>              (equal (symbol-name (cadr (car si::arglist)))
>                     (symbol-name 'CHK-ACCEPTABLE-DEFUNS)))
>   :entry (break)))
> 
> (COMPILER::T1EXPR)
> 
> >#+gcl
> (progn
>   ;; ALLOCATEs to speed compilation by reducing gc on the GCL,
>   ;; machine, virtual and physical address space we enjoy on elgin.
>   (progn
>     (si::set-hole-size 2000)
>     (si::allocate 'relocatable-blocks 170000 t)
>     (si::allocate 'contiguous-blocks 10000 t)
>     (si::allocate 'cons 100000 t)
>     (si::allocate 'sfun 10000 t)
>     (si::allocate 'array 30000 t)
>     (si::allocate 'fixnum 10000 t)
>     (si::allocate 'structure 10000 t)
>     (si::allocate 'symbol 10000 t)))
> 
> [GC for 170000 RELOCATABLE-BLOCKS pages..(T=2).GC finished]
> [GC for 170000 RELOCATABLE-BLOCKS pages..(T=2).GC finished]
> [GC for 170000 RELOCATABLE-BLOCKS pages..(T=30).GC finished]
> [GC for 170000 RELOCATABLE-BLOCKS pages..(T=33).GC finished]
> [GC for 170000 RELOCATABLE-BLOCKS pages..(T=40).GC finished]
> [GC for 167930 RELOCATABLE-BLOCKS pages..(T=42).GC finished]
> 
> T
> 
> >(load "init.lisp")
> (acl2::compile-acl2)
> 
> 
> 
> Loading init.lisp
> Loading acl2-init.lisp
> Loading acl2.lisp
> Loading acl2-fns.lisp
> Finished loading acl2-fns.lisp
> ;; Compiling acl2-fns.lisp.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling acl2-fns.o.
> Loading acl2-fns.o
> start address -T 0xa0c8100 Finished loading acl2-fns.o
> Finished loading acl2.lisp
> Finished loading acl2-init.lisp
> Finished loading init.lisp
> T
> 
> >
> Loading acl2-check.lisp
> Check completed.
> Finished loading acl2-check.lisp
> Loading axioms.lisp
> Finished loading axioms.lisp
> ;; Compiling axioms.lisp.
> ; (DEFUN SET-SKIPPED-PROOFSP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::SKIPPED-PROOFSP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINC$ ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-BASE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-CASE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LISP-BOOK-SYNTAXP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INFIXP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PATHNAME-OS-TO-UNIX ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::MSWINDOWS-DRIVE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN MAIN-TIMER ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::MAIN-TIMER is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN SET-TIMER ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::TIMER-ALIST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRIN1$ ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CURRENT-PACKAGE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::CURRENT-ACL2-WORLD is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-SKIP-PROOFSP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-SKIP-PROOFSP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WORMHOLE1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-NAME is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-INPUT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-OUTPUT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> axioms.c: In function `L456':
> axioms.c:31547: warning: comparison is always true due to limited range of 
> data type
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling axioms.o.
> Loading axioms.o
> start address -T 0xa196ee0 Finished loading axioms.o
> Loading basis.lisp
> Finished loading basis.lisp
> ;; Compiling basis.lisp.
> ; (DEFUN FLSZ-ATOM ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CURRENT-PACKAGE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN OUTPUT-IN-INFIXP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INFIXP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN FLSZ ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-BASE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN FMT-HARD-RIGHT-MARGIN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::FMT-HARD-RIGHT-MARGIN is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN FMT-SOFT-RIGHT-MARGIN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::FMT-SOFT-RIGHT-MARGIN is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WRITE-FOR-READ ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WRITE-FOR-READ is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN USER-DEFAULT-EVISC-TUPLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::USER-DEFAULT-EVISC-TUPLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN USER-TERM-EVISC-TUPLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::USER-TERM-EVISC-TUPLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN TERM-EVISC-TUPLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::EVISCERATE-HIDE-TERMS is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN ERROR-FMS ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::STANDARD-CO is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PUSH-WARNING-FRAME ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::ACCUMULATED-WARNINGS is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PUSH-IO-RECORD ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-REVERSED is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN SAVED-OUTPUT-TOKEN-P ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-P is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-TOKEN-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN OUTPUT-IGNORED-P ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN ERROR1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WARNING1-BODY ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PROOFS-CO is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN CHECK-SUM-STRING1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CHECK-SUM-WEIRDNESS is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-REDEFINITION-ACTION ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-REDEFINITION-ACTION is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN STANDARD-OI ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::STANDARD-OI is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-PROMPT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-PROMPT is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-KEYWORD-ALIASES ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-KEYWORD-ALIASES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-PRE-EVAL-FILTER ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-PRE-EVAL-FILTER is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-PRE-EVAL-PRINT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-PRE-EVAL-PRINT is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-POST-EVAL-PRINT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-POST-EVAL-PRINT is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-EVISC-TUPLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-EVISC-TUPLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-ERROR-TRIPLES ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-ERROR-TRIPLES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-ERROR-ACTION ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-ERROR-ACTION is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-QUERY-CONTROL-ALIST ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-QUERY-CONTROL-ALIST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN LD-VERBOSE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-VERBOSE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling basis.o.
> Loading basis.o
> start address -T 0xa1e94e0 Finished loading basis.o
> Loading translate.lisp
> Finished loading translate.lisp
> ;; Compiling translate.lisp.
> ; (DEFUN W-OF-ANY-STATE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CURRENT-ACL2-WORLD is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN EV-FNCALL ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GUARD-CHECKING-ON is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::SAFE-MODE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN TRANSLATE11-ERROR ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::TRANSLATE-ERROR-DEPTH is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling translate.o.
> Loading translate.o
> start address -T 0xa287fa0 Finished loading translate.o
> Loading type-set-a.lisp
> Finished loading type-set-a.lisp
> ;; Compiling type-set-a.lisp.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling type-set-a.o.
> Loading type-set-a.o
> start address -T 0xa220220 Finished loading type-set-a.o
> Loading linear-a.lisp
> Finished loading linear-a.lisp
> ;; Compiling linear-a.lisp.
> ; (DEFUN ACCUMULATE-TTREE-INTO-STATE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::ACCUMULATED-TTREE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling linear-a.o.
> Loading linear-a.o
> start address -T 0xa2aa200 Finished loading linear-a.o
> Loading type-set-b.lisp
> Finished loading type-set-b.lisp
> ;; Compiling type-set-b.lisp.
> ; (DEFUN PUSH-ACCP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-NAME is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-INPUT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-OUTPUT is undefined.
> ;; The compiler will assume this variable is a global.
> [GC for 30000 ARRAY pages..(T=66).GC finished]
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling type-set-b.o.
> Loading type-set-b.o
> start address -T 0xa6c5000 Finished loading type-set-b.o
> Loading linear-b.lisp
> Finished loading linear-b.lisp
> ;; Compiling linear-b.lisp.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling linear-b.o.
> Loading linear-b.o
> start address -T 0xa283240 Finished loading linear-b.o
> Loading non-linear.lisp
> Finished loading non-linear.lisp
> ;; Compiling non-linear.lisp.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling non-linear.o.
> Loading non-linear.o
> start address -T 0xa2707c0 Finished loading non-linear.o
> Loading rewrite.lisp
> Finished loading rewrite.lisp
> ;; Compiling rewrite.lisp.
> ; (DEFUN RESTORE-BRR-GLOBALS ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-INPUT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-OUTPUT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::BRR-MONITORED-RUNES is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::BRR-STACK is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::BRR-GSTACK is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::BRR-ALIST is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::BRR-TERM-EVISC-TUPLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN GET-BRR-GLOBAL ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WORMHOLE-NAME is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN INITIALIZE-BRR-STACK ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GSTACKP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN FREE-VARS-DISPLAY-LIMIT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::FREE-VARS-DISPLAY-LIMIT is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN STUFF-STANDARD-OI ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-PRE-EVAL-PRINT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::STANDARD-OI is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN RAW-MODE-P ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::ACL2-RAW-MODE-P is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DEFUN-MODE-PROMPT-STRING ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GUARD-CHECKING-ON is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN BRR-PROMPT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CURRENT-PACKAGE is undefined.
> ;; The compiler will assume this variable is a global.
> [GC for 30000 ARRAY pages..(T=65).GC finished]
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling rewrite.o.
> Loading rewrite.o
> start address -T 0xa7129e0 Finished loading rewrite.o
> Loading simplify.lisp
> Finished loading simplify.lisp
> ;; Compiling simplify.lisp.
> ; (DEFUN SETUP-SIMPLIFY-CLAUSE-POT-LST1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GSTACKP is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling simplify.o.
> Loading simplify.o
> start address -T 0xa6eb660 Finished loading simplify.o
> Loading bdd.lisp
> Finished loading bdd.lisp
> ;; Compiling bdd.lisp.
> ; (DEFUN IF-HT-MAX-LENGTH ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::IF-HT-MAX-LENGTH is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN OP-HT-MAX-LENGTH ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::OP-HT-MAX-LENGTH is undefined.
> ;; The compiler will assume this variable is a global.
> [GC for 100000 CONS pages..(T=69).GC finished]
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling bdd.o.
> Loading bdd.o
> start address -T 0xa757f20 Finished loading bdd.o
> Loading other-processes.lisp
> Finished loading other-processes.lisp
> ;; Compiling other-processes.lisp.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling other-processes.o.
> Loading other-processes.o
> start address -T 0xa791060 Finished loading other-processes.o
> Loading induct.lisp
> Finished loading induct.lisp
> ;; Compiling induct.lisp.
> ; (DEFUN INDUCT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling induct.o.
> Loading induct.o
> start address -T 0xa776fc0 Finished loading induct.o
> Loading history-management.lisp
> Finished loading history-management.lisp
> ;; Compiling history-management.lisp.
> ; (DEFUN START-PROOF-TREE-FN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::CHECKPOINT-PROCESSORS is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::CHECKPOINT-FORCED-GOALS is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE-BUFFER-WIDTH is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE-INDENT is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-PROOF-TREE-CTX ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::FMT-HARD-RIGHT-MARGIN is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::FMT-SOFT-RIGHT-MARGIN is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-PROOF-TREE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE-CTX is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-REDEFINITION-WARNING ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-REDEFINITION-ACTION is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN INITIALIZE-SUMMARY-ACCUMULATORS ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::ACCUMULATED-TTREE is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-REVERSED is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-RULES-SUMMARY ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-LDD ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-BASE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN ACL2-QUERY1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INFIXP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DEFLABEL-FN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-P is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DOC-PREFIX ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::DOC-PREFIX is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN SAVE-MORE-DOC-STATE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::MORE-DOC-STATE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN SET-DOC-CHAR-SUBST-TABLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::DOC-CHAR-SUBST-TABLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DOC-FMT-ALIST ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::DOC-FMT-ALIST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DOC-MARKUP-TABLE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::DOC-MARKUP-TABLE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN BAR-SEP-P ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::BAR-SEP-P is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-DOC-STRING-PART1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::MORE-DOC-MIN-LINES is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::MORE-DOC-MAX-LINES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PRINT-DOC ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-DOC-START-COLUMN is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN DOC-FN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::LD-KEYWORD-ALIASES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN HELP-FN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::ACL2-VERSION is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WALKABOUT1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::WALKABOUT-ALIST is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN SHOW-BDD-TERM ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::BDDNOTES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN TRANSLATE-IN-THEORY-HINT ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GUARD-CHECKING-ON is undefined.
> ;; The compiler will assume this variable is a global.
> [GC for 30000 ARRAY pages..(T=67).GC finished]
> [GC for 162994 RELOCATABLE-BLOCKS pages..(T=55).GC finished]
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling history-management.o.
> Loading history-management.o
> start address -T 0xa7b7880 Finished loading history-management.o
> Loading prove.lisp
> Finished loading prove.lisp
> ;; Compiling prove.lisp.
> ; (DEFUN EXPAND-ABBREVIATIONS ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GSTACKP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN EXTEND-PROOF-TREE-FOR-FORCING-ROUND ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN INITIALIZE-PROOF-TREE1 ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE-CTX is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN INITIALIZE-PROOF-TREE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WATERFALL-STEP ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::BDDNOTES is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN WATERFALL-PRINT-CLAUSE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-CLAUSE-IDS is undefined.
> ;; The compiler will assume this variable is a global.
> ; (DEFUN PROVE ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::GUARD-CHECKING-ON is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::IN-PROVE-FLG is undefined.
> ;; The compiler will assume this variable is a global.
> ;; End of Pass 1.  
> ;; End of Pass 2.  
> ;; OPTIMIZE levels: Safety=0 (No runtime error checking), Space=0, Speed=3, 
> (Debug quality ignored)
> ;; Finished compiling prove.o.
> Loading prove.o
> start address -T 0xa894ba0 Finished loading prove.o
> Loading defuns.lisp
> Finished loading defuns.lisp
> ;; Compiling defuns.lisp.
> ; (DEFUN PROVE-TERMINATION ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::INHIBIT-OUTPUT-LST is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::WINDOW-INTERFACEP is undefined.
> ;; The compiler will assume this variable is a global.
> [GC for 100000 CONS pages..(T=64).GC finished]
> ; (DEFUN VERIFY-GUARDS-FN ...) is being compiled.
> ;; The variable ACL2_GLOBAL_ACL2::SAVED-OUTPUT-P is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PROOF-TREE-CTX is undefined.
> ;; The compiler will assume this variable is a global.
> ;; The variable ACL2_GLOBAL_ACL2::PRINT-BASE is undefined.
> ;; The compiler will assume this variable is a global.
>   1> 
> Raw Lisp Break.
> Break
> 
> Broken at SYSTEM::CLCS-BREAK-LEVEL.  Type :H for Help.
>  1 (Continue) Return from BREAK.
>  2 Retry compiling file #P"defuns.lisp".
>  3 Return to top level.
> dbl:ACL2>>:bt
> 
> #0   CLCS-BREAK-LEVEL 
> {loc0=#<simple-condition.0>,loc1=nil,loc2=nil,loc3=t,loc4=t,loc5=condition,loc6=...}
>  [ihs=32]
> #1   APPLY {loc0=#<compiled-function 
> system::clcs-break-level>,loc1=(#<simple-condition.0>)} [ihs=31]
> #2   APPLY {loc0=#<compiled-function 
> system::clcs-break-level>,loc1=(#<simple-condition.0>)} [ihs=30]
> #3   INVOKE-DEBUGGER 
> {loc0=#<simple-condition.0>,loc1=nil,loc2=#<simple-condition.0>} [ihs=28]
> #4   BREAK {loc0=(nil),loc1=(#<@123FF320> 
> nil),loc2=((#<conditions:restart.1>) (#<condition...} [ihs=27]
> #5   TRACE-CALL {loc0=nil,loc1=nil,loc2=nil} [ihs=25]
> #6   T1EXPR {(defun chk-acceptable-defuns (lst ctx wrld ...) ...)=nil,} 
> [ihs=24]
> #7   COMPILE-FILE1 
> {loc0=#P"defuns.lisp",loc1=#P"defuns.o",loc2=t,loc3=nil,loc4=nil,loc5=nil,loc6=n...}
>  [ihs=23]
> #8   CLCS-COMPILE-FILE {loc0=(#P"defuns.lisp"),loc1=nil,loc2=(nil 
> #P"defuns.lisp"),loc3=(#<@16934778> n...} [ihs=22]
> #9   APPLY {loc0=#<compiled-function 
> conditions::clcs-compile-file>,loc1=(#P"defuns.lisp")} [ihs=21]
> #10   APPLY {loc0=#<compiled-function 
> conditions::clcs-compile-file>,loc1=(#P"defuns.lisp")} [ihs=20]
> #11  Computing args for  VALUES {} [ihs=19]
> #12   EVAL {loc0=nil,loc1=nil,loc2=nil,loc3=#<interpreted-function 
> (lisp:lambda-block compi...} [ihs=6]
> #13   TOP-LEVEL {loc0=((when system::tmp (# # #) 
> ...)),loc1=#<compiled-function format>,loc2=nil...} [ihs=5]
> #14   FUNCALL {loc0=#<compiled-function system:top-level>} [ihs=4]
> NIL
> dbl:ACL2>>:r
> NIL
> [GC for 30000 ARRAY pages..(T=65).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 162969 RELOCATABLE-BLOCKS pages..(T=54).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 162154 RELOCATABLE-BLOCKS pages..(T=49).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 162154 RELOCATABLE-BLOCKS pages..(T=48).GC finished]
> [GC for 30000 ARRAY pages..(T=61).GC finished]
> [GC for 30000 ARRAY pages..(T=61).GC finished]
> [GC for 30000 ARRAY pages..(T=59).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 162154 RELOCATABLE-BLOCKS pages..(T=48).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> [GC for 30000 ARRAY pages..(T=60).GC finished]
> 
> Raw Lisp Break.
> Console interrupt.
> 
> Broken at SYSTEM::CLCS-BREAK-LEVEL.  Type :H for Help.
>  1 (Continue) Continues execution.
>  2 Retry compiling file #P"defuns.lisp".
>  3 Return to top level.
> dbl:ACL2>>; interrupted after 5 minutes
> ;  I have let it run here 12 hours!!!!!!!!!
> :bt
> 
> #0   CLCS-BREAK-LEVEL 
> {loc0=#<conditions:simple-error.3>,loc1=error,loc2=nil,loc3=t,loc4=t,loc5=condit...}
>  [ihs=481]
> #1   APPLY {loc0=#<compiled-function 
> system::clcs-break-level>,loc1=(#<conditions:simple-er...} [ihs=480]
> #2   APPLY {loc0=#<compiled-function 
> system::clcs-break-level>,loc1=(#<conditions:simple-er...} [ihs=479]
> #3   INVOKE-DEBUGGER 
> {loc0=#<conditions:simple-error.3>,loc1=nil,loc2=#<conditions:simple-error.3>}
>  [ihs=477]
> #4   ERROR {loc0="Console interrupt.",loc1=nil} [ihs=476]
> #5   CERROR {loc0="Continues execution.",loc1="Console interrupt.",loc2=(nil 
> nil "Continues ...} [ihs=475]
> #6   CLCS-TERMINAL-INTERRUPT {loc0=t} [ihs=474]
> #7   C1FMLA {loc0=(eq symbol-class 
> :common-lisp-compliant),loc1=#S(compiler::info type t ......} [ihs=473]
> #8   C1SYMBOL-FUN {loc0=if,loc1=((eq symbol-class :common-lisp-compliant) 
> (er-progn (# # # ...) (#...} [ihs=472]
> #9   C1EXPR {loc0=(if (eq symbol-class :common-lisp-compliant) (er-progn (# # 
> # ...) (# # # ...} [ihs=471]
> #10   C1EXPR* {loc0=(if (eq symbol-class :common-lisp-compliant) (er-progn (# 
> # # ...) (# # # ...} [ihs=470]
> #11   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=469]
> #12   C1EXPR {loc0=(multiple-value-bind 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=468]
> #13   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-use...} [ihs=467]
> #14   C1EXPR {loc0=(mv-let (er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-els...} [ihs=466]
> #15   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (mv-let (# # #) (# # # ...) ...} [ihs=465]
> #16   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (mv-let (# # #) 
> (# # # ...) ...))} [ihs=464]
> #17   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=463]
> #18   C1EXPR {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=462]
> #19   C1EXPR* {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=461]
> #20   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp 
> #1=(mv er-progn-not-to-be-u...} [ihs=460]
> #21   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=459]
> #22   C1PROGN {loc0=((if er-progn-not-to-be-used-elsewhere-erp #1=(# # # ...) 
> ...)),loc1=t} [ihs=458]
> #23   C1DECL-BODY {loc0=nil,loc1=((if er-progn-not-to-be-used-elsewhere-erp 
> #1=(# # # ...) ...)),l...} [ihs=457]
> #24   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=456]
> #25   C1EXPR {loc0=(multiple-value-bind 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=455]
> #26   C1SYMBOL-FUN 
> {loc0=mv-let,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-...} [ihs=454]
> #27   C1EXPR {loc0=(mv-let #1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-...} [ihs=453]
> #28   C1SYMBOL-FUN {loc0=er-progn,loc1=((if (# # #) (# # #) ...) (if (# # #) 
> (# # #) ...) (mv-let (...} [ihs=452]
> #29   C1EXPR {loc0=(er-progn (if (# # #) (# # #) ...) (if (# # #) (# # #) 
> ...) ...)} [ihs=451]
> #30   C1PROGN {loc0=((er-progn (# # # ...) (# # # ...) ...)),loc1=t} [ihs=450]
> #31   C1DECL-BODY {loc0=nil,loc1=((er-progn (# # # ...) (# # # ...) 
> ...)),loc2=nil,loc3=t,loc4=t,l...} [ihs=449]
> #32   C1SYMBOL-FUN {loc0=let*,loc1=(((# #) (# #)) (er-progn (# # # ...) (# # 
> # ...) ...)),loc2=(((#...} [ihs=448]
> #33   C1EXPR {loc0=(let* ((# #) (# #)) (er-progn (# # # ...) (# # # ...) 
> ...))} [ihs=447]
> #34   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) (let* 
> (# #) (# # # ...))),lo...} [ihs=446]
> #35   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (let* (# #) (# # 
> # ...)))} [ihs=445]
> #36   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=444]
> #37   C1EXPR {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=443]
> #38   C1EXPR* {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=442]
> #39   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used...} [ihs=441]
> #40   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=440]
> #41   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=439]
> #42   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp (# # # ...) 
> ...)),loc1=#S(compi...} [ihs=438]
> #43   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhere-...} [ihs=437]
> #44   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=436]
> #45   C1EXPR {loc0=(multiple-value-bind 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=435]
> #46   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-use...} [ihs=434]
> #47   C1EXPR {loc0=(mv-let (er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-els...} [ihs=433]
> #48   C1SYMBOL-FUN {loc0=er-progn,loc1=((if assumep (# #) ...) (let* (# #) (# 
> # # ...))),loc2=#<com...} [ihs=432]
> #49   C1EXPR {loc0=(er-progn (if assumep (# #) ...) (let* (# #) (# # # 
> ...)))} [ihs=431]
> #50   C1PROGN {loc0=((er-progn (# # # ...) (# # #))),loc1=t} [ihs=430]
> #51   C1DECL-BODY {loc0=nil,loc1=((er-progn (# # # ...) (# # 
> #))),loc2=nil,loc3=t,loc4=t,loc5=-1,l...} [ihs=429]
> #52   C1SYMBOL-FUN {loc0=let*,loc1=(((# #) (# #)) (er-progn (# # # ...) (# # 
> #))),loc2=(((# #) (# #...} [ihs=428]
> #53   C1EXPR {loc0=(let* ((# #) (# #)) (er-progn (# # # ...) (# # #)))} 
> [ihs=427]
> #54   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) (let* 
> (# #) (# # #))),loc2=#...} [ihs=426]
> #55   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (let* (# #) (# # 
> #)))} [ihs=425]
> #56   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-let-star-use-nowhere-else) (let* (# #) (# 
> # ...} [ihs=424]
> #57   C1EXPR {loc0=(check-vars-not-free (er-let-star-use-nowhere-else) (let* 
> (# #) (# # #)))} [ihs=423]
> #58   C1SYMBOL-FUN {loc0=er-let*,loc1=(nil (let* (# #) (# # 
> #))),loc2=#<compiled-function er-let*>,...} [ihs=422]
> #59   C1EXPR {loc0=(er-let* nil (let* (# #) (# # #)))} [ihs=421]
> #60   C1EXPR* {loc0=(er-let* nil (let* (# #) (# # #))),loc1=#S(compiler::info 
> type t ...)} [ihs=420]
> #61   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else bod...} [ihs=419]
> #62   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else bodies-a...} [ihs=418]
> #63   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=417]
> #64   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=416]
> #65   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=415]
> #66   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=414]
> #67   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> bodies-and-bindings state) (translate-bodie...} [ihs=413]
> #68   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else 
> bodies-and-binding...} [ihs=412]
> #69   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> bodies-and-bindings sta...} [ihs=411]
> #70   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> bodies-and-bindings state) (tra...} [ihs=410]
> #71   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else bodies-and-bindings 
> state) (translat...} [ihs=409]
> #72   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #)) (let* (# #) (# # 
> #))),loc2=#<compiled-function er-le...} [ihs=408]
> #73   C1EXPR {loc0=(er-let* ((# #)) (let* (# #) (# # #)))} [ihs=407]
> #74   C1EXPR* {loc0=(er-let* ((# #)) (let* (# #) (# # 
> #))),loc1=#S(compiler::info type t ...)} [ihs=406]
> #75   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrl...} [ihs=405]
> #76   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrld2 .....} [ihs=404]
> #77   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=403]
> #78   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=402]
> #79   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=401]
> #80   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=400]
> #81   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> wrld2 state) (update-w big-mutrec (# # # .....} [ihs=399]
> #82   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else wrld2 state) 
> (upda...} [ihs=398]
> #83   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else wrld2 
> state) (update-w ...} [ihs=397]
> #84   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else wrld2 
> state) (update-w big-mutr...} [ihs=396]
> #85   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else wrld2 state) 
> (update-w big-mutrec (#...} [ihs=395]
> #86   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #)) (let* (# #) (# # 
> #))),loc2=#<compiled-function...} [ihs=394]
> #87   C1EXPR {loc0=(er-let* ((# #) (# #)) (let* (# #) (# # #)))} [ihs=393]
> #88   C1EXPR* {loc0=(er-let* ((# #) (# #)) (let* (# #) (# # 
> #))),loc1=#S(compiler::info type t...} [ihs=392]
> #89   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrl...} [ihs=391]
> #90   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrld1 .....} [ihs=390]
> #91   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=389]
> #92   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=388]
> #93   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=387]
> #94   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=386]
> #95   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> wrld1 state) (update-w big-mutrec (# # # .....} [ihs=385]
> #96   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else wrld1 state) 
> (upda...} [ihs=384]
> #97   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else wrld1 
> state) (update-w ...} [ihs=383]
> #98   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else wrld1 
> state) (update-w big-mutr...} [ihs=382]
> #99   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else wrld1 state) 
> (update-w big-mutrec (#...} [ihs=381]
> #100   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #)) (let* (# #) (# # 
> #))),loc2=#<compiled-fu...} [ihs=380]
> #101   C1EXPR {loc0=(er-let* ((# #) (# #) (# #)) (let* (# #) (# # #)))} 
> [ihs=379]
> #102   C1PROGN {loc0=((er-let* (# # #) (# # #))),loc1=t} [ihs=378]
> #103   C1DECL-BODY {loc0=nil,loc1=((er-let* (# # #) (# # 
> #))),loc2=nil,loc3=t,loc4=t,loc5=6,loc6=t,...} [ihs=377]
> #104   C1SYMBOL-FUN {loc0=let,loc1=(((# #) (# #)) (er-let* (# # #) (# # 
> #))),loc2=(((# #) (# #)) (er...} [ihs=376]
> #105   C1EXPR {loc0=(let ((# #) (# #)) (er-let* (# # #) (# # #)))} [ihs=375]
> #106   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) (let 
> (# #) (# # #))),loc2=#<...} [ihs=374]
> #107   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (let (# #) (# # 
> #)))} [ihs=373]
> #108   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=372]
> #109   C1EXPR {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=371]
> #110   C1EXPR* {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=370]
> #111   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used...} [ihs=369]
> #112   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=368]
> #113   C1PROGN {loc0=((if er-progn-not-to-be-used-elsewhere-erp (# # # ...) 
> ...)),loc1=t} [ihs=367]
> #114   C1DECL-BODY {loc0=nil,loc1=((if er-progn-not-to-be-used-elsewhere-erp 
> (# # # ...) ...)),loc2...} [ihs=366]
> #115   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=365]
> #116   C1EXPR {loc0=(multiple-value-bind 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=364]
> #117   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-use...} [ihs=363]
> #118   C1EXPR {loc0=(mv-let (er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-els...} [ihs=362]
> #119   C1SYMBOL-FUN {loc0=er-progn,loc1=((cond (# #) (# #)) (let (# #) (# # 
> #))),loc2=#<compiled-fun...} [ihs=361]
> #120   C1EXPR {loc0=(er-progn (cond (# #) (# #)) (let (# #) (# # #)))} 
> [ihs=360]
> #121   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (er-progn (# # #) (# # #))),...} [ihs=359]
> #122   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (er-progn (# # 
> #) (# # #)))} [ihs=358]
> #123   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-let-star-use-nowhere-else) (er-progn (# # 
> #)...} [ihs=357]
> #124   C1EXPR {loc0=(check-vars-not-free (er-let-star-use-nowhere-else) 
> (er-progn (# # #) (# #...} [ihs=356]
> #125   C1SYMBOL-FUN {loc0=er-let*,loc1=(nil (er-progn (# # #) (# # 
> #))),loc2=#<compiled-function er-...} [ihs=355]
> #126   C1EXPR {loc0=(er-let* nil (er-progn (# # #) (# # #)))} [ihs=354]
> #127   C1EXPR* {loc0=(er-let* nil (er-progn (# # #) (# # 
> #))),loc1=#S(compiler::info type t ......} [ihs=353]
> #128   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else nor...} [ihs=352]
> #129   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else normaliz...} [ihs=351]
> #130   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=350]
> #131   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=349]
> #132   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=348]
> #133   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type t ...),...} [ihs=347]
> #134   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else normalizeps 
> state)...} [ihs=346]
> #135   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> normalizeps state) (get...} [ihs=345]
> #136   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> normalizeps state) (get-normali...} [ihs=344]
> #137   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else normalizeps state) 
> (get-normalizeps ...} [ihs=343]
> #138   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #)) (er-progn (# # #) (# # 
> #))),loc2=#<compiled-function...} [ihs=342]
> #139   C1EXPR {loc0=(er-let* ((# #)) (er-progn (# # #) (# # #)))} [ihs=341]
> #140   C1EXPR* {loc0=(er-let* ((# #)) (er-progn (# # #) (# # 
> #))),loc1=#S(compiler::info type t...} [ihs=340]
> #141   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else otf...} [ihs=339]
> #142   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else otf-flg ...} [ihs=338]
> #143   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=337]
> #144   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=336]
> #145   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=335]
> #146   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type t ...),...} [ihs=334]
> #147   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else otf-flg state) 
> (if...} [ihs=333]
> #148   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> otf-flg state) (if do-n...} [ihs=332]
> #149   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else otf-flg 
> state) (if do-not-trans...} [ihs=331]
> #150   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else otf-flg state) (if 
> do-not-translate-...} [ihs=330]
> #151   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #)) (er-progn (# # #) (# # 
> #))),loc2=#<compiled-fu...} [ihs=329]
> #152   C1EXPR {loc0=(er-let* ((# #) (# #)) (er-progn (# # #) (# # #)))} 
> [ihs=328]
> #153   C1EXPR* {loc0=(er-let* ((# #) (# #)) (er-progn (# # #) (# # 
> #))),loc1=#S(compiler::info ...} [ihs=327]
> #154   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else std...} [ihs=326]
> #155   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else std-hint...} [ihs=325]
> #156   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=324]
> #157   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=323]
> #158   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=322]
> #159   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type (values...} [ihs=321]
> #160   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else std-hints 
> state) (...} [ihs=320]
> #161   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> std-hints state) (value...} [ihs=319]
> #162   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> std-hints state) (value nil) (c...} [ihs=318]
> #163   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else std-hints state) 
> (value nil) ...)} [ihs=317]
> #164   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #)) (er-progn (# # #) 
> (# # #))),loc2=#<compi...} [ihs=316]
> #165   C1EXPR {loc0=(er-let* ((# #) (# #) (# #)) (er-progn (# # #) (# # #)))} 
> [ihs=315]
> #166   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #)) (er-progn (# # #) (# # 
> #))),loc1=#S(compiler:...} [ihs=314]
> #167   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else gua...} [ihs=313]
> #168   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else guard-hi...} [ihs=312]
> #169   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=311]
> #170   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=310]
> #171   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=309]
> #172   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=308]
> #173   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> guard-hints state) (if (# # #) (# #) ...) (...} [ihs=307]
> #174   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else guard-hints 
> state)...} [ihs=306]
> #175   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> guard-hints state) (if ...} [ihs=305]
> #176   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> guard-hints state) (if (# # #) ...} [ihs=304]
> #177   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else guard-hints state) 
> (if (# # #) (# #)...} [ihs=303]
> #178   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=302]
> #179   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=301]
> #180   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=300]
> #181   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else hin...} [ihs=299]
> #182   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else hints .....} [ihs=298]
> #183   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=297]
> #184   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=296]
> #185   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=295]
> #186   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=294]
> #187   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> hints state) (if (# # #) (# #) ...) (cond (...} [ihs=293]
> #188   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else hints state) 
> (if (...} [ihs=292]
> #189   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else hints 
> state) (if (# # #...} [ihs=291]
> #190   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else hints 
> state) (if (# # #) (# #) ...} [ihs=290]
> #191   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else hints state) (if (# 
> # #) (# #) ...) ...} [ihs=289]
> #192   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=288]
> #193   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=287]
> #194   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=286]
> #195   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else rel...} [ihs=285]
> #196   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else rel ...)...} [ihs=284]
> #197   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=283]
> #198   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=282]
> #199   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=281]
> #200   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=280]
> #201   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> rel state) (get-unambiguous-xargs-flg :well...} [ihs=279]
> #202   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else rel state) 
> (get-un...} [ihs=278]
> #203   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else rel 
> state) (get-unambig...} [ihs=277]
> #204   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else rel 
> state) (get-unambiguous-xar...} [ihs=276]
> #205   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else rel state) 
> (get-unambiguous-xargs-fl...} [ihs=275]
> #206   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=274]
> #207   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=273]
> #208   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=272]
> #209   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else mea...} [ihs=271]
> #210   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else measures...} [ihs=270]
> #211   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=269]
> #212   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=268]
> #213   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=267]
> #214   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type t ...),...} [ihs=266]
> #215   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else measures state) 
> (t...} [ihs=265]
> #216   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> measures state) (transl...} [ihs=264]
> #217   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else measures 
> state) (translate-term...} [ihs=263]
> #218   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else measures state) 
> (translate-term-lst ...} [ihs=262]
> #219   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=261]
> #220   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=260]
> #221   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=259]
> #222   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else unt...} [ihs=258]
> #223   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else untransl...} [ihs=257]
> #224   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=256]
> #225   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=255]
> #226   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=254]
> #227   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type t ...),...} [ihs=253]
> #228   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else 
> untranslated-measu...} [ihs=252]
> #229   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> untranslated-measures s...} [ihs=251]
> #230   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> untranslated-measures state) (g...} [ihs=250]
> #231   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else 
> untranslated-measures state) (get-me...} [ihs=249]
> #232   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=248]
> #233   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=247]
> #234   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=246]
> #235   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else doc...} [ihs=245]
> #236   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else doc-pair...} [ihs=244]
> #237   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=243]
> #238   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=242]
> #239   C1PROGN {loc0=((cond (# #) (# #))),loc1=t} [ihs=241]
> #240   C1DECL-BODY {loc0=nil,loc1=((cond (# #) (# 
> #))),loc2=nil,loc3=#S(compiler::info type t ...),...} [ihs=240]
> #241   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else doc-pairs 
> state) (...} [ihs=239]
> #242   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> doc-pairs state) (trans...} [ihs=238]
> #243   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> doc-pairs state) (translate-doc...} [ihs=237]
> #244   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else doc-pairs state) 
> (translate-doc-lst ...} [ihs=236]
> #245   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=235]
> #246   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=234]
> #247   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=233]
> #248   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrl...} [ihs=232]
> #249   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else wrld0 .....} [ihs=231]
> #250   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=230]
> #251   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=229]
> #252   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=228]
> #253   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=227]
> #254   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> wrld0 state) (chk-just-new-names names (# #...} [ihs=226]
> #255   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else wrld0 state) 
> (chk-...} [ihs=225]
> #256   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else wrld0 
> state) (chk-just-...} [ihs=224]
> #257   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else wrld0 
> state) (chk-just-new-name...} [ihs=223]
> #258   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else wrld0 state) 
> (chk-just-new-names nam...} [ihs=222]
> #259   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # #) (# # #))),loc2=#<c...} [ihs=221]
> #260   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #)))} [ihs=220]
> #261   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # #) (# # 
> #))),loc1=#S(compi...} [ihs=219]
> #262   C1SYMBOL-FUN {loc0=if,loc1=((eq rc (# #)) (let (#) (# # # ...)) 
> (er-let* (# # # ...) (# # #))...} [ihs=218]
> #263   C1EXPR {loc0=(if (eq rc (# #)) (let (#) (# # # ...)) ...)} [ihs=217]
> #264   C1EXPR* {loc0=(if (eq rc (# #)) (let (#) (# # # ...)) 
> ...),loc1=#S(compiler::info type t...} [ihs=216]
> #265   C1SYMBOL-FUN {loc0=if,loc1=((eq rc (# #)) (value (# #)) (if (# # #) (# 
> # #) ...)),loc2=((eq r...} [ihs=215]
> #266   C1EXPR {loc0=(if (eq rc (# #)) (value (# #)) ...)} [ihs=214]
> #267   C1SYMBOL-FUN {loc0=cond,loc1=(((# # #) (# #)) ((# # #) (# # #)) (t (# 
> # #))),loc2=#<compiled-...} [ihs=213]
> #268   C1EXPR {loc0=(cond ((# # #) (# #)) ((# # #) (# # #)) ...)} [ihs=212]
> #269   C1EXPR* {loc0=(cond ((# # #) (# #)) ((# # #) (# # #)) 
> ...),loc1=#S(compiler::info type t...} [ihs=211]
> #270   C1ARGS {loc0=((cond (# #) (# #) ...)),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=210]
> #271   DECLARE-LET-BINDINGS-NEW1 {loc0=(((# #) (# #)) (cond (# #) (# #) 
> ...)),loc1=t,loc2=nil,loc3=2,loc4=#(),loc...} [ihs=209]
> #272   C1SYMBOL-FUN {loc0=let*,loc1=(((# #) (# #)) (cond (# #) (# #) 
> ...)),loc2=(((# #) (# #)) (cond...} [ihs=208]
> #273   C1EXPR {loc0=(let* ((# #) (# #)) (cond (# #) (# #) ...))} [ihs=207]
> #274   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) (let* 
> (# #) (# # # ...))),lo...} [ihs=206]
> #275   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (let* (# #) (# # 
> # ...)))} [ihs=205]
> #276   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=204]
> #277   C1EXPR {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=203]
> #278   C1EXPR* {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=202]
> #279   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used...} [ihs=201]
> #280   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=200]
> #281   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=199]
> #282   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp (# # # ...) 
> ...)),loc1=#S(compi...} [ihs=198]
> #283   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhere-...} [ihs=197]
> #284   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=196]
> #285   C1EXPR {loc0=(multiple-value-bind 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=195]
> #286   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-use...} [ihs=194]
> #287   C1EXPR {loc0=(mv-let (er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-els...} [ihs=193]
> #288   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (mv-let (# # #) (# # # ...) ...} [ihs=192]
> #289   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (mv-let (# # #) 
> (# # # ...) ...))} [ihs=191]
> #290   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=190]
> #291   C1EXPR {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=189]
> #292   C1EXPR* {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=188]
> #293   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp 
> #1=(mv er-progn-not-to-be-u...} [ihs=187]
> #294   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=186]
> #295   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=185]
> #296   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp #1=(# # # ...) 
> ...)),loc1=#S(co...} [ihs=184]
> #297   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhe...} [ihs=183]
> #298   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=182]
> #299   C1EXPR {loc0=(multiple-value-bind 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=181]
> #300   C1SYMBOL-FUN 
> {loc0=mv-let,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-...} [ihs=180]
> #301   C1EXPR {loc0=(mv-let #1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-...} [ihs=179]
> #302   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (mv-let #2=(# # #) (# # # .....} [ihs=178]
> #303   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (mv-let #2=(# # 
> #) (# # # ...) .....} [ihs=177]
> #304   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=176]
> #305   C1EXPR {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=175]
> #306   C1EXPR* {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=174]
> #307   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp 
> #1=(mv er-progn-not-to-be-u...} [ihs=173]
> #308   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=172]
> #309   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=171]
> #310   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp #1=(# # # ...) 
> ...)),loc1=#S(co...} [ihs=170]
> #311   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhe...} [ihs=169]
> #312   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=168]
> #313   C1EXPR {loc0=(multiple-value-bind 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=167]
> #314   C1SYMBOL-FUN 
> {loc0=mv-let,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-...} [ihs=166]
> #315   C1EXPR {loc0=(mv-let #1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-...} [ihs=165]
> #316   C1SYMBOL-FUN {loc0=er-progn,loc1=((chk-defun-mode defun-mode names 
> ...) (cond (# #) (# #) ......} [ihs=164]
> #317   C1EXPR {loc0=(er-progn (chk-defun-mode defun-mode names ...) (cond (# 
> #) (# #) ...) ......} [ihs=163]
> #318   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (er-progn (# # # ...) (# # #...} [ihs=162]
> #319   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (er-progn (# # # 
> ...) (# # # ...)...} [ihs=161]
> #320   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-let-star-use-nowhere-else) (er-progn (# # 
> # ...} [ihs=160]
> #321   C1EXPR {loc0=(check-vars-not-free (er-let-star-use-nowhere-else) 
> (er-progn (# # # ...) ...} [ihs=159]
> #322   C1SYMBOL-FUN {loc0=er-let*,loc1=(nil (er-progn (# # # ...) (# # # ...) 
> ...)),loc2=#<compiled-...} [ihs=158]
> #323   C1EXPR {loc0=(er-let* nil (er-progn (# # # ...) (# # # ...) ...))} 
> [ihs=157]
> #324   C1EXPR* {loc0=(er-let* nil (er-progn (# # # ...) (# # # ...) 
> ...)),loc1=#S(compiler::inf...} [ihs=156]
> #325   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else ver...} [ihs=155]
> #326   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else verify-g...} [ihs=154]
> #327   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=153]
> #328   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=152]
> #329   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=151]
> #330   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=150]
> #331   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> verify-guards state) (get-unambiguous-xargs...} [ihs=149]
> #332   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else verify-guards 
> stat...} [ihs=148]
> #333   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> verify-guards state) (g...} [ihs=147]
> #334   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> verify-guards state) (get-unamb...} [ihs=146]
> #335   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else verify-guards 
> state) (get-unambiguou...} [ihs=145]
> #336   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #)) (er-progn (# # # ...) (# # # 
> ...) ...)),loc2=#<compi...} [ihs=144]
> #337   C1EXPR {loc0=(er-let* ((# #)) (er-progn (# # # ...) (# # # ...) ...))} 
> [ihs=143]
> #338   C1EXPR* {loc0=(er-let* ((# #)) (er-progn (# # # ...) (# # # ...) 
> ...)),loc1=#S(compiler:...} [ihs=142]
> #339   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else def...} [ihs=141]
> #340   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else defun-mo...} [ihs=140]
> #341   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=139]
> #342   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=138]
> #343   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=137]
> #344   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=136]
> #345   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> defun-mode state) (get-unambiguous-xargs-fl...} [ihs=135]
> #346   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else defun-mode 
> state) ...} [ihs=134]
> #347   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> defun-mode state) (get-...} [ihs=133]
> #348   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> defun-mode state) (get-unambigu...} [ihs=132]
> #349   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else defun-mode state) 
> (get-unambiguous-x...} [ihs=131]
> #350   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #)) (er-progn (# # # ...) 
> (# # # ...) ...)),loc2=#...} [ihs=130]
> #351   C1EXPR {loc0=(er-let* ((# #) (# #)) (er-progn (# # # ...) (# # # ...) 
> ...))} [ihs=129]
> #352   C1EXPR* {loc0=(er-let* ((# #) (# #)) (er-progn (# # # ...) (# # # ...) 
> ...)),loc1=#S(com...} [ihs=128]
> #353   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else non...} [ihs=127]
> #354   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else non-exec...} [ihs=126]
> #355   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=125]
> #356   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=124]
> #357   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=123]
> #358   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=122]
> #359   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> non-executablep state) (get-unambiguous-xar...} [ihs=121]
> #360   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else non-executablep 
> st...} [ihs=120]
> #361   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> non-executablep state) ...} [ihs=119]
> #362   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> non-executablep state) (get-una...} [ihs=118]
> #363   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else non-executablep 
> state) (get-unambigu...} [ihs=117]
> #364   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #)) (er-progn (# # # 
> ...) (# # # ...) ...)),...} [ihs=116]
> #365   C1EXPR {loc0=(er-let* ((# #) (# #) (# #)) (er-progn (# # # ...) (# # # 
> ...) ...))} [ihs=115]
> #366   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #)) (er-progn (# # # ...) (# # 
> # ...) ...)),loc1=...} [ihs=114]
> #367   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else gua...} [ihs=113]
> #368   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else guards ....} [ihs=112]
> #369   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=111]
> #370   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=110]
> #371   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=109]
> #372   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=108]
> #373   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> guards state) (translate-term-lst (# # #) (...} [ihs=107]
> #374   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else guards state) 
> (tra...} [ihs=106]
> #375   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else guards 
> state) (translat...} [ihs=105]
> #376   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else guards 
> state) (translate-term-l...} [ihs=104]
> #377   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else guards state) 
> (translate-term-lst (#...} [ihs=103]
> #378   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # # ...) (# # # ...) .....} [ihs=102]
> #379   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # # ...) (# 
> # # ...) ...))} [ihs=101]
> #380   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # # ...) 
> (# # # ...) ...)),l...} [ihs=100]
> #381   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else sto...} [ihs=99]
> #382   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else stobjs-i...} [ihs=98]
> #383   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=97]
> #384   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=96]
> #385   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=95]
> #386   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=94]
> #387   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> stobjs-in-lst state) (get-stobjs-in-lst fiv...} [ihs=93]
> #388   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else stobjs-in-lst 
> stat...} [ihs=92]
> #389   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else 
> stobjs-in-lst state) (g...} [ihs=91]
> #390   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else 
> stobjs-in-lst state) (get-stobj...} [ihs=90]
> #391   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else stobjs-in-lst 
> state) (get-stobjs-in-...} [ihs=89]
> #392   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #) (# #) (# #) ...) (er-progn (# 
> # # ...) (# # # ...) .....} [ihs=88]
> #393   C1EXPR {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # # ...) (# 
> # # ...) ...))} [ihs=87]
> #394   C1EXPR* {loc0=(er-let* ((# #) (# #) (# #) ...) (er-progn (# # # ...) 
> (# # # ...) ...)),l...} [ihs=86]
> #395   C1ARGS {loc0=((er-let* (# # # ...) (# # # 
> ...))),loc1=#S(compiler::info type t ...),loc...} [ihs=85]
> #396   DECLARE-LET-BINDINGS-NEW1 {loc0=(((# #) (# #) (# #) ...) (er-let* (# # 
> # ...) (# # # ...))),loc1=t,loc2=ni...} [ihs=84]
> #397   C1SYMBOL-FUN {loc0=let*,loc1=(((# #) (# #) (# #) ...) (er-let* (# # # 
> ...) (# # # ...))),loc2...} [ihs=83]
> #398   C1EXPR {loc0=(let* ((# #) (# #) (# #) ...) (er-let* (# # # ...) (# # # 
> ...)))} [ihs=82]
> #399   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) (let* 
> (# # # ...) (# # #))),...} [ihs=81]
> #400   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (let* (# # # 
> ...) (# # #)))} [ihs=80]
> #401   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=79]
> #402   C1EXPR {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=78]
> #403   C1EXPR* {loc0=(check-vars-not-free 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=77]
> #404   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used...} [ihs=76]
> #405   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=75]
> #406   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp (mv 
> er-progn-not-to-be-used-else...} [ihs=74]
> #407   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp (# # # ...) 
> ...)),loc1=#S(compi...} [ihs=73]
> #408   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhere-...} [ihs=72]
> #409   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-...} [ihs=71]
> #410   C1EXPR {loc0=(multiple-value-bind 
> (er-progn-not-to-be-used-elsewhere-erp er-progn-not-t...} [ihs=70]
> #411   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-use...} [ihs=69]
> #412   C1EXPR {loc0=(mv-let (er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-els...} [ihs=68]
> #413   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (mv-let (# # #) (# # # ...) ...} [ihs=67]
> #414   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (mv-let (# # #) 
> (# # # ...) ...))} [ihs=66]
> #415   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=65]
> #416   C1EXPR {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=64]
> #417   C1EXPR* {loc0=(check-vars-not-free 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=63]
> #418   C1SYMBOL-FUN {loc0=if,loc1=(er-progn-not-to-be-used-elsewhere-erp 
> #1=(mv er-progn-not-to-be-u...} [ihs=62]
> #419   C1EXPR {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=61]
> #420   C1EXPR* {loc0=(if er-progn-not-to-be-used-elsewhere-erp #1=(mv 
> er-progn-not-to-be-used-e...} [ihs=60]
> #421   C1ARGS {loc0=((if er-progn-not-to-be-used-elsewhere-erp #1=(# # # ...) 
> ...)),loc1=#S(co...} [ihs=59]
> #422   DECLARE-MULTIPLE-VALUE-BINDINGS 
> {loc0=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-elsewhe...} [ihs=58]
> #423   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-pro...} [ihs=57]
> #424   C1EXPR {loc0=(multiple-value-bind 
> #1=(er-progn-not-to-be-used-elsewhere-erp er-progn-no...} [ihs=56]
> #425   C1SYMBOL-FUN 
> {loc0=mv-let,loc1=(#1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-...} [ihs=55]
> #426   C1EXPR {loc0=(mv-let #1=(er-progn-not-to-be-used-elsewhere-erp 
> er-progn-not-to-be-used-...} [ihs=54]
> #427   C1SYMBOL-FUN {loc0=er-progn,loc1=((chk-no-duplicate-defuns (# #) ctx 
> ...) (chk-xargs-keywords...} [ihs=53]
> #428   C1EXPR {loc0=(er-progn (chk-no-duplicate-defuns (# #) ctx ...) 
> (chk-xargs-keywords five...} [ihs=52]
> #429   C1SYMBOL-FUN {loc0=translate-and-test,loc1=((lambda (#) (# # #)) 
> (er-progn (# # # ...) (# # #...} [ihs=51]
> #430   C1EXPR {loc0=(translate-and-test (lambda (#) (# # #)) (er-progn (# # # 
> ...) (# # # ...)...} [ihs=50]
> #431   C1SYMBOL-FUN 
> {loc0=check-vars-not-free,loc1=((er-let-star-use-nowhere-else) (er-progn (# # 
> # ...} [ihs=49]
> #432   C1EXPR {loc0=(check-vars-not-free (er-let-star-use-nowhere-else) 
> (er-progn (# # # ...) ...} [ihs=48]
> #433   C1SYMBOL-FUN {loc0=er-let*,loc1=(nil (er-progn (# # # ...) (# # # ...) 
> ...)),loc2=#<compiled-...} [ihs=47]
> #434   C1EXPR {loc0=(er-let* nil (er-progn (# # # ...) (# # # ...) ...))} 
> [ihs=46]
> #435   C1EXPR* {loc0=(er-let* nil (er-progn (# # # ...) (# # # ...) 
> ...)),loc1=#S(compiler::inf...} [ihs=45]
> #436   C1SYMBOL-FUN {loc0=if,loc1=(er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else fiv...} [ihs=44]
> #437   C1EXPR {loc0=(if er-let-star-use-nowhere-else (mv 
> er-let-star-use-nowhere-else fives .....} [ihs=43]
> #438   C1SYMBOL-FUN {loc0=cond,loc1=((er-let-star-use-nowhere-else (# # # 
> ...)) (t (# # #))),loc2=#<...} [ihs=42]
> #439   C1EXPR {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #)))} [ihs=41]
> #440   C1EXPR* {loc0=(cond (er-let-star-use-nowhere-else (# # # ...)) (t (# # 
> #))),loc1=#S(comp...} [ihs=40]
> #441   C1ARGS {loc0=((cond (# #) (# #))),loc1=#S(compiler::info type t 
> ...),loc2=(nil)} [ihs=39]
> #442   DECLARE-MULTIPLE-VALUE-BINDINGS {loc0=((er-let-star-use-nowhere-else 
> fives state) (chk-defuns-tuples lst ctx ......} [ihs=38]
> #443   C1SYMBOL-FUN 
> {loc0=multiple-value-bind,loc1=((er-let-star-use-nowhere-else fives state) 
> (chk-...} [ihs=37]
> #444   C1EXPR {loc0=(multiple-value-bind (er-let-star-use-nowhere-else fives 
> state) (chk-defun...} [ihs=36]
> #445   C1SYMBOL-FUN {loc0=mv-let,loc1=((er-let-star-use-nowhere-else fives 
> state) (chk-defuns-tuples...} [ihs=35]
> #446   C1EXPR {loc0=(mv-let (er-let-star-use-nowhere-else fives state) 
> (chk-defuns-tuples lst ...} [ihs=34]
> #447   C1SYMBOL-FUN {loc0=er-let*,loc1=(((# #)) (er-progn (# # # ...) (# # # 
> ...) ...)),loc2=#<compi...} [ihs=33]
> #448   C1EXPR {loc0=(er-let* ((# #)) (er-progn (# # # ...) (# # # ...) ...))} 
> [ihs=32]
> #449   C1PROGN {loc0=((er-let* (#) (# # # ...))),loc1=chk-acceptable-defuns} 
> [ihs=31]
> #450   C1SYMBOL-FUN {loc0=block,loc1=(chk-acceptable-defuns (er-let* (#) (# # 
> # ...))),loc2=(chk-acc...} [ihs=30]
> #451   C1EXPR {loc0=(block chk-acceptable-defuns (er-let* (#) (# # # ...)))} 
> [ihs=29]
> #452   C1PROGN {loc0=((block chk-acceptable-defuns (# # #))),loc1=t} [ihs=28]
> #453   C1DECL-BODY {loc0=nil,loc1=((block chk-acceptable-defuns (# # 
> #))),loc2=nil,loc3=nil,loc4=ni...} [ihs=27]
> #454   C1LAMBDA-EXPR {loc0=((lst ctx wrld ...) (er-let* (#) (# # # 
> ...))),loc1=chk-acceptable-defuns,...} [ihs=26]
> #455   TRACE-CALL {loc0=(defun chk-acceptable-defuns (lst ctx wrld ...) 
> ...),loc1="~S~%",loc2=nil,...} [ihs=25]
> #456   T1EXPR {(defun chk-acceptable-defuns (lst ctx wrld ...) ...)=nil,} 
> [ihs=24]
> #457   COMPILE-FILE1 
> {loc0=#P"defuns.lisp",loc1=#P"defuns.o",loc2=t,loc3=nil,loc4=nil,loc5=nil,loc6=n...}
>  [ihs=23]
> #458   CLCS-COMPILE-FILE {loc0=(#P"defuns.lisp"),loc1=nil,loc2=(nil 
> #P"defuns.lisp"),loc3=(#<@16934778> n...} [ihs=22]
> #459   APPLY {loc0=#<compiled-function 
> conditions::clcs-compile-file>,loc1=(#P"defuns.lisp")} [ihs=21]
> #460   APPLY {loc0=#<compiled-function 
> conditions::clcs-compile-file>,loc1=(#P"defuns.lisp")} [ihs=20]
> #461  Computing args for  VALUES {} [ihs=19]
> #462   EVAL {loc0=nil,loc1=nil,loc2=nil,loc3=#<interpreted-function 
> (lisp:lambda-block compi...} [ihs=6]
> #463   TOP-LEVEL {loc0=((when system::tmp (# # #) 
> ...)),loc1=#<compiled-function format>,loc2=nil...} [ihs=5]
> #464   FUNCALL {loc0=#<compiled-function system:top-level>} [ihs=4]
> NIL
> dbl:ACL2>>
> 
> 
> 

-- 
Camm Maguire                                            address@hidden
==========================================================================
"The earth is but one country, and mankind its citizens."  --  Baha'u'llah




reply via email to

[Prev in Thread] Current Thread [Next in Thread]