Description: <short summary of the patch>
 TODO: Put a short summary on the line above and replace this paragraph
 with a longer explanation of this change. Complete the meta-information
 with other relevant fields (see below for details). To make it easier, the
 information below has been extracted from the changelog. Adjust it or drop
 it.
 .
 acl2 (8.4dfsg-1) unstable; urgency=medium
 .
   * New upstream release
Author: Camm Maguire <camm@debian.org>

---
The information above should follow the Patch Tagging Guidelines, please
checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
are templates for supplementary fields that you might want to add:

Origin: <vendor|upstream|other>, <url of original patch>
Bug: <url in upstream bugtracker>
Bug-Debian: https://bugs.debian.org/<bugnumber>
Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
Forwarded: <no|not-needed|url proving that it has been forwarded>
Reviewed-By: <name and email of someone who approved the patch>
Last-Update: 2021-10-28

Index: acl2-8.5dfsg/apply.lisp
===================================================================
--- acl2-8.5dfsg.orig/apply.lisp
+++ acl2-8.5dfsg/apply.lisp
@@ -874,7 +874,7 @@
 (defun guess-ilks-alist (fn new-badge term ilk wrld alist)
 
 ; Fn is the name of a function being defined.  New-badge is either nil or a
-; proposed badge for fn and term is a term (initally the body of fn) occuring
+; proposed badge for fn and term is a term (initally the body of fn) occurring
 ; in a slot of ilk ilk.  Note: term contains no ACL2 lambda applications!  We
 ; try to determine the ilks of the free vars in term, extending alist to record
 ; what we find.  We return (mv msg alist'), where either msg is an error
Index: acl2-8.5dfsg/axioms.lisp
===================================================================
--- acl2-8.5dfsg.orig/axioms.lisp
+++ acl2-8.5dfsg/axioms.lisp
@@ -28906,7 +28906,7 @@ Lisp definition."
 ; where we want to avoid compilation because of the use of make-event, and we
 ; also want to avoid evaluation during pass 1 of initialization, because we are
 ; waiting for a suitable function-theory.  We cannot simply define when-logic
-; to be nil in raw Lisp, becase its use is not limited to the definition of
+; to be nil in raw Lisp, because its use is not limited to the definition of
 ; local.
 
   #-acl2-loop-only
Index: acl2-8.5dfsg/books/acl2s/ccg/ccg-settings.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/ccg/ccg-settings.lsp
+++ acl2-8.5dfsg/books/acl2s/ccg/ccg-settings.lsp
@@ -13,7 +13,7 @@
 
 ;; CCG settings
 
-; dont be too verbose
+; don't be too verbose
  (set-ccg-print-proofs nil)     
  (set-ccg-inhibit-output-lst
   '(QUERY BASICS PERFORMANCE BUILD/REFINE SIZE-CHANGE))
Index: acl2-8.5dfsg/books/acl2s/cgen/acl2s-parameter.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/acl2s-parameter.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/acl2s-parameter.lisp
@@ -574,7 +574,7 @@ These are stored in the constant @('*acl
                         `(table acl2s-defaults-table 
                                   ',',',(keywordify param)
                                   ',(acl2::change acl2s-param-info% ',r :value ',v))))
-;;; setter is a macro, so dont quote the args to it whereas the above
+;;; setter is a macro, so don't quote the args to it whereas the above
 ;;; table macro needs quoted args because its 3rd parameter is &rest rst
                   (value `(,',setter ,',v (,table-update-form));embedded event
                         ))
Index: acl2-8.5dfsg/books/acl2s/cgen/base-cgen-rules.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/base-cgen-rules.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/base-cgen-rules.lisp
@@ -137,7 +137,7 @@ date created: [2016-04-14 Thu]
     (mv X1 X2)))
     
 (cgen::define-rule append-fixer1
-  :hyp (true-listp X3) ;dont worry about this, it will backchain!
+  :hyp (true-listp X3) ;don't worry about this, it will backchain!
   :rule (mv-let (X1 X2) (append-fixer1 X3 X1)
                 (equal X3 (binary-append X1 X2)))
   :rule-classes :fixer)
Index: acl2-8.5dfsg/books/acl2s/cgen/basis.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/basis.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/basis.lisp
@@ -30,7 +30,7 @@
 ;;;;            suffix A_1 indicates A1 is the first argument
 ;;;;            A~ is sometimes used to denote a modified A, but
 ;;;;              sometimes I use A1, A2, ideally I would like to use
-;;;;              A', A'', to denote such things, but Sedan doesnt
+;;;;              A', A'', to denote such things, but Sedan doesn't
 ;;;;              like this syntax, I shud check CLTL
 
 ;;;; Discipline/Style:
@@ -59,7 +59,7 @@
 ;;;;    12. Use anonymous functions only inside list comprehensions and
 ;;;;        all maps and filters are to be used only via LC syntax.
 ;;;;    13. All the above fancy stuff is to be done within the def
-;;;;        macro, dont modify b* which can be nested. Thus we are
+;;;;        macro, don't modify b* which can be nested. Thus we are
 ;;;;        assured of the top-level variable-free scope in which we
 ;;;;        apply our synatx customization.
 
Index: acl2-8.5dfsg/books/acl2s/cgen/build-enumcalls.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/build-enumcalls.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/build-enumcalls.lisp
@@ -307,7 +307,7 @@
                   (t 
                    (prog2$
                      (cw? (normal-output-flag vl)
-                          "~|Cgen/Error: ~x0 doesnt appear to be a type.~%" type)
+                          "~|Cgen/Error: ~x0 doesn't appear to be a type.~%" type)
                      (acl2::make enum-info% :domain-size 0 :category :empty :expr nil :expr2 nil)))))))))))
 
 
@@ -530,7 +530,7 @@ thought about how to implement it.
 ;; enumerator call expression")
 ;;   (declare (xargs :verify-guards nil))
 ;;   (if (endp v-cs%-alst)
-;;       (mv nil (reverse ans.)) ;dont change the original dependency order
+;;       (mv nil (reverse ans.)) ;don't change the original dependency order
 ;;     (b* (((cons x cs%) (car v-cs%-alst))
 ;;          ((mv domain-size ?min-rec-depth ?max-rec-depth calls)
 ;;           (cs%-enumcalls cs% vl wrld  (strip-cars ans.)))
@@ -595,7 +595,7 @@ equality constraint that will be used fo
   we walk down the alist, translating each type constraint to the corresponding
 enumerator type/expr to be displayed in verbose mode")
   (if (endp v-cs%-alst)
-      (reverse ans.) ;dont change the original dependency order
+      (reverse ans.) ;don't change the original dependency order
     (b* (((cons x cs%) (car v-cs%-alst))
          (type (displayed-defdata-type/eq-constraint cs% (strip-cars ans.))))
      
Index: acl2-8.5dfsg/books/acl2s/cgen/callback.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/callback.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/callback.lisp
@@ -409,7 +409,7 @@ Nested testing not allowed! Skipping tes
                                                      type-alist tau-interval-alist 
                                                      NIL 
                                                      *initial-test-outcomes%* 
-; we dont care about witnesses and the start time and do no accumulation.
+; we don't care about witnesses and the start time and do no accumulation.
                                                      *initial-gcs%*
                                                      temp-cgen-state
                                                      ctx state))
@@ -605,7 +605,7 @@ Nested testing not allowed! Skipping tes
        (vl (acl2s-defaults :get verbosity-level))
   
 ; Always push the event into the event-stack for matching with
-; finalize. The default is to push :ignore-cgen, which is overriden
+; finalize. The default is to push :ignore-cgen, which is overridden
 ; later, if cgen takes this event to give the conjecture under test.
        (event-stack (@ event-stack))
        (event-stack~ (cons :ignore-cgen event-stack)) ;ensure this keyword is never a event ctx
@@ -672,7 +672,7 @@ Nested testing not allowed! Skipping tes
        (ctx (compute-event-ctx ctx-form))
        (print-summary-p (and (cget print-cgen-summary) 
                              (> (access gcs% cts) 0)
-; dont print at the end of defun/defuns events (any help to CCG by cgen is invisible) TODO
+; don't print at the end of defun/defuns events (any help to CCG by cgen is invisible) TODO
                              (member-eq ctx '(ACL2::THM ACL2::DEFTHM ACL2::VERIFY-GUARDS))))
        
        (- (cw? (system-debug-flag vl) "~|CEgen/SysDebug: Exiting event with gcs% : ~x0. ~ ctx: ~x1 print-cgen-summ : ~x2 ~%" gcs% ctx (cget print-cgen-summary)))
@@ -742,7 +742,7 @@ Nested testing not allowed! Skipping tes
        (ctx (compute-event-ctx ctx-form))
        (print-summary-p (and (cget print-cgen-summary) 
                              ;(> (access gcs% cts) 0) ;commented out to collect vacuous stats
-; dont print at the end of defun/defuns events (any help to CCG by cgen is invisible) TODO
+; don't print at the end of defun/defuns events (any help to CCG by cgen is invisible) TODO
                              (allowed-cgen-event-ctx-p ctx)))
 
        
Index: acl2-8.5dfsg/books/acl2s/cgen/cgen-rules.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/cgen-rules.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/cgen-rules.lisp
@@ -187,7 +187,7 @@ Invariants:
 ;       (fixed-constraint-term (acl2::subcor-var Out mv-expanded-fixer-terms constraint-term))
        (Vars (reverse (acl2::all-vars constraint-term)))
        ((unless (and (subsetp-eq Vars (union-eq In Out)) (subsetp-eq Out Vars)))
-        (er soft ctx "~| Invariant doesnt hold: ~x0 subsetof ~x1 and ~x2 subsetof ~x0~%"
+        (er soft ctx "~| Invariant doesn't hold: ~x0 subsetof ~x1 and ~x2 subsetof ~x0~%"
             Vars (union-eq In Out) Out))
        (rule-metadata (list (cons :In In)
                             (cons :Out Out)
Index: acl2-8.5dfsg/books/acl2s/cgen/cgen-search.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/cgen-search.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/cgen-search.lisp
@@ -243,7 +243,7 @@ Why is ACL2 not good at this?
   (b* (
        ;; (defaults (cget params))
 ;;        (N (get1 :num-trials defaults 0)) ;shudnt it be 100?
-;; ;Note: I dont need to provide the default arg 0 above, since we are
+;; ;Note: I don't need to provide the default arg 0 above, since we are
 ;; ;sure the defaults alist we get is complete i.e it would definitely
 ;; ;contain the key ':num-trials'. But I am envisioning a scenario, where
 ;; ;I might call this function on its own and not via test?, then this
Index: acl2-8.5dfsg/books/acl2s/cgen/fixers-gl-backend.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/fixers-gl-backend.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/fixers-gl-backend.lisp
@@ -475,7 +475,7 @@ downloaded from the webpage.
             (when (and (member x (g1 :out f1)) ;x should flow out of f1
                       (member x (g1 :in f2))  ; and into f2
                       (not (equal f1 f2))     ;ignore loops (in hyps)
-                      ;(not (equal f1 f3)) ; BUG: dont ignore these, these are to be caught!
+                      ;(not (equal f1 f3)) ; BUG: don't ignore these, these are to be caught!
                       )
               (collect (list x f1 f2 f3))))))
 
@@ -1242,7 +1242,7 @@ bindings:
           (prog2$
            (cw? (verbose-stats-flag vl) "~|Got a sat assignment for #literals = ~x0~%" n)
            (mv nil A n state)))
-         ((when (eq mode :sat)) ;dont continue maxsat loop if in this mode
+         ((when (eq mode :sat)) ;don't continue maxsat loop if in this mode
           (mv erp A n state))
 
          )
Index: acl2-8.5dfsg/books/acl2s/cgen/fixers2.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/fixers2.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/fixers2.lisp
@@ -514,7 +514,7 @@ SAT(term) == \/ SAT(f-lits_i)
 
 
 #|
-In the second pass, we dont worry about cterms, we only look at f-lits .
+In the second pass, we don't worry about cterms, we only look at f-lits .
 Note that a prule has a single f-lit to match, but multiple fixer-terms to complete
 the matching.
 
Index: acl2-8.5dfsg/books/acl2s/cgen/incremental-search.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/incremental-search.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/incremental-search.lisp
@@ -305,7 +305,7 @@ loop.  Any inconsistency in P results in
 last decision made in Assign. For more details refer to the FMCAD paper.")
 
 ; here are abbreviations for functions with looooong arg lists
-; dont read them, go directly to the body of the function, refer to these
+; don't read them, go directly to the body of the function, refer to these
 ; abbreviations while reading the main code.
 ; NOTE: f* names have defun local scope and not across defuns/clique :(
 
Index: acl2-8.5dfsg/books/acl2s/cgen/infer-enum-shape.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/infer-enum-shape.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/infer-enum-shape.lisp
@@ -187,7 +187,7 @@
 
 
 (defs  ;;might be mut-rec, but right now I assume tht I wont encounter
-       ;;AND and OR like if expressions, and hence dont need the
+       ;;AND and OR like if expressions, and hence don't need the
        ;;mutually-recursive counterpart of v-cs%-alist-from-term. TODO
   (v-cs%-alist-from-term. (term vl wrld ans.)
   (decl :sig ((pseudo-term fixnum plist-world  symbol-cs%-alist)
@@ -427,7 +427,7 @@ into eq-constraint field and put interva
 
      (v-cs%-alist-from-terms. hyps+ vl wrld v-cs%-alst))))
 
-; TODO: Right now we dont use ACL2's type-alist to full effect. For
+; TODO: Right now we don't use ACL2's type-alist to full effect. For
 ; example, we might get that (len x) > 3 is non-nil in the type-alist
 ; but missing in the actual hypotheses, this causes loss in crucial
 ; shape information.
Index: acl2-8.5dfsg/books/acl2s/cgen/propagate.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/propagate.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/propagate.lisp
@@ -113,7 +113,7 @@
 ;;       (simplify-hyps1-under-assignment 
 ;;        (cdr rem-hyps) init-hyps x a hints
 ;;        (if (equal shyp ''t) ans.
-;;          (append ans. (list shyp))) ;dont mess with order
+;;          (append ans. (list shyp))) ;don't mess with order
 ;;        vl state))))
 
 
@@ -191,7 +191,7 @@
        (cdr rem-hyps) init-hyps hints
        (cond ((type-hyp-p hyp (w state)) (append ans. (list hyp))) ;leave type hyps unchanged
              ((equal shyp ''t) ans.)
-             (t (append ans. shyp-list))) ;dont mess with order
+             (t (append ans. shyp-list))) ;don't mess with order
        vl state))))
 
 (def simplify-hyps-under-assignment (hyps x a vl state)
@@ -275,7 +275,7 @@
 ;; ;inside test-checkpoint??
 ;;        (mv (prog2$ 
 ;;             (cw? (normal-output-flag vl)
-;; "~|BAD: conclusion got reduced to something we dont want!!~|")
+;; "~|BAD: conclusion got reduced to something we don't want!!~|")
 ;;             T)
 ;;            (list shyps sconcl) state))
       (vars (all-vars-lst (cons sconcl shyps))))
Index: acl2-8.5dfsg/books/acl2s/cgen/prove-cgen.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/prove-cgen.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/prove-cgen.lisp
@@ -28,7 +28,7 @@
                                   proof-builder event history
                                   proof-tree summary)))) 
                     
-;doesnt work on an make-event
+;doesn't work on an make-event
 ||#
 
 
@@ -47,7 +47,7 @@
 ;; Pre-condition var-term-alst is in proper let* order, o.w let*
 ;; complains
 ;; April 30 '12: Return to simple trans-eval with state
-;; we dont care about efficiency wrt ev-w because we only ever print
+;; we don't care about efficiency wrt ev-w because we only ever print
 ;; a small number of cts/wts.
 ;; May 13th '12 : better naming
 
@@ -659,7 +659,7 @@ history s-hist.")
                 (mv :? cgen-state state)))
          
        (testing-enabled (cget testing-enabled ))
-       ((when (eq testing-enabled NIL)) ;dont do any testing
+       ((when (eq testing-enabled NIL)) ;don't do any testing
         (prog2$ (cw? (verbose-flag vl) 
                      "~|Cgen/Note: TESTING-ENABLED is set to NIL; skipping this form altogether.~|")
                 (mv :? cgen-state state)))
@@ -746,7 +746,7 @@ history s-hist.")
                 (mv :? cgen-state state)))
          
        (testing-enabled (cget testing-enabled ))
-       ((when (eq testing-enabled NIL)) ;dont do any testing
+       ((when (eq testing-enabled NIL)) ;don't do any testing
         (prog2$ (cw? (verbose-flag vl) 
                      "~|Cgen/Note: TESTING-ENABLED is set to NIL; skipping this form altogether.~|")
                 (mv :? cgen-state state)))
@@ -855,7 +855,7 @@ history s-hist.")
                                                      "( THM ...)" wrld state))
                             
                             (ttree (acl2::prove ',term
-;; TODO: Matt's code doesnt work through induction and forcing rds
+;; TODO: Matt's code doesn't work through induction and forcing rds
 ;; Also the OTF flag is set to true, to test all initial subgoals. 
                                           (acl2::make-pspv ens wrld state
                                                      :displayed-goal ',form
Index: acl2-8.5dfsg/books/acl2s/cgen/select.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/select.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/select.lisp
@@ -198,7 +198,7 @@
            )
       (put-interdependency-edges-in-alst 
        (cdr term-lst) all-terms
-       (union-entries-in-adj-list vars ;sloppy, dont want self-edges
+       (union-entries-in-adj-list vars ;sloppy, don't want self-edges
                                   (set-difference-eq rest-vars vars)
                                   alst)))))
          
@@ -247,10 +247,10 @@ processed, the annotation of edges is al
             (quotep hyp)
             (and (equal (len hyp) 2)
                  (equal (len (get-free-vars1 (cadr hyp) nil)) 1))) ;monadic term
-        (build-vdependency-graph (cdr hyp-lst) alst alst-C incoming)) ;dont do anything
+        (build-vdependency-graph (cdr hyp-lst) alst alst-C incoming)) ;don't do anything
        
        ((undirected-2-rel? hyp);(~ x  y)
-;dont draw an edge
+;don't draw an edge
         (build-vdependency-graph (cdr hyp-lst) alst alst-C incoming))
 
        ((directed-2-rel? hyp);(= x (f y))
Index: acl2-8.5dfsg/books/acl2s/cgen/simple-graph-array.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/simple-graph-array.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/simple-graph-array.lisp
@@ -241,7 +241,7 @@ the vertice with the maximum post time."
 
 ;fs means Functionaly dependent vars
 ;ASSUMPTION: alst has all the variables as keys already
-;this function just updates the entries, doesnt insert
+;this function just updates the entries, doesn't insert
 ;new entries.
 (defun union-entry-in-adj-list (var fvars alst)
   (declare (xargs :guard (and (adjacency-listp alst)
@@ -290,7 +290,7 @@ the vertice with the maximum post time."
            (equal (transpose-alst (transpose-alst x))
                   x)))
 
-(defthm transpose-doesnt-change-order
+(defthm transpose-doesn't-change-order
   (implies (adjacency-list1p x)
            (equal (strip-cars (transpose-alst x))
                   (strip-cars x))))
Index: acl2-8.5dfsg/books/acl2s/cgen/simple-search.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/simple-search.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/simple-search.lisp
@@ -429,7 +429,7 @@ eg:n/a")
             (gcs% (gcs-1+ cts))
             (m    (access test-outcomes% |#cts|))
             (test-outcomes% ;TODO:per subgoal num-cts stored??
-             (if (< m num-print-cts) ;dont store extra unless
+             (if (< m num-print-cts) ;don't store extra unless
                  (b* ((test-outcomes% (change test-outcomes% cts (cons A A-cts))))
                    test-outcomes%)
                test-outcomes%))
@@ -458,7 +458,7 @@ eg:n/a")
                                 (change test-outcomes% wts-hyp-vals-list
                                         (cons hyp-vals (access test-outcomes% wts-hyp-vals-list)))
                               test-outcomes%))
-            (test-outcomes%   (test-outcomes-1+ wts))) ;BUGGY -- we dont know if its a duplicate. FIXME
+            (test-outcomes%   (test-outcomes-1+ wts))) ;BUGGY -- we don't know if its a duplicate. FIXME
 ;                         in       
          (mv test-outcomes% gcs%)))
 
@@ -717,7 +717,7 @@ where
     (er-progn
      (b* (((mv & (the (unsigned-byte 31) rseed.))
            (defdata::genrandom-seed 2 (defdata::getseed state)))
-          (state (defdata::putseed rseed. state))) ;make some progress -- dont get stuck on the same sequence of seeds
+          (state (defdata::putseed rseed. state))) ;make some progress -- don't get stuck on the same sequence of seeds
        (value nil))
      (assign ss-temp-result :timed-out)
      (mv T nil state)))))
@@ -770,7 +770,7 @@ Use :simple search strategy to find coun
 ")
   
   (if (endp vars)
-; dont even try trivial forms like constant expressions
+; don't even try trivial forms like constant expressions
       (b* ((form  `(implies (and ,@hyps) ,concl))
            ((mv erp c state)
             (trans-eval-single-value form ctx state))
@@ -896,7 +896,7 @@ Use :simple search strategy to find coun
 ; - Can be switched to wormholes if needed. (But then we cant use state to share the result of run-tests)
 ; - Is this parallelizable? Are wormholes?
 ; [2014-09-21 Sun] Reverted back to trans-eval. It is simpler and hopefully the interrupt story is saner!
-; But we still dont use make-event, due to which we have to redef.
+; But we still don't use make-event, due to which we have to redef.
     (trans-eval
        
      `(with-output :stack :pop
Index: acl2-8.5dfsg/books/acl2s/cgen/testing-regression.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/testing-regression.lsp
+++ acl2-8.5dfsg/books/acl2s/cgen/testing-regression.lsp
@@ -285,7 +285,7 @@
           (not (equal "isosceles" (shape x)))))
 )
 
-;; testcase 3 (memory updates dont commute)
+;; testcase 3 (memory updates don't commute)
 ;NOTE: The following example too, 'simple' works good enough
 
 ;another example demonstrating how having the ability to find
@@ -652,7 +652,7 @@
 ; 27th Aug '12, to get rid of the above error, one needs to
 ; submit a compound recognizer rul(declare (xargs :guard (pseudo-termp term)
                    :verify-guards nil))
-; Additionally I also make sure that I dont break the invariant
+; Additionally I also make sure that I don't break the invariant
 ; that after propagating a X=const assignment, X will not appear
 ; as a free variable in the resulting simplified hyp
 
Index: acl2-8.5dfsg/books/acl2s/cgen/top.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/top.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/top.lisp
@@ -76,7 +76,7 @@
 
 
 ; For now lets keep the nats not more than 1000 to avoid stack-overflow
-; on non-tail-recursive functions. If you dont like these, comment
+; on non-tail-recursive functions. If you don't like these, comment
 ; them out, or write your own custom test enumerators and attach them
 (defdata-attach pos :test-enumerator nth-pos-testing)
 
@@ -88,7 +88,7 @@
 ;Note on xdoc: <= or < cannot be used inside defxdoc!!
 
 (defun test?-fn (form hints override-defaults state)
-; Jan 9th 2013, dont print summary unless there was a counterexample.
+; Jan 9th 2013, don't print summary unless there was a counterexample.
   (declare (xargs :mode :program
                   :stobjs (state)))
 ;        :sig ((any hints keyword-value-listp state) -> (mv erp any state))
@@ -137,7 +137,7 @@
  Therefore, no counterexamples exist. ~%" (if hints "" " (without induction)"))
                              (mv NIL state)))
 ; either prove failed, or we didnt call prove. Either way if we didnt find a cts
-; then we say the test? succeeded! But dont print if print-cgen-summary is nil.
+; then we say the test? succeeded! But don't print if print-cgen-summary is nil.
               (t (prog2$
                   (cgen::cw? (and pts? (cgen::normal-output-flag vl))
                        "~%Test? succeeded. No counterexamples were found.~%")
Index: acl2-8.5dfsg/books/acl2s/cgen/with-timeout.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/cgen/with-timeout.lisp
+++ acl2-8.5dfsg/books/acl2s/cgen/with-timeout.lisp
@@ -78,7 +78,7 @@ with-timeout-ev instead"
 
 ;the following is for internal use only. I use it in timing out
 ;top-level-test? form, where i manually make a function body
-;corresponding to the top-level-test?-fn, this way I dont have to
+;corresponding to the top-level-test?-fn, this way I don't have to
 ;worry about capturing free variables
 
 (defmacro with-timeout1 (duration form timeout-form)
Index: acl2-8.5dfsg/books/acl2s/defdata/base.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/base.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/base.lisp
@@ -281,7 +281,7 @@ on a per data definition basis or
 
 
 
-;;only strings upto len 1 to 8
+;;only strings up to len 1 to 8
 (defun nth-string-builtin (n)
   (declare (xargs :guard (natp n)))
   (let* ((str-len (1+ (mod n 7)))
@@ -337,7 +337,7 @@ on a per data definition basis or
   (nth (mod n *len-alpha-num-chars*) *alpha-num-chars*))
 
 ;(defdata character-list (listof character))
-;;only strings upto len 1 to 8
+;;only strings up to len 1 to 8
 (defun nth-character-list-builtin (n)
   (declare (xargs :guard (natp n)))
   (let* ((str-len (1+ (mod n 7)))
Index: acl2-8.5dfsg/books/acl2s/defdata/defdata-attach.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/defdata-attach.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/defdata-attach.lisp
@@ -39,7 +39,7 @@ data last modified: [2015-06-09 Tue]
     (:match-type (member-eq val '(:match :subterm-match)))
     (:meta-replace (symbol-doublet-listp val)) ;let binding
 
-    (otherwise t) ;dont be strict.
+    (otherwise t) ;don't be strict.
     ))
 
 (defun ill-formed-metadata-entry-msg1 (key val)
@@ -235,7 +235,7 @@ data last modified: [2015-06-09 Tue]
        ;;check if key is overridable
        ((when (and (subsetp (strip-cars kwd-alist) *defdata-attach-need-override-permission-keywords*)
                    (not override-ok-p)))
-        (er hard? ctx "~| ~x0 can only be overriden if :override-ok t is provided.~%" keys))
+        (er hard? ctx "~| ~x0 can only be overridden if :override-ok t is provided.~%" keys))
 
        (events (cond ((get1 :equiv kwd-alist)
                       (defdata-attach/equiv name kwd-alist verbosep wrld))
Index: acl2-8.5dfsg/books/acl2s/defdata/defdata-core.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/defdata-core.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/defdata-core.lisp
@@ -1632,7 +1632,7 @@ capturing the metadata associated with e
 | :max-rec-depth      | pos              | 30      | no/yes   | max version of above          |
 |---------------------+------------------+---------+----------+-------------------------------|
 | :satisfies          | expr(x)          |         | no       | boolean expr over x and names |
-|                     |                  |         |          | occuring in def and x ranges  |
+|                     |                  |         |          | occurring in def and x ranges  |
 |                     |                  |         |          | over values of the type       |
 |---------------------+------------------+---------+----------+-------------------------------|
 | :satisfies-fixer    | 1-arity fn       | n/i     | no       | expr(f(x)) is true            |
Index: acl2-8.5dfsg/books/acl2s/defdata/defdata-regression.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/defdata-regression.lsp
+++ acl2-8.5dfsg/books/acl2s/defdata/defdata-regression.lsp
@@ -420,7 +420,7 @@
     :timeout 80)
  
 
-;mutually recursive types (doesnt work in COMPATIBLE MODE)
+;mutually recursive types (doesn't work in COMPATIBLE MODE)
 
 (defdata
   (sexpr (oneof symbol
Index: acl2-8.5dfsg/books/acl2s/defdata/defdata-util.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/defdata-util.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/defdata-util.lisp
@@ -334,7 +334,7 @@
        ((when (eq P1 P2)) t)
        (P2-neg-implicants-tau (getprop P2 'acl2::neg-implicants acl2::*tau-empty* 'acl2::current-acl2-world wrld))
        (P2-neg-pairs (acl2::access acl2::tau P2-neg-implicants-tau :neg-pairs)))
-    ;guard verif fails since, we dont know if P2-neg-implicants is a alist.
+    ;guard verif fails since, we don't know if P2-neg-implicants is a alist.
     (rassoc-eq P1 P2-neg-pairs)))
 
 (verify-termination ACL2::UPPER-BOUND-<)
@@ -362,7 +362,7 @@
        ((when (eq P1 P2)) nil)
        (P1-pos-implicants-tau (getprop P1 'acl2::pos-implicants acl2::*tau-empty* 'acl2::current-acl2-world wrld))
        (P1-neg-pairs (acl2::access acl2::tau P1-pos-implicants-tau :neg-pairs)))
-    ;guard verif fails since, we dont know if P2-pos-implicants is a alist.
+    ;guard verif fails since, we don't know if P2-pos-implicants is a alist.
     (rassoc-eq P2 P1-neg-pairs)))
 
 ;----------above is copied from utilities.lisp -----------------------
@@ -388,7 +388,7 @@
       (let ((typename (acl2::subseq pred-name 0 (1- len-predname))));strip last char which is 'p'
         (acl2s::fix-intern-in-pkg-of-sym typename sym))
       NIL))) ;TODO.Beware
-      ;(er hard 'get-typesymbol-from-pred "~x0 doesnt follow our convention of predicates ending with 'p'.~%" sym))))
+      ;(er hard 'get-typesymbol-from-pred "~x0 doesn't follow our convention of predicates ending with 'p'.~%" sym))))
 
 ;;-- (make-predicate-symbol 'integer "ACL2S B") ==> ACL2S B::INTEGERP
 (defun make-predicate-symbol (sym pkg)
Index: acl2-8.5dfsg/books/acl2s/defdata/enumerators-gen.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/enumerators-gen.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/enumerators-gen.lisp
@@ -55,14 +55,14 @@ data last modified: [2017-06-25 Sun]
 (defun make-enum-I (s i   kwd-alist M C B wrld)
   "Make enumerator interpretation for core defdata exp s.
  where
- i is the name of the current indicial argument (dont confuse with an integer)
+ i is the name of the current indicial argument (don't confuse with an integer)
  kwd-alist gives some defaults.
  M is type metadata table + some basic info for the clique of types being defined.
  C is the constructor table + some basic info for new constructors.
  B is the builtin combinator table."
 
   (cond ((possible-constant-value-p s)
-         (if (quotep s) s (list 'QUOTE s))) ;its already quoted, dont quote it furthur.
+         (if (quotep s) s (list 'QUOTE s))) ;its already quoted, don't quote it furthur.
 
         ((proper-symbolp s)
          (if (assoc-eq s M) `(,(get2 s :enumerator M) ,i)  s))
@@ -232,7 +232,7 @@ data last modified: [2017-06-25 Sun]
         (cons (if (> k 1) 
                   `((MV ,(car comp-svars) (THE (UNSIGNED-BYTE 31) _SEED))
                     (GENRANDOM-SEED (1+ (NFIX ,svar)) _SEED))
-                ;; only one recursive case left, then dont partition
+                ;; only one recursive case left, then don't partition
                 `((MV ,(car comp-svars) (THE (UNSIGNED-BYTE 31) _SEED))
                   (MV ,svar _SEED)))
               (uniformly-partition-size-binding-aux `(- ,svar ,(car comp-svars))
@@ -278,7 +278,7 @@ data last modified: [2017-06-25 Sun]
  (defun make-enum/acc-I (s i kwd-alist new-names M C B wrld)
    (declare (ignorable new-names))
    "enumerator/acc interpretation for core defdata exp s.
-i is the name of the current indicial argument (dont confuse with an integer) that is used as recursion measure.
+i is the name of the current indicial argument (don't confuse with an integer) that is used as recursion measure.
 kwd-alist gives some defaults.
 new-names is self-explanatory (imp to find recursive references)
 M is type metadata table + some basic info for the clique of types being defined.
Index: acl2-8.5dfsg/books/acl2s/defdata/record.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/record.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/record.lisp
@@ -373,7 +373,7 @@ data last modified: [2014-08-06]
        (sel-name (s+ (get-dest-prefix conx-name) fname :separator "" :pkg curr-pkg)))
     `((defthm ,(curr-pkg-s+ pred  fname 'inverse-def)
         (implies (,pred x) ;earlier it was unconditional, but this leads to erroneous/unwanted dest-elim applications
-;         (syntaxp (atom x))  ;this doesnt work for nested dest-elim in one elim process
+;         (syntaxp (atom x))  ;this doesn't work for nested dest-elim in one elim process
          (equal (mget ,kname x) (,sel-name x)))
         :hints (("Goal" :in-theory (e/d () (,@disabled-runes) (,sel-name))))))))
 
@@ -550,7 +550,7 @@ data last modified: [2014-08-06]
         ((acl2::fquotep e) A.)
         (t (if (and (eq 'acl2::mget (acl2::ffn-symb e))
                     (= (len e) 3)
-                    (= 2 (len (second e)));otherwise fquotep doesnt typecheck.
+                    (= 2 (len (second e)));otherwise fquotep doesn't typecheck.
                     (acl2::fquotep (second e))
                     (keywordp (acl2::unquote (second e)))
                     (acl2::variablep (third e)))
Index: acl2-8.5dfsg/books/acl2s/defdata/sig.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defdata/sig.lisp
+++ acl2-8.5dfsg/books/acl2s/defdata/sig.lisp
@@ -139,7 +139,7 @@ get as much automated polymorphic suppor
 
 ; sig macro for polymorphic support.
 
-; I dont think we are ever going to have more than 3 type parameters, but lets start with 12.
+; I don't think we are ever going to have more than 3 type parameters, but lets start with 12.
 (logic)
 (encapsulate
  (((Ap *) => *)
@@ -245,7 +245,7 @@ get as much automated polymorphic suppor
 ;   (pairlis$ *allowed-type-vars* *tvar-typename-alist*))
 
 
-;ACHTUNG: make sure people dont use names from defdata namespace. Note that A,Ap,... reside in defdata namespace.
+;ACHTUNG: make sure people don't use names from defdata namespace. Note that A,Ap,... reside in defdata namespace.
 (def-const *initial-tvar-M*
   (type-metadata-bases (strip-cdrs *tvar-typename-alist*) "DEFDATA"))
 
@@ -258,7 +258,7 @@ get as much automated polymorphic suppor
    (cond ((quotep texp) '())
          ((keywordp texp) (list texp))
          ((atom texp) '())
-         ((not (true-listp texp)) ;right now we dont support named texp
+         ((not (true-listp texp)) ;right now we don't support named texp
           (er hard? ctx "~| ~x0 : Named type expressions not supported.~%" texp))
          (t (collect-type-vars-texps (cdr texp) ctx))))
  (defun collect-type-vars-texps (texps ctx)
@@ -273,7 +273,7 @@ get as much automated polymorphic suppor
    (cond ((quotep texp) '())
          ((keywordp texp) '())
          ((atom texp) (if (predicate-name texp) '() (list texp)))
-         ((not (true-listp texp)) ;right now we dont support named texp
+         ((not (true-listp texp)) ;right now we don't support named texp
           (er hard? ctx "~| ~x0 : Named type expressions not supported.~%" texp))
          (t (collect-undefined-typenames-texps (cdr texp) ctx wrld))))
  (defun collect-undefined-typenames-texps (texps ctx wrld)
@@ -1065,7 +1065,7 @@ constant). In the latter return a lambda
 (defun sig-events (parsed wrld)
   (b* (((list name suffix arg-types ret-type kwd-alist) parsed)
        (cgenp (acl2::logical-namep 'acl2s::acl2s-defaults wrld))
-       ;; dont even call acl2s-defaults if cgen/top is not included. This
+       ;; don't even call acl2s-defaults if cgen/top is not included. This
        ;; allows defdata/sig to be used independently of cgen
        (local-testing-downgraded-form
         (and cgenp
Index: acl2-8.5dfsg/books/acl2s/defunc.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/defunc.lisp
+++ acl2-8.5dfsg/books/acl2s/defunc.lisp
@@ -1090,7 +1090,7 @@ Let termination-strictp, function-contra
 
 (defmacro update-xargs-decls (decls &key guard mode)
   `(acl2::update-xargs-decls-fn ,decls ,guard ,mode))
-;Note : Macro confusion, if I put ',decls or ',ic, it doesnt
+;Note : Macro confusion, if I put ',decls or ',ic, it doesn't
 ;work. Macros are not that nice, one needs to know the context in
 ;which they are called, if I call from program context where decls,
 ;guard are variable names, you should not use quotes, but if you use
Index: acl2-8.5dfsg/books/acl2s/demos/alloy-comparison.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/demos/alloy-comparison.lsp
+++ acl2-8.5dfsg/books/acl2s/demos/alloy-comparison.lsp
@@ -33,7 +33,7 @@
 
 
 ;(defdata Group (cons 'G acl2s::pos)) ;bad because it gets dest-elimed. 
-;records also dont work since map lemmas do not go through
+;records also don't work since map lemmas do not go through
 
 (defdata Name (oneof Alias Group))
 (defdata Target (oneof Address Name))
Index: acl2-8.5dfsg/books/acl2s/demos/dsp-type-and-fixer-defuns.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/acl2s/demos/dsp-type-and-fixer-defuns.lisp
+++ acl2-8.5dfsg/books/acl2s/demos/dsp-type-and-fixer-defuns.lisp
@@ -370,7 +370,7 @@
     (if (shorterp p p0 g) p p0)))
 
 
-(defund shortest-path-fxr2 (a b p g) ;dont use
+(defund shortest-path-fxr2 (a b p g) ;don't use
   (b* (((mv p g) (path-from-to-fix p a b g)))
       ;lets add paths that might be shorter
       (mv (pick-shortest (find-all-simple-paths a b g) g p) g)))
Index: acl2-8.5dfsg/books/build/Makefile-books
===================================================================
--- /dev/null
+++ acl2-8.5dfsg/books/build/Makefile-books
@@ -0,0 +1,8970 @@
+./clause-processors/replace-equalities.lisp
+./clause-processors/instantiate.lisp
+./clause-processors/constant-prop.lisp
+./clause-processors/witness-cp.lisp
+./clause-processors/pseudo-term-fty.lisp
+./clause-processors/let-abstraction.lisp
+./clause-processors/replace-defined-consts.lisp
+./clause-processors/magic-ev.lisp
+./clause-processors/unify-subst.lisp
+./clause-processors/ev-theoremp.lisp
+./clause-processors/ev-find-rules.lisp
+./clause-processors/find-matching.lisp
+./clause-processors/meta-extract-user.lisp
+./clause-processors/decomp-hint.lisp
+./clause-processors/bv-add.lisp
+./clause-processors/sublis-var-meaning.lisp
+./clause-processors/ev-ind.lisp
+./clause-processors/replace-impl.lisp
+./clause-processors/term-vars.lisp
+./clause-processors/find-subterms.lisp
+./clause-processors/just-expand.lisp
+./clause-processors/meta-extract-simple-test.lisp
+./clause-processors/bindinglist.lisp
+./clause-processors/null-fail-hints.lisp
+./clause-processors/induction.lisp
+./clause-processors/remove-hyp.lisp
+./clause-processors/generalize.lisp
+./clause-processors/deps-SULFA.lisp
+./clause-processors/bv-add-tests.lisp
+./clause-processors/doc.lisp
+./clause-processors/bv-add-common.lisp
+./clause-processors/nvalues-thms.lisp
+./clause-processors/eval-alist-equiv.lisp
+./clause-processors/equality.lisp
+./clause-processors/term-patterns.lisp
+./clause-processors/autohide.lisp
+./clause-processors/basic-examples.lisp
+./clause-processors/equality-tests.lisp
+./clause-processors/multi-env-trick.lisp
+./clause-processors/stobj-preservation.lisp
+./clause-processors/join-thms.lisp
+./clause-processors/use-by-hint.lisp
+./parsers/earley/earley-parser.lisp
+./parsers/earley/defprimitive.lisp
+./parsers/earley/strings.lisp
+./parsers/earley/grammar-reader.lisp
+./parsers/earley/read-file-characters-no-error.lisp
+./parsers/earley/read-line.lisp
+./parsers/earley/tokenizer.lisp
+./parsers/earley/object-representations.lisp
+./ordinals/ordinals-without-arithmetic.lisp
+./ordinals/ordinal-counter-examples.lisp
+./ordinals/ordinal-addition.lisp
+./ordinals/ordinal-isomorphism.lisp
+./ordinals/ordinal-multiplication.lisp
+./ordinals/lexicographic-ordering-without-arithmetic.lisp
+./ordinals/ordinals.lisp
+./ordinals/limits.lisp
+./ordinals/e0-ordinal.lisp
+./ordinals/proof-of-well-foundedness.lisp
+./ordinals/lexicographic-ordering.lisp
+./ordinals/ordinal-exponentiation.lisp
+./ordinals/ordinal-basic-thms.lisp
+./ordinals/ordinal-total-order.lisp
+./ordinals/lexicographic-book.lisp
+./ordinals/top-with-meta.lisp
+./ordinals/ordinal-definitions.lisp
+./hacking/doc-section.lisp
+./hacking/defstruct-parsing.lisp
+./hacking/defcode.lisp
+./hacking/bridge.lisp
+./hacking/hacking-xdoc.lisp
+./hacking/dynamic-make-event.lisp
+./hacking/evalable-ld-printing.lisp
+./hacking/subsumption.lisp
+./hacking/progn-bang-enh.lisp
+./hacking/redefun.lisp
+./hacking/raw.lisp
+./hacking/rewrite-code.lisp
+./hacking/table-guard.lisp
+./hacking/dynamic-make-event-test.lisp
+./hacking/all.lisp
+./hacking/hacker.lisp
+./projects/curve25519/top.lisp
+./projects/curve25519/ecp.lisp
+./projects/curve25519/terms.lisp
+./projects/curve25519/tripp.lisp
+./projects/curve25519/axioms.lisp
+./projects/curve25519/reduce.lisp
+./projects/apply/definductor.lisp
+./projects/apply/base.lisp
+./projects/apply/top.lisp
+./projects/apply/copy-nat-tree.lisp
+./projects/apply/relink-fancy-scion.lisp
+./projects/apply/mempos.lisp
+./projects/apply/loop.lisp
+./projects/apply/loop-recursion-examples.lisp
+./projects/apply/loop-tests.lisp
+./projects/apply/report.lisp
+./projects/apply/apply-lemmas.lisp
+./projects/apply/prog-mode-tests-book.lisp
+./projects/apply/definductor-tests.lisp
+./projects/x86isa/proofs/factorial/fact-wormhole-abstraction.lisp
+./projects/x86isa/proofs/factorial/fact-inductive-assertions.lisp
+./projects/x86isa/proofs/dissertation-examples/clc-stc-system-level-marking-view.lisp
+./projects/x86isa/proofs/dissertation-examples/clc-stc-system-level-non-marking-view.lisp
+./projects/x86isa/proofs/dissertation-examples/clc-stc-app-view.lisp
+./projects/x86isa/proofs/popcount/popcount-general.lisp
+./projects/x86isa/proofs/popcount/popcount.lisp
+./projects/x86isa/proofs/top.lisp
+./projects/x86isa/proofs/powOfTwo/powOfTwo.lisp
+./projects/x86isa/proofs/dataCopy/loop-recur.lisp
+./projects/x86isa/proofs/dataCopy/dataCopy.lisp
+./projects/x86isa/proofs/dataCopy/loop-base.lisp
+./projects/x86isa/proofs/dataCopy/init.lisp
+./projects/x86isa/proofs/codewalker-examples/base.lisp
+./projects/x86isa/proofs/codewalker-examples/factorial.lisp
+./projects/x86isa/proofs/codewalker-examples/popcount-32.lisp
+./projects/x86isa/proofs/zeroCopy/marking-view/zeroCopy-part-2.lisp
+./projects/x86isa/proofs/zeroCopy/marking-view/read-page-after-write-to-page-table.lisp
+./projects/x86isa/proofs/zeroCopy/marking-view/zeroCopy.lisp
+./projects/x86isa/proofs/zeroCopy/marking-view/zeroCopy-part-1.lisp
+./projects/x86isa/proofs/zeroCopy/marking-view/zeroCopy-init.lisp
+./projects/x86isa/proofs/zeroCopy/non-marking-view/zeroCopy.lisp
+./projects/x86isa/proofs/wordCount/wc-addr-byte.lisp
+./projects/x86isa/proofs/wordCount/wc.lisp
+./projects/x86isa/proofs/utilities/top.lisp
+./projects/x86isa/proofs/utilities/sys-view/top.lisp
+./projects/x86isa/proofs/utilities/sys-view/common-system-level-utils.lisp
+./projects/x86isa/proofs/utilities/sys-view/non-marking-view-top.lisp
+./projects/x86isa/proofs/utilities/sys-view/marking-view-utils.lisp
+./projects/x86isa/proofs/utilities/sys-view/gl-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/bind-free-utils.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/page-directory-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/page-walk-side-effects.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/top.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/common-paging-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/pml4-table-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/page-table-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/page-dir-ptr-table-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/gather-paging-structures-thms.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/la-to-pa-lemmas.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/paging-basics.lisp
+./projects/x86isa/proofs/utilities/sys-view/paging/gather-paging-structures.lisp
+./projects/x86isa/proofs/utilities/sys-view/marking-view-top.lisp
+./projects/x86isa/proofs/utilities/sys-view/physical-memory-utils.lisp
+./projects/x86isa/proofs/utilities/disjoint.lisp
+./projects/x86isa/proofs/utilities/basics.lisp
+./projects/x86isa/proofs/utilities/general-memory-utils.lisp
+./projects/x86isa/proofs/utilities/row-wow-thms.lisp
+./projects/x86isa/proofs/utilities/app-view/environment-utils.lisp
+./projects/x86isa/proofs/utilities/app-view/top.lisp
+./projects/x86isa/proofs/utilities/app-view/user-level-memory-utils.lisp
+./projects/x86isa/top.lisp
+./projects/x86isa/portcullis/utils.lisp
+./projects/x86isa/portcullis/sharp-dot-defuns.lisp
+./projects/x86isa/portcullis/sharp-dot-constants.lisp
+./projects/x86isa/portcullis/portcullis.lisp
+./projects/x86isa/machine/segmentation.lisp
+./projects/x86isa/machine/physical-memory.lisp
+./projects/x86isa/machine/new-decode.lisp
+./projects/x86isa/machine/guard-helpers.lisp
+./projects/x86isa/machine/three-byte-opcodes-dispatch.lisp
+./projects/x86isa/machine/prefix-modrm-sib-decoding.lisp
+./projects/x86isa/machine/x86.lisp
+./projects/x86isa/machine/vex-opcodes-dispatch.lisp
+./projects/x86isa/machine/top-level-memory.lisp
+./projects/x86isa/machine/dispatch-creator.lisp
+./projects/x86isa/machine/other-non-det.lisp
+./projects/x86isa/machine/syscalls.lisp
+./projects/x86isa/machine/evex-opcodes-dispatch.lisp
+./projects/x86isa/machine/dispatch-macros.lisp
+./projects/x86isa/machine/two-byte-opcodes-dispatch.lisp
+./projects/x86isa/machine/inst-structs.lisp
+./projects/x86isa/machine/cpuid.lisp
+./projects/x86isa/machine/inst-listing.lisp
+./projects/x86isa/machine/decoding-and-spec-utils.lisp
+./projects/x86isa/machine/linear-memory.lisp
+./projects/x86isa/machine/register-readers-and-writers.lisp
+./projects/x86isa/machine/cpuid-constants.lisp
+./projects/x86isa/machine/application-level-memory.lisp
+./projects/x86isa/machine/state.lisp
+./projects/x86isa/machine/instructions/segmentation.lisp
+./projects/x86isa/machine/instructions/arith-and-logic-spec.lisp
+./projects/x86isa/machine/instructions/syscall.lisp
+./projects/x86isa/machine/instructions/jump-and-loop.lisp
+./projects/x86isa/machine/instructions/xor-spec.lisp
+./projects/x86isa/machine/instructions/fp/shuffle-and-unpack.lisp
+./projects/x86isa/machine/instructions/fp/base.lisp
+./projects/x86isa/machine/instructions/fp/top.lisp
+./projects/x86isa/machine/instructions/fp/convert.lisp
+./projects/x86isa/machine/instructions/fp/add-mul-spec.lisp
+./projects/x86isa/machine/instructions/fp/mxcsr.lisp
+./projects/x86isa/machine/instructions/fp/arithmetic.lisp
+./projects/x86isa/machine/instructions/fp/bitscan.lisp
+./projects/x86isa/machine/instructions/fp/mov.lisp
+./projects/x86isa/machine/instructions/fp/simd-integer.lisp
+./projects/x86isa/machine/instructions/fp/cvt-spec.lisp
+./projects/x86isa/machine/instructions/fp/logical.lisp
+./projects/x86isa/machine/instructions/fp/arith-spec.lisp
+./projects/x86isa/machine/instructions/fp/sqrt-spec.lisp
+./projects/x86isa/machine/instructions/fp/cmp-spec.lisp
+./projects/x86isa/machine/instructions/top.lisp
+./projects/x86isa/machine/instructions/exchange.lisp
+./projects/x86isa/machine/instructions/rotates-spec.lisp
+./projects/x86isa/machine/instructions/multiply-spec.lisp
+./projects/x86isa/machine/instructions/subroutine.lisp
+./projects/x86isa/machine/instructions/and-spec.lisp
+./projects/x86isa/machine/instructions/string.lisp
+./projects/x86isa/machine/instructions/shifts-spec.lisp
+./projects/x86isa/machine/instructions/arith-and-logic.lisp
+./projects/x86isa/machine/instructions/signextend.lisp
+./projects/x86isa/machine/instructions/divide-spec.lisp
+./projects/x86isa/machine/instructions/add-spec.lisp
+./projects/x86isa/machine/instructions/rotate-and-shift.lisp
+./projects/x86isa/machine/instructions/conditional.lisp
+./projects/x86isa/machine/instructions/push-and-pop.lisp
+./projects/x86isa/machine/instructions/or-spec.lisp
+./projects/x86isa/machine/instructions/sub-spec.lisp
+./projects/x86isa/machine/instructions/divide.lisp
+./projects/x86isa/machine/instructions/bit.lisp
+./projects/x86isa/machine/instructions/move.lisp
+./projects/x86isa/machine/instructions/multiply.lisp
+./projects/x86isa/machine/paging.lisp
+./projects/x86isa/machine/modes.lisp
+./projects/x86isa/machine/rflags-spec.lisp
+./projects/x86isa/machine/syscall-numbers.lisp
+./projects/x86isa/machine/environment.lisp
+./projects/x86isa/doc.lisp
+./projects/x86isa/tools/execution/top.lisp
+./projects/x86isa/tools/execution/examples/top.lisp
+./projects/x86isa/tools/execution/examples/dataCopy/dataCopy.lisp
+./projects/x86isa/tools/execution/examples/fibonacci.lisp
+./projects/x86isa/tools/execution/examples/factorial.lisp
+./projects/x86isa/tools/execution/examples/zeroCopy/readValues-addr-byte.lisp
+./projects/x86isa/tools/execution/examples/zeroCopy/pageWalk1G-addr-byte.lisp
+./projects/x86isa/tools/execution/examples/zeroCopy/modifyPagingEntry-addr-byte.lisp
+./projects/x86isa/tools/execution/examples/nop-sequence/nop.lisp
+./projects/x86isa/tools/execution/examples/fibonacci32.lisp
+./projects/x86isa/tools/execution/init-state.lisp
+./projects/x86isa/tools/execution/execloaders.lisp
+./projects/x86isa/tools/execution/init-page-tables.lisp
+./projects/x86isa/tools/execution/instrument/top.lisp
+./projects/x86isa/utils/segmentation-structures.lisp
+./projects/x86isa/utils/utilities.lisp
+./projects/x86isa/utils/records-0.lisp
+./projects/x86isa/utils/fp-structures.lisp
+./projects/x86isa/utils/basic-structs.lisp
+./projects/x86isa/utils/paging-structures.lisp
+./projects/x86isa/utils/structures.lisp
+./projects/concurrent-programs/bakery/properties-of-sets.lisp
+./projects/concurrent-programs/bakery/final-theorems.lisp
+./projects/concurrent-programs/bakery/variables.lisp
+./projects/concurrent-programs/bakery/programs.lisp
+./projects/concurrent-programs/bakery/records.lisp
+./projects/concurrent-programs/bakery/properties.lisp
+./projects/concurrent-programs/bakery/inv-sufficient.lisp
+./projects/concurrent-programs/bakery/inv-persists.lisp
+./projects/concurrent-programs/bakery/initial-state.lisp
+./projects/concurrent-programs/bakery/stutter1-match.lisp
+./projects/concurrent-programs/bakery/measures.lisp
+./projects/concurrent-programs/bakery/lexicographic.lisp
+./projects/concurrent-programs/bakery/stutter2.lisp
+./projects/concurrent-programs/bakery/lexicographic-pos.lisp
+./projects/concurrent-programs/bakery/labels.lisp
+./projects/concurrent-programs/bakery/pos-temp.lisp
+./projects/concurrent-programs/bakery/apply-total-order.lisp
+./projects/concurrent-programs/bakery/fairenv.lisp
+./projects/apply-model-2/apply-prim.lisp
+./projects/apply-model-2/apply-constraints.lisp
+./projects/apply-model-2/ex1/defattach-demo.lisp
+./projects/apply-model-2/ex1/user-defs.lisp
+./projects/apply-model-2/ex1/evaluation-lemmas.lisp
+./projects/apply-model-2/ex1/all-warrants-valid.lisp
+./projects/apply-model-2/ex1/doppelgangers.lisp
+./projects/apply-model-2/weights-and-measures.lisp
+./projects/apply-model-2/apply.lisp
+./projects/apply-model-2/report.lisp
+./projects/apply-model-2/portcullis.lisp
+./projects/apply-model-2/ex2/user-thms.lisp
+./projects/apply-model-2/ex2/defattach-demo.lisp
+./projects/apply-model-2/ex2/user-defs.lisp
+./projects/apply-model-2/ex2/evaluation-lemmas.lisp
+./projects/apply-model-2/ex2/all-warrants-valid.lisp
+./projects/apply-model-2/ex2/doppelgangers.lisp
+./projects/simple-url-parser/parse-url.lisp
+./projects/avr-isa/avr8_isa_lemmas.lisp
+./projects/avr-isa/avr8_isa.lisp
+./projects/pltpa/pltpa.lisp
+./projects/pltpa/standard-proveall-failures.lisp
+./projects/pltpa/chk-jacm-proveall.lisp
+./projects/pltpa/chk-standard-proveall.lisp
+./projects/paco/utilities.lisp
+./projects/paco/rewrite.lisp
+./projects/paco/simplify.lisp
+./projects/paco/paco.lisp
+./projects/paco/prove.lisp
+./projects/paco/books/proveall-book.lisp
+./projects/paco/elim-dest.lisp
+./projects/paco/database.lisp
+./projects/paco/output-module.lisp
+./projects/paco/foundations.lisp
+./projects/paco/type-set.lisp
+./projects/paco/induct.lisp
+./projects/hexnet/helper-functions.lisp
+./projects/hexnet/hexnet-model.lisp
+./projects/hybrid-systems/tm-floor.lisp
+./projects/hybrid-systems/computed-hints.lisp
+./projects/hybrid-systems/phi-exists.lisp
+./projects/hybrid-systems/arith-nsa4.lisp
+./projects/hybrid-systems/eexp.lisp
+./projects/hybrid-systems/nsa.lisp
+./projects/hybrid-systems/o-real-p.lisp
+./projects/hybrid-systems/phi-properties.lisp
+./projects/hybrid-systems/phi-unique.lisp
+./projects/hybrid-systems/abs.lisp
+./projects/hybrid-systems/example.lisp
+./projects/taspi/proofs/sets.lisp
+./projects/taspi/proofs/fringes-taspi.lisp
+./projects/taspi/proofs/omerge-good-order.lisp
+./projects/taspi/sets-input/top.lisp
+./projects/taspi/sets-input/mast.lisp
+./projects/taspi/sets-input/multipolar-loose.lisp
+./projects/taspi/sets-input/tree-support-in-set.lisp
+./projects/taspi/sets-input/greedy.lisp
+./projects/taspi/sets-input/mct.lisp
+./projects/taspi/sets-input/tree-compat.lisp
+./projects/taspi/sets-input/consensus.lisp
+./projects/taspi/tree-generation/tree-gen-helper/basics.lisp
+./projects/taspi/tree-generation/branch-and-bound/bandb.lisp
+./projects/taspi/tree-generation/distance-based/naive-quartet-method.lisp
+./projects/taspi/tree-generation/heuristics/do-search.lisp
+./projects/taspi/tree-generation/heuristics/tbr.lisp
+./projects/taspi/tree-generation/heuristics/spr.lisp
+./projects/taspi/tree-score/efficient-pscores.lisp
+./projects/taspi/tree-score/min-length.lisp
+./projects/taspi/tree-score/opt-pairwise.lisp
+./projects/taspi/tree-score/costs.lisp
+./projects/taspi/tree-score/circle-scoring.lisp
+./projects/taspi/tree-score/efficient-pscores-help.lisp
+./projects/taspi/tree-score/ambig-score.lisp
+./projects/taspi/tree-score/fitch-scoring.lisp
+./projects/taspi/tree-score/pscores.lisp
+./projects/taspi/taspi-xdoc.lisp
+./projects/taspi/tree-distance/symm-diff.lisp
+./projects/taspi/tree-distance/rf.lisp
+./projects/taspi/single-input/tree-stats.lisp
+./projects/taspi/single-input/taxa-based.lisp
+./projects/taspi/code/brlens/trees-with-brlens.lisp
+./projects/taspi/code/brlens/brlens.lisp
+./projects/taspi/code/replete/replete-helper.lisp
+./projects/taspi/code/replete/replete-guards.lisp
+./projects/taspi/code/replete/replete.lisp
+./projects/taspi/code/gen-helper/top.lisp
+./projects/taspi/code/gen-helper/bdd-functions.lisp
+./projects/taspi/code/gen-helper/extra.lisp
+./projects/taspi/code/gen-helper/fast-lists.lisp
+./projects/taspi/code/gen-helper/sets.lisp
+./projects/taspi/code/gen-trees/app-rev-lists.lisp
+./projects/taspi/code/gen-trees/top.lisp
+./projects/taspi/code/gen-trees/sets-lists-trees.lisp
+./projects/taspi/code/gen-trees/btrees-bdds.lisp
+./projects/taspi/code/gen-trees/btrees-bdds-sets.lisp
+./projects/taspi/code/gen-trees/btrees.lisp
+./projects/taspi/code/gen-trees/tree-predicates.lisp
+./projects/taspi/code/sequences/p-inform.lisp
+./projects/taspi/code/sequences/align.lisp
+./projects/taspi/code/sequences/seqs.lisp
+./projects/taspi/code/fringes/fringes-guards.lisp
+./projects/taspi/code/fringes/fringes-props.lisp
+./projects/taspi/code/fringes/fringes.lisp
+./projects/taspi/code/build/build-term-guards.lisp
+./projects/taspi/code/build/build-term.lisp
+./projects/taspi/code/tree-manip/sort-help.lisp
+./projects/taspi/code/tree-manip/top.lisp
+./projects/taspi/code/tree-manip/mv-root.lisp
+./projects/taspi/code/tree-manip/insertion-based-sort.lisp
+./projects/taspi/code/tree-manip/quicksort.lisp
+./projects/taspi/code/tree-manip/merge-based-sort.lisp
+./projects/taspi/database/entry.lisp
+./projects/taspi/database/props.lisp
+./projects/taspi/database/db.lisp
+./projects/taspi/database/filters.lisp
+./projects/taspi/database/db-from-list.lisp
+./projects/codewalker/demo-fact-partial.lisp
+./projects/codewalker/simplify-under-hyps.lisp
+./projects/codewalker/if-tracker.lisp
+./projects/codewalker/demo-fact-preamble.lisp
+./projects/codewalker/terminatricks.lisp
+./projects/codewalker/demo-fact-count-up.lisp
+./projects/codewalker/codewalker.lisp
+./projects/codewalker/demo-fact.lisp
+./projects/codewalker/m1-version-3.lisp
+./projects/die-hard-bottle-game/work.lisp
+./projects/die-hard-bottle-game/top.lisp
+./projects/die-hard-bottle-game/my-mod-gcd.lisp
+./projects/sidekick/lock.lisp
+./projects/sidekick/top.lisp
+./projects/sidekick/session.lisp
+./projects/sidekick/disassemble.lisp
+./projects/sidekick/io.lisp
+./projects/sidekick/eventdata.lisp
+./projects/sidekick/webcommand.lisp
+./projects/sidekick/lookup.lisp
+./projects/sidekick/server.lisp
+./projects/sidekick/portcullis.lisp
+./projects/sidekick/explore.lisp
+./projects/sidekick/lint.lisp
+./projects/include-doc.lisp
+./projects/arm/fadd/lza.lisp
+./projects/arm/fadd/special.lisp
+./projects/arm/fadd/lshift.lisp
+./projects/arm/fadd/fma.lisp
+./projects/arm/fadd/prelim.lisp
+./projects/arm/fadd/summary.lisp
+./projects/arm/fadd/alignment.lisp
+./projects/arm/fadd/round.lisp
+./projects/arm/fadd/fadd64.lisp
+./projects/arm/fadd/addition.lisp
+./projects/arm/fadd/clz.lisp
+./projects/arm/fadd/comp.lisp
+./projects/arm/fadd/fadd.lisp
+./projects/arm/second/fdiv2/quotient.lisp
+./projects/arm/second/fdiv2/special.lisp
+./projects/arm/second/fdiv2/prelim.lisp
+./projects/arm/second/fdiv2/algorithm.lisp
+./projects/arm/second/fdiv2/summary.lisp
+./projects/arm/second/fdiv2/round.lisp
+./projects/arm/second/fdiv2/normalize.lisp
+./projects/arm/second/fdiv2/first.lisp
+./projects/arm/second/fdiv2/final.lisp
+./projects/arm/second/fdiv2/fdiv2.lisp
+./projects/arm/second/fdiv2/induct.lisp
+./projects/arm/second/fadd64/lza.lisp
+./projects/arm/second/fadd64/special.lisp
+./projects/arm/second/fadd64/lshift.lisp
+./projects/arm/second/fadd64/fma.lisp
+./projects/arm/second/fadd64/prelim.lisp
+./projects/arm/second/fadd64/summary.lisp
+./projects/arm/second/fadd64/alignment.lisp
+./projects/arm/second/fadd64/round.lisp
+./projects/arm/second/fadd64/fadd64.lisp
+./projects/arm/second/fadd64/addition.lisp
+./projects/arm/second/fadd64/clz.lisp
+./projects/arm/second/fadd64/comp.lisp
+./projects/arm/second/fadd64/fadd.lisp
+./projects/arm/second/idiv8/ispow2.lisp
+./projects/arm/second/idiv8/prelim.lisp
+./projects/arm/second/idiv8/algorithm.lisp
+./projects/arm/second/idiv8/summary.lisp
+./projects/arm/second/idiv8/loop.lisp
+./projects/arm/second/idiv8/post.lisp
+./projects/arm/second/idiv8/first.lisp
+./projects/arm/second/idiv8/early.lisp
+./projects/arm/second/idiv8/quot.lisp
+./projects/arm/second/idiv8/idiv8.lisp
+./projects/arm/second/idiv8/induct.lisp
+./projects/arm/second/fsqrt4/quotient.lisp
+./projects/arm/second/fsqrt4/special.lisp
+./projects/arm/second/fsqrt4/fsqrt4.lisp
+./projects/arm/second/fsqrt4/rounder.lisp
+./projects/arm/second/fsqrt4/prelim.lisp
+./projects/arm/second/fsqrt4/algorithm.lisp
+./projects/arm/second/fsqrt4/summary.lisp
+./projects/arm/second/fsqrt4/normalize.lisp
+./projects/arm/second/fsqrt4/clz.lisp
+./projects/arm/second/fsqrt4/final.lisp
+./projects/arm/second/fsqrt4/induct.lisp
+./projects/arm/second/fma32/lza.lisp
+./projects/arm/second/fma32/special.lisp
+./projects/arm/second/fma32/hc52.lisp
+./projects/arm/second/fma32/prelim.lisp
+./projects/arm/second/fma32/summary.lisp
+./projects/arm/second/fma32/resrnd.lisp
+./projects/arm/second/fma32/fma32.lisp
+./projects/arm/second/fma32/spec.lisp
+./projects/arm/second/fma32/sum.lisp
+./projects/arm/second/fma32/sumshft.lisp
+./projects/arm/second/fma32/final.lisp
+./projects/arm/second/fma32/addends.lisp
+./projects/arm/second/fmul64/expinc.lisp
+./projects/arm/second/fmul64/fused.lisp
+./projects/arm/second/fmul64/special.lisp
+./projects/arm/second/fmul64/product.lisp
+./projects/arm/second/fmul64/prelim.lisp
+./projects/arm/second/fmul64/unrounded.lisp
+./projects/arm/second/fmul64/fmul64.lisp
+./projects/arm/second/fmul64/summary.lisp
+./projects/arm/second/fmul64/denorm.lisp
+./projects/arm/second/fmul64/norm.lisp
+./projects/arm/second/fmul64/clz.lisp
+./projects/arm/second/fmul64/final.lisp
+./projects/arm/second/fmul64/rndbits.lisp
+./projects/arm/second/fdiv8/quotient.lisp
+./projects/arm/second/fdiv8/special.lisp
+./projects/arm/second/fdiv8/rounder.lisp
+./projects/arm/second/fdiv8/prelim.lisp
+./projects/arm/second/fdiv8/algorithm.lisp
+./projects/arm/second/fdiv8/summary.lisp
+./projects/arm/second/fdiv8/fdiv8.lisp
+./projects/arm/second/fdiv8/normalize.lisp
+./projects/arm/second/fdiv8/clz.lisp
+./projects/arm/second/fdiv8/first.lisp
+./projects/arm/second/fdiv8/final.lisp
+./projects/arm/second/fdiv8/induct.lisp
+./projects/arm/fmul/expinc.lisp
+./projects/arm/fmul/fused.lisp
+./projects/arm/fmul/special.lisp
+./projects/arm/fmul/product.lisp
+./projects/arm/fmul/prelim.lisp
+./projects/arm/fmul/unrounded.lisp
+./projects/arm/fmul/fmul64.lisp
+./projects/arm/fmul/summary.lisp
+./projects/arm/fmul/denorm.lisp
+./projects/arm/fmul/norm.lisp
+./projects/arm/fmul/clz.lisp
+./projects/arm/fmul/final.lisp
+./projects/arm/fmul/rndbits.lisp
+./projects/arm/fsqrt/quotient.lisp
+./projects/arm/fsqrt/fsqrt64.lisp
+./projects/arm/fsqrt/special.lisp
+./projects/arm/fsqrt/rounder.lisp
+./projects/arm/fsqrt/prelim.lisp
+./projects/arm/fsqrt/algorithm.lisp
+./projects/arm/fsqrt/summary.lisp
+./projects/arm/fsqrt/normalize.lisp
+./projects/arm/fsqrt/clz.lisp
+./projects/arm/fsqrt/final.lisp
+./projects/arm/fsqrt/induct.lisp
+./projects/arm/fdiv/quotient.lisp
+./projects/arm/fdiv/special.lisp
+./projects/arm/fdiv/rounder.lisp
+./projects/arm/fdiv/prelim.lisp
+./projects/arm/fdiv/summary.lisp
+./projects/arm/fdiv/fdiv64.lisp
+./projects/arm/fdiv/normalize.lisp
+./projects/arm/fdiv/clz.lisp
+./projects/arm/fdiv/prescale.lisp
+./projects/arm/fdiv/final.lisp
+./projects/arm/fdiv/induct.lisp
+./projects/arm/utils/macros.lisp
+./projects/arm/utils/arith-utils.lisp
+./projects/arm/utils/rtl-utils.lisp
+./projects/arm/utils/aarch64-specs.lisp
+./projects/arm/utils/fp-constants.lisp
+./projects/apply-model-2-deps.lisp
+./projects/cache-coherence/german-protocol/german.lisp
+./projects/cache-coherence/vi/utils.lisp
+./projects/cache-coherence/vi/vi-correct.lisp
+./projects/cache-coherence/vi/vi-impl.lisp
+./projects/rp-rewriter/cl-correct.lisp
+./projects/rp-rewriter/proofs/aux-function-lemmas.lisp
+./projects/rp-rewriter/proofs/extract-formula-lemmas.lisp
+./projects/rp-rewriter/proofs/ex-counterpart-lemmas.lisp
+./projects/rp-rewriter/proofs/apply-meta-lemmas.lisp
+./projects/rp-rewriter/proofs/proof-functions.lisp
+./projects/rp-rewriter/proofs/match-lhs-lemmas.lisp
+./projects/rp-rewriter/proofs/rp-state-functions-lemmas.lisp
+./projects/rp-rewriter/proofs/proof-function-lemmas.lisp
+./projects/rp-rewriter/proofs/eval-functions-lemmas.lisp
+./projects/rp-rewriter/proofs/measure-lemmas.lisp
+./projects/rp-rewriter/proofs/rp-correct.lisp
+./projects/rp-rewriter/proofs/apply-bindings-lemmas.lisp
+./projects/rp-rewriter/proofs/local-lemmas.lisp
+./projects/rp-rewriter/proofs/guards.lisp
+./projects/rp-rewriter/proofs/rp-equal-lemmas.lisp
+./projects/rp-rewriter/proofs/rp-rw-lemmas.lisp
+./projects/rp-rewriter/top.lisp
+./projects/rp-rewriter/user-lemmas.lisp
+./projects/rp-rewriter/extract-formula.lisp
+./projects/rp-rewriter/lib/mult3/adder-rules.lisp
+./projects/rp-rewriter/lib/mult3/meta-top.lisp
+./projects/rp-rewriter/lib/mult3/summation-tree-meta-fncs.lisp
+./projects/rp-rewriter/lib/mult3/summation-tree-meta-fncs-correct.lisp
+./projects/rp-rewriter/lib/mult3/fnc-defs.lisp
+./projects/rp-rewriter/lib/mult3/lemmas-2.lisp
+./projects/rp-rewriter/lib/mult3/equal-meta.lisp
+./projects/rp-rewriter/lib/mult3/sum-merge-fncs-correct.lisp
+./projects/rp-rewriter/lib/mult3/adder-rules-meta.lisp
+./projects/rp-rewriter/lib/mult3/svl-spec.lisp
+./projects/rp-rewriter/lib/mult3/pp-flatten-meta-fncs.lisp
+./projects/rp-rewriter/lib/mult3/demo/demo-1.lisp
+./projects/rp-rewriter/lib/mult3/demo/demo-3.lisp
+./projects/rp-rewriter/lib/mult3/demo/demo-2.lisp
+./projects/rp-rewriter/lib/mult3/spec.lisp
+./projects/rp-rewriter/lib/mult3/sum-merge-fncs.lisp
+./projects/rp-rewriter/lib/mult3/mult-rules.lisp
+./projects/rp-rewriter/lib/mult3/doc.lisp
+./projects/rp-rewriter/lib/mult3/pp-flatten-meta-correct.lisp
+./projects/rp-rewriter/lib/mult3/svl-top.lisp
+./projects/rp-rewriter/lib/mult3/svtv-top.lisp
+./projects/rp-rewriter/lib/mult3/lemmas.lisp
+./projects/rp-rewriter/lib/mult2/adder-rules.lisp
+./projects/rp-rewriter/lib/mult2/meta-top.lisp
+./projects/rp-rewriter/lib/mult2/summation-tree-meta-fncs.lisp
+./projects/rp-rewriter/lib/mult2/summation-tree-meta-fncs-correct.lisp
+./projects/rp-rewriter/lib/mult2/fnc-defs.lisp
+./projects/rp-rewriter/lib/mult2/equal-meta.lisp
+./projects/rp-rewriter/lib/mult2/adder-rules-meta.lisp
+./projects/rp-rewriter/lib/mult2/svl-spec.lisp
+./projects/rp-rewriter/lib/mult2/pp-flatten-meta-fncs.lisp
+./projects/rp-rewriter/lib/mult2/spec.lisp
+./projects/rp-rewriter/lib/mult2/mult-rules.lisp
+./projects/rp-rewriter/lib/mult2/doc.lisp
+./projects/rp-rewriter/lib/mult2/pp-flatten-meta-correct.lisp
+./projects/rp-rewriter/lib/mult2/svl-top.lisp
+./projects/rp-rewriter/lib/mult2/lemmas.lisp
+./projects/rp-rewriter/lib/mult2/demo.lisp
+./projects/rp-rewriter/lib/mult/adder-rules.lisp
+./projects/rp-rewriter/lib/mult/binary-fn-defs.lisp
+./projects/rp-rewriter/lib/mult/top.lisp
+./projects/rp-rewriter/lib/mult/mult-defs.lisp
+./projects/rp-rewriter/lib/mult/svl-spec.lisp
+./projects/rp-rewriter/lib/mult/multiplier-rules.lisp
+./projects/rp-rewriter/lib/mult/spec.lisp
+./projects/rp-rewriter/lib/mult/doc.lisp
+./projects/rp-rewriter/lib/mult/meta/f2-new-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/top.lisp
+./projects/rp-rewriter/lib/mult/meta/pp-flatten-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/equal-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/adder-rules-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/pp-flatten-meta-syntax-correct.lisp
+./projects/rp-rewriter/lib/mult/meta/sum-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/m2-new-meta.lisp
+./projects/rp-rewriter/lib/mult/meta/pp-order-fncs.lisp
+./projects/rp-rewriter/lib/mult/meta/pp-sum-meta.lisp
+./projects/rp-rewriter/lib/mult/svl-top.lisp
+./projects/rp-rewriter/lib/mult/demo.lisp
+./projects/rp-rewriter/lib/mult/greedy-lemmas.lisp
+./projects/rp-rewriter/meta-rule-macros.lisp
+./projects/rp-rewriter/macros.lisp
+./projects/rp-rewriter/eval-functions.lisp
+./projects/rp-rewriter/rp-state-functions.lisp
+./projects/rp-rewriter/misc.lisp
+./projects/rp-rewriter/rp-rewriter.lisp
+./projects/rp-rewriter/portcullis.lisp
+./projects/rp-rewriter/meta/top.lisp
+./projects/rp-rewriter/meta/hons-get-meta.lisp
+./projects/rp-rewriter/meta/equal-meta.lisp
+./projects/rp-rewriter/meta/implies-meta.lisp
+./projects/rp-rewriter/meta/fast-alist-free-meta.lisp
+./projects/rp-rewriter/meta/mv-nth-meta.lisp
+./projects/rp-rewriter/meta/portcullis.lisp
+./projects/rp-rewriter/meta/hons-acons-meta.lisp
+./projects/rp-rewriter/aux-functions.lisp
+./projects/rac/lisp/translate.lisp
+./projects/rac/lisp/internal-fns-gen.lisp
+./projects/rac/examples/imul/imul.lisp
+./projects/rac/examples/imul/proof.lisp
+./projects/leftist-trees/top.lisp
+./projects/leftist-trees/leftist-tree-defthms.lisp
+./projects/leftist-trees/leftist-trees-xdoc.lisp
+./projects/leftist-trees/leftist-tree-sort-equivalent3.lisp
+./projects/leftist-trees/leftist-tree-sort.lisp
+./projects/leftist-trees/leftist-tree-sort-equivalent.lisp
+./projects/leftist-trees/leftist-tree-sort-equivalent2.lisp
+./projects/leftist-trees/leftist-tree-defuns.lisp
+./projects/smtlink/top.lisp
+./projects/smtlink/examples/inverter.lisp
+./projects/smtlink/examples/basictypes.lisp
+./projects/smtlink/examples/ringosc.lisp
+./projects/smtlink/examples/util.lisp
+./projects/smtlink/examples/examples.lisp
+./projects/smtlink/verified/computed-hints.lisp
+./projects/smtlink/verified/uninterpreted-fn-cp.lisp
+./projects/smtlink/verified/hint-please.lisp
+./projects/smtlink/verified/hint-interface.lisp
+./projects/smtlink/verified/Smtlink.lisp
+./projects/smtlink/verified/type-extract-cp.lisp
+./projects/smtlink/verified/pseudo-lambda-lemmas.lisp
+./projects/smtlink/verified/fty.lisp
+./projects/smtlink/verified/basics.lisp
+./projects/smtlink/verified/expand-cp.lisp
+./projects/smtlink/verified/type-hyp.lisp
+./projects/smtlink/verified/add-hypo-cp.lisp
+./projects/smtlink/verified/extractor.lisp
+./projects/smtlink/portcullis.lisp
+./projects/smtlink/trusted/z3-py/header.lisp
+./projects/smtlink/trusted/z3-py/translate-type.lisp
+./projects/smtlink/trusted/z3-py/names.lisp
+./projects/smtlink/trusted/z3-py/magic-fix.lisp
+./projects/smtlink/trusted/z3-py/translator.lisp
+./projects/smtlink/trusted/z3-py/datatypes.lisp
+./projects/smtlink/trusted/z3-py/pretty-printer.lisp
+./projects/smtlink/trusted/z3-py/recover-type-hyp.lisp
+./projects/smtlink/trusted/prove.lisp
+./projects/smtlink/trusted/run.lisp
+./projects/smtlink/trusted/write.lisp
+./projects/smtlink/trusted/trusted-cp.lisp
+./projects/smtlink/doc.lisp
+./projects/smtlink/top-doc.lisp
+./projects/smtlink/config.lisp
+./projects/oracle/stv-invariant-extraction-pitfall/alu.lisp
+./projects/oracle/stv-decomp-theory-expander.lisp
+./projects/equational/weighting.lisp
+./projects/equational/paramod.lisp
+./projects/equational/resolution.lisp
+./projects/equational/general.lisp
+./projects/equational/bewijs.lisp
+./projects/equational/prover.lisp
+./projects/equational/unification.lisp
+./projects/symbolic/m5/utilities.lisp
+./projects/symbolic/m5/demo.lisp
+./projects/symbolic/generic/total-correctness.lisp
+./projects/symbolic/generic/defsimulate.lisp
+./projects/symbolic/generic/tiny-fib-correct.lisp
+./projects/symbolic/generic/measures.lisp
+./projects/symbolic/generic/partial-correctness.lisp
+./projects/symbolic/generic/factorial-jvm-correct.lisp
+./projects/symbolic/generic/assertions.lisp
+./projects/symbolic/tiny-triangle/tiny-triangle-correct.lisp
+./projects/symbolic/tiny-triangle/triangle-def.lisp
+./projects/symbolic/tiny-fib/tiny.lisp
+./projects/symbolic/tiny-fib/defstobj+.lisp
+./projects/symbolic/tiny-fib/tiny-rewrites.lisp
+./projects/symbolic/tiny-fib/fib-def.lisp
+./projects/irv/top.lisp
+./projects/irv/satisfied-criteria.lisp
+./projects/irv/irv.lisp
+./projects/irv/portcullis.lisp
+./projects/sb-machine/proofs/completed/writes-with-fence-dumb.lisp
+./projects/sb-machine/proofs/completed/writes-with-fence-ghost.lisp
+./projects/sb-machine/proofs/completed/stupid2.lisp
+./projects/sb-machine/proofs/completed/fence.lisp
+./projects/sb-machine/proofs/completed/stupid.lisp
+./projects/sb-machine/proofs/completed/portcullis.lisp
+./projects/sb-machine/proofs/completed/writes-with-fence.lisp
+./projects/sb-machine/proofs/completed/stupid3.lisp
+./projects/sb-machine/sb.lisp
+./projects/sb-machine/tools.lisp
+./projects/sb-machine/portcullis.lisp
+./projects/sat/lrat/top.lisp
+./projects/sat/lrat/sorted/lrat-checker-support.lisp
+./projects/sat/lrat/sorted/test-driver.lisp
+./projects/sat/lrat/sorted/lrat-checker.lisp
+./projects/sat/lrat/sorted/run.lisp
+./projects/sat/lrat/sorted/lrat-parser.lisp
+./projects/sat/lrat/incremental/test-driver.lisp
+./projects/sat/lrat/incremental/top.lisp
+./projects/sat/lrat/incremental/soundness.lisp
+./projects/sat/lrat/incremental/print-formula.lisp
+./projects/sat/lrat/incremental/limits.lisp
+./projects/sat/lrat/incremental/incremental.lisp
+./projects/sat/lrat/incremental/clrat-parser.lisp
+./projects/sat/lrat/incremental/run.lisp
+./projects/sat/lrat/incremental/soundness-main.lisp
+./projects/sat/lrat/incremental/soundness-main-1.lisp
+./projects/sat/lrat/early/rev1/truth-monotone.lisp
+./projects/sat/lrat/early/rev1/test-driver.lisp
+./projects/sat/lrat/early/rev1/satisfiable-add-proof-clause.lisp
+./projects/sat/lrat/early/rev1/satisfiable-add-proof-clause-drat.lisp
+./projects/sat/lrat/early/rev1/top.lisp
+./projects/sat/lrat/early/rev1/sat-drat-claim-2-3.lisp
+./projects/sat/lrat/early/rev1/satisfiable-add-proof-clause-rup.lisp
+./projects/sat/lrat/early/rev1/lrat-checker.lisp
+./projects/sat/lrat/early/rev1/soundness.lisp
+./projects/sat/lrat/early/rev1/run.lisp
+./projects/sat/lrat/early/rev1/sat-drat-claim-2.lisp
+./projects/sat/lrat/early/rev1/satisfiable-add-proof-clause-base.lisp
+./projects/sat/lrat/early/rev1/lrat-parser.lisp
+./projects/sat/lrat/early/rev1/unit-propagation-monotone.lisp
+./projects/sat/lrat/early/rev1/sat-drat-claim-1.lisp
+./projects/sat/lrat/early/rev1/unit-propagation-correct.lisp
+./projects/sat/lrat/early/rev1/unit-propagation-implies-unsat.lisp
+./projects/sat/lrat/early/rev2/truth-monotone.lisp
+./projects/sat/lrat/early/rev2/test-driver.lisp
+./projects/sat/lrat/early/rev2/satisfiable-add-proof-clause.lisp
+./projects/sat/lrat/early/rev2/satisfiable-add-proof-clause-drat.lisp
+./projects/sat/lrat/early/rev2/top.lisp
+./projects/sat/lrat/early/rev2/sat-drat-claim-2-3.lisp
+./projects/sat/lrat/early/rev2/satisfiable-add-proof-clause-rup.lisp
+./projects/sat/lrat/early/rev2/lrat-checker.lisp
+./projects/sat/lrat/early/rev2/soundness.lisp
+./projects/sat/lrat/early/rev2/satisfiable-maybe-shrink-formula.lisp
+./projects/sat/lrat/early/rev2/run.lisp
+./projects/sat/lrat/early/rev2/sat-drat-claim-2.lisp
+./projects/sat/lrat/early/rev2/satisfiable-add-proof-clause-base.lisp
+./projects/sat/lrat/early/rev2/lrat-parser.lisp
+./projects/sat/lrat/early/rev2/unit-propagation-monotone.lisp
+./projects/sat/lrat/early/rev2/sat-drat-claim-1.lisp
+./projects/sat/lrat/early/rev2/unit-propagation-correct.lisp
+./projects/sat/lrat/early/rev2/unit-propagation-implies-unsat.lisp
+./projects/sat/lrat/early/drat/drat-checker-basic.lisp
+./projects/sat/lrat/cube/transform.lisp
+./projects/sat/lrat/cube/verify-for-cube-soundness-lemmas.lisp
+./projects/sat/lrat/cube/clean-formula.lisp
+./projects/sat/lrat/cube/run.lisp
+./projects/sat/lrat/cube/cube.lisp
+./projects/sat/lrat/cube/verify-for-cube-soundness.lisp
+./projects/sat/lrat/cube/verify-for-cube-soundness-main.lisp
+./projects/sat/lrat/list-based/truth-monotone.lisp
+./projects/sat/lrat/list-based/test-driver.lisp
+./projects/sat/lrat/list-based/satisfiable-add-proof-clause.lisp
+./projects/sat/lrat/list-based/satisfiable-add-proof-clause-drat.lisp
+./projects/sat/lrat/list-based/top.lisp
+./projects/sat/lrat/list-based/sat-drat-claim-2-3.lisp
+./projects/sat/lrat/list-based/satisfiable-add-proof-clause-rup.lisp
+./projects/sat/lrat/list-based/lrat-checker.lisp
+./projects/sat/lrat/list-based/soundness.lisp
+./projects/sat/lrat/list-based/satisfiable-maybe-shrink-formula.lisp
+./projects/sat/lrat/list-based/run.lisp
+./projects/sat/lrat/list-based/sat-drat-claim-2.lisp
+./projects/sat/lrat/list-based/satisfiable-add-proof-clause-base.lisp
+./projects/sat/lrat/list-based/lrat-parser.lisp
+./projects/sat/lrat/list-based/unit-propagation-monotone.lisp
+./projects/sat/lrat/list-based/sat-drat-claim-1.lisp
+./projects/sat/lrat/list-based/unit-propagation-correct.lisp
+./projects/sat/lrat/list-based/unit-propagation-implies-unsat.lisp
+./projects/sat/lrat/stobj-based/test-driver.lisp
+./projects/sat/lrat/stobj-based/lrat-checker.lisp
+./projects/sat/lrat/stobj-based/soundness.lisp
+./projects/sat/lrat/stobj-based/limits.lisp
+./projects/sat/lrat/stobj-based/run.lisp
+./projects/sat/lrat/stobj-based/equiv.lisp
+./projects/sat/lrat/stobj-based/lrat-parser.lisp
+./projects/sat/lrat/portcullis.lisp
+./projects/sat/zz-resolution-checker/zz-two-pass.lisp
+./projects/sat/zz-resolution-checker/zz.lisp
+./projects/sat/zz-resolution-checker/zz-check.lisp
+./projects/sat/zz-resolution-checker/zz-resolve.lisp
+./projects/sat/zz-resolution-checker/zz-record.lisp
+./projects/sat/zz-resolution-checker/zzv-interface.lisp
+./projects/sat/zz-resolution-checker/zz-induction.lisp
+./projects/sat/proof-checker-array/assignment-equiv.lisp
+./projects/sat/proof-checker-array/top.lisp
+./projects/sat/proof-checker-array/supplemental/all-literals.lisp
+./projects/sat/proof-checker-array/supplemental/literal.lisp
+./projects/sat/proof-checker-array/supplemental/unique.lisp
+./projects/sat/proof-checker-array/supplemental/assignment.lisp
+./projects/sat/proof-checker-array/supplemental/ternary.lisp
+./projects/sat/proof-checker-array/supplemental/mv-nth.lisp
+./projects/sat/proof-checker-array/supplemental/evaluator.lisp
+./projects/sat/proof-checker-array/supplemental/sets.lisp
+./projects/sat/proof-checker-array/supplemental/old-literal.lisp
+./projects/sat/proof-checker-array/supplemental/clause.lisp
+./projects/sat/proof-checker-array/supplemental/sb60.lisp
+./projects/sat/proof-checker-array/supplemental/unit-propagation.lisp
+./projects/sat/proof-checker-array/assignment-st.lisp
+./projects/sat/proof-checker-array/portcullis.lisp
+./projects/sat/proof-checker-array/farray.lisp
+./projects/sat/proof-checker-array/rat-checker-new.lisp
+./projects/sat/proof-checker-itp13/top.lisp
+./projects/sat/proof-checker-itp13/supplemental/all-literals.lisp
+./projects/sat/proof-checker-itp13/supplemental/literal.lisp
+./projects/sat/proof-checker-itp13/supplemental/unique.lisp
+./projects/sat/proof-checker-itp13/supplemental/assignment.lisp
+./projects/sat/proof-checker-itp13/supplemental/ternary.lisp
+./projects/sat/proof-checker-itp13/supplemental/mv-nth.lisp
+./projects/sat/proof-checker-itp13/supplemental/evaluator.lisp
+./projects/sat/proof-checker-itp13/supplemental/sets.lisp
+./projects/sat/proof-checker-itp13/supplemental/clause.lisp
+./projects/sat/proof-checker-itp13/supplemental/unit-propagation.lisp
+./projects/sat/proof-checker-itp13/portcullis.lisp
+./projects/sat/proof-checker-itp13/rat-checker.lisp
+./projects/sat/dimacs-reader/portcullis.lisp
+./projects/sat/dimacs-reader/reader.lisp
+./projects/stateman/stateman22.lisp
+./projects/stateman/portcullis.lisp
+./projects/stateman/byte-addressed-state.lisp
+./projects/execloader/base.lisp
+./projects/execloader/top.lisp
+./projects/execloader/elf-reader.lisp
+./projects/execloader/elf-stobj.lisp
+./projects/execloader/mach-o-stobj.lisp
+./projects/execloader/mach-o-reader.lisp
+./projects/execloader/portcullis.lisp
+./projects/execloader/mach-o-constants.lisp
+./projects/execloader/elf-structs.lisp
+./projects/execloader/mach-o-structs.lisp
+./projects/doc.lisp
+./projects/regex/regex-parse-brace.lisp
+./projects/regex/regex-tests.lisp
+./projects/regex/regex-parse-bracket.lisp
+./projects/regex/regex-fileio.lisp
+./projects/regex/regex-chartrans.lisp
+./projects/regex/regex-parse.lisp
+./projects/regex/equal-based-set.lisp
+./projects/regex/regex-defs.lisp
+./projects/regex/regex-ui.lisp
+./projects/regex/portcullis.lisp
+./projects/regex/grep-command-line.lisp
+./projects/regex/defset-encapsulates.lisp
+./projects/regex/regex-exec.lisp
+./projects/regex/input-list.lisp
+./projects/regex/defset-macros.lisp
+./projects/top-doc.lisp
+./projects/translators/l3-to-acl2-deps.lisp
+./projects/translators/l3-to-acl2/examples/mips/mips.lisp
+./projects/translators/l3-to-acl2/examples/thacker/gold/tiny.lisp
+./projects/translators/l3-to-acl2/examples/thacker/gold/tiny-logic.lisp
+./projects/translators/l3-to-acl2/examples/thacker/tiny-manual.lisp
+./projects/translators/l3-to-acl2/examples/thacker/run.lisp
+./projects/translators/l3-to-acl2/translator/l3.lisp
+./projects/translators/l3-to-acl2/translator/l3-to-acl2.lisp
+./projects/translators/l3-to-acl2/target.lisp
+./projects/security/jfkr/random.lisp
+./projects/security/jfkr/diffie-helman.lisp
+./projects/security/jfkr/encryption.lisp
+./projects/security/jfkr/jfkr.lisp
+./projects/security/sha-2/sha-2.lisp
+./projects/security/util/byte-operations.lisp
+./projects/security/des-ghosh/des.lisp
+./projects/security/des-ghosh/des-test.lisp
+./projects/apply-model-deps.lisp
+./projects/fm9001/de.lisp
+./projects/fm9001/utils.lisp
+./projects/fm9001/tv-alu-help.lisp
+./projects/fm9001/tv-if.lisp
+./projects/fm9001/fm9001-memory.lisp
+./projects/fm9001/post-alu.lisp
+./projects/fm9001/dual-port-ram.lisp
+./projects/fm9001/primitives.lisp
+./projects/fm9001/proofs.lisp
+./projects/fm9001/tv-dec-pass.lisp
+./projects/fm9001/alu-spec.lisp
+./projects/fm9001/regfile.lisp
+./projects/fm9001/expand-fm9001.lisp
+./projects/fm9001/pg-theory.lisp
+./projects/fm9001/constants.lisp
+./projects/fm9001/fast-zero.lisp
+./projects/fm9001/macros.lisp
+./projects/fm9001/pre-alu.lisp
+./projects/fm9001/tree-number.lisp
+./projects/fm9001/control.lisp
+./projects/fm9001/vector-macros.lisp
+./projects/fm9001/unbound.lisp
+./projects/fm9001/store-resultp.lisp
+./projects/fm9001/fm9001-hardware.lisp
+./projects/fm9001/vector-module.lisp
+./projects/fm9001/extend-immediate.lisp
+./projects/fm9001/flags.lisp
+./projects/fm9001/hard-spec.lisp
+./projects/fm9001/memory.lisp
+./projects/fm9001/final-reset.lisp
+./projects/fm9001/assoc-eq-value.lisp
+./projects/fm9001/portcullis.lisp
+./projects/fm9001/v-inc4.lisp
+./projects/fm9001/reg.lisp
+./projects/fm9001/primp-database.lisp
+./projects/fm9001/pad-vectors.lisp
+./projects/fm9001/chip.lisp
+./projects/fm9001/control-modules.lisp
+./projects/fm9001/expand-fm9001-macros.lisp
+./projects/fm9001/list-rewrites.lisp
+./projects/fm9001/monotonicity-macros.lisp
+./projects/fm9001/core-alu.lisp
+./projects/fm9001/v-equal.lisp
+./projects/fm9001/f-functions.lisp
+./projects/fm9001/approx.lisp
+./projects/fm9001/fm9001-spec.lisp
+./projects/fm9001/t-or-nor.lisp
+./projects/async/de.lisp
+./projects/async/utils.lisp
+./projects/async/tv-if.lisp
+./projects/async/index.lisp
+./projects/async/arbitration/arb-merge.lisp
+./projects/async/arbitration/comp-interl1.lisp
+./projects/async/arbitration/interl-ll.lisp
+./projects/async/arbitration/igcd1.lisp
+./projects/async/arbitration/igcd2.lisp
+./projects/async/arbitration/comp-interl2.lisp
+./projects/async/arbitration/arb-merge2.lisp
+./projects/async/arbitration/arb-merge1.lisp
+./projects/async/arbitration/simulators2.lisp
+./projects/async/arbitration/comp-interl.lisp
+./projects/async/arbitration/simulators1.lisp
+./projects/async/arbitration/interl2.lisp
+./projects/async/arbitration/interl1.lisp
+./projects/async/serial-adder/serial-add.lisp
+./projects/async/serial-adder/sipo-sreg.lisp
+./projects/async/serial-adder/serial-sub.lisp
+./projects/async/serial-adder/piso2-sreg.lisp
+./projects/async/serial-adder/simulators.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/de.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/utils.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/alu-spec.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/constants.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/32-bit-serial-adder-control.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/macros.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/adder.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/unbound.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/store-n.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/vector-module.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/memory.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/primp-database.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/control-modules.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/32-bit-serial-adder.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/link-joint.lisp
+./projects/async/serial-adder/32-bit-serial-adder-old/fm9001-spec.lisp
+./projects/async/serial-adder/piso-sreg.lisp
+./projects/async/macros.lisp
+./projects/async/comparators/fast-zero.lisp
+./projects/async/comparators/v-greater.lisp
+./projects/async/comparators/v-less.lisp
+./projects/async/comparators/v-equal.lisp
+./projects/async/comparators/t-or-nor.lisp
+./projects/async/tree-number.lisp
+./projects/async/gcd/gcd1.lisp
+./projects/async/gcd/gcd-spec.lisp
+./projects/async/gcd/comp-gcd.lisp
+./projects/async/gcd/gcd-cond.lisp
+./projects/async/gcd/gcd-body2.lisp
+./projects/async/gcd/comp-gcd-cond.lisp
+./projects/async/gcd/gcd-body3.lisp
+./projects/async/gcd/q10-comp-gcd.lisp
+./projects/async/gcd/gcd-body1.lisp
+./projects/async/gcd/gcd-alg.lisp
+./projects/async/gcd/q10-gcd1.lisp
+./projects/async/gcd/simulators.lisp
+./projects/async/gcd/gcd2.lisp
+./projects/async/gcd/gcd3.lisp
+./projects/async/vector-macros.lisp
+./projects/async/unbound.lisp
+./projects/async/store-n.lisp
+./projects/async/telescope/telescope.lisp
+./projects/async/vector-module.lisp
+./projects/async/hard-spec.lisp
+./projects/async/assoc-eq-value.lisp
+./projects/async/portcullis.lisp
+./projects/async/adders/counter.lisp
+./projects/async/adders/adder.lisp
+./projects/async/adders/subtractor.lisp
+./projects/async/adders/add-sub.lisp
+./projects/async/primp-database.lisp
+./projects/async/merge.lisp
+./projects/async/tools/convert-edif.lisp
+./projects/async/fifo/queue3.lisp
+./projects/async/fifo/queue8-l.lisp
+./projects/async/fifo/round-robin4.lisp
+./projects/async/fifo/alt-branch.lisp
+./projects/async/fifo/queue2.lisp
+./projects/async/fifo/queue5.lisp
+./projects/async/fifo/alt-merge.lisp
+./projects/async/fifo/queue3-l.lisp
+./projects/async/fifo/queue5-l.lisp
+./projects/async/fifo/queue10-l.lisp
+./projects/async/fifo/queue20-l.lisp
+./projects/async/fifo/queue40-l.lisp
+./projects/async/fifo/queue10.lisp
+./projects/async/fifo/queue11-l.lisp
+./projects/async/fifo/queue9-l.lisp
+./projects/async/fifo/simulators.lisp
+./projects/async/fifo/queue4.lisp
+./projects/async/fifo/round-robin2.lisp
+./projects/async/fifo/comp-v-or.lisp
+./projects/async/fifo/queue4-l.lisp
+./projects/async/fifo/round-robin1.lisp
+./projects/async/fifo/wig-wag.lisp
+./projects/async/fifo/round-robin3.lisp
+./projects/async/list-rewrites.lisp
+./projects/async/branch.lisp
+./projects/async/f-functions.lisp
+./projects/async/link-joint.lisp
+./projects/farray/portcullis.lisp
+./projects/farray/farray.lisp
+./projects/quadratic-reciprocity/gauss.lisp
+./projects/quadratic-reciprocity/fermat.lisp
+./projects/quadratic-reciprocity/euler.lisp
+./projects/quadratic-reciprocity/support/gauss.lisp
+./projects/quadratic-reciprocity/support/fermat.lisp
+./projects/quadratic-reciprocity/support/euler.lisp
+./projects/quadratic-reciprocity/support/euclid.lisp
+./projects/quadratic-reciprocity/support/mersenne.lisp
+./projects/quadratic-reciprocity/support/eisenstein.lisp
+./projects/quadratic-reciprocity/support/pratt.lisp
+./projects/quadratic-reciprocity/euclid.lisp
+./projects/quadratic-reciprocity/mersenne.lisp
+./projects/quadratic-reciprocity/eisenstein.lisp
+./projects/quadratic-reciprocity/pratt.lisp
+./projects/legacy-defrstobj/typed-record-tests.lisp
+./projects/legacy-defrstobj/fancy-worseguy.lisp
+./projects/legacy-defrstobj/g-delete-keys.lisp
+./projects/legacy-defrstobj/groundwork/array-rec.lisp
+./projects/legacy-defrstobj/groundwork/demo3.lisp
+./projects/legacy-defrstobj/groundwork/local.lisp
+./projects/legacy-defrstobj/groundwork/demo5.lisp
+./projects/legacy-defrstobj/groundwork/demo2.lisp
+./projects/legacy-defrstobj/groundwork/demo4.lisp
+./projects/legacy-defrstobj/groundwork/demo1.lisp
+./projects/legacy-defrstobj/basic-tests.lisp
+./projects/legacy-defrstobj/def-typed-record.lisp
+./projects/legacy-defrstobj/portcullis.lisp
+./projects/legacy-defrstobj/defrstobj.lisp
+./projects/legacy-defrstobj/array-lemmas.lisp
+./projects/legacy-defrstobj/typed-records.lisp
+./projects/fifo/fifo-list-based.lisp
+./projects/wp-gen/mutrec/mutrec.lisp
+./projects/wp-gen/shared.lisp
+./projects/wp-gen/wp-gen.lisp
+./projects/shnf/top.lisp
+./projects/shnf/support.lisp
+./projects/milawa/doc.lisp
+./projects/srt/support/sqrt.lisp
+./projects/srt/support/seed.lisp
+./projects/srt/support/srt.lisp
+./projects/srt/support/arith.lisp
+./projects/srt/support/division.lisp
+./projects/srt/srt.lisp
+./projects/apply-model/apply-prim.lisp
+./projects/apply-model/apply-constraints.lisp
+./projects/apply-model/ex1/defattach-demo.lisp
+./projects/apply-model/ex1/user-defs.lisp
+./projects/apply-model/ex1/evaluation-lemmas.lisp
+./projects/apply-model/ex1/all-warrants-valid.lisp
+./projects/apply-model/ex1/doppelgangers.lisp
+./projects/apply-model/weights-and-measures.lisp
+./projects/apply-model/apply.lisp
+./projects/apply-model/report.lisp
+./projects/apply-model/portcullis.lisp
+./projects/apply-model/ex2/user-thms.lisp
+./projects/apply-model/ex2/defattach-demo.lisp
+./projects/apply-model/ex2/user-defs.lisp
+./projects/apply-model/ex2/evaluation-lemmas.lisp
+./projects/apply-model/ex2/all-warrants-valid.lisp
+./projects/apply-model/ex2/doppelgangers.lisp
+./projects/filesystems/tar-stuff.lisp
+./projects/filesystems/file-system-lemmas.lisp
+./projects/filesystems/hifat.lisp
+./projects/filesystems/oracle.lisp
+./projects/filesystems/test-stuff.lisp
+./projects/filesystems/lofat-to-string-inversion.lisp
+./projects/filesystems/lofat.lisp
+./projects/filesystems/examples/ls-rm-example.lisp
+./projects/filesystems/examples/wc-truncate-example.lisp
+./projects/filesystems/hifat-to-lofat-inversion.lisp
+./projects/filesystems/lofat-syscalls.lisp
+./projects/filesystems/l-models/file-system-4.lisp
+./projects/filesystems/l-models/file-system-1.lisp
+./projects/filesystems/l-models/file-system-3.lisp
+./projects/filesystems/l-models/file-system-6.lisp
+./projects/filesystems/l-models/file-system-2.lisp
+./projects/filesystems/l-models/file-system-5.lisp
+./projects/filesystems/eqfat.lisp
+./projects/filesystems/fat32.lisp
+./projects/filesystems/hifat-syscalls.lisp
+./projects/filesystems/hifat/hifat-cluster-count.lisp
+./projects/filesystems/hifat/hifat-equiv.lisp
+./projects/filesystems/hifat/hifat-entry-count.lisp
+./projects/filesystems/test/mkfs.fat-3.0.20-replicant.lisp
+./projects/filesystems/test/ls-replicant.lisp
+./projects/filesystems/test/truncate-replicant.lisp
+./projects/filesystems/test/wc-replicant.lisp
+./projects/filesystems/test/rm-replicant.lisp
+./projects/filesystems/test/compare-disks.lisp
+./projects/filesystems/test/read-disk-image-write-disk-image.lisp
+./projects/filesystems/test/mv-replicant.lisp
+./projects/filesystems/test/tar-writer.lisp
+./projects/filesystems/test/mkdir-replicant.lisp
+./projects/filesystems/test/rmdir-replicant.lisp
+./projects/filesystems/test/tar-reader.lisp
+./projects/filesystems/test/cp-replicant.lisp
+./projects/filesystems/test/stat-replicant.lisp
+./projects/filesystems/test/mkfs.fat-3.0.28-replicant.lisp
+./projects/filesystems/test/mkfs.fat-4.1-replicant.lisp
+./projects/filesystems/utilities/cluster-listp.lisp
+./projects/filesystems/utilities/member-intersectp.lisp
+./projects/filesystems/utilities/block-listp.lisp
+./projects/filesystems/utilities/bounded-nat-listp.lisp
+./projects/filesystems/utilities/set-indices.lisp
+./projects/filesystems/utilities/flatten-equiv.lisp
+./projects/filesystems/utilities/insert-text.lisp
+./projects/filesystems/utilities/find-n-free-blocks.lisp
+./projects/filesystems/utilities/generate-index-list.lisp
+./projects/filesystems/utilities/not-intersectp-list.lisp
+./projects/filesystems/lofat/lofat-place-file.lisp
+./projects/filesystems/lofat/update-data-region.lisp
+./projects/filesystems/lofat/fat32-in-memory.lisp
+./projects/filesystems/lofat/lofat-pwrite.lisp
+./projects/filesystems/lofat/lofat-remove-file.lisp
+./projects/filesystems/lofat/lofat-mkdir.lisp
+./projects/filesystems/lofat/stobj-find-n-free-clusters.lisp
+./projects/filesystems/abs-separate.lisp
+./projects/filesystems/absfat/abs-find-file-src.lisp
+./projects/filesystems/absfat/path-clear.lisp
+./projects/filesystems/absfat/partial-collapse.lisp
+./projects/filesystems/absfat/abs-alloc.lisp
+./projects/filesystems/absfat/chain-leading-to-complete.lisp
+./projects/filesystems/absfat/abs-find-file.lisp
+./projects/filesystems/examples.lisp
+./projects/filesystems/abs-syscalls.lisp
+./projects/filesystems/l-models.lisp
+./defexec/reflexive/reflexive.lisp
+./defexec/ordinals/supporting-ordinals.lisp
+./defexec/defpun-exec/defpun-exec.lisp
+./defexec/find-path/fpst.lisp
+./defexec/find-path/graph/linear-find-path.lisp
+./defexec/find-path/graph/find-path2.lisp
+./defexec/find-path/graph/helpers.lisp
+./defexec/find-path/graph/find-path3.lisp
+./defexec/find-path/graph/find-path1.lisp
+./defexec/find-path/run-fpst.lisp
+./defexec/other-apps/qsort/programs.lisp
+./defexec/other-apps/qsort/first-last.lisp
+./defexec/other-apps/qsort/intermediate-to-spec.lisp
+./defexec/other-apps/qsort/spec-properties.lisp
+./defexec/other-apps/qsort/merge-intermediate.lisp
+./defexec/other-apps/qsort/nth-update-nth.lisp
+./defexec/other-apps/qsort/sort-qs-properties.lisp
+./defexec/other-apps/qsort/load-extract.lisp
+./defexec/other-apps/qsort/final-theorem.lisp
+./defexec/other-apps/qsort/total-order.lisp
+./defexec/other-apps/qsort/permutations.lisp
+./defexec/other-apps/qsort/intermediate-program.lisp
+./defexec/other-apps/qsort/split-qs-properties.lisp
+./defexec/other-apps/qsort/extraction.lisp
+./defexec/other-apps/misc/stobjsim.lisp
+./defexec/other-apps/misc/memos.lisp
+./defexec/other-apps/records/records.lisp
+./defexec/other-apps/records/inline.lisp
+./defexec/other-apps/records/recordsim.lisp
+./defexec/dag-unification/dag-unification-st.lisp
+./defexec/dag-unification/terms.lisp
+./defexec/dag-unification/list-unification-rules.lisp
+./defexec/dag-unification/subsumption-subst.lisp
+./defexec/dag-unification/terms-dag-stobj.lisp
+./defexec/dag-unification/dag-unification-l.lisp
+./defexec/dag-unification/subsumption.lisp
+./defexec/dag-unification/matching.lisp
+./defexec/dag-unification/dags.lisp
+./defexec/dag-unification/basic.lisp
+./defexec/dag-unification/dag-unification-rules.lisp
+./defexec/dag-unification/terms-as-dag.lisp
+./doc/compare-fast-vs-slow.lisp
+./doc/top-slow.lisp
+./doc/top.lisp
+./doc/practices.lisp
+./doc/top-topic.lisp
+./doc/more-topics.lisp
+./doc/relnotes.lisp
+./xdoc/preprocess.lisp
+./xdoc/base.lisp
+./xdoc/fmt-to-str.lisp
+./xdoc/top.lisp
+./xdoc/parse-xml.lisp
+./xdoc/unsound-eval.lisp
+./xdoc/word-wrap.lisp
+./xdoc/xtopic.lisp
+./xdoc/fmt-to-str-orig.lisp
+./xdoc/display.lisp
+./xdoc/book-thms.lisp
+./xdoc/importance.lisp
+./xdoc/linkcheck.lisp
+./xdoc/names.lisp
+./xdoc/archive.lisp
+./xdoc/verbosep.lisp
+./xdoc/book-thms-example.lisp
+./xdoc/save-rendered.lisp
+./xdoc/defxdoc-raw.lisp
+./xdoc/autolink.lisp
+./xdoc/save.lisp
+./xdoc/tests/preprocessor-tests.lisp
+./xdoc/tests/unsound-eval-tests.lisp
+./xdoc/tests/defsection-tests.lisp
+./xdoc/str.lisp
+./xdoc/debug.lisp
+./xdoc/import-acl2doc.lisp
+./xdoc/alter.lisp
+./xdoc/spellcheck.lisp
+./xdoc/defxdoc-plus.lisp
+./xdoc/archive-matching-topics.lisp
+./xdoc/topics.lisp
+./xdoc/constructors.lisp
+./xdoc/save-fancy.lisp
+./xdoc/xdoc-error.lisp
+./xdoc/all.lisp
+./xdoc/defxdoc-plus-tests.lisp
+./xdoc/save-classic.lisp
+./xdoc/prepare-topic.lisp
+./finite-set-theory/total-ordering.lisp
+./finite-set-theory/set-theory.lisp
+./bdd/cbf.lisp
+./bdd/pg-theory.lisp
+./bdd/alu.lisp
+./bdd/bool-ops.lisp
+./bdd/alu-proofs.lisp
+./bdd/bdd-primitives.lisp
+./bdd/hamming.lisp
+./data-structures/alist-defthms.lisp
+./data-structures/no-duplicates.lisp
+./data-structures/list-defuns.lisp
+./data-structures/utilities.lisp
+./data-structures/alist-defuns.lisp
+./data-structures/number-list-theory.lisp
+./data-structures/top.lisp
+./data-structures/list-defthms.lisp
+./data-structures/number-list-defuns.lisp
+./data-structures/alist-theory.lisp
+./data-structures/list-theory.lisp
+./data-structures/number-list-defthms.lisp
+./data-structures/memories/memory-impl.lisp
+./data-structures/memories/private.lisp
+./data-structures/memories/memory.lisp
+./data-structures/memories/portcullis.lisp
+./data-structures/memories/log2.lisp
+./data-structures/memories/memtree.lisp
+./data-structures/array1.lisp
+./data-structures/portcullis.lisp
+./data-structures/structures.lisp
+./data-structures/defalist.lisp
+./data-structures/set-defthms.lisp
+./data-structures/set-theory.lisp
+./data-structures/set-defuns.lisp
+./data-structures/deflist.lisp
+./coi/generalize/generalize.lisp
+./coi/lists/list-top.lisp
+./coi/lists/memberp.lisp
+./coi/lists/acl2-count.lisp
+./coi/lists/listset-induction.lisp
+./coi/lists/mixed.lisp
+./coi/lists/set.lisp
+./coi/lists/disjoint.lisp
+./coi/lists/nth-and-update-nth.lisp
+./coi/lists/nth-meta.lisp
+./coi/lists/update-nth-array.lisp
+./coi/lists/subsetp.lisp
+./coi/lists/mv-nth.lisp
+./coi/lists/repeat.lisp
+./coi/lists/nth-meta2.lisp
+./coi/lists/portcullis.lisp
+./coi/lists/map-cons.lisp
+./coi/lists/basic.lisp
+./coi/lists/remove-induction.lisp
+./coi/lists/find-index.lisp
+./coi/lists/remove.lisp
+./coi/super-ihs/plus-logapp-suck.lisp
+./coi/super-ihs/hacks.lisp
+./coi/super-ihs/carry.lisp
+./coi/super-ihs/logcar.lisp
+./coi/super-ihs/logapp.lisp
+./coi/super-ihs/lshu.lisp
+./coi/super-ihs/evenp.lisp
+./coi/super-ihs/logcons.lisp
+./coi/super-ihs/meta.lisp
+./coi/super-ihs/from-rtl.lisp
+./coi/super-ihs/inductions.lisp
+./coi/super-ihs/eric.lisp
+./coi/super-ihs/bit-functions.lisp
+./coi/super-ihs/arithmetic.lisp
+./coi/super-ihs/basics.lisp
+./coi/super-ihs/logpair.lisp
+./coi/super-ihs/logtail.lisp
+./coi/super-ihs/logbitp.lisp
+./coi/super-ihs/unsigned-byte-p.lisp
+./coi/super-ihs/logical-logops.lisp
+./coi/super-ihs/logbit.lisp
+./coi/super-ihs/fast.lisp
+./coi/super-ihs/logior-logapp-crock.lisp
+./coi/super-ihs/loghead.lisp
+./coi/super-ihs/logcdr.lisp
+./coi/super-ihs/loglist.lisp
+./coi/super-ihs/super-ihs.lisp
+./coi/super-ihs/byte-p.lisp
+./coi/super-ihs/symbols.lisp
+./coi/super-ihs/bit-twiddling-logops.lisp
+./coi/super-ihs/signed-byte-p-overflow.lisp
+./coi/super-ihs/iter-sqrt.lisp
+./coi/super-ihs/c-functions.lisp
+./coi/super-ihs/logext.lisp
+./coi/super-ihs/min-max.lisp
+./coi/super-ihs/ash.lisp
+./coi/defpun/defminterm.lisp
+./coi/defpun/ack.lisp
+./coi/defpun/defpun.lisp
+./coi/defpun/defxch.lisp
+./coi/paths/defs.lisp
+./coi/paths/meta.lisp
+./coi/paths/cp-set.lisp
+./coi/paths/diverge.lisp
+./coi/paths/compatibility.lisp
+./coi/paths/dominates.lisp
+./coi/paths/list-path-connection.lisp
+./coi/paths/portcullis.lisp
+./coi/paths/equiv.lisp
+./coi/paths/pm.lisp
+./coi/paths/path.lisp
+./coi/paths/hints.lisp
+./coi/dtrees/base.lisp
+./coi/dtrees/top.lisp
+./coi/dtrees/child.lisp
+./coi/dtrees/royalp.lisp
+./coi/dtrees/set.lisp
+./coi/dtrees/deps.lisp
+./coi/dtrees/portcullis.lisp
+./coi/dtrees/dtree-examples.lisp
+./coi/dtrees/equiv.lisp
+./coi/dtrees/erase.lisp
+./coi/dtrees/raw.lisp
+./coi/dtrees/leafp.lisp
+./coi/gacc/gacc-pkg.lisp
+./coi/gacc/gacc3.lisp
+./coi/gacc/gacc.lisp
+./coi/gacc/mem-fast.lisp
+./coi/gacc/top.lisp
+./coi/gacc/gacc-exports.lisp
+./coi/gacc/gacc2.lisp
+./coi/gacc/list-ops-fast.lisp
+./coi/gacc/ram0.lisp
+./coi/gacc/gax.lisp
+./coi/gacc/tr-path-connection.lisp
+./coi/gacc/portcullis.lisp
+./coi/gacc/ram.lisp
+./coi/gacc/abstract-gacc.lisp
+./coi/gacc/list-ops-common.lisp
+./coi/gacc/block.lisp
+./coi/gacc/wrap.lisp
+./coi/gacc/mem.lisp
+./coi/gacc/finite.lisp
+./coi/gacc/addr-range.lisp
+./coi/gacc/ram3.lisp
+./coi/gacc/fr-path-connection.lisp
+./coi/gacc/ram2b.lisp
+./coi/gacc/bits.lisp
+./coi/gacc/list-ops.lisp
+./coi/gacc/ram2.lisp
+./coi/symbol-fns/symbol-fns.lisp
+./coi/symbol-fns/portcullis.lisp
+./coi/symbol-fns/symbol-fns-exports.lisp
+./coi/bags/extras.lisp
+./coi/bags/top.lisp
+./coi/bags/meta.lisp
+./coi/bags/two-level-meta.lisp
+./coi/bags/two-level.lisp
+./coi/bags/eric-meta.lisp
+./coi/bags/bind-free-rules.lisp
+./coi/bags/cons.lisp
+./coi/bags/pick-a-point.lisp
+./coi/bags/portcullis.lisp
+./coi/bags/neq.lisp
+./coi/bags/basic.lisp
+./coi/maps/maps.lisp
+./coi/maps/typed-maps.lisp
+./coi/maps/portcullis.lisp
+./coi/maps/aliases.lisp
+./coi/nary/nary-mod.lisp
+./coi/nary/nary.lisp
+./coi/nary/ordinal-order.lisp
+./coi/nary/example2.lisp
+./coi/nary/test.lisp
+./coi/nary/rewrite-equal-hint.lisp
+./coi/nary/skip-rewrite.lisp
+./coi/nary/portcullis.lisp
+./coi/nary/new.lisp
+./coi/nary/nth-rules.lisp
+./coi/nary/example.lisp
+./coi/defung/split.lisp
+./coi/defung/rev3.lisp
+./coi/defung/ack-variants.lisp
+./coi/defung/map-ec-call.lisp
+./coi/defung/phony-induction.lisp
+./coi/defung/defung-stress-long.lisp
+./coi/defung/defung-stress.lisp
+./coi/defung/defung.lisp
+./coi/defung/portcullis.lisp
+./coi/defung/fractran.lisp
+./coi/defung/monadic.lisp
+./coi/defung/defung-test.lisp
+./coi/util/fixequiv.lisp
+./coi/util/extra-info.lisp
+./coi/util/ith.lisp
+./coi/util/deffix.lisp
+./coi/util/iff.lisp
+./coi/util/defun-support.lisp
+./coi/util/ifixequiv.lisp
+./coi/util/ordinal-order.lisp
+./coi/util/syntaxp.lisp
+./coi/util/in-conclusion.lisp
+./coi/util/nfixequiv.lisp
+./coi/util/rule-sets-documentation.lisp
+./coi/util/ifdef.lisp
+./coi/util/implies.lisp
+./coi/util/mv-nth.lisp
+./coi/util/defsubtype.lisp
+./coi/util/clause-processor.lisp
+./coi/util/table.lisp
+./coi/util/defun.lisp
+./coi/util/tau.lisp
+./coi/util/rule-sets-support.lisp
+./coi/util/pseudo-translate.lisp
+./coi/util/recursion-support.lisp
+./coi/util/skip-rewrite.lisp
+./coi/util/rewrite-equiv.lisp
+./coi/util/portcullis.lisp
+./coi/util/eliminate-complex-polys.lisp
+./coi/util/rule-sets.lisp
+./coi/util/debug.lisp
+./coi/util/extra-info-test.lisp
+./coi/util/type-alist.lisp
+./coi/util/linearize-complex-polys.lisp
+./coi/util/defbinding.lisp
+./coi/util/good-rewrite-order.lisp
+./coi/util/defdoc.lisp
+./coi/adviser/test.lisp
+./coi/adviser/adviser.lisp
+./coi/adviser/portcullis.lisp
+./coi/adviser/adviser-pkg.lisp
+./coi/osets/sort.lisp
+./coi/osets/extras.lisp
+./coi/osets/conversions.lisp
+./coi/osets/listsets-base.lisp
+./coi/osets/primitives.lisp
+./coi/osets/quantify.lisp
+./coi/osets/outer.lisp
+./coi/osets/multiappend.lisp
+./coi/osets/set-order.lisp
+./coi/osets/multicons.lisp
+./coi/osets/set-processor.lisp
+./coi/osets/sets.lisp
+./coi/osets/listsets.lisp
+./coi/osets/fast.lisp
+./coi/osets/membership.lisp
+./coi/osets/map.lisp
+./coi/quantification/quantified-equivalence.lisp
+./coi/quantification/quantified-congruence.lisp
+./coi/quantification/quantification.lisp
+./coi/quantification/portcullis.lisp
+./coi/alists/top.lisp
+./coi/alists/subkeyquiv.lisp
+./coi/alists/clearkey.lisp
+./coi/alists/strip.lisp
+./coi/alists/keyquiv.lisp
+./coi/alists/bindequiv.lisp
+./coi/alists/alist-pkg.lisp
+./coi/alists/deshadow.lisp
+./coi/alists/portcullis.lisp
+./coi/alists/preimage.lisp
+./coi/alists/equiv.lisp
+./coi/termination/assuming/zero.lisp
+./coi/termination/assuming/compiler-proof.lisp
+./coi/termination/assuming/complex.lisp
+./coi/termination/assuming/compiler.lisp
+./coi/defstructure/defstructure.lisp
+./coi/defstructure/portcullis.lisp
+./coi/defstructure/defstructure-pkg.lisp
+./coi/syntax/quine.lisp
+./coi/syntax/syntax.lisp
+./coi/syntax/auxilary.lisp
+./coi/syntax/syntax-extensions.lisp
+./coi/syntax/syn-pkg.lisp
+./coi/syntax/portcullis.lisp
+./coi/syntax/defbinding.lisp
+./coi/syntax/defevaluator.lisp
+./coi/records/defarray.lisp
+./coi/records/records.lisp
+./coi/records/domain.lisp
+./coi/records/defrecord-fast.lisp
+./coi/records/defrecord.lisp
+./coi/records/fast/memory-impl.lisp
+./coi/records/fast/private.lisp
+./coi/records/fast/memory.lisp
+./coi/records/fast/log2.lisp
+./coi/records/fast/memtree.lisp
+./coi/records/fixedpoint.lisp
+./coi/records/memory.lisp
+./coi/records/portcullis.lisp
+./coi/records/mem-domain.lisp
+./coi/records/set-domain.lisp
+./coi/gensym/gensym.lisp
+./coi/gensym/gensym-list.lisp
+./coi/documentation.lisp
+./system/apply/apply-prim.lisp
+./system/apply/apply-constraints.lisp
+./system/apply/apply.lisp
+./system/apply/apply-prim-support.lisp
+./system/apply/loop-scions.lisp
+./system/toothbrush-deps.lisp
+./system/doc/render-doc-base.lisp
+./system/doc/render-doc.lisp
+./system/doc/acl2-doc-wrap.lisp
+./system/doc/acl2-manual.lisp
+./system/doc/portcullis.lisp
+./system/doc/developers-guide.lisp
+./system/doc/acl2-doc.lisp
+./system/doc/convert-legacy-doc/export-acl2doc.lisp
+./system/doc/convert-legacy-doc/write-acl2-xdoc.lisp
+./system/doc/convert-legacy-doc/import-acl2doc.lisp
+./system/origin.lisp
+./system/worldp-check.lisp
+./system/subst-expr.lisp
+./system/obviously-equiv-terms.lisp
+./system/top.lisp
+./system/event-names.lisp
+./system/verified-termination-and-guards.lisp
+./system/too-many-ifs.lisp
+./system/legal-variablep.lisp
+./system/compare-out-files.lisp
+./system/devel-check.lisp
+./system/case-match.lisp
+./system/pseudo-tests-and-callsp.lisp
+./system/check-system-guards.lisp
+./system/pcert/top.lisp
+./system/pcert/pkg-test.lisp
+./system/pcert/sub.lisp
+./system/pcert/elide-test.lisp
+./system/pcert/mid.lisp
+./system/pcert/acl2x-pcert-test-2-include.lisp
+./system/pcert/acl2x-pcert-test-2.lisp
+./system/pcert/acl2x-pcert-test-1.lisp
+./system/convert-normalized-term-to-pairs.lisp
+./system/pseudo-command-formp.lisp
+./system/extend-pathname.lisp
+./system/deps-pcert.lisp
+./system/sublis-var.lisp
+./system/cantor-pairing-bijective.lisp
+./system/meta-extract.lisp
+./system/remove-guard-holders-lemmas.lisp
+./system/observation1-cw.lisp
+./system/pseudo-event-formp.lisp
+./system/f-put-global.lisp
+./system/toothbrush/make-toothbrush.lisp
+./system/toothbrush/tests/test-par/test-par.lisp
+./system/toothbrush/tests/test2/test2.lisp
+./system/toothbrush/tests/test1/test1.lisp
+./system/parallel/syntax-tests.lisp
+./system/parallel/proofs/ideal-speedup.lisp
+./system/parallel/hint-tests.lisp
+./system/parallel/spec-mv-let.lisp
+./system/parallel/stress-tests.lisp
+./system/fancy-string-reader-test.lisp
+./system/bind-macro-args.lisp
+./system/pseudo-termp-lemmas.lisp
+./system/merge-sort-term-order.lisp
+./system/fmx-cw.lisp
+./system/dead-source-code.lisp
+./system/optimize-check.lisp
+./system/pseudo-event-landmarkp.lisp
+./system/untranslate-car-cdr.lisp
+./system/subcor-var.lisp
+./system/acl2-system-exports.lisp
+./system/tests/nested-stobj-formals.lisp
+./system/tests/nested-stobj-tests.lisp
+./system/tests/apply-timings.lisp
+./system/tests/verify-termination/top.lisp
+./system/tests/verify-termination/sub.lisp
+./system/tests/cached-fn-inst.lisp
+./system/tests/apply-in-proofs.lisp
+./system/tests/stobj-issues.lisp
+./system/tests/non-executable-stobj.lisp
+./system/tests/induction-rule-with-disabled-scheme.lisp
+./system/tests/fmt-to-string-pkg.lisp
+./system/tests/nested-stobj-two-updates.lisp
+./system/tests/nested-stobj-errors-book.lisp
+./system/tests/cert-data/top1a.lisp
+./system/tests/cert-data/top.lisp
+./system/tests/cert-data/verify-termination.lisp
+./system/tests/cert-data/redef.lisp
+./system/tests/cert-data/encap.lisp
+./system/tests/cert-data/sub1.lisp
+./system/tests/cert-data/top1.lisp
+./system/tests/swap-stobjs.lisp
+./system/tests/defstub.lisp
+./system/tests/state-p-in-guard.lisp
+./system/tests/loop-tests.lisp
+./system/tests/local-stobj.lisp
+./system/tests/untranslate.lisp
+./system/tests/abstract-stobj-nesting/two-ordered-nums-stobj.lisp
+./system/tests/abstract-stobj-nesting/aliasing-tests-book.lisp
+./system/tests/abstract-stobj-nesting/absstobj-with-stobj-array.lisp
+./system/tests/abstract-stobj-nesting/nested-abstract-stobjs-book.lisp
+./system/tests/abstract-stobj-nesting/abs-abs.lisp
+./system/tests/abstract-stobj-nesting/two-usuallyequal-nums-stobj.lisp
+./system/tests/abstract-stobj-nesting/two-usuallyequal-nums-stobj-simpler.lisp
+./system/tests/abstract-stobj-nesting/swap-stobjs-test.lisp
+./system/tests/abstract-stobj-nesting/input-signature-mismatch-with-logic-ok.lisp
+./system/tests/apply-with-memoization.lisp
+./system/tests/early-load-of-compiled/big-const-hons.lisp
+./system/tests/early-load-of-compiled/top.lisp
+./system/tests/early-load-of-compiled/hons-acons-bang-local.lisp
+./system/tests/early-load-of-compiled/fast-alist-local.lisp
+./system/tests/early-load-of-compiled/test1.lisp
+./system/tests/early-load-of-compiled/defun-fast-alist.lisp
+./system/tests/early-load-of-compiled/fast-alist-hons-copy.lisp
+./system/tests/early-load-of-compiled/hons-acons-bang.lisp
+./system/tests/early-load-of-compiled/eq-test.lisp
+./system/tests/early-load-of-compiled/big-def-hons.lisp
+./system/tests/early-load-of-compiled/test2-local.lisp
+./system/tests/early-load-of-compiled/test1-local.lisp
+./system/tests/early-load-of-compiled/fast-alist.lisp
+./system/tests/early-load-of-compiled/hons.lisp
+./system/tests/early-load-of-compiled/big-const.lisp
+./system/tests/early-load-of-compiled/fast-alist-hons-copy-local.lisp
+./system/tests/early-load-of-compiled/hons-local.lisp
+./system/tests/early-load-of-compiled/test2.lisp
+./system/tests/early-load-of-compiled/ttag.lisp
+./system/tests/fmt-to-string.lisp
+./system/tests/read-file-into-string.lisp
+./system/tests/defun-sk-tests.lisp
+./system/tests/tau-contradiction.lisp
+./system/kestrel.lisp
+./system/random.lisp
+./system/pseudo-tests-and-calls-listp.lisp
+./system/hl-addr-combine.lisp
+./system/hl-nat-combine-onto.lisp
+./system/pseudo-command-landmarkp.lisp
+./system/termp.lisp
+./system/merge-sort-symbol-lt.lisp
+./system/bigger-limits.lisp
+./system/pseudo-good-worldp.lisp
+./system/subst-var.lisp
+./system/remove-guard-holders.lisp
+./system/pseudo-event-form-listp.lisp
+./system/optimize-check-aux.lisp
+./system/update-state.lisp
+./system/hons-check/hons-check.lisp
+./system/hons-check/memoize-tests.lisp
+./system/hons-check/basic.lisp
+./system/all-fnnames.lisp
+./oslib/copy-logic.lisp
+./oslib/ls-logic.lisp
+./oslib/file-types-logic.lisp
+./oslib/copy.lisp
+./oslib/top-logic.lisp
+./oslib/top.lisp
+./oslib/rmtree.lisp
+./oslib/dirname-logic.lisp
+./oslib/file-types.lisp
+./oslib/tempfile.lisp
+./oslib/mkdir.lisp
+./oslib/mkdir-logic.lisp
+./oslib/catpath.lisp
+./oslib/tests/copy.lisp
+./oslib/tests/top.lisp
+./oslib/tests/file-types.lisp
+./oslib/tests/mkdir.lisp
+./oslib/tests/ls.lisp
+./oslib/tests/lisptype.lisp
+./oslib/tests/dirname.lisp
+./oslib/tests/date.lisp
+./oslib/tests/getpid.lisp
+./oslib/portcullis.lisp
+./oslib/tempfile-logic.lisp
+./oslib/argv.lisp
+./oslib/ls.lisp
+./oslib/lisptype-logic.lisp
+./oslib/lisptype.lisp
+./oslib/getpid-logic.lisp
+./oslib/argv-logic.lisp
+./oslib/dirname.lisp
+./oslib/date.lisp
+./oslib/getpid.lisp
+./oslib/rmtree-logic.lisp
+./oslib/date-logic.lisp
+./oslib/read-acl2-oracle.lisp
+./proof-builder/extras.lisp
+./workshops/2011/verbeek-schmaltz/sources/invariants.lisp
+./workshops/2011/verbeek-schmaltz/sources/correctness2.lisp
+./workshops/2011/verbeek-schmaltz/sources/GeNoC-misc.lisp
+./workshops/2011/verbeek-schmaltz/sources/invariants2.lisp
+./workshops/2011/verbeek-schmaltz/sources/algorithm.lisp
+./workshops/2011/verbeek-schmaltz/sources/invariants3.lisp
+./workshops/2011/verbeek-schmaltz/sources/definitions.lisp
+./workshops/2011/verbeek-schmaltz/sources/GeNoC-types.lisp
+./workshops/2011/verbeek-schmaltz/sources/correctness.lisp
+./workshops/2011/verbeek-schmaltz/sources/perm.lisp
+./workshops/2011/verbeek-schmaltz/deps.lisp
+./workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.lisp
+./workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.lisp
+./workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.lisp
+./workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.lisp
+./workshops/2011/krug-et-al/support/Y86/asm.lisp
+./workshops/2011/krug-et-al/support/Y86/y86.lisp
+./workshops/2011/krug-et-al/support/MinVisor/setup-nested-page-tables.lisp
+./workshops/2011/krug-et-al/support/MinVisor/va-to-pa-thm.lisp
+./workshops/2011/krug-et-al/support/Utilities/records.lisp
+./workshops/2011/krug-et-al/support/Utilities/disjoint.lisp
+./workshops/2011/krug-et-al/support/Utilities/misc.lisp
+./workshops/2011/krug-et-al/support/Utilities/total-order.lisp
+./workshops/2011/krug-et-al/support/Utilities/bytes-and-words.lisp
+./workshops/2011/krug-et-al/support/Symbolic/defsimulate+.lisp
+./workshops/2011/krug-et-al/support/Symbolic/extended-partial-correctness.lisp
+./workshops/2011/krug-et-al/support/Symbolic/vanilla-partial-correctness.lisp
+./workshops/2011/krug-et-al/support/Memory/memory-acl2.lisp
+./workshops/2011/krug-et-al/support/Memory/memory-raw.lisp
+./workshops/2011/krug-et-al/support/Memory/memory.lisp
+./workshops/2011/krug-et-al/support/Memory/memory-low.lisp
+./workshops/2011/krug-et-al/support/Memory/paging.lisp
+./workshops/2015/chau-kaufmann-hunt/support/utils.lisp
+./workshops/2015/chau-kaufmann-hunt/support/cosines-orthog.lisp
+./workshops/2015/chau-kaufmann-hunt/support/riemann-integral/continuity-2.lisp
+./workshops/2015/chau-kaufmann-hunt/support/riemann-integral/continuous-function-2.lisp
+./workshops/2015/chau-kaufmann-hunt/support/riemann-integral/ftc-1-2.lisp
+./workshops/2015/chau-kaufmann-hunt/support/fourier-coefficients-2.lisp
+./workshops/2015/chau-kaufmann-hunt/support/sine-cosine-orthog.lisp
+./workshops/2015/chau-kaufmann-hunt/support/int-sum.lisp
+./workshops/2015/chau-kaufmann-hunt/support/int-infinite-sum-1.lisp
+./workshops/2015/chau-kaufmann-hunt/support/sines-orthog.lisp
+./workshops/2015/chau-kaufmann-hunt/support/fourier-sums.lisp
+./workshops/2015/chau-kaufmann-hunt/support/fourier-coefficients.lisp
+./workshops/2015/chau-kaufmann-hunt/support/fourier-inner-product.lisp
+./workshops/2015/chau-kaufmann-hunt/support/int-infinite-sum-2.lisp
+./workshops/2015/hardin/support/occurrences-llvm.lisp
+./workshops/2015/hardin/support/LL2.lisp
+./workshops/2015/jain-manolios/support/stack-machine/buffered-stack-cap-3.lisp
+./workshops/2015/jain-manolios/support/stack-machine/buffered-stack-cap-2.lisp
+./workshops/2015/jain-manolios/support/vectorizing-transformation/op-semantics.lisp
+./workshops/2015/jain-manolios/support/vectorizing-transformation/data-struct.lisp
+./workshops/2015/jain-manolios/support/vectorizing-transformation/scalar-vector.lisp
+./workshops/2015/jain-manolios/support/memory-controller/mem-array-cap-2.lisp
+./workshops/2015/jain-manolios/support/memory-controller/mem-array-cap-3.lisp
+./workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.lisp
+./workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.lisp
+./workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.lisp
+./workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.lisp
+./workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.lisp
+./workshops/2003/gamboa-cowles-van-baalen/support/linalg.lisp
+./workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.lisp
+./workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.lisp
+./workshops/2003/kaufmann/support/tool/file-io-pkgs.lisp
+./workshops/2003/kaufmann/support/tool/wrapper.lisp
+./workshops/2003/kaufmann/support/tool/simplify-defuns.lisp
+./workshops/2003/kaufmann/support/output/defs-eq.lisp
+./workshops/2003/kaufmann/support/output/lemmas-out.lisp
+./workshops/2003/kaufmann/support/output/defs-out.lisp
+./workshops/2003/kaufmann/deps.lisp
+./workshops/2003/greve-wilding_mbe/support/fpst.lisp
+./workshops/2003/greve-wilding_mbe/support/run-fpst.lisp
+./workshops/2003/schmaltz-borrione/support/inequalities.lisp
+./workshops/2003/schmaltz-borrione/support/decoder.lisp
+./workshops/2003/schmaltz-borrione/support/predicates.lisp
+./workshops/2003/schmaltz-borrione/support/transfers.lisp
+./workshops/2003/schmaltz-borrione/support/arbiter.lisp
+./workshops/2003/greve-wilding_defrecord/support/defrecord.lisp
+./workshops/2003/moore_rockwell/support/memory-taggings.lisp
+./workshops/2003/greve-wilding-vanfleet/support/separation.lisp
+./workshops/2003/greve-wilding-vanfleet/support/firewallworks.lisp
+./workshops/2003/greve-wilding-vanfleet/support/firewallspec.lisp
+./workshops/2003/greve-wilding-vanfleet/support/make-consistency-test.lisp
+./workshops/2003/greve-wilding-vanfleet/support/compatible.lisp
+./workshops/2003/greve-wilding-vanfleet/deps.lisp
+./workshops/2003/schmaltz-al-sammane-et-al/support/consistency.lisp
+./workshops/2003/toma-borrione/support/padding-384-512.lisp
+./workshops/2003/toma-borrione/support/sha-1.lisp
+./workshops/2003/toma-borrione/support/bv-op-defuns.lisp
+./workshops/2003/toma-borrione/support/padding-1-256.lisp
+./workshops/2003/toma-borrione/support/sha-functions.lisp
+./workshops/2003/toma-borrione/support/sha-384-512.lisp
+./workshops/2003/toma-borrione/support/misc.lisp
+./workshops/2003/toma-borrione/support/sha-256.lisp
+./workshops/2003/toma-borrione/support/bv-op-defthms.lisp
+./workshops/2003/toma-borrione/support/parsing.lisp
+./workshops/2003/sumners/support/example2.lisp
+./workshops/2003/sumners/support/cfair.lisp
+./workshops/2003/sumners/support/example1.lisp
+./workshops/2003/sumners/support/simple.lisp
+./workshops/2003/sumners/support/fair1.lisp
+./workshops/2003/sumners/support/example3.lisp
+./workshops/2003/sumners/support/n2n.lisp
+./workshops/2003/sumners/support/fair2.lisp
+./workshops/2003/austel/support/abs-type.lisp
+./workshops/2003/ray-matthews-tuttle/support/impl-hack.lisp
+./workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
+./workshops/2003/ray-matthews-tuttle/support/cone-of-influence.lisp
+./workshops/2003/ray-matthews-tuttle/support/bis.lisp
+./workshops/2003/ray-matthews-tuttle/support/records.lisp
+./workshops/2003/ray-matthews-tuttle/support/conjunction.lisp
+./workshops/2003/ray-matthews-tuttle/support/ltl.lisp
+./workshops/2003/ray-matthews-tuttle/support/sets.lisp
+./workshops/2003/ray-matthews-tuttle/support/total-order.lisp
+./workshops/2003/ray-matthews-tuttle/support/reductions.lisp
+./workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
+./workshops/2003/ray-matthews-tuttle/support/concrete-ltl.lisp
+./workshops/2003/ray-matthews-tuttle/support/circuits.lisp
+./workshops/2003/ray-matthews-tuttle/support/apply-total-order.lisp
+./workshops/2003/matlin-mccune/support/simp.lisp
+./workshops/2003/tsong/support/shim.lisp
+./workshops/2003/sustik/support/dickson.lisp
+./workshops/2003/moore_vcg/support/utilities.lisp
+./workshops/2003/moore_vcg/support/vcg-examples.lisp
+./workshops/2003/moore_vcg/support/m5.lisp
+./workshops/2003/moore_vcg/support/demo.lisp
+./workshops/2003/hendrix/support/vector.lisp
+./workshops/2003/hendrix/support/matrices.lisp
+./workshops/2003/hendrix/support/mentry.lisp
+./workshops/2003/hendrix/support/msub.lisp
+./workshops/2003/hendrix/support/mscal.lisp
+./workshops/2003/hendrix/support/mtrans.lisp
+./workshops/2003/hendrix/support/madd.lisp
+./workshops/2003/hendrix/support/mdefthms.lisp
+./workshops/2003/hendrix/support/mdefuns.lisp
+./workshops/2003/hendrix/support/mmult.lisp
+./workshops/2003/hendrix/support/mid.lisp
+./workshops/2003/hendrix/support/mzero.lisp
+./workshops/2003/hbl/support/sol1.lisp
+./workshops/2003/hbl/support/sol2.lisp
+./workshops/2017/coglio-kaufmann-smith/support/runes.lisp
+./workshops/2017/coglio-kaufmann-smith/support/example-integers.lisp
+./workshops/2017/coglio-kaufmann-smith/support/simplify-defun.lisp
+./workshops/2017/coglio-kaufmann-smith/support/process-keyword-args.lisp
+./workshops/2017/coglio-kaufmann-smith/support/testing.lisp
+./workshops/2017/coglio-kaufmann-smith/support/simplify-defun-tests.lisp
+./workshops/2017/coglio-kaufmann-smith/support/option-parsing.lisp
+./workshops/2017/coglio-kaufmann-smith/support/pattern-matching.lisp
+./workshops/2017/coglio-kaufmann-smith/support/transformation-table.lisp
+./workshops/2017/coglio-kaufmann-smith/support/example-producer-consumer.lisp
+./workshops/2017/kaufmann-swords/support/intro.lisp
+./workshops/2017/kaufmann-swords/support/context-rw-example.lisp
+./workshops/2017/swords/support/demos.lisp
+./workshops/2017/sumners/support/bakery.lisp
+./workshops/2017/sumners/support/general-theory.lisp
+./workshops/2017/sumners/support/trans-theory.lisp
+./workshops/2017/sumners/support/sets.lisp
+./workshops/2017/sumners/support/bounded-ords.lisp
+./workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
+./workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
+./workshops/2000/sumners1/cdeq/records.lisp
+./workshops/2000/sumners1/cdeq/cdeq-defs.lisp
+./workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
+./workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
+./workshops/2000/russinoff-short/crt.lisp
+./workshops/2000/russinoff-short/summary.lisp
+./workshops/2000/sumners2/bdds/bdd-prf.lisp
+./workshops/2000/sumners2/bdds/bdd-spec.lisp
+./workshops/2000/sumners2/bdds/bdd-mgr.lisp
+./workshops/2000/moore-manolios/partial-functions/tjvm.lisp
+./workshops/2000/moore-manolios/partial-functions/tjvm-examples.lisp
+./workshops/2000/moore-manolios/partial-functions/report.lisp
+./workshops/2000/moore-manolios/partial-functions/defpun.lisp
+./workshops/2000/moore-manolios/partial-functions/mod-1-property.lisp
+./workshops/2000/moore-manolios/partial-functions/defpun-original.lisp
+./workshops/2000/moore-manolios/partial-functions/examples.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/declarations.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/pipe.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/exec.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/constants.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/model.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/main.lisp
+./workshops/2000/russinoff-kaufmann/supporting-materials/inputs.lisp
+./workshops/2000/cowles/books/rTarai6.lisp
+./workshops/2000/cowles/books/tarai1.lisp
+./workshops/2000/cowles/books/tarai10.lisp
+./workshops/2000/cowles/books/rTarai7.lisp
+./workshops/2000/cowles/books/tarai7.lisp
+./workshops/2000/cowles/books/rTarai9.lisp
+./workshops/2000/cowles/books/rTarai8.lisp
+./workshops/2000/cowles/books/tarai4.lisp
+./workshops/2000/cowles/books/tarai3.lisp
+./workshops/2000/cowles/books/tarai2.lisp
+./workshops/2000/cowles/books/tarai8.lisp
+./workshops/2000/cowles/books/tarai5.lisp
+./workshops/2000/cowles/books/tarai6.lisp
+./workshops/2000/cowles/books/tarai9.lisp
+./workshops/2000/cowles/books/tarai11.lisp
+./workshops/2000/medina/polynomials/polynomial.lisp
+./workshops/2000/medina/polynomials/congruences-2.lisp
+./workshops/2000/medina/polynomials/congruences-1.lisp
+./workshops/2000/medina/polynomials/normal-form.lisp
+./workshops/2000/medina/polynomials/term.lisp
+./workshops/2000/medina/polynomials/addition.lisp
+./workshops/2000/medina/polynomials/multiplication.lisp
+./workshops/2000/medina/polynomials/negation.lisp
+./workshops/2000/medina/polynomials/lexicographical-ordering.lisp
+./workshops/2000/medina/polynomials/monomial.lisp
+./workshops/2000/medina/polynomials/examples.lisp
+./workshops/2000/ruiz/multiset/multiset.lisp
+./workshops/2000/ruiz/multiset/defmul.lisp
+./workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.lisp
+./workshops/2000/ruiz/multiset/examples/ackermann/ackermann.lisp
+./workshops/2000/ruiz/multiset/examples/newman/confluence-v0.lisp
+./workshops/2000/ruiz/multiset/examples/newman/newman.lisp
+./workshops/2000/ruiz/multiset/examples/newman/confluence.lisp
+./workshops/2000/ruiz/multiset/examples/newman/local-confluence.lisp
+./workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/base.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/simulator.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/cstate.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/compile.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/setup.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/mstate.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/lstate.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/pstate.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/expr.lisp
+./workshops/2000/lusk-mccune/lusk-mccune-final/util.lisp
+./workshops/2000/manolios/pipeline/trivial/utils.lisp
+./workshops/2000/manolios/pipeline/trivial/b-ops-aux.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/utils.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/model.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/proof.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.lisp
+./workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.lisp
+./workshops/2000/manolios/pipeline/trivial/table-def.lisp
+./workshops/2000/manolios/pipeline/trivial/model.lisp
+./workshops/2000/manolios/pipeline/trivial/trivia.lisp
+./workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.lisp
+./workshops/2000/manolios/pipeline/trivial/proof.lisp
+./workshops/2000/manolios/pipeline/trivial/ihs.lisp
+./workshops/2000/manolios/pipeline/trivial/basic-lemmas.lisp
+./workshops/2000/manolios/pipeline/trivial/basic-def.lisp
+./workshops/2000/manolios/pipeline/pipeline/top/alist-thms.lisp
+./workshops/2000/manolios/pipeline/pipeline/top/meta.lisp
+./workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.lisp
+./workshops/2000/manolios/pipeline/pipeline/top/nth-thms.lisp
+./workshops/2000/manolios/pipeline/pipeline/top/ihs.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.lisp
+./workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.lisp
+./workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.lisp
+./workshops/2020/kwan-peng-greenstreet/abstract-cs.lisp
+./workshops/2020/mert/acl2-vs-rp.lisp
+./workshops/2020/hardin/stk.lisp
+./workshops/2020/hardin/leg64.lisp
+./workshops/2020/hardin/stk-thms.lisp
+./workshops/2020/hardin/fact-leg64-preamble.lisp
+./workshops/2020/hardin/fact-leg64.lisp
+./workshops/2020/hardin/leg64-aux.lisp
+./workshops/2020/greve/nary.lisp
+./workshops/2020/greve/minimal-fractions.lisp
+./workshops/2020/sswords-rewriter/support.lisp
+./workshops/2020/peng-greenstreet/type-options.lisp
+./workshops/2020/peng-greenstreet/judgements.lisp
+./workshops/2020/peng-greenstreet/top.lisp
+./workshops/2020/peng-greenstreet/term-substitution.lisp
+./workshops/2020/peng-greenstreet/partial-eval.lisp
+./workshops/2020/peng-greenstreet/returns-judgement.lisp
+./workshops/2020/peng-greenstreet/type-inference-bottomup.lisp
+./workshops/2020/peng-greenstreet/typed-term.lisp
+./workshops/2020/peng-greenstreet/judgement-fns.lisp
+./workshops/2020/peng-greenstreet/type-inference-topdown.lisp
+./workshops/2020/peng-greenstreet/evaluator.lisp
+./workshops/2020/peng-greenstreet/test-inference.lisp
+./workshops/2020/peng-greenstreet/term-rectify.lisp
+./workshops/2020/peng-greenstreet/path-cond.lisp
+./workshops/2020/peng-greenstreet/utils/basics.lisp
+./workshops/2020/peng-greenstreet/utils/pseudo-term.lisp
+./workshops/2020/peng-greenstreet/utils/pseudo-lambda.lisp
+./workshops/2020/sumners/bake-proofs.lisp
+./workshops/2020/sumners/bake-models.lisp
+./workshops/2020/sumners/bakery.lisp
+./workshops/2020/sumners/gen-models.lisp
+./workshops/2020/sumners/top.lisp
+./workshops/2020/sumners/cycle-check.lisp
+./workshops/2020/sumners/gl-misc-types.lisp
+./workshops/2020/sumners/gl-fin-set.lisp
+./workshops/2020/sumners/portcullis.lisp
+./workshops/2020/sumners/bounded-ords.lisp
+./workshops/2020/sumners/gl-misc-utils.lisp
+./workshops/2020/sumners/wfo-thry.lisp
+./workshops/2020/sumners/gl-setup.lisp
+./workshops/2020/coglio-westfold/schematic-example.lisp
+./workshops/2020/coglio-westfold/integer-example.lisp
+./workshops/2020/coglio-westfold/loop-example.lisp
+./workshops/2020/coglio-westfold/drone-plan/graph.lisp
+./workshops/2020/coglio-westfold/drone-plan/dp-impl.lisp
+./workshops/2020/coglio-westfold/drone-plan/plans.lisp
+./workshops/2020/coglio-westfold/drone-plan/drone-state-iso.lisp
+./workshops/2020/coglio-westfold/drone-plan/dp-impl-support.lisp
+./workshops/2020/coglio-westfold/drone-plan/example.lisp
+./workshops/2020/coglio-westfold/drone-plan/refinement.lisp
+./workshops/2020/sswords-mutual-ind/example.lisp
+./workshops/2020/gamboa-cowles-gamboa/norm-1C.lisp
+./workshops/2020/gamboa-cowles-gamboa/floor1-non-R.lisp
+./workshops/2020/gamboa-cowles-gamboa/prior/raise-to.lisp
+./workshops/2020/gamboa-cowles-gamboa/number-field.lisp
+./workshops/2020/gamboa-cowles-gamboa/polylist.lisp
+./workshops/2018/kaufmann/injections.lisp
+./workshops/2018/kaufmann/subsetp-eq-linear.lisp
+./workshops/2018/kaufmann/defunt-top.lisp
+./workshops/2018/kaufmann/termination-database-utilities.lisp
+./workshops/2018/kaufmann/top.lisp
+./workshops/2018/kaufmann/termination-database.lisp
+./workshops/2018/kaufmann/td-cands.lisp
+./workshops/2018/kaufmann/defunt-tests.lisp
+./workshops/2018/kaufmann/fms-bang-list.lisp
+./workshops/2018/kaufmann/strict-merge-sort.lisp
+./workshops/2018/kaufmann/defunt.lisp
+./workshops/2018/mehta/file-system-4.lisp
+./workshops/2018/mehta/file-system-1.lisp
+./workshops/2018/mehta/file-system-lemmas.lisp
+./workshops/2018/mehta/file-system-3.lisp
+./workshops/2018/mehta/file-system-6.lisp
+./workshops/2018/mehta/block-listp.lisp
+./workshops/2018/mehta/file-system-m1.lisp
+./workshops/2018/mehta/file-system-2.lisp
+./workshops/2018/mehta/file-system-m2.lisp
+./workshops/2018/mehta/bounded-nat-listp.lisp
+./workshops/2018/mehta/fat32.lisp
+./workshops/2018/mehta/set-indices.lisp
+./workshops/2018/mehta/test/mkfs.fat-3.0.20-replicant.lisp
+./workshops/2018/mehta/test/cp-replicant.lisp
+./workshops/2018/mehta/test/mkfs.fat-3.0.28-replicant.lisp
+./workshops/2018/mehta/file-system-5.lisp
+./workshops/2018/mehta/insert-text.lisp
+./workshops/2018/mehta/flatten-lemmas.lisp
+./workshops/2018/mehta/find-n-free-blocks.lisp
+./workshops/2018/mehta/generate-index-list.lisp
+./workshops/2018/gamboa-cowles/de-moivre.lisp
+./workshops/2018/gamboa-cowles/complex-lemmas.lisp
+./workshops/2018/gamboa-cowles/complex-continuity.lisp
+./workshops/2018/gamboa-cowles/norm2.lisp
+./workshops/2018/gamboa-cowles/complex-polynomials.lisp
+./workshops/2018/greve-gacek/varid-type.lisp
+./workshops/2018/greve-gacek/top.lisp
+./workshops/2018/greve-gacek/intersection.lisp
+./workshops/2018/greve-gacek/types.lisp
+./workshops/2018/greve-gacek/poly-proofs.lisp
+./workshops/2018/greve-gacek/env-type.lisp
+./workshops/2018/greve-gacek/sets.lisp
+./workshops/2018/greve-gacek/poly.lisp
+./workshops/2018/greve-gacek/fuzzm-datatypes.lisp
+./workshops/2018/sumners/readme.lisp
+./workshops/2018/sumners/exloop.lisp
+./workshops/2018/sumners/nxtbl.lisp
+./workshops/2018/sumners/vcd.lisp
+./workshops/2018/sumners/support.lisp
+./workshops/2018/sumners/extra.lisp
+./workshops/2018/sumners/exa.lisp
+./workshops/2018/sumners/nxtypes.lisp
+./workshops/2018/sumners/svcnf.lisp
+./workshops/2018/sumners/exsim.lisp
+./workshops/2018/sumners/ipasir-tools-off.lisp
+./workshops/2018/sumners/portcullis.lisp
+./workshops/2018/sumners/extypes.lisp
+./workshops/2018/sumners/exbase.lisp
+./workshops/2018/sumners/exload.lisp
+./workshops/2018/sumners/vcdtypes.lisp
+./workshops/2018/sumners/aignet-ipasir-off.lisp
+./workshops/2018/kwan-greenstreet/continuity.lisp
+./workshops/2018/kwan-greenstreet/cauchy-schwarz.lisp
+./workshops/2018/kwan-greenstreet/top.lisp
+./workshops/2018/kwan-greenstreet/nesterov-4.lisp
+./workshops/2018/kwan-greenstreet/convex.lisp
+./workshops/2018/kwan-greenstreet/nesterov-1.lisp
+./workshops/2018/kwan-greenstreet/nesterov-top.lisp
+./workshops/2018/kwan-greenstreet/metric.lisp
+./workshops/2018/kwan-greenstreet/norm.lisp
+./workshops/2018/kwan-greenstreet/nesterov-3.lisp
+./workshops/2018/kwan-greenstreet/vectors.lisp
+./workshops/2018/kwan-greenstreet/nesterov-2.lisp
+./workshops/2018/kwan-greenstreet/ftc-2.lisp
+./workshops/2004/sumners-ray/support/records.lisp
+./workshops/2004/sumners-ray/support/mesi.lisp
+./workshops/2004/sumners-ray/support/basis.lisp
+./workshops/2004/sumners-ray/support/sets.lisp
+./workshops/2004/sumners-ray/support/total-order.lisp
+./workshops/2004/sumners-ray/support/crit.lisp
+./workshops/2004/ray/support/defpun-exec.lisp
+./workshops/2004/ray/support/defcoerce.lisp
+./workshops/2004/ray/support/generic.lisp
+./workshops/2004/roach-fraij/support/roach-fraij-script.lisp
+./workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.lisp
+./workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.lisp
+./workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.lisp
+./workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.lisp
+./workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.lisp
+./workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.lisp
+./workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.lisp
+./workshops/2004/schmaltz-borrione/support/trip_thms.lisp
+./workshops/2004/schmaltz-borrione/support/predicatesNCie.lisp
+./workshops/2004/schmaltz-borrione/support/mod_lemmas.lisp
+./workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.lisp
+./workshops/2004/schmaltz-borrione/support/routing_main.lisp
+./workshops/2004/schmaltz-borrione/support/trip_book.lisp
+./workshops/2004/schmaltz-borrione/support/collect_msg_book.lisp
+./workshops/2004/schmaltz-borrione/support/switch.lisp
+./workshops/2004/schmaltz-borrione/support/intersect.lisp
+./workshops/2004/schmaltz-borrione/support/scheduler_book.lisp
+./workshops/2004/schmaltz-borrione/support/node.lisp
+./workshops/2004/schmaltz-borrione/support/local_trip_book.lisp
+./workshops/2004/schmaltz-borrione/support/routing_defuns.lisp
+./workshops/2004/schmaltz-borrione/support/make_travel_list_book.lisp
+./workshops/2004/schmaltz-borrione/support/routing_local_lemmas.lisp
+./workshops/2004/schmaltz-borrione/support/octagon_book.lisp
+./workshops/2004/greve/support/mark.lisp
+./workshops/2004/greve/support/defrecord.lisp
+./workshops/2004/davis/support/sort.lisp
+./workshops/2004/davis/support/computed-hints.lisp
+./workshops/2004/davis/support/primitives.lisp
+./workshops/2004/davis/support/quantify.lisp
+./workshops/2004/davis/support/outer.lisp
+./workshops/2004/davis/support/set-order.lisp
+./workshops/2004/davis/support/sets.lisp
+./workshops/2004/davis/support/fast.lisp
+./workshops/2004/davis/support/membership.lisp
+./workshops/2004/davis/support/map.lisp
+./workshops/2004/davis/support/instance.lisp
+./workshops/2004/cowles-gamboa/support/tail-rec.lisp
+./workshops/2004/cowles-gamboa/support/WyoM1-utilities.lisp
+./workshops/2004/cowles-gamboa/support/WyoM1-correct.lisp
+./workshops/2004/cowles-gamboa/support/knuth.lisp
+./workshops/2004/cowles-gamboa/support/WyoM1.lisp
+./workshops/2004/legato/support/generic-theory-tail-recursion-sum.lisp
+./workshops/2004/legato/support/generic-theory-alternative-induction-sum.lisp
+./workshops/2004/legato/support/generic-theory-loop-invariant-sum.lisp
+./workshops/2004/legato/support/generic-theory-tail-recursion-mult.lisp
+./workshops/2004/legato/support/proof-by-generalization-mult.lisp
+./workshops/2004/legato/support/generic-theories.lisp
+./workshops/2004/legato/support/generic-theory-alternative-induction-mult.lisp
+./workshops/2004/legato/support/proof-by-generalization-sum.lisp
+./workshops/2004/legato/support/generic-theory-loop-invariant-mult.lisp
+./workshops/2004/sawada/support/bv.lisp
+./workshops/2004/sawada/support/ihs.lisp
+./workshops/2004/gameiro-manolios/support/transversality.lisp
+./workshops/2004/gameiro-manolios/support/nth-thms.lisp
+./workshops/2004/gameiro-manolios/support/interval.lisp
+./workshops/2004/gameiro-manolios/support/top-with-meta.lisp
+./workshops/2004/manolios-srinivasan/support/Supporting-Books/records.lisp
+./workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.lisp
+./workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.lisp
+./workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.lisp
+./workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp-ex-inp-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp-ex-inp.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp-ex-inp-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp-ex-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp-ex-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/5s-part.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp-ex-inp.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/5s.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-bp-ex.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/cxs-safety.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp-ex.lisp
+./workshops/2004/manolios-srinivasan/support/Benchmark-Problems/fxs-bp.lisp
+./workshops/2004/smith-et-al/support/lists/list-top.lisp
+./workshops/2004/smith-et-al/support/lists/mv-nth.lisp
+./workshops/2004/smith-et-al/support/lists/lists.lisp
+./workshops/2004/smith-et-al/support/lists/list-exports.lisp
+./workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.lisp
+./workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.lisp
+./workshops/2004/smith-et-al/support/bags/bag-exports.lisp
+./workshops/2004/smith-et-al/support/bags/top.lisp
+./workshops/2004/smith-et-al/support/bags/meta.lisp
+./workshops/2004/smith-et-al/support/bags/two-level-meta.lisp
+./workshops/2004/smith-et-al/support/bags/bag-pkg.lisp
+./workshops/2004/smith-et-al/support/bags/two-level.lisp
+./workshops/2004/smith-et-al/support/bags/eric-meta.lisp
+./workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp
+./workshops/2004/smith-et-al/support/bags/cons.lisp
+./workshops/2004/smith-et-al/support/bags/neq.lisp
+./workshops/2004/smith-et-al/support/bags/basic.lisp
+./workshops/2004/smith-et-al/support/syntax/syntax.lisp
+./workshops/2004/smith-et-al/support/syntax/auxilary.lisp
+./workshops/2004/smith-et-al/support/syntax/syntax-extensions.lisp
+./workshops/2004/smith-et-al/support/syntax/syn-pkg.lisp
+./workshops/2004/ruiz-et-al/support/q-dag-unification.lisp
+./workshops/2004/ruiz-et-al/support/q-dag-unification-st.lisp
+./workshops/2004/ruiz-et-al/support/terms.lisp
+./workshops/2004/ruiz-et-al/support/subsumption-subst.lisp
+./workshops/2004/ruiz-et-al/support/lists.lisp
+./workshops/2004/ruiz-et-al/support/prefix-unification-rules.lisp
+./workshops/2004/ruiz-et-al/support/q-dag-unification-rules.lisp
+./workshops/2004/ruiz-et-al/support/subsumption.lisp
+./workshops/2004/ruiz-et-al/support/matching.lisp
+./workshops/2004/ruiz-et-al/support/dags.lisp
+./workshops/2004/ruiz-et-al/support/basic.lisp
+./workshops/2004/ruiz-et-al/support/dag-unification-rules.lisp
+./workshops/2004/ruiz-et-al/support/terms-as-dag.lisp
+./workshops/2006/rager/support/ptest-if-normalization.lisp
+./workshops/2006/rager/support/ptest-mergesort.lisp
+./workshops/2006/rager/support/ptest-fib.lisp
+./workshops/2006/ray/tail/forall.lisp
+./workshops/2006/ray/tail/exists.lisp
+./workshops/2006/kaufmann-moore/support/austel.lisp
+./workshops/2006/kaufmann-moore/support/smith1.lisp
+./workshops/2006/kaufmann-moore/support/warnings.lisp
+./workshops/2006/kaufmann-moore/support/rhs2.lisp
+./workshops/2006/kaufmann-moore/support/mini-proveall-plus.lisp
+./workshops/2006/kaufmann-moore/support/rhs1.lisp
+./workshops/2006/kaufmann-moore/support/rhs1-iff.lisp
+./workshops/2006/kaufmann-moore/support/mini-proveall.lisp
+./workshops/2006/kaufmann-moore/support/greve3.lisp
+./workshops/2006/kaufmann-moore/support/sumners1.lisp
+./workshops/2006/kaufmann-moore/support/greve1.lisp
+./workshops/2006/kaufmann-moore/support/greve2.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.lisp
+./workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.lisp
+./workshops/2006/greve/nary/nary.lisp
+./workshops/2006/greve/nary/nth-rules.lisp
+./workshops/2006/greve/nary/example.lisp
+./workshops/2006/hunt-reeber/support/sat.lisp
+./workshops/2006/hunt-reeber/support/acl2.lisp
+./workshops/2006/hunt-reeber/support/bdd.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed1.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.lisp
+./workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.lisp
+./workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.lisp
+./workshops/2006/swords-cook/lcsoundness/pattern-match.lisp
+./workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.lisp
+./workshops/2006/swords-cook/lcsoundness/defsum-thms.lisp
+./workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.lisp
+./workshops/2006/swords-cook/lcsoundness/defsum.lisp
+./workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.lisp
+./workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.lisp
+./workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.lisp
+./workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.lisp
+./workshops/2014/russinoff-oleary/support/translate.lisp
+./workshops/2014/russinoff-oleary/support/imul.lisp
+./workshops/2014/russinoff-oleary/support/proof.lisp
+./workshops/2014/puri-ray-hao-xie/support/superstep-construction.lisp
+./workshops/2014/puri-ray-hao-xie/support/general-theorems.lisp
+./workshops/2014/puri-ray-hao-xie/support/functions.lisp
+./workshops/2014/puri-ray-hao-xie/support/seq-pp-equivalence.lisp
+./workshops/2014/puri-ray-hao-xie/support/semantics.lisp
+./workshops/2013/van-gastel-schmaltz/books/GeNoC-misc.lisp
+./workshops/2013/van-gastel-schmaltz/books/xmastransfer.lisp
+./workshops/2013/van-gastel-schmaltz/books/xmasnetwork.lisp
+./workshops/2013/van-gastel-schmaltz/books/macro.lisp
+./workshops/2013/van-gastel-schmaltz/books/GeNoC-types.lisp
+./workshops/2013/van-gastel-schmaltz/books/akeys.lisp
+./workshops/2013/van-gastel-schmaltz/books/DefSpeC-reuse.lisp
+./workshops/2013/van-gastel-schmaltz/books/perm.lisp
+./workshops/2013/verbeek-schmaltz/books/mybook.lisp
+./workshops/2013/verbeek-schmaltz/books/parse-state-machine-descriptions.lisp
+./workshops/2013/verbeek-schmaltz/books/asynch.lisp
+./workshops/2013/verbeek-schmaltz/books/asynch2.lisp
+./workshops/2013/joosten-van-gastel-schmaltz/books/closedMonoid.lisp
+./workshops/2013/joosten-van-gastel-schmaltz/books/instance-of-defspec.lisp
+./workshops/2013/joosten-van-gastel-schmaltz/books/perm.lisp
+./workshops/2013/goel-hunt-kaufmann/support/defabsstobj-example.lisp
+./workshops/2013/hardin-hardin/support/nthcdr-theorems.lisp
+./workshops/2013/hardin-hardin/support/APSP.lisp
+./workshops/2013/hardin-hardin/support/integer-listp-theorems.lisp
+./workshops/2009/hardin/deque-stobj/deque-stobj.lisp
+./workshops/2009/hardin/deque-stobj/deque-thms.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.lisp
+./workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.lisp
+./workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.lisp
+./workshops/2009/liu/support/mylet.lisp
+./workshops/2009/liu/support/error-analysis-tool3.lisp
+./workshops/2009/fraij-roach/support/functions.lisp
+./workshops/2009/fraij-roach/support/theorems.lisp
+./workshops/2009/sumners/support/kas.lisp
+./workshops/2009/sumners/support/examples.lisp
+./workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.lisp
+./workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.lisp
+./workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.lisp
+./workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.lisp
+./workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.lisp
+./workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.lisp
+./workshops/2009/cowles-gamboa-triangle-square/materials/tri-sq.lisp
+./workshops/2009/cowles-gamboa-triangle-square/materials/log2.lisp
+./workshops/2007/dillinger-et-al/code/defstruct-parsing.lisp
+./workshops/2007/dillinger-et-al/code/defcode.lisp
+./workshops/2007/dillinger-et-al/code/bridge.lisp
+./workshops/2007/dillinger-et-al/code/defcode-macro.lisp
+./workshops/2007/dillinger-et-al/code/subsumption.lisp
+./workshops/2007/dillinger-et-al/code/redefun.lisp
+./workshops/2007/dillinger-et-al/code/raw.lisp
+./workshops/2007/dillinger-et-al/code/rewrite-code.lisp
+./workshops/2007/dillinger-et-al/code/table-guard.lisp
+./workshops/2007/dillinger-et-al/code/dillinger-et-al-xdoc.lisp
+./workshops/2007/dillinger-et-al/code/all.lisp
+./workshops/2007/dillinger-et-al/code/hacker.lisp
+./workshops/2007/rubio/support/abstract-reductions/newman.lisp
+./workshops/2007/rubio/support/abstract-reductions/confluence.lisp
+./workshops/2007/rubio/support/abstract-reductions/abstract-proofs.lisp
+./workshops/2007/rubio/support/abstract-reductions/convergent.lisp
+./workshops/2007/rubio/support/simplicial-topology/generate-degenerate.lisp
+./workshops/2007/rubio/support/multisets/multiset.lisp
+./workshops/2007/rubio/support/multisets/defmul.lisp
+./workshops/2007/cowles-et-al/support/ray/reflexive.lisp
+./workshops/2007/cowles-et-al/support/ray/reflexive-macros.lisp
+./workshops/2007/cowles-et-al/support/greve/defminterm.lisp
+./workshops/2007/cowles-et-al/support/greve/ack.lisp
+./workshops/2007/cowles-et-al/support/greve/defpun.lisp
+./workshops/2007/cowles-et-al/support/greve/defxch.lisp
+./workshops/2007/cowles-et-al/support/greve/while.lisp
+./workshops/2007/cowles-et-al/support/cowles/while-loop.lisp
+./workshops/2007/erickson/bprove/exdefs.lisp
+./workshops/2007/erickson/bprove/gen.lisp
+./workshops/2007/erickson/bprove/refute.lisp
+./workshops/2007/erickson/bprove/lemgen.lisp
+./workshops/2007/erickson/bprove/bash.lisp
+./workshops/2007/rimlinger/support/Rimlinger.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.lisp
+./workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.lisp
+./workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.lisp
+./workshops/1999/graph/linear-find-path.lisp
+./workshops/1999/graph/find-path2.lisp
+./workshops/1999/graph/helpers.lisp
+./workshops/1999/graph/find-path3.lisp
+./workshops/1999/graph/find-path1.lisp
+./workshops/1999/de-hdl/help-defuns.lisp
+./workshops/1999/de-hdl/primitives.lisp
+./workshops/1999/de-hdl/measure.lisp
+./workshops/1999/de-hdl/syntax.lisp
+./workshops/1999/de-hdl/sts-okp.lisp
+./workshops/1999/de-hdl/arity.lisp
+./workshops/1999/de-hdl/de4.lisp
+./workshops/1999/de-hdl/thm-example.lisp
+./workshops/1999/de-hdl/examples.lisp
+./workshops/1999/deps-multiplier.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Mapping.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/CRT.lisp
+./workshops/1999/embedded/Proof-Of-Contribution/Generic.lisp
+./workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.lisp
+./workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.lisp
+./workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.lisp
+./workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.lisp
+./workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.lisp
+./workshops/1999/pipeline/utils.lisp
+./workshops/1999/pipeline/b-ops-aux.lisp
+./workshops/1999/pipeline/exercise.lisp
+./workshops/1999/pipeline/table-def.lisp
+./workshops/1999/pipeline/model.lisp
+./workshops/1999/pipeline/trivia.lisp
+./workshops/1999/pipeline/b-ops-aux-def.lisp
+./workshops/1999/pipeline/proof.lisp
+./workshops/1999/pipeline/ihs.lisp
+./workshops/1999/pipeline/basic-lemmas.lisp
+./workshops/1999/pipeline/basic-def.lisp
+./workshops/1999/knuth-91/exercise6b.lisp
+./workshops/1999/knuth-91/exercise7a.lisp
+./workshops/1999/knuth-91/exercise4a.lisp
+./workshops/1999/knuth-91/exercise4b.lisp
+./workshops/1999/knuth-91/exercise6a.lisp
+./workshops/1999/knuth-91/knuth-arch.lisp
+./workshops/1999/knuth-91/exercise1.lisp
+./workshops/1999/knuth-91/exercise3.lisp
+./workshops/1999/knuth-91/exercise7b.lisp
+./workshops/1999/knuth-91/exercise5.lisp
+./workshops/1999/knuth-91/exercise2.lisp
+./workshops/1999/knuth-91/aof.lisp
+./workshops/1999/mu-calculus/solutions/ctl.lisp
+./workshops/1999/mu-calculus/solutions/fast-sets.lisp
+./workshops/1999/mu-calculus/solutions/meta.lisp
+./workshops/1999/mu-calculus/solutions/syntax.lisp
+./workshops/1999/mu-calculus/solutions/fixpoints.lisp
+./workshops/1999/mu-calculus/solutions/sets.lisp
+./workshops/1999/mu-calculus/solutions/defung.lisp
+./workshops/1999/mu-calculus/solutions/relations.lisp
+./workshops/1999/mu-calculus/solutions/models.lisp
+./workshops/1999/mu-calculus/solutions/perm.lisp
+./workshops/1999/mu-calculus/solutions/semantics.lisp
+./workshops/1999/mu-calculus/book/fast-sets.lisp
+./workshops/1999/mu-calculus/book/syntax.lisp
+./workshops/1999/mu-calculus/book/fixpoints.lisp
+./workshops/1999/mu-calculus/book/sets.lisp
+./workshops/1999/mu-calculus/book/relations.lisp
+./workshops/1999/mu-calculus/book/models.lisp
+./workshops/1999/mu-calculus/book/semantics.lisp
+./workshops/1999/vhdl/exercises.lisp
+./workshops/1999/vhdl/fact.lisp
+./workshops/1999/vhdl/fact-proof.lisp
+./workshops/1999/vhdl/vhdl.lisp
+./workshops/1999/simulator/tiny.lisp
+./workshops/1999/simulator/exercises.lisp
+./workshops/1999/ste/inference.lisp
+./workshops/1999/ste/fundamental.lisp
+./workshops/1999/ste/boolean.lisp
+./workshops/1999/ste/assertion.lisp
+./workshops/1999/ste/expression.lisp
+./workshops/1999/ste/trajectory.lisp
+./workshops/1999/ste/run.lisp
+./workshops/1999/ste/lemma-4.lisp
+./workshops/1999/ste/state.lisp
+./workshops/1999/ste/util.lisp
+./workshops/1999/ste/circuit.lisp
+./workshops/1999/ste/example.lisp
+./workshops/1999/multiplier/spec.lisp
+./workshops/1999/multiplier/rtl.lisp
+./workshops/1999/multiplier/proof.lisp
+./workshops/1999/multiplier/compiler.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sugar.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/alls.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/base.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/top.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/simplify.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/xeval.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/nnf.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/variables.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/substitution.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/paramod.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/flip.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/close.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/derive.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/pull.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sets.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/keval.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/rename.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/prover.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/permutations.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/resolve.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/modeler.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/cnf.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/instance.lisp
+./workshops/1999/ivy/ivy-v2/ivy-sources/stage.lisp
+./workshops/1999/calculus/solutions/mesh-make-partition.lisp
+./workshops/1999/calculus/solutions/partition-defuns.lisp
+./workshops/1999/calculus/solutions/partitionp-make-partition.lisp
+./workshops/1999/calculus/solutions/partitionp-make-partition-rec.lisp
+./workshops/1999/calculus/solutions/mesh-append.lisp
+./workshops/1999/calculus/solutions/riemann-rcfn-helpers.lisp
+./workshops/1999/compiler/proof1.lisp
+./workshops/1999/compiler/exercises.lisp
+./workshops/1999/compiler/machine.lisp
+./workshops/1999/compiler/evaluator.lisp
+./workshops/1999/compiler/proof.lisp
+./workshops/1999/compiler/compiler.lisp
+./workshops/2002/cowles-primrec/support/defpr.lisp
+./workshops/2002/cowles-primrec/support/tail.lisp
+./workshops/2002/cowles-primrec/support/fix.lisp
+./workshops/2002/cowles-primrec/support/primitive.lisp
+./workshops/2002/cowles-primrec/support/bad-def1.lisp
+./workshops/2002/cowles-primrec/support/bad-def.lisp
+./workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.lisp
+./workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.lisp
+./workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.lisp
+./workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.lisp
+./workshops/2002/manolios-kaufmann/support/sorting/perm-order.lisp
+./workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.lisp
+./workshops/2002/manolios-kaufmann/support/sorting/total-order.lisp
+./workshops/2002/manolios-kaufmann/support/sorting/quicksort.lisp
+./workshops/2002/manolios-kaufmann/support/sorting/perm.lisp
+./workshops/2002/manolios-kaufmann/support/total-order/soundness.lisp
+./workshops/2002/manolios-kaufmann/support/total-order/total-order-easy-direction.lisp
+./workshops/2002/manolios-kaufmann/support/total-order/total-order.lisp
+./workshops/2002/manolios-kaufmann/support/records/records.lisp
+./workshops/2002/manolios-kaufmann/support/records/total-order.lisp
+./workshops/2002/manolios-kaufmann/support/records/records-original.lisp
+./workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.lisp
+./workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.lisp
+./workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.lisp
+./workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.lisp
+./workshops/2002/martin-alonso-perez-sancho/support/Adleman.lisp
+./workshops/2002/kaufmann-sumners/support/records0.lisp
+./workshops/2002/kaufmann-sumners/support/records.lisp
+./workshops/2002/kaufmann-sumners/support/sets.lisp
+./workshops/2002/cowles-flat/support/flat-z.lisp
+./workshops/2002/cowles-flat/support/flat-nested.lisp
+./workshops/2002/cowles-flat/support/flat-ackermann.lisp
+./workshops/2002/cowles-flat/support/flat.lisp
+./workshops/2002/cowles-flat/support/flat-reverse.lisp
+./workshops/2002/cowles-flat/support/flat-primitive.lisp
+./workshops/2002/cowles-flat/support/flat-tail.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.lisp
+./workshops/2002/georgelin-borrione-ostier/support/utils.lisp
+./workshops/2002/georgelin-borrione-ostier/support/acl2-transl.lisp
+./workshops/2002/georgelin-borrione-ostier/support/generates-functions.lisp
+./workshops/2002/georgelin-borrione-ostier/support/generates-theorems.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.lisp
+./workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/upol.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/term.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.lisp
+./workshops/2002/medina-palomo-alonso/support/section-3/monomial.lisp
+./workshops/2002/medina-palomo-alonso/support/section-2/upol-2.lisp
+./workshops/2002/medina-palomo-alonso/support/section-2/npol.lisp
+./workshops/2002/medina-palomo-alonso/support/section-2/upol-1.lisp
+./ihs/math-lemmas.lisp
+./ihs/logops-lemmas.lisp
+./ihs/ihs-init.lisp
+./ihs/@logops.lisp
+./ihs/ihs-definitions.lisp
+./ihs/quotient-remainder-lemmas.lisp
+./ihs/logops-definitions.lisp
+./ihs/ihs-theories.lisp
+./ihs/ihs-doc-topic.lisp
+./ihs/ihs-lemmas.lisp
+./ihs/basic-definitions.lisp
+./rtl/rel9/lib/rtlarr.lisp
+./rtl/rel9/lib/gl.lisp
+./rtl/rel9/lib/mult.lisp
+./rtl/rel9/lib/top.lisp
+./rtl/rel9/lib/sqrt.lisp
+./rtl/rel9/lib/openers.lisp
+./rtl/rel9/lib/bvecp-helpers.lisp
+./rtl/rel9/lib/simplify-model-helpers.lisp
+./rtl/rel9/lib/round.lisp
+./rtl/rel9/lib/logn2log.lisp
+./rtl/rel9/lib/bvecp-raw-helpers.lisp
+./rtl/rel9/lib/float.lisp
+./rtl/rel9/lib/rom-helpers.lisp
+./rtl/rel9/lib/reps.lisp
+./rtl/rel9/lib/add.lisp
+./rtl/rel9/lib/simple-loop-helpers.lisp
+./rtl/rel9/lib/package-defs.lisp
+./rtl/rel9/lib/srt.lisp
+./rtl/rel9/lib/masc.lisp
+./rtl/rel9/lib/basic.lisp
+./rtl/rel9/lib/clocks.lisp
+./rtl/rel9/lib/rtl.lisp
+./rtl/rel9/lib/util.lisp
+./rtl/rel9/lib/logn.lisp
+./rtl/rel9/lib/bits.lisp
+./rtl/rel9/lib/log.lisp
+./rtl/rel9/support/lib3/rtlarr.lisp
+./rtl/rel9/support/lib3/base.lisp
+./rtl/rel9/support/lib3/mult.lisp
+./rtl/rel9/support/lib3/top.lisp
+./rtl/rel9/support/lib3/openers.lisp
+./rtl/rel9/support/lib3/bvecp-helpers.lisp
+./rtl/rel9/support/lib3/simplify-model-helpers.lisp
+./rtl/rel9/support/lib3/round.lisp
+./rtl/rel9/support/lib3/logn2log.lisp
+./rtl/rel9/support/lib3/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib3/float.lisp
+./rtl/rel9/support/lib3/rom-helpers.lisp
+./rtl/rel9/support/lib3/reps.lisp
+./rtl/rel9/support/lib3/add.lisp
+./rtl/rel9/support/lib3/simple-loop-helpers.lisp
+./rtl/rel9/support/lib3/package-defs.lisp
+./rtl/rel9/support/lib3/basic.lisp
+./rtl/rel9/support/lib3/clocks.lisp
+./rtl/rel9/support/lib3/rtl.lisp
+./rtl/rel9/support/lib3/util.lisp
+./rtl/rel9/support/lib3/logn.lisp
+./rtl/rel9/support/lib3/arith.lisp
+./rtl/rel9/support/lib3/bits.lisp
+./rtl/rel9/support/lib3/log.lisp
+./rtl/rel9/support/lib1.delta1/bvecp-raw-helpers-extra.lisp
+./rtl/rel9/support/lib1.delta1/mult-proofs.lisp
+./rtl/rel9/support/lib1.delta1/mult.lisp
+./rtl/rel9/support/lib1.delta1/basic-extra.lisp
+./rtl/rel9/support/lib1.delta1/round.lisp
+./rtl/rel9/support/lib1.delta1/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib1.delta1/float.lisp
+./rtl/rel9/support/lib1.delta1/simple-loop-helpers.lisp
+./rtl/rel9/support/lib1.delta1/bits-extra.lisp
+./rtl/rel9/support/lib1.delta1/basic.lisp
+./rtl/rel9/support/lib1.delta1/round-extra2.lisp
+./rtl/rel9/support/lib1.delta1/arith.lisp
+./rtl/rel9/support/lib1.delta1/bits.lisp
+./rtl/rel9/support/lib1.delta1/simple-loop-helpers-extra.lisp
+./rtl/rel9/support/lib1.delta1/float-extra2.lisp
+./rtl/rel9/support/lib1.delta1/arith-extra.lisp
+./rtl/rel9/support/top/top.lisp
+./rtl/rel9/support/lib2/rtlarr.lisp
+./rtl/rel9/support/lib2/base.lisp
+./rtl/rel9/support/lib2/mult.lisp
+./rtl/rel9/support/lib2/top.lisp
+./rtl/rel9/support/lib2/openers.lisp
+./rtl/rel9/support/lib2/bvecp-helpers.lisp
+./rtl/rel9/support/lib2/simplify-model-helpers.lisp
+./rtl/rel9/support/lib2/round.lisp
+./rtl/rel9/support/lib2/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib2/float.lisp
+./rtl/rel9/support/lib2/rom-helpers.lisp
+./rtl/rel9/support/lib2/reps.lisp
+./rtl/rel9/support/lib2/add.lisp
+./rtl/rel9/support/lib2/simple-loop-helpers.lisp
+./rtl/rel9/support/lib2/package-defs.lisp
+./rtl/rel9/support/lib2/basic.lisp
+./rtl/rel9/support/lib2/clocks.lisp
+./rtl/rel9/support/lib2/rtl.lisp
+./rtl/rel9/support/lib2/util.lisp
+./rtl/rel9/support/lib2/arith.lisp
+./rtl/rel9/support/lib2/bits.lisp
+./rtl/rel9/support/lib2/log.lisp
+./rtl/rel9/support/lib2.delta1/bits-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/rtl-new.lisp
+./rtl/rel9/support/lib2.delta1/rtlarr.lisp
+./rtl/rel9/support/lib2.delta1/simplify-model-helpers-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/logn2log-proofs.lisp
+./rtl/rel9/support/lib2.delta1/mult-proofs.lisp
+./rtl/rel9/support/lib2.delta1/log-support.lisp
+./rtl/rel9/support/lib2.delta1/reps-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/mult.lisp
+./rtl/rel9/support/lib2.delta1/top.lisp
+./rtl/rel9/support/lib2.delta1/reps-new.lisp
+./rtl/rel9/support/lib2.delta1/logn-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/float-proofs.lisp
+./rtl/rel9/support/lib2.delta1/round-proofs.lisp
+./rtl/rel9/support/lib2.delta1/logn-proofs.lisp
+./rtl/rel9/support/lib2.delta1/simple-loop-helpers-proofs.lisp
+./rtl/rel9/support/lib2.delta1/bvecp-helpers.lisp
+./rtl/rel9/support/lib2.delta1/float-new.lisp
+./rtl/rel9/support/lib2.delta1/add-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/simplify-model-helpers-new.lisp
+./rtl/rel9/support/lib2.delta1/simplify-model-helpers.lisp
+./rtl/rel9/support/lib2.delta1/bits-proofs.lisp
+./rtl/rel9/support/lib2.delta1/bvecp-raw-helpers-proofs.lisp
+./rtl/rel9/support/lib2.delta1/round.lisp
+./rtl/rel9/support/lib2.delta1/logn2log.lisp
+./rtl/rel9/support/lib2.delta1/log-proofs.lisp
+./rtl/rel9/support/lib2.delta1/mult-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib2.delta1/simplify-model-helpers-proofs.lisp
+./rtl/rel9/support/lib2.delta1/log-new.lisp
+./rtl/rel9/support/lib2.delta1/float.lisp
+./rtl/rel9/support/lib2.delta1/round-new.lisp
+./rtl/rel9/support/lib2.delta1/bits-new.lisp
+./rtl/rel9/support/lib2.delta1/reps-proofs.lisp
+./rtl/rel9/support/lib2.delta1/add-new.lisp
+./rtl/rel9/support/lib2.delta1/reps.lisp
+./rtl/rel9/support/lib2.delta1/add.lisp
+./rtl/rel9/support/lib2.delta1/simple-loop-helpers.lisp
+./rtl/rel9/support/lib2.delta1/round-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/mult-new.lisp
+./rtl/rel9/support/lib2.delta1/float-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/log-support-proofs.lisp
+./rtl/rel9/support/lib2.delta1/rtl.lisp
+./rtl/rel9/support/lib2.delta1/log-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/util.lisp
+./rtl/rel9/support/lib2.delta1/logn-new.lisp
+./rtl/rel9/support/lib2.delta1/rtl-proofs.lisp
+./rtl/rel9/support/lib2.delta1/logn.lisp
+./rtl/rel9/support/lib2.delta1/arith.lisp
+./rtl/rel9/support/lib2.delta1/bits.lisp
+./rtl/rel9/support/lib2.delta1/rtlarr-new.lisp
+./rtl/rel9/support/lib2.delta1/rtl-new-proofs.lisp
+./rtl/rel9/support/lib2.delta1/log.lisp
+./rtl/rel9/support/lib2.delta1/add-proofs.lisp
+./rtl/rel9/support/lib1.delta2/float-extra.lisp
+./rtl/rel9/support/lib1.delta2/float.lisp
+./rtl/rel9/support/lib3.delta2/mult.lisp
+./rtl/rel9/support/lib3.delta2/top.lisp
+./rtl/rel9/support/lib3.delta2/simplify-model-helpers.lisp
+./rtl/rel9/support/lib3.delta2/round.lisp
+./rtl/rel9/support/lib3.delta2/logn2log.lisp
+./rtl/rel9/support/lib3.delta2/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib3.delta2/float.lisp
+./rtl/rel9/support/lib3.delta2/rom-helpers.lisp
+./rtl/rel9/support/lib3.delta2/reps.lisp
+./rtl/rel9/support/lib3.delta2/add.lisp
+./rtl/rel9/support/lib3.delta2/simple-loop-helpers.lisp
+./rtl/rel9/support/lib3.delta2/bits-old.lisp
+./rtl/rel9/support/lib3.delta2/masc.lisp
+./rtl/rel9/support/lib3.delta2/basic.lisp
+./rtl/rel9/support/lib3.delta2/logn.lisp
+./rtl/rel9/support/lib3.delta2/bits.lisp
+./rtl/rel9/support/lib3.delta2/log.lisp
+./rtl/rel9/support/support/lxor0.lisp
+./rtl/rel9/support/support/rtlarr.lisp
+./rtl/rel9/support/support/add3-proofs.lisp
+./rtl/rel9/support/support/logs.lisp
+./rtl/rel9/support/support/lop3-proofs.lisp
+./rtl/rel9/support/support/encode.lisp
+./rtl/rel9/support/support/setbitn.lisp
+./rtl/rel9/support/support/trunc-proofs.lisp
+./rtl/rel9/support/support/top.lisp
+./rtl/rel9/support/support/land0.lisp
+./rtl/rel9/support/support/lop2.lisp
+./rtl/rel9/support/support/lop1-proofs.lisp
+./rtl/rel9/support/support/mulcat.lisp
+./rtl/rel9/support/support/lior.lisp
+./rtl/rel9/support/support/bvecp-proofs.lisp
+./rtl/rel9/support/support/lior0.lisp
+./rtl/rel9/support/support/mulcat-proofs.lisp
+./rtl/rel9/support/support/openers.lisp
+./rtl/rel9/support/support/sticky-proofs.lisp
+./rtl/rel9/support/support/badguys.lisp
+./rtl/rel9/support/support/near+-proofs.lisp
+./rtl/rel9/support/support/cat-def.lisp
+./rtl/rel9/support/support/sticky.lisp
+./rtl/rel9/support/support/logorc1.lisp
+./rtl/rel9/support/support/decode.lisp
+./rtl/rel9/support/support/sgn.lisp
+./rtl/rel9/support/support/lnot.lisp
+./rtl/rel9/support/support/land0-proofs.lisp
+./rtl/rel9/support/support/cat-proofs.lisp
+./rtl/rel9/support/support/bvecp-helpers.lisp
+./rtl/rel9/support/support/sumbits.lisp
+./rtl/rel9/support/support/bvecp-lemmas.lisp
+./rtl/rel9/support/support/logior.lisp
+./rtl/rel9/support/support/add3.lisp
+./rtl/rel9/support/support/round-extra.lisp
+./rtl/rel9/support/support/simplify-model-helpers.lisp
+./rtl/rel9/support/support/bitn.lisp
+./rtl/rel9/support/support/bits-proofs.lisp
+./rtl/rel9/support/support/float-extra.lisp
+./rtl/rel9/support/support/lextra0.lisp
+./rtl/rel9/support/support/logand-proofs.lisp
+./rtl/rel9/support/support/logior1.lisp
+./rtl/rel9/support/support/fadd-extra0.lisp
+./rtl/rel9/support/support/bias.lisp
+./rtl/rel9/support/support/lnot-proofs.lisp
+./rtl/rel9/support/support/bits-trunc.lisp
+./rtl/rel9/support/support/rewrite-theory.lisp
+./rtl/rel9/support/support/log-proofs.lisp
+./rtl/rel9/support/support/lop3.lisp
+./rtl/rel9/support/support/logior1-proofs.lisp
+./rtl/rel9/support/support/near.lisp
+./rtl/rel9/support/support/stick.lisp
+./rtl/rel9/support/support/drnd-original.lisp
+./rtl/rel9/support/support/setbits-proofs.lisp
+./rtl/rel9/support/support/logior-proofs.lisp
+./rtl/rel9/support/support/bvecp.lisp
+./rtl/rel9/support/support/logxor.lisp
+./rtl/rel9/support/support/mod4.lisp
+./rtl/rel9/support/support/away.lisp
+./rtl/rel9/support/support/lop2-proofs.lisp
+./rtl/rel9/support/support/bitn-proofs.lisp
+./rtl/rel9/support/support/float.lisp
+./rtl/rel9/support/support/rom-helpers.lisp
+./rtl/rel9/support/support/lognot.lisp
+./rtl/rel9/support/support/merge2.lisp
+./rtl/rel9/support/support/decode-proofs.lisp
+./rtl/rel9/support/support/lextra-proofs.lisp
+./rtl/rel9/support/support/log-equal.lisp
+./rtl/rel9/support/support/away-proofs.lisp
+./rtl/rel9/support/support/model-helpers.lisp
+./rtl/rel9/support/support/all-ones.lisp
+./rtl/rel9/support/support/ereps.lisp
+./rtl/rel9/support/support/near-proofs.lisp
+./rtl/rel9/support/support/simple-loop-helpers.lisp
+./rtl/rel9/support/support/stick-proofs.lisp
+./rtl/rel9/support/support/logeqv.lisp
+./rtl/rel9/support/support/ereps-proofs.lisp
+./rtl/rel9/support/support/bits-trunc-proofs.lisp
+./rtl/rel9/support/support/fadd-extra.lisp
+./rtl/rel9/support/support/package-defs.lisp
+./rtl/rel9/support/support/land.lisp
+./rtl/rel9/support/support/oddr-proofs.lisp
+./rtl/rel9/support/support/shft.lisp
+./rtl/rel9/support/support/ocat.lisp
+./rtl/rel9/support/support/lextra.lisp
+./rtl/rel9/support/support/trunc.lisp
+./rtl/rel9/support/support/bias-proofs.lisp
+./rtl/rel9/support/support/fast-and.lisp
+./rtl/rel9/support/support/clocks.lisp
+./rtl/rel9/support/support/oddr.lisp
+./rtl/rel9/support/support/rtl.lisp
+./rtl/rel9/support/support/logand.lisp
+./rtl/rel9/support/support/ireps.lisp
+./rtl/rel9/support/support/util.lisp
+./rtl/rel9/support/support/setbitn-proofs.lisp
+./rtl/rel9/support/support/merge.lisp
+./rtl/rel9/support/support/cat.lisp
+./rtl/rel9/support/support/top1.lisp
+./rtl/rel9/support/support/lxor0-proofs.lisp
+./rtl/rel9/support/support/bits.lisp
+./rtl/rel9/support/support/lop1.lisp
+./rtl/rel9/support/support/lior0-proofs.lisp
+./rtl/rel9/support/support/setbits.lisp
+./rtl/rel9/support/support/ground-zero.lisp
+./rtl/rel9/support/support/guards.lisp
+./rtl/rel9/support/support/fadd.lisp
+./rtl/rel9/support/support/near+.lisp
+./rtl/rel9/support/support/log.lisp
+./rtl/rel9/support/support/rnd.lisp
+./rtl/rel9/support/support/lxor.lisp
+./rtl/rel9/support/support/ash.lisp
+./rtl/rel9/support/lib3.delta1/sqrt.lisp
+./rtl/rel9/support/lib3.delta1/seed.lisp
+./rtl/rel9/support/lib3.delta1/sqrt66.lisp
+./rtl/rel9/support/lib3.delta1/srt.lisp
+./rtl/rel9/support/lib3.delta1/division.lisp
+./rtl/rel9/support/lib1/rtlarr.lisp
+./rtl/rel9/support/lib1/top.lisp
+./rtl/rel9/support/lib1/openers.lisp
+./rtl/rel9/support/lib1/bvecp-helpers.lisp
+./rtl/rel9/support/lib1/simplify-model-helpers.lisp
+./rtl/rel9/support/lib1/round.lisp
+./rtl/rel9/support/lib1/bvecp-raw-helpers.lisp
+./rtl/rel9/support/lib1/float.lisp
+./rtl/rel9/support/lib1/rom-helpers.lisp
+./rtl/rel9/support/lib1/reps.lisp
+./rtl/rel9/support/lib1/add.lisp
+./rtl/rel9/support/lib1/simple-loop-helpers.lisp
+./rtl/rel9/support/lib1/package-defs.lisp
+./rtl/rel9/support/lib1/basic.lisp
+./rtl/rel9/support/lib1/clocks.lisp
+./rtl/rel9/support/lib1/rtl.lisp
+./rtl/rel9/support/lib1/util.lisp
+./rtl/rel9/support/lib1/arith.lisp
+./rtl/rel9/support/lib1/bits.lisp
+./rtl/rel9/support/lib1/log.lisp
+./rtl/rel9/support/lib2.delta3/base.lisp
+./rtl/rel9/support/lib2.delta3/simplify-model-helpers.lisp
+./rtl/rel9/support/lib3.delta3/gl.lisp
+./rtl/rel9/support/lib3.delta3/mult.lisp
+./rtl/rel9/support/lib3.delta3/round.lisp
+./rtl/rel9/support/lib3.delta3/sqrt66.lisp
+./rtl/rel9/support/lib3.delta3/masc.lisp
+./rtl/rel9/support/lib2.delta2/add-lib.lisp
+./rtl/rel9/support/lib2.delta2/base.lisp
+./rtl/rel9/support/lib2.delta2/add.lisp
+./rtl/rel9/support/lib2.delta2/bits.lisp
+./rtl/rel9/support/lib2.delta2/log.lisp
+./rtl/rel9/arithmetic/floor-proofs.lisp
+./rtl/rel9/arithmetic/fl-hacks.lisp
+./rtl/rel9/arithmetic/expo.lisp
+./rtl/rel9/arithmetic/fp.lisp
+./rtl/rel9/arithmetic/floor.lisp
+./rtl/rel9/arithmetic/extra-rules.lisp
+./rtl/rel9/arithmetic/hacks.lisp
+./rtl/rel9/arithmetic/top.lisp
+./rtl/rel9/arithmetic/fl.lisp
+./rtl/rel9/arithmetic/fp2.lisp
+./rtl/rel9/arithmetic/predicate.lisp
+./rtl/rel9/arithmetic/product.lisp
+./rtl/rel9/arithmetic/fl-proofs.lisp
+./rtl/rel9/arithmetic/expo-proofs.lisp
+./rtl/rel9/arithmetic/expt-proofs.lisp
+./rtl/rel9/arithmetic/x-2xx.lisp
+./rtl/rel9/arithmetic/complex-rationalp.lisp
+./rtl/rel9/arithmetic/power2p.lisp
+./rtl/rel9/arithmetic/negative-syntaxp.lisp
+./rtl/rel9/arithmetic/mod-proofs.lisp
+./rtl/rel9/arithmetic/rationalp.lisp
+./rtl/rel9/arithmetic/arith2.lisp
+./rtl/rel9/arithmetic/common-factor-defuns.lisp
+./rtl/rel9/arithmetic/nniq.lisp
+./rtl/rel9/arithmetic/even-odd2.lisp
+./rtl/rel9/arithmetic/mod.lisp
+./rtl/rel9/arithmetic/even-odd2-proofs.lisp
+./rtl/rel9/arithmetic/even-odd.lisp
+./rtl/rel9/arithmetic/integerp.lisp
+./rtl/rel9/arithmetic/fl-expt.lisp
+./rtl/rel9/arithmetic/basic.lisp
+./rtl/rel9/arithmetic/product-proofs.lisp
+./rtl/rel9/arithmetic/cg.lisp
+./rtl/rel9/arithmetic/denominator.lisp
+./rtl/rel9/arithmetic/expt.lisp
+./rtl/rel9/arithmetic/arith.lisp
+./rtl/rel9/arithmetic/unary-divide.lisp
+./rtl/rel9/arithmetic/mod-expt.lisp
+./rtl/rel9/arithmetic/common-factor.lisp
+./rtl/rel9/arithmetic/ground-zero.lisp
+./rtl/rel9/arithmetic/inverted-factor.lisp
+./rtl/rel9/arithmetic/numerator.lisp
+./rtl/rel9/arithmetic/induct.lisp
+./rtl/rel1/lib3/top.lisp
+./rtl/rel1/lib3/brat.lisp
+./rtl/rel1/lib3/round.lisp
+./rtl/rel1/lib3/float.lisp
+./rtl/rel1/lib3/reps.lisp
+./rtl/rel1/lib3/basic.lisp
+./rtl/rel1/lib3/bits.lisp
+./rtl/rel1/lib3/fadd.lisp
+./rtl/rel1/support/odd.lisp
+./rtl/rel1/support/fp.lisp
+./rtl/rel1/support/floor.lisp
+./rtl/rel1/support/proofs.lisp
+./rtl/rel1/support/sticky.lisp
+./rtl/rel1/support/logxor-lemmas.lisp
+./rtl/rel1/support/x-2xx.lisp
+./rtl/rel1/support/fadd/top.lisp
+./rtl/rel1/support/fadd/lop2.lisp
+./rtl/rel1/support/fadd/add3.lisp
+./rtl/rel1/support/fadd/lop3.lisp
+./rtl/rel1/support/fadd/stick.lisp
+./rtl/rel1/support/fadd/lop1.lisp
+./rtl/rel1/support/rewrite-theory.lisp
+./rtl/rel1/support/near.lisp
+./rtl/rel1/support/away.lisp
+./rtl/rel1/support/float.lisp
+./rtl/rel1/support/loglemmas.lisp
+./rtl/rel1/support/reps.lisp
+./rtl/rel1/support/add.lisp
+./rtl/rel1/support/logdefs.lisp
+./rtl/rel1/support/trunc.lisp
+./rtl/rel1/support/basic.lisp
+./rtl/rel1/support/merge.lisp
+./rtl/rel1/support/logxor-def.lisp
+./rtl/rel1/support/divsqrt.lisp
+./rtl/rel1/support/rnd.lisp
+./rtl/rel1/lib1/top.lisp
+./rtl/rel1/lib1/brat.lisp
+./rtl/rel1/lib1/round.lisp
+./rtl/rel1/lib1/float.lisp
+./rtl/rel1/lib1/reps.lisp
+./rtl/rel1/lib1/basic.lisp
+./rtl/rel1/lib1/bits.lisp
+./rtl/rel11/lib/rcp.lisp
+./rtl/rel11/lib/defs.lisp
+./rtl/rel11/lib/gl.lisp
+./rtl/rel11/lib/mult.lisp
+./rtl/rel11/lib/top.lisp
+./rtl/rel11/lib/sqrt.lisp
+./rtl/rel11/lib/top-alt.lisp
+./rtl/rel11/lib/excps.lisp
+./rtl/rel11/lib/round.lisp
+./rtl/rel11/lib/div.lisp
+./rtl/rel11/lib/rac.lisp
+./rtl/rel11/lib/float.lisp
+./rtl/rel11/lib/reps.lisp
+./rtl/rel11/lib/add.lisp
+./rtl/rel11/lib/srt.lisp
+./rtl/rel11/lib/doc.lisp
+./rtl/rel11/lib/top-doc.lisp
+./rtl/rel11/lib/basic.lisp
+./rtl/rel11/lib/util.lisp
+./rtl/rel11/lib/bits.lisp
+./rtl/rel11/lib/log.lisp
+./rtl/rel11/support/old-round.lisp
+./rtl/rel11/support/rcp.lisp
+./rtl/rel11/support/rnd-near-equal.lisp
+./rtl/rel11/support/lza.lisp
+./rtl/rel11/support/drnd.lisp
+./rtl/rel11/support/gl.lisp
+./rtl/rel11/support/mult.lisp
+./rtl/rel11/support/top.lisp
+./rtl/rel11/support/sqrt.lisp
+./rtl/rel11/support/excps.lisp
+./rtl/rel11/support/round.lisp
+./rtl/rel11/support/injection.lisp
+./rtl/rel11/support/newton.lisp
+./rtl/rel11/support/definitions.lisp
+./rtl/rel11/support/div.lisp
+./rtl/rel11/support/rac.lisp
+./rtl/rel11/support/float.lisp
+./rtl/rel11/support/rom-helpers.lisp
+./rtl/rel11/support/reps.lisp
+./rtl/rel11/support/add.lisp
+./rtl/rel11/support/lza2.lisp
+./rtl/rel11/support/simple-loop-helpers.lisp
+./rtl/rel11/support/srt.lisp
+./rtl/rel11/support/clz.lisp
+./rtl/rel11/support/basic.lisp
+./rtl/rel11/support/harrison.lisp
+./rtl/rel11/support/verify-guards.lisp
+./rtl/rel11/support/util.lisp
+./rtl/rel11/support/markstein.lisp
+./rtl/rel11/support/ppa.lisp
+./rtl/rel11/support/bits.lisp
+./rtl/rel11/support/example.lisp
+./rtl/rel11/support/log.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/top.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/openers.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/round.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/logn2log.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/float.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/package-defs.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/clocks.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/util.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/logn.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/lib/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/base.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/openers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/logn2log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/package-defs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/clocks.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/util.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/logn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/bvecp-raw-helpers-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/basic-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/bits-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/round-extra2.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/float-extra2.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta1/arith-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/top/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/base.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/openers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/package-defs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/clocks.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/util.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bits-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/simplify-model-helpers-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn2log-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log-support.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/float-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/round-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/float-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/simplify-model-helpers-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bits-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bvecp-raw-helpers-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn2log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/simplify-model-helpers-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/round-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bits-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/round-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/float-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log-support-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/util.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn-new.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/logn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta2/float-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1.delta2/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/logn2log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/bits-old.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/logn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta2/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lxor0.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/encode.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/setbitn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/trunc-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/land0.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/mulcat.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lior.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bvecp-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lior0.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/mulcat-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/openers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/sticky-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/badguys.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/near+-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/cat-def.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/sticky.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logorc1.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/decode.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/sgn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lnot.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/land0-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/cat-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/sumbits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bvecp-lemmas.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logior.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/round-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bitn.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bits-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/float-extra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lextra0.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logand-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logior1.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bias.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lnot-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bits-trunc.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/rewrite-theory.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/log-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logior1-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/near.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/drnd-original.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/setbits-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logior-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bvecp.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logxor.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/mod4.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/away.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bitn-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lognot.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/merge2.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/decode-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lextra-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/log-equal.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/away-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/all-ones.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ereps.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/near-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logeqv.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ereps-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bits-trunc-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/package-defs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/land.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/oddr-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/shft.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ocat.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lextra.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/trunc.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bias-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/fast-and.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/clocks.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/oddr.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/logand.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ireps.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/util.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/setbitn-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/merge.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/cat.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/top1.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lxor0-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lior0-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/setbits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ground-zero.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/guards.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/near+.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/rnd.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/lxor.lisp
+./rtl/rel11/rel9-rtl-pkg/support/support/ash.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/top.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/openers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/bvecp-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/bvecp-raw-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/float.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/reps.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/package-defs.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/clocks.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/rtl.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/util.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib1/log.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta3/base.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta3/simplify-model-helpers.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib3.delta3/round.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta2/add-lib.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta2/base.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta2/bits.lisp
+./rtl/rel11/rel9-rtl-pkg/support/lib2.delta2/log.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/floor-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fl-hacks.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/expo.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fp.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/floor.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/extra-rules.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/hacks.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/top.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fl.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fp2.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/predicate.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/product.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fl-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/expo-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/expt-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/x-2xx.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/complex-rationalp.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/power2p.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/negative-syntaxp.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/mod-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/rationalp.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/arith2.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/common-factor-defuns.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/nniq.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/even-odd2.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/mod.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/even-odd2-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/even-odd.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/integerp.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/fl-expt.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/basic.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/product-proofs.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/cg.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/denominator.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/expt.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/arith.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/unary-divide.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/mod-expt.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/common-factor.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/ground-zero.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/inverted-factor.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/numerator.lisp
+./rtl/rel11/rel9-rtl-pkg/arithmetic/induct.lisp
+./rtl/rel11/portcullis.lisp
+./rtl/rel4/lib/rtlarr.lisp
+./rtl/rel4/lib/top.lisp
+./rtl/rel4/lib/openers.lisp
+./rtl/rel4/lib/bvecp-helpers.lisp
+./rtl/rel4/lib/simplify-model-helpers.lisp
+./rtl/rel4/lib/round.lisp
+./rtl/rel4/lib/bvecp-raw-helpers.lisp
+./rtl/rel4/lib/float.lisp
+./rtl/rel4/lib/rom-helpers.lisp
+./rtl/rel4/lib/reps.lisp
+./rtl/rel4/lib/simple-loop-helpers.lisp
+./rtl/rel4/lib/package-defs.lisp
+./rtl/rel4/lib/basic.lisp
+./rtl/rel4/lib/clocks.lisp
+./rtl/rel4/lib/rtl.lisp
+./rtl/rel4/lib/util.lisp
+./rtl/rel4/lib/arith.lisp
+./rtl/rel4/lib/bits.lisp
+./rtl/rel4/lib/fadd.lisp
+./rtl/rel4/support/rtlarr.lisp
+./rtl/rel4/support/land-proofs.lisp
+./rtl/rel4/support/add3-proofs.lisp
+./rtl/rel4/support/logs.lisp
+./rtl/rel4/support/lop3-proofs.lisp
+./rtl/rel4/support/drnd.lisp
+./rtl/rel4/support/encode.lisp
+./rtl/rel4/support/setbitn.lisp
+./rtl/rel4/support/lior-proofs.lisp
+./rtl/rel4/support/trunc-proofs.lisp
+./rtl/rel4/support/top.lisp
+./rtl/rel4/support/lop2.lisp
+./rtl/rel4/support/lop1-proofs.lisp
+./rtl/rel4/support/mulcat.lisp
+./rtl/rel4/support/lior.lisp
+./rtl/rel4/support/bvecp-proofs.lisp
+./rtl/rel4/support/mulcat-proofs.lisp
+./rtl/rel4/support/openers.lisp
+./rtl/rel4/support/sticky-proofs.lisp
+./rtl/rel4/support/badguys.lisp
+./rtl/rel4/support/near+-proofs.lisp
+./rtl/rel4/support/cat-def.lisp
+./rtl/rel4/support/sticky.lisp
+./rtl/rel4/support/logorc1.lisp
+./rtl/rel4/support/decode.lisp
+./rtl/rel4/support/sgn.lisp
+./rtl/rel4/support/lnot.lisp
+./rtl/rel4/support/cat-proofs.lisp
+./rtl/rel4/support/bvecp-helpers.lisp
+./rtl/rel4/support/sumbits.lisp
+./rtl/rel4/support/bvecp-lemmas.lisp
+./rtl/rel4/support/logior.lisp
+./rtl/rel4/support/add3.lisp
+./rtl/rel4/support/lxor-proofs.lisp
+./rtl/rel4/support/simplify-model-helpers.lisp
+./rtl/rel4/support/bitn.lisp
+./rtl/rel4/support/bits-proofs.lisp
+./rtl/rel4/support/logand-proofs.lisp
+./rtl/rel4/support/logior1.lisp
+./rtl/rel4/support/bias.lisp
+./rtl/rel4/support/lnot-proofs.lisp
+./rtl/rel4/support/bits-trunc.lisp
+./rtl/rel4/support/rewrite-theory.lisp
+./rtl/rel4/support/log-proofs.lisp
+./rtl/rel4/support/lop3.lisp
+./rtl/rel4/support/logior1-proofs.lisp
+./rtl/rel4/support/near.lisp
+./rtl/rel4/support/stick.lisp
+./rtl/rel4/support/setbits-proofs.lisp
+./rtl/rel4/support/logior-proofs.lisp
+./rtl/rel4/support/bvecp.lisp
+./rtl/rel4/support/logxor.lisp
+./rtl/rel4/support/mod4.lisp
+./rtl/rel4/support/away.lisp
+./rtl/rel4/support/lop2-proofs.lisp
+./rtl/rel4/support/bitn-proofs.lisp
+./rtl/rel4/support/float.lisp
+./rtl/rel4/support/rom-helpers.lisp
+./rtl/rel4/support/lognot.lisp
+./rtl/rel4/support/merge2.lisp
+./rtl/rel4/support/decode-proofs.lisp
+./rtl/rel4/support/lextra-proofs.lisp
+./rtl/rel4/support/log-equal.lisp
+./rtl/rel4/support/away-proofs.lisp
+./rtl/rel4/support/model-helpers.lisp
+./rtl/rel4/support/all-ones.lisp
+./rtl/rel4/support/ereps.lisp
+./rtl/rel4/support/near-proofs.lisp
+./rtl/rel4/support/simple-loop-helpers.lisp
+./rtl/rel4/support/stick-proofs.lisp
+./rtl/rel4/support/logeqv.lisp
+./rtl/rel4/support/ereps-proofs.lisp
+./rtl/rel4/support/bits-trunc-proofs.lisp
+./rtl/rel4/support/package-defs.lisp
+./rtl/rel4/support/land.lisp
+./rtl/rel4/support/oddr-proofs.lisp
+./rtl/rel4/support/shft.lisp
+./rtl/rel4/support/bits-extra.lisp
+./rtl/rel4/support/ocat.lisp
+./rtl/rel4/support/lextra.lisp
+./rtl/rel4/support/trunc.lisp
+./rtl/rel4/support/bias-proofs.lisp
+./rtl/rel4/support/fast-and.lisp
+./rtl/rel4/support/clocks.lisp
+./rtl/rel4/support/oddr.lisp
+./rtl/rel4/support/rtl.lisp
+./rtl/rel4/support/logand.lisp
+./rtl/rel4/support/ireps.lisp
+./rtl/rel4/support/util.lisp
+./rtl/rel4/support/setbitn-proofs.lisp
+./rtl/rel4/support/merge.lisp
+./rtl/rel4/support/cat.lisp
+./rtl/rel4/support/top1.lisp
+./rtl/rel4/support/bits.lisp
+./rtl/rel4/support/lop1.lisp
+./rtl/rel4/support/setbits.lisp
+./rtl/rel4/support/ground-zero.lisp
+./rtl/rel4/support/guards.lisp
+./rtl/rel4/support/fadd.lisp
+./rtl/rel4/support/near+.lisp
+./rtl/rel4/support/log.lisp
+./rtl/rel4/support/rnd.lisp
+./rtl/rel4/support/lxor.lisp
+./rtl/rel4/support/ash.lisp
+./rtl/rel4/user/setbitn.lisp
+./rtl/rel4/user/top.lisp
+./rtl/rel4/user/brat.lisp
+./rtl/rel4/user/mulcat.lisp
+./rtl/rel4/user/lior.lisp
+./rtl/rel4/user/decode.lisp
+./rtl/rel4/user/lnot.lisp
+./rtl/rel4/user/sumbits.lisp
+./rtl/rel4/user/bitn.lisp
+./rtl/rel4/user/logior1.lisp
+./rtl/rel4/user/bias.lisp
+./rtl/rel4/user/bits-trunc.lisp
+./rtl/rel4/user/near.lisp
+./rtl/rel4/user/stick.lisp
+./rtl/rel4/user/bvecp.lisp
+./rtl/rel4/user/away.lisp
+./rtl/rel4/user/ereps.lisp
+./rtl/rel4/user/land.lisp
+./rtl/rel4/user/lextra.lisp
+./rtl/rel4/user/trunc.lisp
+./rtl/rel4/user/cat.lisp
+./rtl/rel4/user/bits.lisp
+./rtl/rel4/user/setbits.lisp
+./rtl/rel4/user/lxor.lisp
+./rtl/rel4/arithmetic/floor-proofs.lisp
+./rtl/rel4/arithmetic/fl-hacks.lisp
+./rtl/rel4/arithmetic/expo.lisp
+./rtl/rel4/arithmetic/fp.lisp
+./rtl/rel4/arithmetic/floor.lisp
+./rtl/rel4/arithmetic/extra-rules.lisp
+./rtl/rel4/arithmetic/hacks.lisp
+./rtl/rel4/arithmetic/top.lisp
+./rtl/rel4/arithmetic/fl.lisp
+./rtl/rel4/arithmetic/fp2.lisp
+./rtl/rel4/arithmetic/predicate.lisp
+./rtl/rel4/arithmetic/product.lisp
+./rtl/rel4/arithmetic/fl-proofs.lisp
+./rtl/rel4/arithmetic/expo-proofs.lisp
+./rtl/rel4/arithmetic/expt-proofs.lisp
+./rtl/rel4/arithmetic/x-2xx.lisp
+./rtl/rel4/arithmetic/complex-rationalp.lisp
+./rtl/rel4/arithmetic/power2p.lisp
+./rtl/rel4/arithmetic/negative-syntaxp.lisp
+./rtl/rel4/arithmetic/mod-proofs.lisp
+./rtl/rel4/arithmetic/rationalp.lisp
+./rtl/rel4/arithmetic/arith2.lisp
+./rtl/rel4/arithmetic/common-factor-defuns.lisp
+./rtl/rel4/arithmetic/nniq.lisp
+./rtl/rel4/arithmetic/even-odd2.lisp
+./rtl/rel4/arithmetic/mod.lisp
+./rtl/rel4/arithmetic/even-odd2-proofs.lisp
+./rtl/rel4/arithmetic/even-odd.lisp
+./rtl/rel4/arithmetic/integerp.lisp
+./rtl/rel4/arithmetic/fl-expt.lisp
+./rtl/rel4/arithmetic/basic.lisp
+./rtl/rel4/arithmetic/product-proofs.lisp
+./rtl/rel4/arithmetic/cg.lisp
+./rtl/rel4/arithmetic/denominator.lisp
+./rtl/rel4/arithmetic/expt.lisp
+./rtl/rel4/arithmetic/arith.lisp
+./rtl/rel4/arithmetic/unary-divide.lisp
+./rtl/rel4/arithmetic/mod-expt.lisp
+./rtl/rel4/arithmetic/common-factor.lisp
+./rtl/rel4/arithmetic/ground-zero.lisp
+./rtl/rel4/arithmetic/inverted-factor.lisp
+./rtl/rel4/arithmetic/numerator.lisp
+./rtl/rel4/arithmetic/induct.lisp
+./acl2s/defintrange.lisp
+./acl2s/defunc.lisp
+./acl2s/utilities.lisp
+./acl2s/custom.lisp
+./acl2s/top.lisp
+./acl2s/ccg/ccg-settings-dependencies.lisp
+./acl2s/ccg/ccg.lisp
+./acl2s/cgen/base-cgen-rules.lisp
+./acl2s/cgen/infer-enum-shape.lisp
+./acl2s/cgen/utilities.lisp
+./acl2s/cgen/cgen-rules.lisp
+./acl2s/cgen/top.lisp
+./acl2s/cgen/cgen-search.lisp
+./acl2s/cgen/fixers-gl-backend.lisp
+./acl2s/cgen/callback.lisp
+./acl2s/cgen/acl2s-parameter.lisp
+./acl2s/cgen/basis.lisp
+./acl2s/cgen/incremental-search.lisp
+./acl2s/cgen/cgen-state.lisp
+./acl2s/cgen/simple-search.lisp
+./acl2s/cgen/fixers-greedy.lisp
+./acl2s/cgen/build-enumcalls.lisp
+./acl2s/cgen/with-timeout.lisp
+./acl2s/cgen/prove-cgen.lisp
+./acl2s/cgen/type.lisp
+./acl2s/cgen/simple-graph-array.lisp
+./acl2s/cgen/propagate.lisp
+./acl2s/cgen/fixers2.lisp
+./acl2s/cgen/select.lisp
+./acl2s/acl2s-size.lisp
+./acl2s/base-arithmetic.lisp
+./acl2s/demos/alloy-support.lisp
+./acl2s/demos/dsp-preservation-rules.lisp
+./acl2s/demos/dsp-defthms.lisp
+./acl2s/demos/refinement-sfm06-with-hazards.lisp
+./acl2s/demos/dsp-type-and-fixer-defuns.lisp
+./acl2s/demos/dsp-fixer-rules.lisp
+./acl2s/demos/dsp-defuns.lisp
+./acl2s/properties.lisp
+./acl2s/definec.lisp
+./acl2s/base-lists.lisp
+./acl2s/mode-acl2s-dependencies.lisp
+./acl2s/cons-size.lisp
+./acl2s/portcullis.lisp
+./acl2s/acl2s-sigs.lisp
+./acl2s/doc.lisp
+./acl2s/top-doc.lisp
+./acl2s/defdata/builtin-combinators.lisp
+./acl2s/defdata/base.lisp
+./acl2s/defdata/top.lisp
+./acl2s/defdata/defdata-core.lisp
+./acl2s/defdata/random-state.lisp
+./acl2s/defdata/defdata-util.lisp
+./acl2s/defdata/register-type.lisp
+./acl2s/defdata/mv-proof.lisp
+./acl2s/defdata/switchnat.lisp
+./acl2s/defdata/var-book.lisp
+./acl2s/defdata/rem-and-floor.lisp
+./acl2s/defdata/listof.lisp
+./acl2s/defdata/tau-characterization.lisp
+./acl2s/defdata/record.lisp
+./acl2s/defdata/num-list-thms.lisp
+./acl2s/defdata/library-support.lisp
+./acl2s/defdata/num-list-fns.lisp
+./acl2s/defdata/register-combinator.lisp
+./acl2s/defdata/number-enums-sampling.lisp
+./acl2s/defdata/register-data-constructor.lisp
+./acl2s/defdata/map.lisp
+./acl2s/defdata/defdata-attach.lisp
+./acl2s/defdata/enumerators-gen.lisp
+./acl2s/defdata/alistof.lisp
+./acl2s/defdata/random-state-basis1.lisp
+./acl2s/defdata/splitnat.lisp
+./acl2s/defdata/sig.lisp
+./acl2s/defdata-testing.lisp
+./acl2s/sorting/sorting.lisp
+./acl2s/base-theory.lisp
+./acl2s/check-equal.lisp
+./demos/defabsstobj-example-3.lisp
+./demos/defabsstobj-example-5.lisp
+./demos/memoize-partial-book.lisp
+./demos/proofs/tightness-lemma-proof.lisp
+./demos/proofs/type-prescription.lisp
+./demos/proofs/tightness-lemma.lisp
+./demos/proofs/linear.lisp
+./demos/sort-by-car.lisp
+./demos/knuth-bendix-problem-1.lisp
+./demos/congruent-stobjs-book.lisp
+./demos/nth-update-nth-meta-extract.lisp
+./demos/list-theory.lisp
+./demos/register-invariant-risk.lisp
+./demos/rewrite-quoted-constant-examples.lisp
+./demos/partial-encapsulate-support.lisp
+./demos/memoize-invoke-book.lisp
+./demos/parallel/matrix-multiplication-parallel.lisp
+./demos/parallel/fibonacci.lisp
+./demos/parallel/matrix-multiplication-serial.lisp
+./demos/parallel/matrix-multiplication-setup.lisp
+./demos/list-equality-from-nth.lisp
+./demos/register-invariant-risk-support.lisp
+./demos/split-types-examples.lisp
+./demos/defabsstobj-example-4-book.lisp
+./demos/tutorial-problems/introductory-challenge-problem-4-athena.lisp
+./demos/tutorial-problems/introductory-challenge-problem-4.lisp
+./demos/tutorial-problems/equivalence-of-two-functions/moore.lisp
+./demos/tutorial-problems/equivalence-of-two-functions/kaufmann.lisp
+./demos/sort-by-car-support.lisp
+./demos/marktoberdorf-08/lecture1-book.lisp
+./demos/marktoberdorf-08/utilities.lisp
+./demos/marktoberdorf-08/preliminary-material.lisp
+./demos/marktoberdorf-08/lecture2-book.lisp
+./demos/marktoberdorf-08/m1-fast.lisp
+./demos/marktoberdorf-08/compile.lisp
+./demos/marktoberdorf-08/g-invariant.lisp
+./demos/marktoberdorf-08/fast.lisp
+./demos/marktoberdorf-08/g-direct.lisp
+./demos/marktoberdorf-08/lecture5-book.lisp
+./demos/marktoberdorf-08/lecture4-book.lisp
+./demos/marktoberdorf-08/lecture3-book.lisp
+./demos/marktoberdorf-08/perm.lisp
+./demos/marktoberdorf-08/m1.lisp
+./demos/defabsstobj-example-2.lisp
+./demos/defabsstobj-example-1.lisp
+./demos/rewrite-quoted-constant-examples-lemmas.lisp
+./demos/modeling/memories.lisp
+./demos/modeling/nondeterminism.lisp
+./demos/modeling/network-state-basic.lisp
+./demos/modeling/nested-stobj-toy-isa.lisp
+./demos/modeling/network-state.lisp
+./demos/big-proof-talks/talk2-book.lisp
+./demos/big-proof-talks/talk1-book.lisp
+./demos/patterned-congruences.lisp
+./demos/partial-encapsulate.lisp
+./demos/mini-proveall-book.lisp
+./demos/meta-wf-guarantee-example.lisp
+./demos/stobj-equality-from-fields.lisp
+./demos/constants-that-require-modifying-state.lisp
+./demos/gl-and-use-example.lisp
+./demos/gl-and-std/defprod-constants.lisp
+./demos/gl-and-std/defaggregate-constants.lisp
+./demos/gl-and-std/defaggregate-keywords.lisp
+./demos/brr-free-variables-book.lisp
+./unicode/utf8-decode.lisp
+./unicode/uchar.lisp
+./unicode/z-listp.lisp
+./unicode/utf8-encode.lisp
+./unicode/utf8-table37.lisp
+./unicode/partition.lisp
+./unicode/read-utf8.lisp
+./unicode/sum-list.lisp
+./unicode/utf8-table36.lisp
+./tau/bounders/find-maximal-1d.lisp
+./tau/bounders/tau-bounders-tests.lisp
+./tau/bounders/find-minimal-2d.lisp
+./tau/bounders/find-maximal-2d.lisp
+./tau/bounders/elementary-bounders.lisp
+./tau/bounders/find-minimal-1d.lisp
+./arithmetic-2/meta/cancel-terms-meta.lisp
+./arithmetic-2/meta/common-meta.lisp
+./arithmetic-2/meta/cancel-terms-helper.lisp
+./arithmetic-2/meta/collect-terms-meta.lisp
+./arithmetic-2/meta/mini-theories.lisp
+./arithmetic-2/meta/top.lisp
+./arithmetic-2/meta/numerator-and-denominator.lisp
+./arithmetic-2/meta/expt-helper.lisp
+./arithmetic-2/meta/pre.lisp
+./arithmetic-2/meta/post.lisp
+./arithmetic-2/meta/integerp.lisp
+./arithmetic-2/meta/expt.lisp
+./arithmetic-2/meta/non-linear.lisp
+./arithmetic-2/meta/integerp-meta.lisp
+./arithmetic-2/floor-mod/floor-mod.lisp
+./arithmetic-2/floor-mod/floor-mod-helper.lisp
+./arithmetic-2/pass1/mini-theories.lisp
+./arithmetic-2/pass1/top.lisp
+./arithmetic-2/pass1/prefer-times.lisp
+./arithmetic-2/pass1/basic-arithmetic-helper.lisp
+./arithmetic-2/pass1/numerator-and-denominator.lisp
+./arithmetic-2/pass1/inequalities.lisp
+./arithmetic-2/pass1/expt-helper.lisp
+./arithmetic-2/pass1/basic-arithmetic.lisp
+./arithmetic-2/pass1/expt.lisp
+./arithmetic-2/pass1/numerator-and-denominator-helper.lisp
+./make-event/eval-tests.lisp
+./make-event/double-cert-test.lisp
+./make-event/macros-skip-proofs-include.lisp
+./make-event/nested-check.lisp
+./make-event/make-redundant.lisp
+./make-event/defconst-fast.lisp
+./make-event/dotimes.lisp
+./make-event/eval-check-tests.lisp
+./make-event/assert-check-include.lisp
+./make-event/eval-check.lisp
+./make-event/local-elided.lisp
+./make-event/basic-pkg.lisp
+./make-event/defrefine.lisp
+./make-event/nested.lisp
+./make-event/stobj-test.lisp
+./make-event/gen-defun-check.lisp
+./make-event/read-from-file.lisp
+./make-event/make-event-keywords-or-exp.lisp
+./make-event/local-elided-include.lisp
+./make-event/macros-include.lisp
+./make-event/portcullis-expansion-include.lisp
+./make-event/macros.lisp
+./make-event/local-requires-skip-check.lisp
+./make-event/macros-skip-proofs.lisp
+./make-event/search-generation.lisp
+./make-event/defspec.lisp
+./make-event/acl2x-help.lisp
+./make-event/double-cert-test-1.lisp
+./make-event/gen-defun.lisp
+./make-event/proof-by-arith.lisp
+./make-event/assert-check.lisp
+./make-event/embeddable-event-forms.lisp
+./make-event/acl2x-help-test.lisp
+./make-event/defconst-fast-examples.lisp
+./make-event/defrule.lisp
+./make-event/basic-pkg-check.lisp
+./make-event/basic.lisp
+./make-event/test-case-check.lisp
+./make-event/make-event-keywords-or-exp-check.lisp
+./make-event/gen-defthm-check.lisp
+./make-event/local-requires-skip-check-include.lisp
+./make-event/basic-check.lisp
+./make-event/logical-tangent.lisp
+./make-event/test-case.lisp
+./make-event/portcullis-expansion.lisp
+./make-event/require-book.lisp
+./make-event/inline-book.lisp
+./make-event/gen-defthm.lisp
+./kestrel/auto-termination/injections.lisp
+./kestrel/auto-termination/subsetp-eq-linear.lisp
+./kestrel/auto-termination/defunt-top.lisp
+./kestrel/auto-termination/termination-database-utilities.lisp
+./kestrel/auto-termination/top.lisp
+./kestrel/auto-termination/termination-database.lisp
+./kestrel/auto-termination/td-cands.lisp
+./kestrel/auto-termination/defunt-tests.lisp
+./kestrel/auto-termination/fms-bang-list.lisp
+./kestrel/auto-termination/strict-merge-sort.lisp
+./kestrel/auto-termination/defunt.lisp
+./kestrel/alists-light/strip-cars2.lisp
+./kestrel/alists-light/symbol-alistp.lisp
+./kestrel/alists-light/maybe-replace-var.lisp
+./kestrel/alists-light/lookup-equal-safe.lisp
+./kestrel/alists-light/uniquify-alist-eq.lisp
+./kestrel/alists-light/top.lisp
+./kestrel/alists-light/lookup-eq-required.lisp
+./kestrel/alists-light/pairlis-dollar.lisp
+./kestrel/alists-light/lookup-eq-safe.lisp
+./kestrel/alists-light/lookup-equal.lisp
+./kestrel/alists-light/lookup-eq.lisp
+./kestrel/alists-light/acons-unique.lisp
+./kestrel/alists-light/compat.lisp
+./kestrel/alists-light/assoc-equal.lisp
+./kestrel/alists-light/lookup.lisp
+./kestrel/alists-light/alistp.lisp
+./kestrel/alists-light/lookup-safe.lisp
+./kestrel/alists-light/strip-cdrs.lisp
+./kestrel/alists-light/lookup-eq-lst.lisp
+./kestrel/alists-light/pairlis-dollar-fast.lisp
+./kestrel/alists-light/strip-cars.lisp
+./kestrel/alists-light/acons.lisp
+./kestrel/alists-light/clear-key.lisp
+./kestrel/alists-light/keep-pairs.lisp
+./kestrel/algorithm-theories/top.lisp
+./kestrel/algorithm-theories/generic-tail-rec.lisp
+./kestrel/zcash/top.lisp
+./kestrel/zcash/jubjub.lisp
+./kestrel/zcash/pedersen-hash.lisp
+./kestrel/zcash/constants.lisp
+./kestrel/zcash/lift-zcash-r1cs.lisp
+./kestrel/zcash/randomness-beacon.lisp
+./kestrel/zcash/portcullis.lisp
+./kestrel/zcash/blake2-hash.lisp
+./kestrel/zcash/jubjub-montgomery.lisp
+./kestrel/zcash/bit-byte-integer-conversions.lisp
+./kestrel/library-wrappers/my-make-flag.lisp
+./kestrel/library-wrappers/ihs-quotient-remainder-lemmas.lisp
+./kestrel/library-wrappers/arithmetic-equalities.lisp
+./kestrel/library-wrappers/sublistp.lisp
+./kestrel/library-wrappers/arithmetic-inequalities.lisp
+./kestrel/library-wrappers/my-make-flag-tests.lisp
+./kestrel/library-wrappers/arithmetic-top-with-meta.lisp
+./kestrel/library-wrappers/ihs-logops-lemmas.lisp
+./kestrel/library-wrappers/list-defpkg.lisp
+./kestrel/crypto/mimc/top.lisp
+./kestrel/crypto/mimc/round-constants-for-semaphore.lisp
+./kestrel/crypto/mimc/mimcsponge-spec-rules.lisp
+./kestrel/crypto/mimc/mimcsponge.lisp
+./kestrel/crypto/mimc/portcullis.lisp
+./kestrel/crypto/mimc/doc.lisp
+./kestrel/crypto/mimc/mimcsponge-tests.lisp
+./kestrel/crypto/attachments/top.lisp
+./kestrel/crypto/attachments/keccak-256.lisp
+./kestrel/crypto/attachments/sha-256.lisp
+./kestrel/crypto/attachments/hmac-sha-512.lisp
+./kestrel/crypto/attachments/pbkdf2-hmac-sha-512.lisp
+./kestrel/crypto/pfcs/examples-deep.lisp
+./kestrel/crypto/pfcs/abstract-syntax-operations.lisp
+./kestrel/crypto/pfcs/top.lisp
+./kestrel/crypto/pfcs/well-formedness.lisp
+./kestrel/crypto/pfcs/semantics-shallow.lisp
+./kestrel/crypto/pfcs/abstract-syntax.lisp
+./kestrel/crypto/pfcs/portcullis.lisp
+./kestrel/crypto/pfcs/semantics.lisp
+./kestrel/crypto/pfcs/examples-shallow.lisp
+./kestrel/crypto/pfcs/semantics-deep.lisp
+./kestrel/crypto/pfcs/proof-support.lisp
+./kestrel/crypto/top.lisp
+./kestrel/crypto/interfaces/hmac-sha-256.lisp
+./kestrel/crypto/interfaces/aes-192-cbc-pkcs7.lisp
+./kestrel/crypto/interfaces/top.lisp
+./kestrel/crypto/interfaces/keccak-256.lisp
+./kestrel/crypto/interfaces/definterface-encrypt-block.lisp
+./kestrel/crypto/interfaces/definterface-pbkdf2.lisp
+./kestrel/crypto/interfaces/sha-512.lisp
+./kestrel/crypto/interfaces/aes-128-cbc-pkcs7.lisp
+./kestrel/crypto/interfaces/aes-256-cbc-pkcs7.lisp
+./kestrel/crypto/interfaces/sha-256.lisp
+./kestrel/crypto/interfaces/pbkdf2-hmac-sha-256.lisp
+./kestrel/crypto/interfaces/definterface-encrypt-init.lisp
+./kestrel/crypto/interfaces/hmac-sha-512.lisp
+./kestrel/crypto/interfaces/aes-128.lisp
+./kestrel/crypto/interfaces/definterface-hmac.lisp
+./kestrel/crypto/interfaces/keccak-512.lisp
+./kestrel/crypto/interfaces/aes-256.lisp
+./kestrel/crypto/interfaces/aes-192.lisp
+./kestrel/crypto/interfaces/definterface-hash.lisp
+./kestrel/crypto/interfaces/ripemd-160.lisp
+./kestrel/crypto/interfaces/pbkdf2-hmac-sha-512.lisp
+./kestrel/crypto/padding/pad-to-448-validation.lisp
+./kestrel/crypto/padding/pad-to-896.lisp
+./kestrel/crypto/padding/top.lisp
+./kestrel/crypto/padding/pad-to-896-tests.lisp
+./kestrel/crypto/padding/pad-to-448-tests.lisp
+./kestrel/crypto/padding/pad-to-896-validation.lisp
+./kestrel/crypto/padding/portcullis.lisp
+./kestrel/crypto/padding/doc.lisp
+./kestrel/crypto/padding/pad-to-448.lisp
+./kestrel/crypto/primes/baby-jubjub-subgroup-prime.lisp
+./kestrel/crypto/primes/bls12-381-prime.lisp
+./kestrel/crypto/primes/top.lisp
+./kestrel/crypto/primes/secp256k1-group-prime.lisp
+./kestrel/crypto/primes/bls12-377-prime.lisp
+./kestrel/crypto/primes/edwards-bls12-377-subgroup-prime.lisp
+./kestrel/crypto/primes/secp256k1-field-prime.lisp
+./kestrel/crypto/primes/jubjub-subgroup-prime.lisp
+./kestrel/crypto/primes/bn-254-group-prime.lisp
+./kestrel/crypto/ecurve/prime-field-intro.lisp
+./kestrel/crypto/ecurve/points-fty.lisp
+./kestrel/crypto/ecurve/top.lisp
+./kestrel/crypto/ecurve/secp256k1-types.lisp
+./kestrel/crypto/ecurve/short-weierstrass-validation.lisp
+./kestrel/crypto/ecurve/secp256k1-tests.lisp
+./kestrel/crypto/ecurve/secp256k1-interface.lisp
+./kestrel/crypto/ecurve/edwards-bls12.lisp
+./kestrel/crypto/ecurve/twisted-edwards-closure-simp.lisp
+./kestrel/crypto/ecurve/secp256k1-attachment.lisp
+./kestrel/crypto/ecurve/tests-top.lisp
+./kestrel/crypto/ecurve/points.lisp
+./kestrel/crypto/ecurve/bls12-377-domain-parameters.lisp
+./kestrel/crypto/ecurve/short-weierstrass-closure-simp.lisp
+./kestrel/crypto/ecurve/twisted-edwards-closure-core.lisp
+./kestrel/crypto/ecurve/prime-field-squares.lisp
+./kestrel/crypto/ecurve/short-weierstrass-closure-lemma.lisp
+./kestrel/crypto/ecurve/secp256k1.lisp
+./kestrel/crypto/ecurve/secp256k1-domain-parameters.lisp
+./kestrel/crypto/ecurve/prime-field-squares-euler-criterion.lisp
+./kestrel/crypto/ecurve/portcullis.lisp
+./kestrel/crypto/ecurve/prime-field-extra-rules.lisp
+./kestrel/crypto/ecurve/secp256k1-point-conversions.lisp
+./kestrel/crypto/ecurve/twisted-edwards.lisp
+./kestrel/crypto/ecurve/birational-montgomery-twisted-edwards.lisp
+./kestrel/crypto/ecurve/montgomery.lisp
+./kestrel/crypto/ecurve/odd-prime-fields.lisp
+./kestrel/crypto/ecurve/short-weierstrass.lisp
+./kestrel/crypto/kdf/top.lisp
+./kestrel/crypto/kdf/pbkdf2-hmac-sha-512-tests.lisp
+./kestrel/crypto/kdf/portcullis.lisp
+./kestrel/crypto/kdf/doc.lisp
+./kestrel/crypto/kdf/pbkdf2-hmac-sha-512.lisp
+./kestrel/crypto/blake/blake2s-tests.lisp
+./kestrel/crypto/blake/blake-256.lisp
+./kestrel/crypto/blake/blake-256-padding.lisp
+./kestrel/crypto/blake/top.lisp
+./kestrel/crypto/blake/blake2s-extended.lisp
+./kestrel/crypto/blake/blake-common-32.lisp
+./kestrel/crypto/blake/portcullis.lisp
+./kestrel/crypto/blake/blake2s-extended-validation.lisp
+./kestrel/crypto/blake/blake2s-extended-tests.lisp
+./kestrel/crypto/blake/blake-256-tests.lisp
+./kestrel/crypto/blake/blake2s.lisp
+./kestrel/crypto/sha-2/sha-256-tests.lisp
+./kestrel/crypto/sha-2/top.lisp
+./kestrel/crypto/sha-2/sha-384-tests.lisp
+./kestrel/crypto/sha-2/tests-top.lisp
+./kestrel/crypto/sha-2/sha-512-tests.lisp
+./kestrel/crypto/sha-2/sha-512.lisp
+./kestrel/crypto/sha-2/sha-224-tests.lisp
+./kestrel/crypto/sha-2/sha-224.lisp
+./kestrel/crypto/sha-2/sha-256.lisp
+./kestrel/crypto/sha-2/sha-384.lisp
+./kestrel/crypto/sha-2/portcullis.lisp
+./kestrel/crypto/sha-2/doc.lisp
+./kestrel/crypto/ecdsa/top.lisp
+./kestrel/crypto/ecdsa/secp256k1-interface.lisp
+./kestrel/crypto/ecdsa/deterministic-ecdsa-secp256k1-tests.lisp
+./kestrel/crypto/ecdsa/deterministic-ecdsa-exposing-k-secp256k1.lisp
+./kestrel/crypto/ecdsa/secp256k1-attachment.lisp
+./kestrel/crypto/ecdsa/portcullis.lisp
+./kestrel/crypto/ecdsa/deterministic-ecdsa-secp256k1.lisp
+./kestrel/crypto/hmac/hmac-sha-256.lisp
+./kestrel/crypto/hmac/top.lisp
+./kestrel/crypto/hmac/hmac-sha-256-tests.lisp
+./kestrel/crypto/hmac/hmac-sha-512-tests.lisp
+./kestrel/crypto/hmac/portcullis.lisp
+./kestrel/crypto/hmac/hmac-sha-512.lisp
+./kestrel/crypto/hmac/doc.lisp
+./kestrel/crypto/portcullis.lisp
+./kestrel/crypto/r1cs/top.lisp
+./kestrel/crypto/r1cs/gadgets/boolean-alt-rules.lisp
+./kestrel/crypto/r1cs/gadgets/top.lisp
+./kestrel/crypto/r1cs/gadgets/boolean-rules.lisp
+./kestrel/crypto/r1cs/gadgets/nonzero-rules.lisp
+./kestrel/crypto/r1cs/gadgets/xor-rules.lisp
+./kestrel/crypto/r1cs/gadgets/selection-rules.lisp
+./kestrel/crypto/r1cs/sparse/rules-axe.lisp
+./kestrel/crypto/r1cs/sparse/top.lisp
+./kestrel/crypto/r1cs/sparse/r1cs.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/boolean.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/top.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/conditional-equality.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/boolean-alt.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/packing-tests.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/xor.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/boolean-tests.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/packing.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/selection.lisp
+./kestrel/crypto/r1cs/sparse/gadgets/nonzero.lisp
+./kestrel/crypto/r1cs/sparse/r1cs-tests.lisp
+./kestrel/crypto/r1cs/sparse/rules.lisp
+./kestrel/crypto/r1cs/sparse/doc.lisp
+./kestrel/crypto/r1cs/sparse/rule-lists.lisp
+./kestrel/crypto/r1cs/gadgets.lisp
+./kestrel/crypto/r1cs/valuations.lisp
+./kestrel/crypto/r1cs/portcullis.lisp
+./kestrel/crypto/r1cs/doc.lisp
+./kestrel/crypto/r1cs/tools/axe-syntaxp-evaluator-r1cs.lisp
+./kestrel/crypto/r1cs/tools/top.lisp
+./kestrel/crypto/r1cs/tools/axe-evaluator-r1cs.lisp
+./kestrel/crypto/r1cs/tools/lift-r1cs-old.lisp
+./kestrel/crypto/r1cs/tools/filter-and-combine-symbol-alists.lisp
+./kestrel/crypto/r1cs/tools/verify-r1cs.lisp
+./kestrel/crypto/r1cs/tools/lift-r1cs-common.lisp
+./kestrel/crypto/r1cs/tools/lift-r1cs-rules.lisp
+./kestrel/crypto/r1cs/tools/axe-prover-r1cs.lisp
+./kestrel/crypto/r1cs/tools/order-r1cs-vars.lisp
+./kestrel/crypto/r1cs/tools/doc.lisp
+./kestrel/crypto/r1cs/tools/lift-r1cs.lisp
+./kestrel/crypto/r1cs/tools/axe-syntax-functions-r1cs.lisp
+./kestrel/crypto/r1cs/tools/axe-rules-r1cs.lisp
+./kestrel/crypto/r1cs/tools/lift-r1cs-rule-lists.lisp
+./kestrel/crypto/r1cs/proof-support.lisp
+./kestrel/crypto/keccak/top.lisp
+./kestrel/crypto/keccak/keccak-tests.lisp
+./kestrel/crypto/keccak/keccak.lisp
+./kestrel/crypto/keccak/keccak-team-tests.lisp
+./kestrel/crypto/keccak/keccak-team-test-data.lisp
+./kestrel/crypto/keccak/portcullis.lisp
+./kestrel/crypto/keccak/documentation.lisp
+./kestrel/hdwallet/top.lisp
+./kestrel/hdwallet/wallet-tests.lisp
+./kestrel/hdwallet/wallet.lisp
+./kestrel/hdwallet/portcullis.lisp
+./kestrel/hdwallet/wallet-executable.lisp
+./kestrel/random/top.lisp
+./kestrel/random/minstd-rand.lisp
+./kestrel/random/minstd-rand0.lisp
+./kestrel/error-checking/ensure-symbol-is-fresh-event-name.lisp
+./kestrel/error-checking/ensure-value-is-in-list-tests.lisp
+./kestrel/error-checking/ensure-list-has-no-duplicates-tests.lisp
+./kestrel/error-checking/top.lisp
+./kestrel/error-checking/ensure-symbol-is-fresh-event-name-tests.lisp
+./kestrel/error-checking/ensure-value-is-symbol-tests.lisp
+./kestrel/error-checking/ensure-value-is-true-list-tests.lisp
+./kestrel/error-checking/ensure-value-is-in-list.lisp
+./kestrel/error-checking/ensure-value-is-symbol.lisp
+./kestrel/error-checking/ensure-function-is-defined-tests.lisp
+./kestrel/error-checking/ensure-value-is-not-in-list-tests.lisp
+./kestrel/error-checking/ensure-value-is-boolean-tests.lisp
+./kestrel/error-checking/ensure-value-is-nil-tests.lisp
+./kestrel/error-checking/ensure-value-is-legal-variable-name.lisp
+./kestrel/error-checking/ensure-list-has-no-duplicates.lisp
+./kestrel/error-checking/ensure-function-is-defined.lisp
+./kestrel/error-checking/ensure-value-is-function-name-tests.lisp
+./kestrel/error-checking/ensure-value-is-string-tests.lisp
+./kestrel/error-checking/ensure-function-is-guard-verified.lisp
+./kestrel/error-checking/ensure-value-is-string.lisp
+./kestrel/error-checking/ensure-value-is-untranslated-term.lisp
+./kestrel/error-checking/ensure-value-is-boolean.lisp
+./kestrel/error-checking/ensure-value-is-function-name.lisp
+./kestrel/error-checking/ensure-value-is-legal-variable-name-tests.lisp
+./kestrel/error-checking/ensure-function-is-logic-mode.lisp
+./kestrel/error-checking/ensure-value-is-true-list.lisp
+./kestrel/error-checking/ensure-function-is-pure-if-raw-tests.lisp
+./kestrel/error-checking/ensure-function-is-guard-verified-tests.lisp
+./kestrel/error-checking/ensure-function-is-pure-if-raw.lisp
+./kestrel/error-checking/ensure-value-is-symbol-list.lisp
+./kestrel/error-checking/ensure-function-is-logic-mode-tests.lisp
+./kestrel/error-checking/ensure-value-is-not-in-list.lisp
+./kestrel/error-checking/ensure-value-is-untranslated-term-tests.lisp
+./kestrel/error-checking/ensure-value-is-symbol-list-tests.lisp
+./kestrel/error-checking/ensure-value-is-nil.lisp
+./kestrel/error-checking/def-error-checker.lisp
+./kestrel/top.lisp
+./kestrel/c/top.lisp
+./kestrel/c/atc/integer-formats.lisp
+./kestrel/c/atc/values.lisp
+./kestrel/c/atc/arrays.lisp
+./kestrel/c/atc/abstract-syntax-operations.lisp
+./kestrel/c/atc/dynamic-semantics.lisp
+./kestrel/c/atc/function-environments.lisp
+./kestrel/c/atc/top.lisp
+./kestrel/c/atc/term-recognizers.lisp
+./kestrel/c/atc/static-semantics.lisp
+./kestrel/c/atc/execution.lisp
+./kestrel/c/atc/pointers.lisp
+./kestrel/c/atc/abstract-syntax.lisp
+./kestrel/c/atc/input-processing.lisp
+./kestrel/c/atc/defthm-disjoint.lisp
+./kestrel/c/atc/integer-conversions.lisp
+./kestrel/c/atc/portable-ascii-identifiers.lisp
+./kestrel/c/atc/generation.lisp
+./kestrel/c/atc/conditional-expressions.lisp
+./kestrel/c/atc/types.lisp
+./kestrel/c/atc/computation-states.lisp
+./kestrel/c/atc/table.lisp
+./kestrel/c/atc/tests/calls.lisp
+./kestrel/c/atc/tests/conversions.lisp
+./kestrel/c/atc/tests/arrays.lisp
+./kestrel/c/atc/tests/operators.lisp
+./kestrel/c/atc/tests/conditionals.lisp
+./kestrel/c/atc/tests/constants.lisp
+./kestrel/c/atc/tests/int.lisp
+./kestrel/c/atc/tests/ops-diff-types.lisp
+./kestrel/c/atc/tests/checksum.lisp
+./kestrel/c/atc/tests/loops.lisp
+./kestrel/c/atc/tests/arrays-write.lisp
+./kestrel/c/atc/tests/mbt.lisp
+./kestrel/c/atc/tests/assign.lisp
+./kestrel/c/atc/tests/nonstrict.lisp
+./kestrel/c/atc/tests/locvars.lisp
+./kestrel/c/atc/doc.lisp
+./kestrel/c/atc/integer-operations.lisp
+./kestrel/c/atc/errors.lisp
+./kestrel/c/atc/integers.lisp
+./kestrel/c/atc/pretty-printer.lisp
+./kestrel/c/atc/shallow-embedding.lisp
+./kestrel/c/atc/tutorial.lisp
+./kestrel/c/atc/let-designations.lisp
+./kestrel/c/atc/proof-support.lisp
+./kestrel/c/atc/pack.lisp
+./kestrel/c/atc/atc.lisp
+./kestrel/c/portcullis.lisp
+./kestrel/c/language/keywords.lisp
+./kestrel/c/language/top.lisp
+./kestrel/c/language/bytes.lisp
+./kestrel/c/language/character-sets.lisp
+./kestrel/event-macros/cw-event-tests.lisp
+./kestrel/event-macros/applicability-conditions.lisp
+./kestrel/event-macros/top.lisp
+./kestrel/event-macros/event-generation-soft.lisp
+./kestrel/event-macros/fail-event-tests.lisp
+./kestrel/event-macros/restore-output.lisp
+./kestrel/event-macros/make-event-terse-tests.lisp
+./kestrel/event-macros/fail-event.lisp
+./kestrel/event-macros/input-processing.lisp
+./kestrel/event-macros/intro-macros-tests.lisp
+./kestrel/event-macros/try-event-tests.lisp
+./kestrel/event-macros/proof-preparation.lisp
+./kestrel/event-macros/event-generation.lisp
+./kestrel/event-macros/restore-output-tests.lisp
+./kestrel/event-macros/template-generators.lisp
+./kestrel/event-macros/make-event-terse.lisp
+./kestrel/event-macros/screen-printing.lisp
+./kestrel/event-macros/intro-macros.lisp
+./kestrel/event-macros/cw-event.lisp
+./kestrel/event-macros/results.lisp
+./kestrel/event-macros/xdoc-constructors.lisp
+./kestrel/event-macros/evmac-input-hints-p.lisp
+./kestrel/event-macros/try-event.lisp
+./kestrel/event-macros/definedness.lisp
+./kestrel/bv/bitxnor.lisp
+./kestrel/bv/getbit2.lisp
+./kestrel/bv/bitnot.lisp
+./kestrel/bv/sbvmoddown.lisp
+./kestrel/bv/bvuminus.lisp
+./kestrel/bv/bitand.lisp
+./kestrel/bv/defs.lisp
+./kestrel/bv/bit-to-bool.lisp
+./kestrel/bv/rules8.lisp
+./kestrel/bv/bvcount.lisp
+./kestrel/bv/getbit-rules.lisp
+./kestrel/bv/bvdiv.lisp
+./kestrel/bv/top.lisp
+./kestrel/bv/defs-arith.lisp
+./kestrel/bv/logtail-def.lisp
+./kestrel/bv/rules3.lisp
+./kestrel/bv/bvashr.lisp
+./kestrel/bv/rightrotate32.lisp
+./kestrel/bv/floor-mod-expt.lisp
+./kestrel/bv/logapp.lisp
+./kestrel/bv/rules5.lisp
+./kestrel/bv/logorc1.lisp
+./kestrel/bv/logxor-b.lisp
+./kestrel/bv/bool-to-bit.lisp
+./kestrel/bv/slice-def.lisp
+./kestrel/bv/logior.lisp
+./kestrel/bv/bvif2.lisp
+./kestrel/bv/bvsx.lisp
+./kestrel/bv/sbvlt-rules.lisp
+./kestrel/bv/sbvlt.lisp
+./kestrel/bv/bvdiv-rules.lisp
+./kestrel/bv/rules2.lisp
+./kestrel/bv/bvor.lisp
+./kestrel/bv/sbvdiv.lisp
+./kestrel/bv/rules4.lisp
+./kestrel/bv/bvchop-def.lisp
+./kestrel/bv/bvif.lisp
+./kestrel/bv/ones-complement.lisp
+./kestrel/bv/bitor.lisp
+./kestrel/bv/bvminus.lisp
+./kestrel/bv/bitxor.lisp
+./kestrel/bv/bitwise.lisp
+./kestrel/bv/bvshr.lisp
+./kestrel/bv/repeatbit.lisp
+./kestrel/bv/sbvdivdown-rules.lisp
+./kestrel/bv/bitp.lisp
+./kestrel/bv/adder.lisp
+./kestrel/bv/arith2.lisp
+./kestrel/bv/bvchop.lisp
+./kestrel/bv/logxor.lisp
+./kestrel/bv/rightrotate.lisp
+./kestrel/bv/logtail.lisp
+./kestrel/bv/logior-b.lisp
+./kestrel/bv/rules6.lisp
+./kestrel/bv/rules.lisp
+./kestrel/bv/bvshr-def.lisp
+./kestrel/bv/sbvrem-rules.lisp
+./kestrel/bv/lognot.lisp
+./kestrel/bv/trim.lisp
+./kestrel/bv/bvnot.lisp
+./kestrel/bv/getbit.lisp
+./kestrel/bv/leftrotate16.lisp
+./kestrel/bv/leftrotate64.lisp
+./kestrel/bv/unsigned-byte-p.lisp
+./kestrel/bv/bvminus-rules.lisp
+./kestrel/bv/slice-rules.lisp
+./kestrel/bv/bvlt.lisp
+./kestrel/bv/bvcat-def.lisp
+./kestrel/bv/bytep.lisp
+./kestrel/bv/rules10.lisp
+./kestrel/bv/sbvdivdown.lisp
+./kestrel/bv/bvcat.lisp
+./kestrel/bv/logeqv.lisp
+./kestrel/bv/leftrotate32.lisp
+./kestrel/bv/repeatbit2.lisp
+./kestrel/bv/rotate.lisp
+./kestrel/bv/bvmult.lisp
+./kestrel/bv/bv-tests.lisp
+./kestrel/bv/rules0.lisp
+./kestrel/bv/defs-bitwise.lisp
+./kestrel/bv/bvcat2.lisp
+./kestrel/bv/doc.lisp
+./kestrel/bv/unsigned-byte-p-forced.lisp
+./kestrel/bv/logapp-def.lisp
+./kestrel/bv/leftrotate.lisp
+./kestrel/bv/bvshl-def.lisp
+./kestrel/bv/sbvrem.lisp
+./kestrel/bv/logand.lisp
+./kestrel/bv/bvplus.lisp
+./kestrel/bv/bvmod.lisp
+./kestrel/bv/unsigned-byte-p2.lisp
+./kestrel/bv/rules9.lisp
+./kestrel/bv/bv-syntax.lisp
+./kestrel/bv/signed-byte-p.lisp
+./kestrel/bv/ops32.lisp
+./kestrel/bv/idioms.lisp
+./kestrel/bv/arith.lisp
+./kestrel/bv/sbvdiv-rules.lisp
+./kestrel/bv/logand2.lisp
+./kestrel/bv/ops64.lisp
+./kestrel/bv/overflow-and-underflow.lisp
+./kestrel/bv/getbit-def.lisp
+./kestrel/bv/single-bit.lisp
+./kestrel/bv/rules7.lisp
+./kestrel/bv/slice2.lisp
+./kestrel/bv/logext.lisp
+./kestrel/bv/bvshl.lisp
+./kestrel/bv/bvand.lisp
+./kestrel/bv/putbits.lisp
+./kestrel/bv/bvxor.lisp
+./kestrel/bv/slice.lisp
+./kestrel/bv/bvsx-def.lisp
+./kestrel/strings-light/split-chars-repeatedly.lisp
+./kestrel/strings-light/split-string-repeatedly.lisp
+./kestrel/strings-light/upcase.lisp
+./kestrel/strings-light/top.lisp
+./kestrel/strings-light/downcase-doc.lisp
+./kestrel/strings-light/split-chars.lisp
+./kestrel/strings-light/downcase.lisp
+./kestrel/strings-light/split-string.lisp
+./kestrel/strings-light/doc.lisp
+./kestrel/strings-light/upcase-doc.lisp
+./kestrel/isar/top.lisp
+./kestrel/isar/defisar.lisp
+./kestrel/isar/portcullis.lisp
+./kestrel/isar/defisar-doc.lisp
+./kestrel/isar/defisar-tests.lisp
+./kestrel/file-io-light/read-file-into-stobj.lisp
+./kestrel/file-io-light/write-objects-to-channel.lisp
+./kestrel/file-io-light/file-length-dollar.lisp
+./kestrel/file-io-light/top.lisp
+./kestrel/file-io-light/open-output-channel.lisp
+./kestrel/file-io-light/file-write-date-dollar.lisp
+./kestrel/file-io-light/open-output-channel-bang.lisp
+./kestrel/file-io-light/read-file-into-byte-list.lisp
+./kestrel/file-io-light/print-object-dollar.lisp
+./kestrel/file-io-light/write-bytes-to-file-bang.lisp
+./kestrel/file-io-light/open-input-channel.lisp
+./kestrel/file-io-light/write-objects-to-file-bang.lisp
+./kestrel/file-io-light/compat.lisp
+./kestrel/file-io-light/write-objects-to-file.lisp
+./kestrel/file-io-light/read-file-into-character-list.lisp
+./kestrel/file-io-light/write-strings-to-file-bang.lisp
+./kestrel/file-io-light/write-strings-to-file.lisp
+./kestrel/file-io-light/princ-dollar.lisp
+./kestrel/file-io-light/write-byte-dollar.lisp
+./kestrel/file-io-light/write-strings-to-channel.lisp
+./kestrel/file-io-light/file-is-newer-thanp.lisp
+./kestrel/file-io-light/write-bytes-to-channel.lisp
+./kestrel/file-io-light/doc.lisp
+./kestrel/file-io-light/read-byte-dollar.lisp
+./kestrel/file-io-light/read-object-from-file.lisp
+./kestrel/file-io-light/write-bytes-to-file.lisp
+./kestrel/file-io-light/read-object.lisp
+./kestrel/maps/maps.lisp
+./kestrel/maps/maps0.lisp
+./kestrel/axe/dag-array-builders3.lisp
+./kestrel/axe/def-dag-builder-theorems.lisp
+./kestrel/axe/defthm-axe-basic-tests.lisp
+./kestrel/axe/step-increments.lisp
+./kestrel/axe/defthm-axe-basic.lisp
+./kestrel/axe/prover-basic-clause-processor.lisp
+./kestrel/axe/sublis-var-and-eval.lisp
+./kestrel/axe/shorter-list.lisp
+./kestrel/axe/rule-limits.lisp
+./kestrel/axe/make-implication-dag.lisp
+./kestrel/axe/dag-conjuncts.lisp
+./kestrel/axe/dag-array-printing.lisp
+./kestrel/axe/remove-duplicates-from-sorted-list.lisp
+./kestrel/axe/unguarded-primitives.lisp
+./kestrel/axe/depth-array.lisp
+./kestrel/axe/stp-counterexamples.lisp
+./kestrel/axe/supporting-vars.lisp
+./kestrel/axe/memoization.lisp
+./kestrel/axe/make-axe-syntaxp-evaluator-tests.lisp
+./kestrel/axe/instantiate-hyp.lisp
+./kestrel/axe/check-equivs.lisp
+./kestrel/axe/make-dag-indices.lisp
+./kestrel/axe/top.lisp
+./kestrel/axe/substitute-vars2.lisp
+./kestrel/axe/known-booleans.lisp
+./kestrel/axe/axe-rules.lisp
+./kestrel/axe/make-evaluator-common.lisp
+./kestrel/axe/print-constant.lisp
+./kestrel/axe/rewriter-basic.lisp
+./kestrel/axe/rules3.lisp
+./kestrel/axe/merge-term-into-dag-array-basic.lisp
+./kestrel/axe/instantiate-hyp-basic.lisp
+./kestrel/axe/get-disjuncts.lisp
+./kestrel/axe/dag-to-term-with-lets.lisp
+./kestrel/axe/prune-with-contexts.lisp
+./kestrel/axe/make-node-replacement-alist.lisp
+./kestrel/axe/list-rules.lisp
+./kestrel/axe/make-axe-rules-tests.lisp
+./kestrel/axe/make-evaluator-simple-tests.lisp
+./kestrel/axe/known-booleans-tests.lisp
+./kestrel/axe/equality-assumptions.lisp
+./kestrel/axe/make-rewriter-simple.lisp
+./kestrel/axe/node-replacement-array2.lisp
+./kestrel/axe/dargp-less-than.lisp
+./kestrel/axe/add-bitxor-nest-to-dag-array.lisp
+./kestrel/axe/unguarded-built-ins.lisp
+./kestrel/axe/make-evaluator.lisp
+./kestrel/axe/dag-array-builders2.lisp
+./kestrel/axe/make-axe-rules.lisp
+./kestrel/axe/dag-exprs.lisp
+./kestrel/axe/axe-trees.lisp
+./kestrel/axe/crunch-dag2.lisp
+./kestrel/axe/merge-sort-by-cdr-greater.lisp
+./kestrel/axe/result-array.lisp
+./kestrel/axe/bv-rules-axe0.lisp
+./kestrel/axe/make-conjunction-dag.lisp
+./kestrel/axe/stp-clause-processor.lisp
+./kestrel/axe/bounded-dag-parent-arrayp.lisp
+./kestrel/axe/leaves-of-normalized-bvxor-nest.lisp
+./kestrel/axe/equivalent-dags.lisp
+./kestrel/axe/interpreted-function-alists.lisp
+./kestrel/axe/merge-tree-into-dag-array-basic.lisp
+./kestrel/axe/dag-parent-array.lisp
+./kestrel/axe/dargp.lisp
+./kestrel/axe/unroll-spec-basic.lisp
+./kestrel/axe/list-rules-axe.lisp
+./kestrel/axe/merge-dag-into-dag-quick.lisp
+./kestrel/axe/dag-parent-array-with-name.lisp
+./kestrel/axe/unroll-spec.lisp
+./kestrel/axe/make-axe-rules2.lisp
+./kestrel/axe/make-term-into-dag-simple.lisp
+./kestrel/axe/contexts.lisp
+./kestrel/axe/make-axe-bind-free-evaluator.lisp
+./kestrel/axe/dag-array-builders.lisp
+./kestrel/axe/all-dargp-less-than.lisp
+./kestrel/axe/rules2.lisp
+./kestrel/axe/get-disjuncts-tests.lisp
+./kestrel/axe/make-axe-syntaxp-evaluator.lisp
+./kestrel/axe/tests-top.lisp
+./kestrel/axe/make-equality-dag.lisp
+./kestrel/axe/prover-common.lisp
+./kestrel/axe/conjunctions-and-disjunctions.lisp
+./kestrel/axe/stp-clause-processor-tests.lisp
+./kestrel/axe/replace-using-assumptions.lisp
+./kestrel/axe/rules1.lisp
+./kestrel/axe/node-replacement-alist.lisp
+./kestrel/axe/merge-sort-less-than-rules.lisp
+./kestrel/axe/dagify.lisp
+./kestrel/axe/wf-dagp.lisp
+./kestrel/axe/make-term-into-dag-array-simple.lisp
+./kestrel/axe/unguarded-defuns.lisp
+./kestrel/axe/replace-var-rules.lisp
+./kestrel/axe/packbv-axe.lisp
+./kestrel/axe/dag-size.lisp
+./kestrel/axe/axe-tree-vars.lisp
+./kestrel/axe/count-worlds.lisp
+./kestrel/axe/worklists.lisp
+./kestrel/axe/splitting.lisp
+./kestrel/axe/simplify-xors-tests.lisp
+./kestrel/axe/substitute-vars.lisp
+./kestrel/axe/bv-rules.lisp
+./kestrel/axe/bv-array-rules-axe.lisp
+./kestrel/axe/prover-stress-test.lisp
+./kestrel/axe/make-term-into-dag-array-basic.lisp
+./kestrel/axe/interpreted-function-alistp.lisp
+./kestrel/axe/assumption-array.lisp
+./kestrel/axe/rewriter-support.lisp
+./kestrel/axe/prune-with-contexts-tests.lisp
+./kestrel/axe/dag-size-fast.lisp
+./kestrel/axe/make-instantiation-code-simple-free-vars.lisp
+./kestrel/axe/get-args-not-done.lisp
+./kestrel/axe/unify-term-and-dag.lisp
+./kestrel/axe/evaluator.lisp
+./kestrel/axe/defconst-computed2.lisp
+./kestrel/axe/make-instantiation-code-simple.lisp
+./kestrel/axe/tactic-prover-tests.lisp
+./kestrel/axe/dag-constant-alist.lisp
+./kestrel/axe/jvm/axe-syntaxp-evaluator-jvm.lisp
+./kestrel/axe/jvm/unroll-java-code2.lisp
+./kestrel/axe/jvm/top.lisp
+./kestrel/axe/jvm/jvm-rules-axe2.lisp
+./kestrel/axe/jvm/lifter2.lisp
+./kestrel/axe/jvm/unroll-java-code.lisp
+./kestrel/axe/jvm/lifter-utilities.lisp
+./kestrel/axe/jvm/axe-syntax-functions-jvm2.lisp
+./kestrel/axe/jvm/axe-bind-free-evaluator-jvm.lisp
+./kestrel/axe/jvm/jvm-rules-axe.lisp
+./kestrel/axe/jvm/rule-lists-jvm.lisp
+./kestrel/axe/jvm/axe-syntax-functions-jvm.lisp
+./kestrel/axe/jvm/lifter-utilities3.lisp
+./kestrel/axe/jvm/formal-unit-tester.lisp
+./kestrel/axe/jvm/unroll-java-code-common.lisp
+./kestrel/axe/jvm/lifter.lisp
+./kestrel/axe/jvm/lifter-utilities2.lisp
+./kestrel/axe/jvm/rewriter-jvm.lisp
+./kestrel/axe/jvm/rules-in-rule-lists-jvm.lisp
+./kestrel/axe/match-hyp-with-nodenum-to-assume-false.lisp
+./kestrel/axe/prove-with-stp.lisp
+./kestrel/axe/dag-array-printing2.lisp
+./kestrel/axe/elim.lisp
+./kestrel/axe/query-tests.lisp
+./kestrel/axe/no-atoms.lisp
+./kestrel/axe/rewriter-common.lisp
+./kestrel/axe/supporting-nodes.lisp
+./kestrel/axe/prune-tests.lisp
+./kestrel/axe/result-array-stobj.lisp
+./kestrel/axe/refined-assumption-alists.lisp
+./kestrel/axe/axe-bind-free-result-okayp.lisp
+./kestrel/axe/dag-tests.lisp
+./kestrel/axe/make-substitution-code-simple.lisp
+./kestrel/axe/nodenum-type-alists.lisp
+./kestrel/axe/rewriter-tests.lisp
+./kestrel/axe/axe-clause-utilities.lisp
+./kestrel/axe/axe-bind-free-evaluator-basic.lisp
+./kestrel/axe/renaming-array.lisp
+./kestrel/axe/bv-list-rules-axe.lisp
+./kestrel/axe/add-bvxor-nest-to-dag-array.lisp
+./kestrel/axe/axe-syntax-functions-bv.lisp
+./kestrel/axe/hit-counts.lisp
+./kestrel/axe/basic-rules.lisp
+./kestrel/axe/sortedp-less-than-or-equal.lisp
+./kestrel/axe/unify-tree-and-dag.lisp
+./kestrel/axe/query.lisp
+./kestrel/axe/group-axe.lisp
+./kestrel/axe/axe-syntaxp-evaluator-basic.lisp
+./kestrel/axe/check-equivs-tests.lisp
+./kestrel/axe/rewriter.lisp
+./kestrel/axe/rule-alists.lisp
+./kestrel/axe/prover-basic-tests.lisp
+./kestrel/axe/dag-to-term.lisp
+./kestrel/axe/make-instantiation-code-simple-no-free-vars2.lisp
+./kestrel/axe/x86/top.lisp
+./kestrel/axe/x86/unroll-x86-code.lisp
+./kestrel/axe/simplify-xors.lisp
+./kestrel/axe/elaborate-rule-items.lisp
+./kestrel/axe/merge-sort-less-than.lisp
+./kestrel/axe/prover.lisp
+./kestrel/axe/equality-assumption-alists.lisp
+./kestrel/axe/equality-pairs.lisp
+./kestrel/axe/dag-arrays.lisp
+./kestrel/axe/dag-parent-arrayp.lisp
+./kestrel/axe/term-equal-dag.lisp
+./kestrel/axe/def-simplified-tests.lisp
+./kestrel/axe/util2.lisp
+./kestrel/axe/conjoin-term-with-dag.lisp
+./kestrel/axe/make-assumption-array.lisp
+./kestrel/axe/bounded-dag-exprs.lisp
+./kestrel/axe/evaluator-basic.lisp
+./kestrel/axe/defthm-stp-tests.lisp
+./kestrel/axe/safe-unquote.lisp
+./kestrel/axe/prove-with-stp-tests.lisp
+./kestrel/axe/tagged-rule-sets.lisp
+./kestrel/axe/doc.lisp
+./kestrel/axe/make-evaluator-tests.lisp
+./kestrel/axe/dags.lisp
+./kestrel/axe/translation-array.lisp
+./kestrel/axe/rebuild-literals.lisp
+./kestrel/axe/make-evaluator-simple.lisp
+./kestrel/axe/known-predicates.lisp
+./kestrel/axe/crunch-dag.lisp
+./kestrel/axe/consecutivep.lisp
+./kestrel/axe/dag-variable-alist.lisp
+./kestrel/axe/make-term-into-dag-basic.lisp
+./kestrel/axe/def-simplified.lisp
+./kestrel/axe/sublis-var-and-eval-basic.lisp
+./kestrel/axe/axe-rules-mixed.lisp
+./kestrel/axe/bv-rules-axe.lisp
+./kestrel/axe/alist-suitable-for-hypsp.lisp
+./kestrel/axe/unify-term-and-dag-fast-correct.lisp
+./kestrel/axe/tries.lisp
+./kestrel/axe/prover-basic.lisp
+./kestrel/axe/axe-syntax-functions.lisp
+./kestrel/axe/rewriter-basic-tests.lisp
+./kestrel/axe/axe-rule-lists.lisp
+./kestrel/axe/consecutivep2.lisp
+./kestrel/axe/merge-nodes-into-dag-array.lisp
+./kestrel/axe/rebuild-nodes2.lisp
+./kestrel/axe/keep-atoms.lisp
+./kestrel/axe/translate-dag-to-stp.lisp
+./kestrel/axe/equivs.lisp
+./kestrel/axe/tactic-prover.lisp
+./kestrel/axe/math-rules.lisp
+./kestrel/axe/rebuild-nodes.lisp
+./kestrel/axe/boolean-rules-axe.lisp
+./kestrel/axe/if-rules.lisp
+./kestrel/axe/lists-axe.lisp
+./kestrel/axe/make-instantiation-code-simple-no-free-vars.lisp
+./kestrel/axe/make-prover-simple.lisp
+./kestrel/axe/prune.lisp
+./kestrel/axe/set-rules.lisp
+./kestrel/axe/rule-lists.lisp
+./kestrel/axe/worklist-array.lisp
+./kestrel/axe/call-axe-script.lisp
+./kestrel/axe/all-dargp.lisp
+./kestrel/axe/numeric-lists.lisp
+./kestrel/axe/axe-types.lisp
+./kestrel/axe/make-term-into-dag-basic-tests.lisp
+./kestrel/axe/node-replacement-alist-for-context.lisp
+./kestrel/axe/axe-syntax.lisp
+./kestrel/axe/make-clause-processor-simple.lisp
+./kestrel/axe/dag-info.lisp
+./kestrel/axe/make-dag-variable-alist.lisp
+./kestrel/axe/node-replacement-array.lisp
+./kestrel/axe/stored-rules.lisp
+./kestrel/axe/defthm-axe.lisp
+./kestrel/axe/unify-term-and-dag-fast.lisp
+./kestrel/axe/rules-in-rule-lists.lisp
+./kestrel/axe/unroll-spec-basic-tests.lisp
+./kestrel/axe/fixup-context.lisp
+./kestrel/axe/unroll-spec-tests.lisp
+./kestrel/axe/merge-term-into-dag-array-simple.lisp
+./kestrel/axe/dag-size2.lisp
+./kestrel/axe/make-dag-constant-alist.lisp
+./kestrel/axe/lenconsmeta.lisp
+./kestrel/axe/evaluator-tests.lisp
+./kestrel/axe/rational-lists.lisp
+./kestrel/axe/dag-or-term-to-dag-basic.lisp
+./kestrel/axe/defthm-stp.lisp
+./kestrel/arrays-2d/bv-arrays-2d.lisp
+./kestrel/arrays-2d/arrays-2d.lisp
+./kestrel/booleans/bool-fix.lisp
+./kestrel/booleans/top.lisp
+./kestrel/booleans/boolor.lisp
+./kestrel/booleans/boolxor.lisp
+./kestrel/booleans/compat.lisp
+./kestrel/booleans/booleans.lisp
+./kestrel/booleans/booland.lisp
+./kestrel/booleans/boolif.lisp
+./kestrel/arithmetic-light/min.lisp
+./kestrel/arithmetic-light/floor-and-expt.lisp
+./kestrel/arithmetic-light/times.lisp
+./kestrel/arithmetic-light/floor.lisp
+./kestrel/arithmetic-light/plus-and-minus.lisp
+./kestrel/arithmetic-light/top.lisp
+./kestrel/arithmetic-light/floor-mod-expt.lisp
+./kestrel/arithmetic-light/imagpart.lisp
+./kestrel/arithmetic-light/expt2.lisp
+./kestrel/arithmetic-light/divides.lisp
+./kestrel/arithmetic-light/floor2.lisp
+./kestrel/arithmetic-light/truncate.lisp
+./kestrel/arithmetic-light/power-of-2p.lisp
+./kestrel/arithmetic-light/integer-length2.lisp
+./kestrel/arithmetic-light/less-than-or-equal.lisp
+./kestrel/arithmetic-light/rem.lisp
+./kestrel/arithmetic-light/minus.lisp
+./kestrel/arithmetic-light/types.lisp
+./kestrel/arithmetic-light/compat.lisp
+./kestrel/arithmetic-light/mod-expt-fast-unguarded.lisp
+./kestrel/arithmetic-light/even-and-odd.lisp
+./kestrel/arithmetic-light/ceiling-of-lg.lisp
+./kestrel/arithmetic-light/mod-expt-fast.lisp
+./kestrel/arithmetic-light/mod.lisp
+./kestrel/arithmetic-light/lg.lisp
+./kestrel/arithmetic-light/limit-expt.lisp
+./kestrel/arithmetic-light/max.lisp
+./kestrel/arithmetic-light/less-than.lisp
+./kestrel/arithmetic-light/abs.lisp
+./kestrel/arithmetic-light/mod2.lisp
+./kestrel/arithmetic-light/integerp.lisp
+./kestrel/arithmetic-light/ceiling.lisp
+./kestrel/arithmetic-light/doc.lisp
+./kestrel/arithmetic-light/nonnegative-integer-quotient.lisp
+./kestrel/arithmetic-light/plus.lisp
+./kestrel/arithmetic-light/natp.lisp
+./kestrel/arithmetic-light/denominator.lisp
+./kestrel/arithmetic-light/plus-and-times.lisp
+./kestrel/arithmetic-light/expt.lisp
+./kestrel/arithmetic-light/mod-and-expt.lisp
+./kestrel/arithmetic-light/times-and-divides.lisp
+./kestrel/arithmetic-light/realpart.lisp
+./kestrel/arithmetic-light/complex.lisp
+./kestrel/arithmetic-light/numerator.lisp
+./kestrel/arithmetic-light/ifix.lisp
+./kestrel/arithmetic-light/integer-length.lisp
+./kestrel/arithmetic-light/ash.lisp
+./kestrel/yul/top.lisp
+./kestrel/yul/static-semantics.lisp
+./kestrel/yul/abstract-syntax.lisp
+./kestrel/yul/concrete-syntax.lisp
+./kestrel/yul/grammar-new.lisp
+./kestrel/yul/portcullis.lisp
+./kestrel/yul/errors.lisp
+./kestrel/yul/grammar-old.lisp
+./kestrel/apt/restrict.lisp
+./kestrel/apt/solve-tests-acl2-rewriter.lisp
+./kestrel/apt/schemalg-divconq-oset-0-1-doc.lisp
+./kestrel/apt/propagate-iso.lisp
+./kestrel/apt/restrict-doc.lisp
+./kestrel/apt/propagate-iso-test-3.lisp
+./kestrel/apt/simplify-term-tests.lisp
+./kestrel/apt/simplify-defun-impl.lisp
+./kestrel/apt/schemalg-doc.lisp
+./kestrel/apt/simplify-tests.lisp
+./kestrel/apt/casesplit-doc.lisp
+./kestrel/apt/top.lisp
+./kestrel/apt/casesplit-tests.lisp
+./kestrel/apt/simplify.lisp
+./kestrel/apt/casesplit-template.lisp
+./kestrel/apt/parteval-template.lisp
+./kestrel/apt/parteval-doc.lisp
+./kestrel/apt/schemalg-template-generators.lisp
+./kestrel/apt/solve-template-proofs.lisp
+./kestrel/apt/isodata-doc.lisp
+./kestrel/apt/isodata.lisp
+./kestrel/apt/solve-doc.lisp
+./kestrel/apt/solve-method-acl2-rewriter.lisp
+./kestrel/apt/tailrec-tests.lisp
+./kestrel/apt/isodata-tests-workshop.lisp
+./kestrel/apt/simplify-defun-sk-tests.lisp
+./kestrel/apt/expdata-tests.lisp
+./kestrel/apt/tailrec.lisp
+./kestrel/apt/schemalg-concrete-tests.lisp
+./kestrel/apt/schemalg.lisp
+./kestrel/apt/tailrec-doc.lisp
+./kestrel/apt/parteval-tests.lisp
+./kestrel/apt/simplify-defun-tests.lisp
+./kestrel/apt/solve-method-axe-rewriter.lisp
+./kestrel/apt/schemalg-divconq-list-0-1-doc.lisp
+./kestrel/apt/common-concepts.lisp
+./kestrel/apt/expdata-doc.lisp
+./kestrel/apt/restrict-tests.lisp
+./kestrel/apt/common-options.lisp
+./kestrel/apt/simplify-term-impl.lisp
+./kestrel/apt/tailrec-examples.lisp
+./kestrel/apt/portcullis.lisp
+./kestrel/apt/schemalg-divconq-oset-0-1-template-tests.lisp
+./kestrel/apt/simplify-doc.lisp
+./kestrel/apt/parteval.lisp
+./kestrel/apt/doc.lisp
+./kestrel/apt/simplify-defun-doc.lisp
+./kestrel/apt/solve-tests-manual.lisp
+./kestrel/apt/casesplit.lisp
+./kestrel/apt/simplify-defun-sk-impl.lisp
+./kestrel/apt/utilities/defaults-table.lisp
+./kestrel/apt/utilities/transformation-table2.lisp
+./kestrel/apt/utilities/top.lisp
+./kestrel/apt/utilities/deftransformation-tests.lisp
+./kestrel/apt/utilities/input-processing-soft.lisp
+./kestrel/apt/utilities/fixup-ignores.lisp
+./kestrel/apt/utilities/maybe-verify-guards2.lisp
+./kestrel/apt/utilities/input-processing.lisp
+./kestrel/apt/utilities/process-keyword-args.lisp
+./kestrel/apt/utilities/remove-event-types.lisp
+./kestrel/apt/utilities/names.lisp
+./kestrel/apt/utilities/print-specifiers.lisp
+./kestrel/apt/utilities/transformation-table-tests.lisp
+./kestrel/apt/utilities/untranslate-specifiers.lisp
+./kestrel/apt/utilities/option-parsing.lisp
+./kestrel/apt/utilities/make-becomes-theorem.lisp
+./kestrel/apt/utilities/defun-variant.lisp
+./kestrel/apt/utilities/pattern-matching.lisp
+./kestrel/apt/utilities/generate-print-events.lisp
+./kestrel/apt/utilities/pattern-matching-ext.lisp
+./kestrel/apt/utilities/deftransformation.lisp
+./kestrel/apt/utilities/print-specifiers-tests.lisp
+./kestrel/apt/utilities/hints-specifiers.lisp
+./kestrel/apt/utilities/transformation-prologue.lisp
+./kestrel/apt/utilities/pattern-matching-ext-tests.lisp
+./kestrel/apt/utilities/xdoc-constructors.lisp
+./kestrel/apt/utilities/set-stobjs-in-declares-to-match.lisp
+./kestrel/apt/utilities/transformation-table.lisp
+./kestrel/apt/utilities/extract-non-local-events.lisp
+./kestrel/apt/utilities/pattern-matching-ext-support.lisp
+./kestrel/apt/utilities/function-renamingp.lisp
+./kestrel/apt/expdata.lisp
+./kestrel/apt/propagate-iso-doc.lisp
+./kestrel/apt/schemalg-template-proofs.lisp
+./kestrel/apt/solve-tests-axe-rewriter.lisp
+./kestrel/apt/schemalg-divconq-list-0-1-template-tests.lisp
+./kestrel/apt/propagate-iso-test-2.lisp
+./kestrel/apt/solve-templates.lisp
+./kestrel/apt/solve.lisp
+./kestrel/apt/propagate-iso-test-1.lisp
+./kestrel/apt/schemalg-divconq-list-0-1-2-doc.lisp
+./kestrel/apt/simplify-defun-sk-doc.lisp
+./kestrel/apt/simplify-term-doc.lisp
+./kestrel/apt/isodata-tests.lisp
+./kestrel/prime-fields/bind-free-common.lisp
+./kestrel/prime-fields/bind-free-tests.lisp
+./kestrel/prime-fields/fep.lisp
+./kestrel/prime-fields/fe-listp.lisp
+./kestrel/prime-fields/prime-fields.lisp
+./kestrel/prime-fields/top.lisp
+./kestrel/prime-fields/neg.lisp
+./kestrel/prime-fields/support.lisp
+./kestrel/prime-fields/fe-listp-fast.lisp
+./kestrel/prime-fields/mul.lisp
+./kestrel/prime-fields/fep-fix.lisp
+./kestrel/prime-fields/equal-of-add-move-negs-bind-free.lisp
+./kestrel/prime-fields/equal-of-add-cancel-bind-free.lisp
+./kestrel/prime-fields/bitp-idioms.lisp
+./kestrel/prime-fields/minus1.lisp
+./kestrel/prime-fields/rules2.lisp
+./kestrel/prime-fields/prime-fields-rules.lisp
+./kestrel/prime-fields/inv.lisp
+./kestrel/prime-fields/unguarded-defuns.lisp
+./kestrel/prime-fields/div.lisp
+./kestrel/prime-fields/bv-rules.lisp
+./kestrel/prime-fields/pow.lisp
+./kestrel/prime-fields/printing.lisp
+./kestrel/prime-fields/bind-free-rules.lisp
+./kestrel/prime-fields/equal-of-add-cancel.lisp
+./kestrel/prime-fields/add.lisp
+./kestrel/prime-fields/portcullis.lisp
+./kestrel/prime-fields/equal-of-add-move-negs.lisp
+./kestrel/prime-fields/doc.lisp
+./kestrel/prime-fields/bv-rules-axe.lisp
+./kestrel/prime-fields/rule-lists.lisp
+./kestrel/prime-fields/equal-of-add-rules.lisp
+./kestrel/prime-fields/sub.lisp
+./kestrel/prime-fields/prime-fields-alt.lisp
+./kestrel/prime-fields/prime-fields-rules-axe.lisp
+./kestrel/acl2-arrays/typed-acl2-arrays-tests.lisp
+./kestrel/acl2-arrays/top.lisp
+./kestrel/acl2-arrays/acl2-arrays.lisp
+./kestrel/acl2-arrays/aset1-list.lisp
+./kestrel/acl2-arrays/typed-acl2-arrays.lisp
+./kestrel/acl2-arrays/expandable-arrays.lisp
+./kestrel/acl2-arrays/doc.lisp
+./kestrel/acl2-arrays/bounded-nat-alists.lisp
+./kestrel/acl2-arrays/aref1-list.lisp
+./kestrel/acl2pl/values.lisp
+./kestrel/acl2pl/top.lisp
+./kestrel/acl2pl/programs.lisp
+./kestrel/acl2pl/packages.lisp
+./kestrel/acl2pl/equivalence.lisp
+./kestrel/acl2pl/interpreter.lisp
+./kestrel/acl2pl/functions.lisp
+./kestrel/acl2pl/evaluation-states.lisp
+./kestrel/acl2pl/primitive-functions.lisp
+./kestrel/acl2pl/portcullis.lisp
+./kestrel/acl2pl/translated-terms.lisp
+./kestrel/acl2pl/evaluation.lisp
+./kestrel/json/top.lisp
+./kestrel/json/json-bstar.lisp
+./kestrel/json/abstract-syntax.lisp
+./kestrel/json/json-bstar-tests.lisp
+./kestrel/json/portcullis.lisp
+./kestrel/json/parser-output-to-abstract-syntax.lisp
+./kestrel/json/light-ast-check.lisp
+./kestrel/json-parser/parse-json.lisp
+./kestrel/json-parser/parse-json-tests.lisp
+./kestrel/json-parser/parse-json-file.lisp
+./kestrel/jvm/locals.lisp
+./kestrel/jvm/frames.lisp
+./kestrel/jvm/method-designator-strings-tests.lisp
+./kestrel/jvm/utilities.lisp
+./kestrel/jvm/arrays.lisp
+./kestrel/jvm/floats.lisp
+./kestrel/jvm/instructions.lisp
+./kestrel/jvm/top.lisp
+./kestrel/jvm/do-inst-rules.lisp
+./kestrel/jvm/int-subtypes.lisp
+./kestrel/jvm/java-types.lisp
+./kestrel/jvm/arrays-2d.lisp
+./kestrel/jvm/load-class-from-hierarchy.lisp
+./kestrel/jvm/methods.lisp
+./kestrel/jvm/heap0.lisp
+./kestrel/jvm/execution.lisp
+./kestrel/jvm/events-for-class.lisp
+./kestrel/jvm/adslemmas.lisp
+./kestrel/jvm/control-flow.lisp
+./kestrel/jvm/strings.lisp
+./kestrel/jvm/jvm-facts0.lisp
+./kestrel/jvm/symbolic-execution-common.lisp
+./kestrel/jvm/jvm-facts.lisp
+./kestrel/jvm/method-descriptors.lisp
+./kestrel/jvm/descriptors.lisp
+./kestrel/jvm/types.lisp
+./kestrel/jvm/get-method-info.lisp
+./kestrel/jvm/set-classes.lisp
+./kestrel/jvm/class-and-path-utils.lisp
+./kestrel/jvm/fields.lisp
+./kestrel/jvm/read-and-parse-class-file.lisp
+./kestrel/jvm/control-flow-tests.lisp
+./kestrel/jvm/class-file-parser.lisp
+./kestrel/jvm/jvm-rules2.lisp
+./kestrel/jvm/float-to-bits.lisp
+./kestrel/jvm/adstop.lisp
+./kestrel/jvm/method-designator-strings.lisp
+./kestrel/jvm/arrays0.lisp
+./kestrel/jvm/symbolic-execution.lisp
+./kestrel/jvm/operand-stacks.lisp
+./kestrel/jvm/portcullis.lisp
+./kestrel/jvm/heap.lisp
+./kestrel/jvm/array-building.lisp
+./kestrel/jvm/utilities2.lisp
+./kestrel/jvm/ads.lisp
+./kestrel/jvm/intern-table.lisp
+./kestrel/jvm/call-stacks.lisp
+./kestrel/jvm/pc-designators.lisp
+./kestrel/jvm/load-class.lisp
+./kestrel/jvm/floats2.lisp
+./kestrel/jvm/class-tables.lisp
+./kestrel/jvm/jvm-rules.lisp
+./kestrel/jvm/execution2.lisp
+./kestrel/jvm/jvm.lisp
+./kestrel/jvm/classes.lisp
+./kestrel/jvm/symbolic-execution2.lisp
+./kestrel/jvm/execution-common.lisp
+./kestrel/jvm/ads2.lisp
+./kestrel/bv-lists/bvplus-list.lisp
+./kestrel/bv-lists/byte-to-bits.lisp
+./kestrel/bv-lists/bvchop-list.lisp
+./kestrel/bv-lists/bits-and-bytes-inversions.lisp
+./kestrel/bv-lists/bytes-to-bits-little2.lisp
+./kestrel/bv-lists/width-of-widest-int.lisp
+./kestrel/bv-lists/bv-array-conversions2-tests.lisp
+./kestrel/bv-lists/top.lisp
+./kestrel/bv-lists/byte-listp.lisp
+./kestrel/bv-lists/unsigned-byte-listp.lisp
+./kestrel/bv-lists/bytes-to-bits-little.lisp
+./kestrel/bv-lists/all-unsigned-byte-p2.lisp
+./kestrel/bv-lists/bytes-to-bits2.lisp
+./kestrel/bv-lists/bv-array-conversions.lisp
+./kestrel/bv-lists/bv-array-write.lisp
+./kestrel/bv-lists/bvchop-list2.lisp
+./kestrel/bv-lists/bytes-to-bits.lisp
+./kestrel/bv-lists/tests-top.lisp
+./kestrel/bv-lists/len-mult-of-8p.lisp
+./kestrel/bv-lists/all-all-unsigned-byte-p.lisp
+./kestrel/bv-lists/len-mult-of-8p-rules.lisp
+./kestrel/bv-lists/unsigned-byte-listp-def.lisp
+./kestrel/bv-lists/compat.lisp
+./kestrel/bv-lists/all-signed-byte-p.lisp
+./kestrel/bv-lists/string-to-bits.lisp
+./kestrel/bv-lists/map-packbv-tests.lisp
+./kestrel/bv-lists/unpackbv.lisp
+./kestrel/bv-lists/map-packbv.lisp
+./kestrel/bv-lists/getbit-list.lisp
+./kestrel/bv-lists/packbv.lisp
+./kestrel/bv-lists/bv-array-conversions2.lisp
+./kestrel/bv-lists/bits-to-bytes2.lisp
+./kestrel/bv-lists/packbv-tests.lisp
+./kestrel/bv-lists/packing.lisp
+./kestrel/bv-lists/packbv-def.lisp
+./kestrel/bv-lists/bv-arrays.lisp
+./kestrel/bv-lists/bv-array-read.lisp
+./kestrel/bv-lists/bits-to-byte-little.lisp
+./kestrel/bv-lists/all-unsigned-byte-p.lisp
+./kestrel/bv-lists/unpackbv-def.lisp
+./kestrel/bv-lists/byte-to-bits-little.lisp
+./kestrel/bv-lists/doc.lisp
+./kestrel/bv-lists/bits-to-byte-little-rules.lisp
+./kestrel/bv-lists/packbv-theorems.lisp
+./kestrel/bv-lists/bits-to-byte.lisp
+./kestrel/bv-lists/logext-list.lisp
+./kestrel/bv-lists/bit-listp-rules.lisp
+./kestrel/bv-lists/bvxor-list-rules.lisp
+./kestrel/bv-lists/bvnth.lisp
+./kestrel/bv-lists/bv-arrayp.lisp
+./kestrel/bv-lists/bvnot-list.lisp
+./kestrel/bv-lists/bvxor-list.lisp
+./kestrel/bv-lists/bits-to-bytes-little2.lisp
+./kestrel/bv-lists/map-slice.lisp
+./kestrel/bv-lists/bit-listp.lisp
+./kestrel/bv-lists/bits-to-bytes-little.lisp
+./kestrel/bv-lists/packbv-little.lisp
+./kestrel/bv-lists/bits-and-bytes-inversions-little.lisp
+./kestrel/bv-lists/list-patterns.lisp
+./kestrel/bv-lists/packbv-and-unpackbv.lisp
+./kestrel/bv-lists/bits-to-bytes.lisp
+./kestrel/soft/defthm-inst.lisp
+./kestrel/soft/defchoose2.lisp
+./kestrel/soft/defequal.lisp
+./kestrel/soft/top.lisp
+./kestrel/soft/define-sk2.lisp
+./kestrel/soft/core.lisp
+./kestrel/soft/define2.lisp
+./kestrel/soft/defequal-tests.lisp
+./kestrel/soft/defun-inst.lisp
+./kestrel/soft/tests.lisp
+./kestrel/soft/defsoft.lisp
+./kestrel/soft/gen-macro2-of-macro.lisp
+./kestrel/soft/defunvar.lisp
+./kestrel/soft/portcullis.lisp
+./kestrel/soft/defequal-doc.lisp
+./kestrel/soft/defun2.lisp
+./kestrel/soft/workshop-talk-examples.lisp
+./kestrel/soft/defun-sk2.lisp
+./kestrel/soft/workshop-paper-examples.lisp
+./kestrel/soft/implementation.lisp
+./kestrel/soft/defund-sk2.lisp
+./kestrel/soft/defund2.lisp
+./kestrel/soft/documentation.lisp
+./kestrel/simpl-imp/top.lisp
+./kestrel/simpl-imp/abstract-syntax.lisp
+./kestrel/simpl-imp/interpreter.lisp
+./kestrel/simpl-imp/portcullis.lisp
+./kestrel/simpl-imp/semantics.lisp
+./kestrel/simpl-imp/examples.lisp
+./kestrel/abnf/operations.lisp
+./kestrel/abnf/abstractor.lisp
+./kestrel/abnf/core-rules.lisp
+./kestrel/abnf/top.lisp
+./kestrel/abnf/parsing-primitives.lisp
+./kestrel/abnf/abstract-syntax.lisp
+./kestrel/abnf/parser.lisp
+./kestrel/abnf/concrete-syntax.lisp
+./kestrel/abnf/portcullis.lisp
+./kestrel/abnf/parser-verification.lisp
+./kestrel/abnf/semantics.lisp
+./kestrel/abnf/parser-and-abstractor-validation.lisp
+./kestrel/abnf/examples.lisp
+./kestrel/x86/parsers/parse-mach-o-file.lisp
+./kestrel/x86/parsers/parse-pe-file.lisp
+./kestrel/x86/parsers/top.lisp
+./kestrel/x86/parsers/pe-tools.lisp
+./kestrel/x86/parsers/parsed-executable-tools.lisp
+./kestrel/x86/parsers/parse-elf-file.lisp
+./kestrel/x86/parsers/parse-executable.lisp
+./kestrel/x86/parsers/parser-utils.lisp
+./kestrel/x86/parsers/mach-o-tools.lisp
+./kestrel/x86/top.lisp
+./kestrel/x86/portcullis.lisp
+./kestrel/x86/tools/support0.lisp
+./kestrel/x86/tools/run-until-return.lisp
+./kestrel/x86/tools/unroll-x86-code-old.lisp
+./kestrel/x86/tools/top.lisp
+./kestrel/x86/tools/support.lisp
+./kestrel/x86/tools/support-x86.lisp
+./kestrel/x86/tools/read-and-write.lisp
+./kestrel/x86/tools/lifter-support.lisp
+./kestrel/x86/tools/support-axe.lisp
+./kestrel/x86/tools/write-over-write-rules.lisp
+./kestrel/x86/tools/assumptions32.lisp
+./kestrel/x86/tools/support32.lisp
+./kestrel/x86/tools/assumptions64.lisp
+./kestrel/x86/tools/flags.lisp
+./kestrel/x86/tools/support2.lisp
+./kestrel/x86/tools/conditions.lisp
+./kestrel/x86/tools/bitops.lisp
+./kestrel/x86/tools/linear-memory.lisp
+./kestrel/x86/tools/register-readers-and-writers.lisp
+./kestrel/x86/tools/assumptions.lisp
+./kestrel/x86/tools/rule-lists.lisp
+./kestrel/x86/tools/read-over-write-rules.lisp
+./kestrel/x86/tools/symsim.lisp
+./kestrel/typed-lists-light/nat-listp.lisp
+./kestrel/typed-lists-light/items-have-len.lisp
+./kestrel/typed-lists-light/all-greater.lisp
+./kestrel/typed-lists-light/map-char-code.lisp
+./kestrel/typed-lists-light/top.lisp
+./kestrel/typed-lists-light/bytes-to-printable-string.lisp
+./kestrel/typed-lists-light/all-alistp.lisp
+./kestrel/typed-lists-light/maxelem2.lisp
+./kestrel/typed-lists-light/map-strip-cars.lisp
+./kestrel/typed-lists-light/all-less-than-or-equal-all.lisp
+./kestrel/typed-lists-light/all-rationalp.lisp
+./kestrel/typed-lists-light/rational-listp.lisp
+./kestrel/typed-lists-light/all-integerp2.lisp
+./kestrel/typed-lists-light/all-integerp.lisp
+./kestrel/typed-lists-light/compat.lisp
+./kestrel/typed-lists-light/integer-listp.lisp
+./kestrel/typed-lists-light/minelem2.lisp
+./kestrel/typed-lists-light/less-than-or-equal-all.lisp
+./kestrel/typed-lists-light/all-less-rules.lisp
+./kestrel/typed-lists-light/string-listp.lisp
+./kestrel/typed-lists-light/all-true-listp.lisp
+./kestrel/typed-lists-light/minelem.lisp
+./kestrel/typed-lists-light/all-all-integerp.lisp
+./kestrel/typed-lists-light/integer-lists.lisp
+./kestrel/typed-lists-light/symbol-listp.lisp
+./kestrel/typed-lists-light/map-code-char.lisp
+./kestrel/typed-lists-light/character-listp.lisp
+./kestrel/typed-lists-light/all-less-than-or-equal.lisp
+./kestrel/typed-lists-light/character-list-listp.lisp
+./kestrel/typed-lists-light/maxelem.lisp
+./kestrel/typed-lists-light/doc.lisp
+./kestrel/typed-lists-light/all-less.lisp
+./kestrel/typed-lists-light/all-consp.lisp
+./kestrel/typed-lists-light/symbol-listp2.lisp
+./kestrel/typed-lists-light/pseudo-term-listp.lisp
+./kestrel/typed-lists-light/all-integerp-of-repeat.lisp
+./kestrel/typed-lists-light/all-natp.lisp
+./kestrel/sequences/subsequencep-equal.lisp
+./kestrel/sequences/generics-utilities.lisp
+./kestrel/sequences/defexists.lisp
+./kestrel/sequences/defforall.lisp
+./kestrel/sequences/defmap.lisp
+./kestrel/sequences/deffilter.lisp
+./kestrel/doc.lisp
+./kestrel/built-in-theorems-doc.lisp
+./kestrel/top-doc.lisp
+./kestrel/fty/fty-omap.lisp
+./kestrel/fty/byte-list32.lisp
+./kestrel/fty/byte-list20.lisp
+./kestrel/fty/defbyte-standard-instances-tests.lisp
+./kestrel/fty/defflatsum.lisp
+./kestrel/fty/deffixequiv-sk-doc.lisp
+./kestrel/fty/ubyte20.lisp
+./kestrel/fty/nati-tests.lisp
+./kestrel/fty/ubyte4-list.lisp
+./kestrel/fty/sbyte3.lisp
+./kestrel/fty/defbyte-ihs-theorems.lisp
+./kestrel/fty/defbytelist-tests.lisp
+./kestrel/fty/top.lisp
+./kestrel/fty/defubyte.lisp
+./kestrel/fty/bin-digit-char.lisp
+./kestrel/fty/sbyte16-list.lisp
+./kestrel/fty/ubyte7.lisp
+./kestrel/fty/ubyte1.lisp
+./kestrel/fty/ubyte8-list.lisp
+./kestrel/fty/nibble-list.lisp
+./kestrel/fty/defunit-doc.lisp
+./kestrel/fty/ubyte8-ihs-theorems.lisp
+./kestrel/fty/bag.lisp
+./kestrel/fty/sbyte128.lisp
+./kestrel/fty/sbyte128-ihs-theorems.lisp
+./kestrel/fty/ubyte4.lisp
+./kestrel/fty/sbyte8.lisp
+./kestrel/fty/fty-set.lisp
+./kestrel/fty/ubyte256-list.lisp
+./kestrel/fty/defbytelist-standard-instances-tests.lisp
+./kestrel/fty/defbyte-tests.lisp
+./kestrel/fty/set.lisp
+./kestrel/fty/sbyte32-ihs-theorems.lisp
+./kestrel/fty/ubyte3.lisp
+./kestrel/fty/ubyte256.lisp
+./kestrel/fty/ubyte11.lisp
+./kestrel/fty/ubyte3-list.lisp
+./kestrel/fty/ubyte6.lisp
+./kestrel/fty/defsubtype-tests.lisp
+./kestrel/fty/deffixequiv-sk.lisp
+./kestrel/fty/deffixtype-alias.lisp
+./kestrel/fty/defomap-tests.lisp
+./kestrel/fty/defsbyte.lisp
+./kestrel/fty/ubyte16-ihs-theorems.lisp
+./kestrel/fty/ubyte64-ihs-theorems.lisp
+./kestrel/fty/ubyte128.lisp
+./kestrel/fty/hex-digit-char.lisp
+./kestrel/fty/sbyte4.lisp
+./kestrel/fty/deflist-of-len-tests.lisp
+./kestrel/fty/defsbytelist.lisp
+./kestrel/fty/sbyte16-ihs-theorems.lisp
+./kestrel/fty/sbyte256.lisp
+./kestrel/fty/defsubtype.lisp
+./kestrel/fty/defset.lisp
+./kestrel/fty/sbyte2.lisp
+./kestrel/fty/defbytelist-standard-instances.lisp
+./kestrel/fty/sbyte3-list.lisp
+./kestrel/fty/byte.lisp
+./kestrel/fty/sbyte64.lisp
+./kestrel/fty/defbyte-standard-instances-ihs-theorems.lisp
+./kestrel/fty/defflatsum-doc.lisp
+./kestrel/fty/ubyte2.lisp
+./kestrel/fty/defset-tests.lisp
+./kestrel/fty/deflist-of-len.lisp
+./kestrel/fty/ubyte16.lisp
+./kestrel/fty/defunit.lisp
+./kestrel/fty/bit-list.lisp
+./kestrel/fty/sbyte4-list.lisp
+./kestrel/fty/byte-list64.lisp
+./kestrel/fty/sbyte2-list.lisp
+./kestrel/fty/nati.lisp
+./kestrel/fty/sbyte64-list.lisp
+./kestrel/fty/sbyte16.lisp
+./kestrel/fty/nibble.lisp
+./kestrel/fty/sbyte1-list.lisp
+./kestrel/fty/oct-digit-char.lisp
+./kestrel/fty/sbyte32.lisp
+./kestrel/fty/dec-digit-char.lisp
+./kestrel/fty/ubyte128-list.lisp
+./kestrel/fty/defbytelist.lisp
+./kestrel/fty/defbyte-standard-instances.lisp
+./kestrel/fty/sbyte8-ihs-theorems.lisp
+./kestrel/fty/ubyte5.lisp
+./kestrel/fty/ubyte128-ihs-theorems.lisp
+./kestrel/fty/ubyte1-list.lisp
+./kestrel/fty/ubyte8.lisp
+./kestrel/fty/ubyte64-list.lisp
+./kestrel/fty/map.lisp
+./kestrel/fty/ubyte16-list.lisp
+./kestrel/fty/ubyte32-ihs-theorems.lisp
+./kestrel/fty/ubyte2-list.lisp
+./kestrel/fty/defbyte.lisp
+./kestrel/fty/ubyte12.lisp
+./kestrel/fty/ubyte32-list.lisp
+./kestrel/fty/nat-set.lisp
+./kestrel/fty/deffixtype-alias-tests.lisp
+./kestrel/fty/sbyte32-list.lisp
+./kestrel/fty/sbyte128-list.lisp
+./kestrel/fty/sbyte256-list.lisp
+./kestrel/fty/byte-list.lisp
+./kestrel/fty/sbyte64-ihs-theorems.lisp
+./kestrel/fty/defubytelist.lisp
+./kestrel/fty/sbyte8-list.lisp
+./kestrel/fty/ubyte11-list.lisp
+./kestrel/fty/ubyte32.lisp
+./kestrel/fty/defomap.lisp
+./kestrel/fty/sbyte1.lisp
+./kestrel/fty/ubyte64.lisp
+./kestrel/lists-light/subsequencep-equal.lisp
+./kestrel/lists-light/subsequencep-equal-def.lisp
+./kestrel/lists-light/equiv-def.lisp
+./kestrel/lists-light/memberp.lisp
+./kestrel/lists-light/all-equal-dollar.lisp
+./kestrel/lists-light/all-same.lisp
+./kestrel/lists-light/top.lisp
+./kestrel/lists-light/revappend.lisp
+./kestrel/lists-light/remove-nth-tests.lisp
+./kestrel/lists-light/all-eql-dollar.lisp
+./kestrel/lists-light/firstn.lisp
+./kestrel/lists-light/union-equal.lisp
+./kestrel/lists-light/no-duplicatesp-equal.lisp
+./kestrel/lists-light/reverse-list-def.lisp
+./kestrel/lists-light/all-same-eql.lisp
+./kestrel/lists-light/update-subrange2.lisp
+./kestrel/lists-light/group-and-ungroup.lisp
+./kestrel/lists-light/remove1-equal.lisp
+./kestrel/lists-light/set-difference-equal.lisp
+./kestrel/lists-light/remove1-dollar-def.lisp
+./kestrel/lists-light/prefixp2.lisp
+./kestrel/lists-light/subsequencep.lisp
+./kestrel/lists-light/add-to-set-equal.lisp
+./kestrel/lists-light/memberp-def.lisp
+./kestrel/lists-light/update-nth.lisp
+./kestrel/lists-light/length.lisp
+./kestrel/lists-light/perm2.lisp
+./kestrel/lists-light/rules2.lisp
+./kestrel/lists-light/count-occs.lisp
+./kestrel/lists-light/perm-def.lisp
+./kestrel/lists-light/memberp2.lisp
+./kestrel/lists-light/len-at-least.lisp
+./kestrel/lists-light/append.lisp
+./kestrel/lists-light/nthcdr.lisp
+./kestrel/lists-light/update-nth2.lisp
+./kestrel/lists-light/repeat.lisp
+./kestrel/lists-light/rules.lisp
+./kestrel/lists-light/last.lisp
+./kestrel/lists-light/cons.lisp
+./kestrel/lists-light/remove-duplicates-equal.lisp
+./kestrel/lists-light/append-with-key.lisp
+./kestrel/lists-light/first-non-member.lisp
+./kestrel/lists-light/subsetp-equal.lisp
+./kestrel/lists-light/finalcdr.lisp
+./kestrel/lists-light/subrange.lisp
+./kestrel/lists-light/len.lisp
+./kestrel/lists-light/intersection-equal.lisp
+./kestrel/lists-light/true-list-fix.lisp
+./kestrel/lists-light/subrange-def.lisp
+./kestrel/lists-light/butlast.lisp
+./kestrel/lists-light/add-to-end.lisp
+./kestrel/lists-light/doc.lisp
+./kestrel/lists-light/reverse.lisp
+./kestrel/lists-light/firstn-def.lisp
+./kestrel/lists-light/ungroup.lisp
+./kestrel/lists-light/cdr.lisp
+./kestrel/lists-light/repeat-tail.lisp
+./kestrel/lists-light/take2.lisp
+./kestrel/lists-light/find-index.lisp
+./kestrel/lists-light/prefixp.lisp
+./kestrel/lists-light/remove-nth.lisp
+./kestrel/lists-light/group2.lisp
+./kestrel/lists-light/member-equal.lisp
+./kestrel/lists-light/all-equal-dollar2.lisp
+./kestrel/lists-light/perm.lisp
+./kestrel/lists-light/group-rules.lisp
+./kestrel/lists-light/remove-equal.lisp
+./kestrel/lists-light/take.lisp
+./kestrel/lists-light/reverse-list.lisp
+./kestrel/lists-light/group.lisp
+./kestrel/lists-light/last-elem.lisp
+./kestrel/lists-light/nth.lisp
+./kestrel/lists-light/first-n-ac.lisp
+./kestrel/lists-light/update-subrange.lisp
+./kestrel/solidity/values.lisp
+./kestrel/solidity/top.lisp
+./kestrel/solidity/boolean-operations.lisp
+./kestrel/solidity/integer-values.lisp
+./kestrel/solidity/boolean-values.lisp
+./kestrel/solidity/portcullis.lisp
+./kestrel/solidity/integer-operations.lisp
+./kestrel/solidity/sld-refs.lisp
+./kestrel/utilities/defopeners-tests.lisp
+./kestrel/utilities/bytes-as-digits.lisp
+./kestrel/utilities/bits-and-ubyte11s-as-digits.lisp
+./kestrel/utilities/integer-arithmetic/operations.lisp
+./kestrel/utilities/integer-arithmetic/top.lisp
+./kestrel/utilities/integer-arithmetic/meta-rules.lisp
+./kestrel/utilities/integer-arithmetic/rules.lisp
+./kestrel/utilities/integer-arithmetic/meta-iplus-equal.lisp
+./kestrel/utilities/symbol-has-propsp.lisp
+./kestrel/utilities/make-or-nice.lisp
+./kestrel/utilities/hex-string-to-bytes.lisp
+./kestrel/utilities/make-termination-theorem-tests.lisp
+./kestrel/utilities/ruler-extenders.lisp
+./kestrel/utilities/apply-fn-if-known.lisp
+./kestrel/utilities/mydefconst.lisp
+./kestrel/utilities/enumerations-tests.lisp
+./kestrel/utilities/er-soft-plus.lisp
+./kestrel/utilities/translate.lisp
+./kestrel/utilities/conjuncts-and-disjuncts.lisp
+./kestrel/utilities/keyword-value-lists-tests.lisp
+./kestrel/utilities/make-termination-theorem.lisp
+./kestrel/utilities/defconst-computed-tests.lisp
+./kestrel/utilities/smaller-termp.lisp
+./kestrel/utilities/mydefconst-tests.lisp
+./kestrel/utilities/typed-tuples-tests.lisp
+./kestrel/utilities/auto-termination.lisp
+./kestrel/utilities/bits-as-digits.lisp
+./kestrel/utilities/defthm-forms.lisp
+./kestrel/utilities/osets.lisp
+./kestrel/utilities/integer-range-lists.lisp
+./kestrel/utilities/verify-guards-forms.lisp
+./kestrel/utilities/error-checking/top.lisp
+./kestrel/utilities/error-checking/tests.lisp
+./kestrel/utilities/maybe-unquote-tests.lisp
+./kestrel/utilities/zp-lists-tests.lisp
+./kestrel/utilities/lists/set-size.lisp
+./kestrel/utilities/lists/append-theorems.lisp
+./kestrel/utilities/lists/nthcdr-theorems.lisp
+./kestrel/utilities/lists/last-theorems.lisp
+./kestrel/utilities/lists/len-const-theorems.lisp
+./kestrel/utilities/lists/intersectp-theorems.lisp
+./kestrel/utilities/lists/top.lisp
+./kestrel/utilities/lists/primitive-theorems.lisp
+./kestrel/utilities/lists/prefixp-theorems.lisp
+./kestrel/utilities/lists/set-size-tests.lisp
+./kestrel/utilities/lists/take-theorems.lisp
+./kestrel/utilities/lists/add-to-set-theorems.lisp
+./kestrel/utilities/lists/rev-theorems.lisp
+./kestrel/utilities/lists/set-difference-theorems.lisp
+./kestrel/utilities/lists/index-of-theorems.lisp
+./kestrel/utilities/lists/intersection-theorems.lisp
+./kestrel/utilities/top.lisp
+./kestrel/utilities/proof-builder-macros.lisp
+./kestrel/utilities/acl2-count.lisp
+./kestrel/utilities/system/paired-names-tests.lisp
+./kestrel/utilities/system/top.lisp
+./kestrel/utilities/system/named-formulas-tests.lisp
+./kestrel/utilities/system/terms.lisp
+./kestrel/utilities/system/numbered-names-tests.lisp
+./kestrel/utilities/system/paired-names.lisp
+./kestrel/utilities/system/numbered-names.lisp
+./kestrel/utilities/system/world-queries.lisp
+./kestrel/utilities/system/fresh-names-tests.lisp
+./kestrel/utilities/system/named-formulas.lisp
+./kestrel/utilities/system/fresh-names.lisp
+./kestrel/utilities/legal-variablep.lisp
+./kestrel/utilities/sublis-expr-plus.lisp
+./kestrel/utilities/bind-from-rules-tests.lisp
+./kestrel/utilities/map-symbol-name.lisp
+./kestrel/utilities/runes.lisp
+./kestrel/utilities/polarity.lisp
+./kestrel/utilities/integer-range-lists-tests.lisp
+./kestrel/utilities/strip-stars-from-name.lisp
+./kestrel/utilities/include-book-paths.lisp
+./kestrel/utilities/all-vars-in-term-bound-in-alistp.lisp
+./kestrel/utilities/nfix.lisp
+./kestrel/utilities/make-var-names.lisp
+./kestrel/utilities/defopeners.lisp
+./kestrel/utilities/make-executable.lisp
+./kestrel/utilities/strings.lisp
+./kestrel/utilities/read-chars.lisp
+./kestrel/utilities/skip-in-book.lisp
+./kestrel/utilities/redundancy.lisp
+./kestrel/utilities/auto-termination-tests.lisp
+./kestrel/utilities/ensure-rules-known.lisp
+./kestrel/utilities/doublets.lisp
+./kestrel/utilities/hex-char-to-val.lisp
+./kestrel/utilities/auto-instance-tests.lisp
+./kestrel/utilities/defmax-nat/top.lisp
+./kestrel/utilities/defmax-nat/implementation.lisp
+./kestrel/utilities/defmax-nat/documentation.lisp
+./kestrel/utilities/equal.lisp
+./kestrel/utilities/defthmr.lisp
+./kestrel/utilities/legal-variable-listp.lisp
+./kestrel/utilities/split-list-fast.lisp
+./kestrel/utilities/coerce.lisp
+./kestrel/utilities/get-username.lisp
+./kestrel/utilities/split-list-fast-rules.lisp
+./kestrel/utilities/keyword-value-lists2.lisp
+./kestrel/utilities/quote.lisp
+./kestrel/utilities/fake-worlds.lisp
+./kestrel/utilities/ints-in-range.lisp
+./kestrel/utilities/terms.lisp
+./kestrel/utilities/xdoc-archiving.lisp
+./kestrel/utilities/verify-guards-program-tests.lisp
+./kestrel/utilities/imported-symbols.lisp
+./kestrel/utilities/integer-range-fixing-tests.lisp
+./kestrel/utilities/magic-macroexpand1-dollar.lisp
+./kestrel/utilities/signed-byte-fixing.lisp
+./kestrel/utilities/directed-untranslate.lisp
+./kestrel/utilities/untranslate-preprocessing.lisp
+./kestrel/utilities/pseudo-termp2.lisp
+./kestrel/utilities/defun-forms.lisp
+./kestrel/utilities/zp-lists.lisp
+./kestrel/utilities/mv-nth.lisp
+./kestrel/utilities/world.lisp
+./kestrel/utilities/string-utilities.lisp
+./kestrel/utilities/declares1.lisp
+./kestrel/utilities/digits-any-base/core-tests.lisp
+./kestrel/utilities/digits-any-base/pow2-4.lisp
+./kestrel/utilities/digits-any-base/top.lisp
+./kestrel/utilities/digits-any-base/core.lisp
+./kestrel/utilities/digits-any-base/defthm-dab-return-types.lisp
+./kestrel/utilities/digits-any-base/pow2-8.lisp
+./kestrel/utilities/digits-any-base/defdigit-grouping.lisp
+./kestrel/utilities/digits-any-base/defdigits.lisp
+./kestrel/utilities/digits-any-base/pow2.lisp
+./kestrel/utilities/digits-any-base/pow2-2.lisp
+./kestrel/utilities/digits-any-base/pow2-3.lisp
+./kestrel/utilities/digits-any-base/pow2-instances.lisp
+./kestrel/utilities/digits-any-base/defthm-dab-return-types-tests.lisp
+./kestrel/utilities/digits-any-base/pow2-1.lisp
+./kestrel/utilities/make-event-quiet.lisp
+./kestrel/utilities/def-constant-opener-tests.lisp
+./kestrel/utilities/bytes-legacy.lisp
+./kestrel/utilities/include-book-dir-dollar.lisp
+./kestrel/utilities/call-script.lisp
+./kestrel/utilities/suppress-invariant-risk.lisp
+./kestrel/utilities/ubi.lisp
+./kestrel/utilities/bind-from-rules.lisp
+./kestrel/utilities/printing.lisp
+./kestrel/utilities/declares0.lisp
+./kestrel/utilities/equal-of-booleans.lisp
+./kestrel/utilities/copy-def-tests.lisp
+./kestrel/utilities/copy-def.lisp
+./kestrel/utilities/subtermp.lisp
+./kestrel/utilities/channels.lisp
+./kestrel/utilities/string-utilities-tests.lisp
+./kestrel/utilities/my-get-event-tests.lisp
+./kestrel/utilities/if.lisp
+./kestrel/utilities/merge-sort-generic.lisp
+./kestrel/utilities/minimize-ruler-extenders.lisp
+./kestrel/utilities/exit-if-function-not-defined.lisp
+./kestrel/utilities/format-strings.lisp
+./kestrel/utilities/fix.lisp
+./kestrel/utilities/untranslated-terms.lisp
+./kestrel/utilities/imported-symbols-theorems.lisp
+./kestrel/utilities/symbol-term-alistp.lisp
+./kestrel/utilities/defmergesort-tests.lisp
+./kestrel/utilities/doublets2.lisp
+./kestrel/utilities/clause-identifiers.lisp
+./kestrel/utilities/file-existsp.lisp
+./kestrel/utilities/make-or.lisp
+./kestrel/utilities/file-io-string-trees.lisp
+./kestrel/utilities/defmacroq.lisp
+./kestrel/utilities/ubyte11s-as-digits.lisp
+./kestrel/utilities/clean-up-lambdas-tests.lisp
+./kestrel/utilities/assert.lisp
+./kestrel/utilities/doc-tests.lisp
+./kestrel/utilities/clean-up-lambdas.lisp
+./kestrel/utilities/disables.lisp
+./kestrel/utilities/integers-from-to.lisp
+./kestrel/utilities/progn.lisp
+./kestrel/utilities/conjunctions.lisp
+./kestrel/utilities/string-trees.lisp
+./kestrel/utilities/myif-def.lisp
+./kestrel/utilities/lambdas-closed-in-termp.lisp
+./kestrel/utilities/expand-lambdas-in-term.lisp
+./kestrel/utilities/unsigned-byte-fixing.lisp
+./kestrel/utilities/deftest.lisp
+./kestrel/utilities/non-ascii-pathnames.lisp
+./kestrel/utilities/ubi-doc.lisp
+./kestrel/utilities/remove-duplicates-equal-dollar.lisp
+./kestrel/utilities/make-tuple.lisp
+./kestrel/utilities/fresh-names2.lisp
+./kestrel/utilities/make-and.lisp
+./kestrel/utilities/make-legal-var-in-acl2-package.lisp
+./kestrel/utilities/lambda-free-termp.lisp
+./kestrel/utilities/defmergesort.lisp
+./kestrel/utilities/event-forms.lisp
+./kestrel/utilities/enumerations.lisp
+./kestrel/utilities/forms.lisp
+./kestrel/utilities/strings/printable-chars.lisp
+./kestrel/utilities/strings/top.lisp
+./kestrel/utilities/strings/alpha-digit-dash-chars.lisp
+./kestrel/utilities/strings/char-kinds-tests.lisp
+./kestrel/utilities/strings/strings-codes-fty.lisp
+./kestrel/utilities/strings/strings-codes-tests.lisp
+./kestrel/utilities/strings/hexstrings.lisp
+./kestrel/utilities/strings/hexchars.lisp
+./kestrel/utilities/strings/chars-codes-fty.lisp
+./kestrel/utilities/strings/hexchars-tests.lisp
+./kestrel/utilities/strings/alpha-digit-chars.lisp
+./kestrel/utilities/strings/chars-codes-tests.lisp
+./kestrel/utilities/strings/string-kinds-tests.lisp
+./kestrel/utilities/strings/string-kinds.lisp
+./kestrel/utilities/strings/char-code-theorems.lisp
+./kestrel/utilities/strings/hex-digit-char-theorems.lisp
+./kestrel/utilities/strings/strings-codes.lisp
+./kestrel/utilities/strings/alpha-uscore-dollar-chars.lisp
+./kestrel/utilities/strings/char-kinds.lisp
+./kestrel/utilities/strings/nondigit-chars.lisp
+./kestrel/utilities/strings/alpha-digit-uscore-dollar-chars.lisp
+./kestrel/utilities/strings/hexstrings-tests.lisp
+./kestrel/utilities/strings/chars-codes.lisp
+./kestrel/utilities/messages-tests.lisp
+./kestrel/utilities/directed-untranslate-tests.lisp
+./kestrel/utilities/gen-xdoc-for-file.lisp
+./kestrel/utilities/doc.lisp
+./kestrel/utilities/messages.lisp
+./kestrel/utilities/acons-fast.lisp
+./kestrel/utilities/channel-contents.lisp
+./kestrel/utilities/user-interface.lisp
+./kestrel/utilities/maybe-unquote.lisp
+./kestrel/utilities/erp.lisp
+./kestrel/utilities/string-contains-charp.lisp
+./kestrel/utilities/typed-tuples.lisp
+./kestrel/utilities/integers-from-to-tests.lisp
+./kestrel/utilities/xdoc-paras.lisp
+./kestrel/utilities/integers-from-to-as-set.lisp
+./kestrel/utilities/state.lisp
+./kestrel/utilities/wrap-all.lisp
+./kestrel/utilities/my-get-event.lisp
+./kestrel/utilities/bits-and-bytes-as-digits.lisp
+./kestrel/utilities/submit-events.lisp
+./kestrel/utilities/auto-instance.lisp
+./kestrel/utilities/make-ord.lisp
+./kestrel/utilities/orelse.lisp
+./kestrel/utilities/make-cons-nest.lisp
+./kestrel/utilities/depends-on-table.lisp
+./kestrel/utilities/get-process-id.lisp
+./kestrel/utilities/keyword-value-lists.lisp
+./kestrel/utilities/keywords-to-acl2-package.lisp
+./kestrel/utilities/myif.lisp
+./kestrel/utilities/user-interface-tests.lisp
+./kestrel/utilities/remove-guard-holders.lisp
+./kestrel/utilities/true-list-listp-theorems.lisp
+./kestrel/utilities/event-tuples-between.lisp
+./kestrel/utilities/lambdas.lisp
+./kestrel/utilities/temp-dirs.lisp
+./kestrel/utilities/unsigned-byte-list-fixing.lisp
+./kestrel/utilities/merge-sort-symbol-less-than.lisp
+./kestrel/utilities/make-and-nice.lisp
+./kestrel/utilities/omaps/core.lisp
+./kestrel/utilities/omaps/tests.lisp
+./kestrel/utilities/omaps/portcullis.lisp
+./kestrel/utilities/omaps/with-fixing-theorems.lisp
+./kestrel/utilities/oset-theorems.lisp
+./kestrel/utilities/def-constant-opener.lisp
+./kestrel/utilities/linter.lisp
+./kestrel/utilities/typed-lists/top.lisp
+./kestrel/utilities/typed-lists/nat-list-fix-theorems.lisp
+./kestrel/utilities/typed-lists/bit-listp.lisp
+./kestrel/utilities/proof-builder-macros-tests.lisp
+./kestrel/utilities/declares.lisp
+./kestrel/utilities/deftest-tests.lisp
+./kestrel/utilities/polarity-tests.lisp
+./kestrel/utilities/trans-eval-error-triple.lisp
+./kestrel/utilities/defconst-from-file.lisp
+./kestrel/utilities/verify-guards-program.lisp
+./kestrel/utilities/osets-tests.lisp
+./kestrel/utilities/pseudo-termp.lisp
+./kestrel/utilities/pos-fix.lisp
+./kestrel/utilities/assert-with-stobjs.lisp
+./kestrel/utilities/signed-byte-list-fixing.lisp
+./kestrel/utilities/pack.lisp
+./kestrel/utilities/get-vars-from-term.lisp
+./kestrel/utilities/doublets-tests.lisp
+./kestrel/utilities/lets.lisp
+./kestrel/utilities/string-trees-tests.lisp
+./kestrel/utilities/hints.lisp
+./kestrel/utilities/unify.lisp
+./kestrel/utilities/magic-macroexpand.lisp
+./kestrel/utilities/integer-range-fixing.lisp
+./kestrel/utilities/fresh-names.lisp
+./kestrel/utilities/defconst-computed.lisp
+./kestrel/utilities/functions-in-world.lisp
+./kestrel/sets/sets.lisp
+./kestrel/terms-light/top.lisp
+./kestrel/terms-light/sublis-var-simple.lisp
+./kestrel/terms-light/bound-vars-in-term.lisp
+./kestrel/terms-light/free-vars-in-term.lisp
+./kestrel/ethereum/hex-prefix.lisp
+./kestrel/ethereum/top.lisp
+./kestrel/ethereum/crypto.lisp
+./kestrel/ethereum/mmp-trees.lisp
+./kestrel/ethereum/rlp/encoding.lisp
+./kestrel/ethereum/rlp/top.lisp
+./kestrel/ethereum/rlp/big-endian.lisp
+./kestrel/ethereum/rlp/trees.lisp
+./kestrel/ethereum/rlp/tests-errors.lisp
+./kestrel/ethereum/rlp/tests-wiki.lisp
+./kestrel/ethereum/rlp/decoding-declarative.lisp
+./kestrel/ethereum/rlp/decoding-executable.lisp
+./kestrel/ethereum/rlp/decodability.lisp
+./kestrel/ethereum/words.lisp
+./kestrel/ethereum/transactions-tests.lisp
+./kestrel/ethereum/basics.lisp
+./kestrel/ethereum/database.lisp
+./kestrel/ethereum/bytes.lisp
+./kestrel/ethereum/portcullis.lisp
+./kestrel/ethereum/nibbles.lisp
+./kestrel/ethereum/semaphore/montgomery2edwards-proof.lisp
+./kestrel/ethereum/semaphore/baby-jubjub.lisp
+./kestrel/ethereum/semaphore/uint32xor-proof.lisp
+./kestrel/ethereum/semaphore/uint32add-2-proof.lisp
+./kestrel/ethereum/semaphore/uint32add-3-proof.lisp
+./kestrel/ethereum/semaphore/top.lisp
+./kestrel/ethereum/semaphore/pedersen-hash.lisp
+./kestrel/ethereum/semaphore/json-to-r1cs/top.lisp
+./kestrel/ethereum/semaphore/json-to-r1cs/cj-to-acl2.lisp
+./kestrel/ethereum/semaphore/json-to-r1cs/load-circom-json.lisp
+./kestrel/ethereum/semaphore/verify-semaphore-r1cs.lisp
+./kestrel/ethereum/semaphore/mimcsponge-5-1-proof.lisp
+./kestrel/ethereum/semaphore/r1cs-proof-rules.lisp
+./kestrel/ethereum/semaphore/base-points-for-pedersen-hash.lisp
+./kestrel/ethereum/semaphore/prime-field-abbreviations.lisp
+./kestrel/ethereum/semaphore/printing.lisp
+./kestrel/ethereum/semaphore/mimcsponge-2-1-proof.lisp
+./kestrel/ethereum/semaphore/portcullis.lisp
+./kestrel/ethereum/semaphore/blake2s-mixing-proof.lisp
+./kestrel/ethereum/semaphore/multimux3-2-proof.lisp
+./kestrel/ethereum/semaphore/mimcsponge-1-1-proof.lisp
+./kestrel/ethereum/semaphore/edwards2montgomery-proof.lisp
+./kestrel/ethereum/semaphore/montgomeryadd-proof.lisp
+./kestrel/ethereum/semaphore/multimux1-2-proof.lisp
+./kestrel/ethereum/semaphore/baby-jubjub-prime.lisp
+./kestrel/ethereum/semaphore/montgomerydouble-proof.lisp
+./kestrel/ethereum/semaphore/rotr-32-7-proof.lisp
+./kestrel/ethereum/semaphore/r1cs-proof-support.lisp
+./kestrel/ethereum/semaphore/binsum-32-2-proof.lisp
+./kestrel/ethereum/semaphore/lift-semaphore-r1cs.lisp
+./kestrel/ethereum/addresses.lisp
+./kestrel/ethereum/scalars.lisp
+./kestrel/ethereum/transactions.lisp
+./kestrel/std/top.lisp
+./kestrel/std/system/remove-dead-if-branches.lisp
+./kestrel/std/system/irecursivep.lisp
+./kestrel/std/system/fresh-logical-name-with-dollars-suffix-tests.lisp
+./kestrel/std/system/definedp-tests.lisp
+./kestrel/std/system/check-if-call.lisp
+./kestrel/std/system/termfnp-tests.lisp
+./kestrel/std/system/definedp-plus-tests.lisp
+./kestrel/std/system/apply-unary-to-terms-tests.lisp
+./kestrel/std/system/check-mv-let-call.lisp
+./kestrel/std/system/all-lambdas-tests.lisp
+./kestrel/std/system/rune-disabledp.lisp
+./kestrel/std/system/induction-machine-plus.lisp
+./kestrel/std/system/macro-args-plus-tests.lisp
+./kestrel/std/system/check-unary-lambda-call.lisp
+./kestrel/std/system/all-vars-open-tests.lisp
+./kestrel/std/system/uguard.lisp
+./kestrel/std/system/quote-term-tests.lisp
+./kestrel/std/system/macro-symbol-listp-tests.lisp
+./kestrel/std/system/defchoose-queries-tests.lisp
+./kestrel/std/system/check-unary-lambda-call-tests.lisp
+./kestrel/std/system/ibody-tests.lisp
+./kestrel/std/system/defun-sk-queries-tests.lisp
+./kestrel/std/system/ruler-extenders.lisp
+./kestrel/std/system/thm-formula-plus-tests.lisp
+./kestrel/std/system/term-queries.lisp
+./kestrel/std/system/apply-unary-to-terms.lisp
+./kestrel/std/system/arity-plus.lisp
+./kestrel/std/system/macro-keyword-args.lisp
+./kestrel/std/system/maybe-pseudo-event-formp.lisp
+./kestrel/std/system/make-mv-let-call-tests.lisp
+./kestrel/std/system/macro-symbolp.lisp
+./kestrel/std/system/pseudo-termfnp-tests.lisp
+./kestrel/std/system/function-namep-tests.lisp
+./kestrel/std/system/rawp.lisp
+./kestrel/std/system/all-program-ffn-symbs.lisp
+./kestrel/std/system/check-mbt-dollar-call-tests.lisp
+./kestrel/std/system/primitivep-plus-tests.lisp
+./kestrel/std/system/known-packages-plus.lisp
+./kestrel/std/system/lambda-closedp-tests.lisp
+./kestrel/std/system/rune-enabledp-tests.lisp
+./kestrel/std/system/make-mv-nth-calls-tests.lisp
+./kestrel/std/system/theorem-symbolp-tests.lisp
+./kestrel/std/system/recursive-calls.lisp
+./kestrel/std/system/function-queries.lisp
+./kestrel/std/system/pseudo-tests-and-callp-tests.lisp
+./kestrel/std/system/ruler-extenders-plus-tests.lisp
+./kestrel/std/system/apply-term-tests.lisp
+./kestrel/std/system/all-vars-in-untranslated-term.lisp
+./kestrel/std/system/well-founded-relation.lisp
+./kestrel/std/system/measure-plus-tests.lisp
+./kestrel/std/system/measured-subset-plus.lisp
+./kestrel/std/system/top.lisp
+./kestrel/std/system/check-user-lambda.lisp
+./kestrel/std/system/lambda-closedp.lisp
+./kestrel/std/system/pseudo-tests-and-call-listp.lisp
+./kestrel/std/system/unwrapped-nonexec-body.lisp
+./kestrel/std/system/non-executablep.lisp
+./kestrel/std/system/make-mv-nth-calls.lisp
+./kestrel/std/system/fsublis-fn-tests.lisp
+./kestrel/std/system/macro-name-listp-tests.lisp
+./kestrel/std/system/check-mbt-dollar-call.lisp
+./kestrel/std/system/install-not-normalized-event-tests.lisp
+./kestrel/std/system/ruler-extenders-plus.lisp
+./kestrel/std/system/conjoin.lisp
+./kestrel/std/system/induction-machine-tests.lisp
+./kestrel/std/system/unquote-term-tests.lisp
+./kestrel/std/system/unquote-term.lisp
+./kestrel/std/system/if-tree-leaf-terms-tests.lisp
+./kestrel/std/system/apply-terms-same-args.lisp
+./kestrel/std/system/ubody.lisp
+./kestrel/std/system/included-books-tests.lisp
+./kestrel/std/system/w.lisp
+./kestrel/std/system/stobjs-out-plus.lisp
+./kestrel/std/system/number-of-results.lisp
+./kestrel/std/system/pseudo-command-landmark-listp.lisp
+./kestrel/std/system/all-non-gv-ffn-symbs.lisp
+./kestrel/std/system/pure-raw-p.lisp
+./kestrel/std/system/table-alist-plus.lisp
+./kestrel/std/system/classes-plus-tests.lisp
+./kestrel/std/system/guard-verified-p-tests.lisp
+./kestrel/std/system/fundef-enabledp-tests.lisp
+./kestrel/std/system/unwrapped-nonexec-body-tests.lisp
+./kestrel/std/system/lambda-guard-verified-exec-fnsp.lisp
+./kestrel/std/system/term-guard-obligation-tests.lisp
+./kestrel/std/system/macro-keyword-args-plus-tests.lisp
+./kestrel/std/system/uguard-tests.lisp
+./kestrel/std/system/function-symbol-listp.lisp
+./kestrel/std/system/tail-recursive-p.lisp
+./kestrel/std/system/all-non-gv-ffn-symbs-tests.lisp
+./kestrel/std/system/irecursivep-tests.lisp
+./kestrel/std/system/termfn-listp.lisp
+./kestrel/std/system/function-symbol-listp-tests.lisp
+./kestrel/std/system/close-lambdas.lisp
+./kestrel/std/system/event-landmark-names-tests.lisp
+./kestrel/std/system/logic-function-namep-tests.lisp
+./kestrel/std/system/dumb-occur-var-open-tests.lisp
+./kestrel/std/system/check-user-term.lisp
+./kestrel/std/system/no-stobjs-p.lisp
+./kestrel/std/system/check-or-call-tests.lisp
+./kestrel/std/system/pseudo-lambdap.lisp
+./kestrel/std/system/remove-mbe-tests.lisp
+./kestrel/std/system/fapply-term.lisp
+./kestrel/std/system/macro-keyword-args-plus.lisp
+./kestrel/std/system/rune-disabledp-tests.lisp
+./kestrel/std/system/measure.lisp
+./kestrel/std/system/remove-trivial-vars-tests.lisp
+./kestrel/std/system/pseudo-event-formp-tests.lisp
+./kestrel/std/system/rune-enabledp.lisp
+./kestrel/std/system/arglistp.lisp
+./kestrel/std/system/fsublis-fn.lisp
+./kestrel/std/system/remove-unused-vars-tests.lisp
+./kestrel/std/system/pseudo-tests-and-callp.lisp
+./kestrel/std/system/pseudo-event-landmark-listp-tests.lisp
+./kestrel/std/system/induction-machine.lisp
+./kestrel/std/system/number-of-results-plus.lisp
+./kestrel/std/system/pure-raw-p-tests.lisp
+./kestrel/std/system/stobjs-out-plus-tests.lisp
+./kestrel/std/system/non-executablep-plus.lisp
+./kestrel/std/system/term-guard-obligation.lisp
+./kestrel/std/system/formals-plus-tests.lisp
+./kestrel/std/system/mvify.lisp
+./kestrel/std/system/plist-worldp-with-formals.lisp
+./kestrel/std/system/install-not-normalized-dollar.lisp
+./kestrel/std/system/uguard-plus.lisp
+./kestrel/std/system/fapply-terms-same-args-tests.lisp
+./kestrel/std/system/irecursivep-plus-tests.lisp
+./kestrel/std/system/definedp-plus.lisp
+./kestrel/std/system/primitivep.lisp
+./kestrel/std/system/lambda-guard-verified-fnsp-tests.lisp
+./kestrel/std/system/defun-sk-queries.lisp
+./kestrel/std/system/theorem-symbolp.lisp
+./kestrel/std/system/classes-plus.lisp
+./kestrel/std/system/stobjs-in-plus.lisp
+./kestrel/std/system/theorem-name-listp.lisp
+./kestrel/std/system/uguard-plus-tests.lisp
+./kestrel/std/system/close-lambdas-tests.lisp
+./kestrel/std/system/fundef-enabledp.lisp
+./kestrel/std/system/macro-name-listp.lisp
+./kestrel/std/system/irecursivep-plus.lisp
+./kestrel/std/system/check-or-call.lisp
+./kestrel/std/system/tail-recursive-p-tests.lisp
+./kestrel/std/system/check-mv-let-call-tests.lisp
+./kestrel/std/system/pseudo-event-formp.lisp
+./kestrel/std/system/conjoin-equalities-tests.lisp
+./kestrel/std/system/arity.lisp
+./kestrel/std/system/thm-formula-plus.lisp
+./kestrel/std/system/stobjs-in-plus-tests.lisp
+./kestrel/std/system/macro-namep.lisp
+./kestrel/std/system/measure-tests.lisp
+./kestrel/std/system/guard-verified-fnsp-tests.lisp
+./kestrel/std/system/ibody.lisp
+./kestrel/std/system/check-mbt-call.lisp
+./kestrel/std/system/fresh-logical-name-with-dollars-suffix.lisp
+./kestrel/std/system/flatten-ands-in-lit.lisp
+./kestrel/std/system/fundef-disabledp-tests.lisp
+./kestrel/std/system/remove-dead-if-branches-tests.lisp
+./kestrel/std/system/macro-namep-tests.lisp
+./kestrel/std/system/pseudo-tests-and-call-listp-tests.lisp
+./kestrel/std/system/known-packages-tests.lisp
+./kestrel/std/system/check-nary-lambda-call.lisp
+./kestrel/std/system/lambda-logic-fnsp-tests.lisp
+./kestrel/std/system/measure-plus.lisp
+./kestrel/std/system/termfn-listp-tests.lisp
+./kestrel/std/system/remove-progn.lisp
+./kestrel/std/system/pseudo-termfn-listp-tests.lisp
+./kestrel/std/system/install-not-normalized-event.lisp
+./kestrel/std/system/defchoose-queries.lisp
+./kestrel/std/system/all-program-ffn-symbs-tests.lisp
+./kestrel/std/system/termfnp.lisp
+./kestrel/std/system/macro-symbol-listp.lisp
+./kestrel/std/system/all-non-gv-exec-ffn-symbs.lisp
+./kestrel/std/system/logical-name-listp.lisp
+./kestrel/std/system/add-suffix-to-fn-or-const.lisp
+./kestrel/std/system/no-stobjs-p-plus-tests.lisp
+./kestrel/std/system/apply-terms-same-args-tests.lisp
+./kestrel/std/system/check-and-call.lisp
+./kestrel/std/system/function-name-listp-tests.lisp
+./kestrel/std/system/macro-required-args.lisp
+./kestrel/std/system/check-user-term-tests.lisp
+./kestrel/std/system/event-landmark-names.lisp
+./kestrel/std/system/maybe-pseudo-event-formp-tests.lisp
+./kestrel/std/system/apply-fn-into-ifs-tests.lisp
+./kestrel/std/system/all-lambdas.lisp
+./kestrel/std/system/fsublis-var-tests.lisp
+./kestrel/std/system/pseudo-termfnp.lisp
+./kestrel/std/system/all-free-bound-vars.lisp
+./kestrel/std/system/fapply-term-tests.lisp
+./kestrel/std/system/term-possible-numbers-of-results.lisp
+./kestrel/std/system/check-lambda-call.lisp
+./kestrel/std/system/lambda-guard-verified-exec-fnsp-tests.lisp
+./kestrel/std/system/check-nary-lambda-call-tests.lisp
+./kestrel/std/system/ubody-plus.lisp
+./kestrel/std/system/well-founded-relation-plus.lisp
+./kestrel/std/system/term-possible-numbers-of-results-tests.lisp
+./kestrel/std/system/unwrapped-nonexec-body-plus.lisp
+./kestrel/std/system/measured-subset.lisp
+./kestrel/std/system/lambdap-tests.lisp
+./kestrel/std/system/lambda-logic-fnsp.lisp
+./kestrel/std/system/pseudo-lambda-listp.lisp
+./kestrel/std/system/logical-name-listp-tests.lisp
+./kestrel/std/system/fundef-disabledp.lisp
+./kestrel/std/system/apply-term.lisp
+./kestrel/std/system/theorem-symbol-listp-tests.lisp
+./kestrel/std/system/quote-term-list.lisp
+./kestrel/std/system/macro-required-args-plus-tests.lisp
+./kestrel/std/system/check-mbt-call-tests.lisp
+./kestrel/std/system/pseudo-lambdap-tests.lisp
+./kestrel/std/system/primitivep-tests.lisp
+./kestrel/std/system/all-vars-open.lisp
+./kestrel/std/system/number-of-results-tests.lisp
+./kestrel/std/system/macro-keyword-args-tests.lisp
+./kestrel/std/system/ubody-tests.lisp
+./kestrel/std/system/remove-mbe.lisp
+./kestrel/std/system/function-namep.lisp
+./kestrel/std/system/no-stobjs-p-tests.lisp
+./kestrel/std/system/thm-formula.lisp
+./kestrel/std/system/conjoin-equalities.lisp
+./kestrel/std/system/number-of-results-plus-tests.lisp
+./kestrel/std/system/pseudo-lambda-listp-tests.lisp
+./kestrel/std/system/pseudo-termfn-listp.lisp
+./kestrel/std/system/table-alist-plus-tests.lisp
+./kestrel/std/system/lambda-listp-tests.lisp
+./kestrel/std/system/all-pkg-names-tests.lisp
+./kestrel/std/system/quote-term.lisp
+./kestrel/std/system/guard-verified-fnsp.lisp
+./kestrel/std/system/measured-subset-tests.lisp
+./kestrel/std/system/mvify-tests.lisp
+./kestrel/std/system/all-non-gv-exec-ffn-symbs-tests.lisp
+./kestrel/std/system/lambda-guard-verified-fnsp.lisp
+./kestrel/std/system/arity-plus-tests.lisp
+./kestrel/std/system/measured-subset-plus-tests.lisp
+./kestrel/std/system/guard-verified-exec-fnsp.lisp
+./kestrel/std/system/all-free-bound-vars-tests.lisp
+./kestrel/std/system/non-executablep-plus-tests.lisp
+./kestrel/std/system/event-name-queries.lisp
+./kestrel/std/system/all-pkg-names.lisp
+./kestrel/std/system/theorem-queries.lisp
+./kestrel/std/system/ubody-plus-tests.lisp
+./kestrel/std/system/pseudo-event-form-listp-tests.lisp
+./kestrel/std/system/function-name-listp.lisp
+./kestrel/std/system/pseudo-event-landmark-listp.lisp
+./kestrel/std/system/thm-formula-tests.lisp
+./kestrel/std/system/definedp.lisp
+./kestrel/std/system/quote-term-list-tests.lisp
+./kestrel/std/system/theorem-namep.lisp
+./kestrel/std/system/guard-verified-p-plus.lisp
+./kestrel/std/system/function-symbolp.lisp
+./kestrel/std/system/classes-tests.lisp
+./kestrel/std/system/non-executablep-tests.lisp
+./kestrel/std/system/lambda-listp.lisp
+./kestrel/std/system/rawp-tests.lisp
+./kestrel/std/system/fresh-namep.lisp
+./kestrel/std/system/theorem-symbol-listp.lisp
+./kestrel/std/system/guard-verified-p-plus-tests.lisp
+./kestrel/std/system/macro-symbolp-tests.lisp
+./kestrel/std/system/remove-progn-tests.lisp
+./kestrel/std/system/pseudo-command-landmark-listp-tests.lisp
+./kestrel/std/system/enhanced-utilities.lisp
+./kestrel/std/system/remove-trivial-vars.lisp
+./kestrel/std/system/lambdap.lisp
+./kestrel/std/system/ruler-extenders-tests.lisp
+./kestrel/std/system/check-list-call.lisp
+./kestrel/std/system/fapply-unary-to-terms.lisp
+./kestrel/std/system/check-lambda-call-tests.lisp
+./kestrel/std/system/guard-verified-exec-fnsp-tests.lisp
+./kestrel/std/system/known-packages.lisp
+./kestrel/std/system/macro-args-plus.lisp
+./kestrel/std/system/pseudo-event-form-listp.lisp
+./kestrel/std/system/make-mv-let-call.lisp
+./kestrel/std/system/theorem-namep-tests.lisp
+./kestrel/std/system/theorem-name-listp-tests.lisp
+./kestrel/std/system/recursive-calls-tests.lisp
+./kestrel/std/system/check-user-lambda-tests.lisp
+./kestrel/std/system/formals-plus.lisp
+./kestrel/std/system/unwrapped-nonexec-body-plus-tests.lisp
+./kestrel/std/system/dumb-occur-var-open.lisp
+./kestrel/std/system/fapply-unary-to-terms-tests.lisp
+./kestrel/std/system/logic-function-namep.lisp
+./kestrel/std/system/getprops.lisp
+./kestrel/std/system/term-transformations.lisp
+./kestrel/std/system/classes.lisp
+./kestrel/std/system/induction-machine-plus-tests.lisp
+./kestrel/std/system/well-founded-relation-tests.lisp
+./kestrel/std/system/guard-verified-p.lisp
+./kestrel/std/system/macro-required-args-tests.lisp
+./kestrel/std/system/primitivep-plus.lisp
+./kestrel/std/system/known-packages-plus-tests.lisp
+./kestrel/std/system/if-tree-leaf-terms.lisp
+./kestrel/std/system/well-founded-relation-plus-tests.lisp
+./kestrel/std/system/check-list-call-tests.lisp
+./kestrel/std/system/add-suffix-to-fn-or-const-tests.lisp
+./kestrel/std/system/macro-required-args-plus.lisp
+./kestrel/std/system/all-fnnames.lisp
+./kestrel/std/system/all-vars.lisp
+./kestrel/std/system/fapply-terms-same-args.lisp
+./kestrel/std/system/remove-unused-vars.lisp
+./kestrel/std/system/check-and-call-tests.lisp
+./kestrel/std/system/no-stobjs-p-plus.lisp
+./kestrel/std/system/fsublis-var.lisp
+./kestrel/std/system/included-books.lisp
+./kestrel/std/system/macro-queries.lisp
+./kestrel/std/system/check-if-call-tests.lisp
+./kestrel/std/system/apply-fn-into-ifs.lisp
+./kestrel/std/system/term-function-recognizers.lisp
+./kestrel/std/basic/top.lisp
+./kestrel/std/basic/organize-symbols-by-name.lisp
+./kestrel/std/basic/symbol-package-name-lst-tests.lisp
+./kestrel/std/basic/good-valuep.lisp
+./kestrel/std/basic/mbt-dollar.lisp
+./kestrel/std/basic/symbol-package-name-non-cl.lisp
+./kestrel/std/basic/symbol-package-name-lst.lisp
+./kestrel/std/basic/organize-symbols-by-pkg-tests.lisp
+./kestrel/std/basic/symbol-package-name-non-cl-tests.lisp
+./kestrel/std/basic/good-pseudo-termp.lisp
+./kestrel/std/basic/organize-symbols-by-name-tests.lisp
+./kestrel/std/basic/organize-symbols-by-pkg.lisp
+./kestrel/std/util/defconstrained-recognizer.lisp
+./kestrel/std/util/defmapping-doc.lisp
+./kestrel/std/util/defarbrec-tests.lisp
+./kestrel/std/util/deftutorial-tests.lisp
+./kestrel/std/util/defmapping-tests-validation.lisp
+./kestrel/std/util/defiso-doc.lisp
+./kestrel/std/util/top.lisp
+./kestrel/std/util/defsurj.lisp
+./kestrel/std/util/defmapping-tests-concrete.lisp
+./kestrel/std/util/defmax-nat.lisp
+./kestrel/std/util/defmax-nat-doc.lisp
+./kestrel/std/util/defund-sk-doc.lisp
+./kestrel/std/util/defund-sk-tests.lisp
+./kestrel/std/util/tuple.lisp
+./kestrel/std/util/defmacro-plus.lisp
+./kestrel/std/util/deffixer.lisp
+./kestrel/std/util/deftutorial.lisp
+./kestrel/std/util/defmin-int-doc.lisp
+./kestrel/std/util/deftutorial-doc.lisp
+./kestrel/std/util/defmax-nat-tests.lisp
+./kestrel/std/util/defund-sk.lisp
+./kestrel/std/util/defmin-int.lisp
+./kestrel/std/util/defmacro-plus-doc.lisp
+./kestrel/std/util/definj-doc.lisp
+./kestrel/std/util/defmapping-tests-utils.lisp
+./kestrel/std/util/defsurj-doc.lisp
+./kestrel/std/util/defarbrec.lisp
+./kestrel/std/util/defmacro-plus-tests.lisp
+./kestrel/std/util/defmax-nat-template.lisp
+./kestrel/std/util/defmin-int-tests.lisp
+./kestrel/std/util/defmapping-tests-template-1-2.lisp
+./kestrel/std/util/definj.lisp
+./kestrel/std/util/defarbrec-template.lisp
+./kestrel/std/util/defarbrec-doc.lisp
+./kestrel/std/util/defthm-commutative.lisp
+./kestrel/std/util/defmapping-tests-template-2-2.lisp
+./kestrel/std/util/defmapping.lisp
+./kestrel/std/util/defiso.lisp
+./kestrel/std/util/defmapping-tests-template-2-1.lisp
+./kestrel/std/util/defmapping-proof-templates.lisp
+./kestrel/std/util/defmin-int-template.lisp
+./kestrel/std/util/defmapping-tests-template-1-1.lisp
+./kestrel/std/util/defmapping-templates.lisp
+./kestrel/std/strings/top.lisp
+./kestrel/std/strings/strtok-bang.lisp
+./kestrel/std/strings/letter-char-p.lisp
+./kestrel/std/strings/char-kinds.lisp
+./kestrel/std/strings/strtok-bang-tests.lisp
+./kestrel/java/top.lisp
+./kestrel/java/atj/java-primitive-array-model.lisp
+./kestrel/java/atj/top.lisp
+./kestrel/java/atj/types-for-bv-fns.lisp
+./kestrel/java/atj/java-types.lisp
+./kestrel/java/atj/types-for-natives.lisp
+./kestrel/java/atj/aij-notions.lisp
+./kestrel/java/atj/code-generation.lisp
+./kestrel/java/atj/input-processing.lisp
+./kestrel/java/atj/types-for-ihs-fns.lisp
+./kestrel/java/atj/java-pretty-printer.lisp
+./kestrel/java/atj/shallow-quoted-constant-generation.lisp
+./kestrel/java/atj/types.lisp
+./kestrel/java/atj/types-for-std-fns.lisp
+./kestrel/java/atj/type-macros.lisp
+./kestrel/java/atj/shallow-code-generation.lisp
+./kestrel/java/atj/java-primitive-arrays.lisp
+./kestrel/java/atj/types-for-built-ins.lisp
+./kestrel/java/atj/post-translation.lisp
+./kestrel/java/atj/pre-translation.lisp
+./kestrel/java/atj/atj.lisp
+./kestrel/java/atj/types-for-list-fns.lisp
+./kestrel/java/atj/tests/natives-deep-guarded.lisp
+./kestrel/java/atj/tests/primitives-deep-unguarded.lisp
+./kestrel/java/atj/tests/booleans-deep-unguarded.lisp
+./kestrel/java/atj/tests/booleans-deep-guarded.lisp
+./kestrel/java/atj/tests/primitives.lisp
+./kestrel/java/atj/tests/acl2-times.lisp
+./kestrel/java/atj/tests/natives-shallow-unguarded.lisp
+./kestrel/java/atj/tests/abnf-shallow-guarded.lisp
+./kestrel/java/atj/tests/abnf-deep-guarded.lisp
+./kestrel/java/atj/tests/primitives-shallow-unguarded.lisp
+./kestrel/java/atj/tests/fibonacci.lisp
+./kestrel/java/atj/tests/multivalue-deep-unguarded.lisp
+./kestrel/java/atj/tests/factorial.lisp
+./kestrel/java/atj/tests/booleans-shallow-unguarded.lisp
+./kestrel/java/atj/tests/fibonacci-shallow-guarded.lisp
+./kestrel/java/atj/tests/booleans-shallow-guarded.lisp
+./kestrel/java/atj/tests/natives.lisp
+./kestrel/java/atj/tests/factorial-deep-unguarded.lisp
+./kestrel/java/atj/tests/primitives-deep-guarded.lisp
+./kestrel/java/atj/tests/multivalue-shallow-guarded.lisp
+./kestrel/java/atj/tests/factorial-shallow-unguarded.lisp
+./kestrel/java/atj/tests/fibonacci-shallow-unguarded.lisp
+./kestrel/java/atj/tests/natives-shallow-guarded.lisp
+./kestrel/java/atj/tests/abnf.lisp
+./kestrel/java/atj/tests/factorial-deep-guarded.lisp
+./kestrel/java/atj/tests/booleans.lisp
+./kestrel/java/atj/tests/primarrays-shallow-guarded.lisp
+./kestrel/java/atj/tests/abnf-shallow-unguarded.lisp
+./kestrel/java/atj/tests/fibonacci-deep-unguarded.lisp
+./kestrel/java/atj/tests/multivalue.lisp
+./kestrel/java/atj/tests/natives-deep-unguarded.lisp
+./kestrel/java/atj/tests/fibonacci-deep-guarded.lisp
+./kestrel/java/atj/tests/primarrays.lisp
+./kestrel/java/atj/tests/multivalue-deep-guarded.lisp
+./kestrel/java/atj/tests/factorial-shallow-guarded.lisp
+./kestrel/java/atj/tests/multivalue-shallow-unguarded.lisp
+./kestrel/java/atj/tests/abnf-deep-unguarded.lisp
+./kestrel/java/atj/tests/primitives-shallow-guarded.lisp
+./kestrel/java/atj/deep-code-generation.lisp
+./kestrel/java/atj/doc.lisp
+./kestrel/java/atj/java-abstract-syntax.lisp
+./kestrel/java/atj/array-write-method-names.lisp
+./kestrel/java/atj/java-syntax-operations.lisp
+./kestrel/java/atj/java-primitives.lisp
+./kestrel/java/atj/common-code-generation.lisp
+./kestrel/java/atj/tutorial.lisp
+./kestrel/java/atj/name-translation.lisp
+./kestrel/java/atj/test-structures.lisp
+./kestrel/java/atj/library-extensions.lisp
+./kestrel/java/aij/top.lisp
+./kestrel/java/aij/assumptions.lisp
+./kestrel/java/portcullis.lisp
+./kestrel/java/language/keywords-validation.lisp
+./kestrel/java/language/decimal-digits-std-strings-theorems.lisp
+./kestrel/java/language/escape-sequences.lisp
+./kestrel/java/language/values.lisp
+./kestrel/java/language/keywords.lisp
+./kestrel/java/language/character-literals.lisp
+./kestrel/java/language/identifiers.lisp
+./kestrel/java/language/top.lisp
+./kestrel/java/language/floating-point-placeholders.lisp
+./kestrel/java/language/binary-digits-validation.lisp
+./kestrel/java/language/reference-types.lisp
+./kestrel/java/language/optional-integer-type-suffix.lisp
+./kestrel/java/language/binary-integer-literals.lisp
+./kestrel/java/language/string-literals.lisp
+./kestrel/java/language/decimal-integer-literals.lisp
+./kestrel/java/language/pointers.lisp
+./kestrel/java/language/binary-digits-std-strings-theorems.lisp
+./kestrel/java/language/primitive-function-macros.lisp
+./kestrel/java/language/unicode-characters.lisp
+./kestrel/java/language/syntax.lisp
+./kestrel/java/language/binary-digits.lisp
+./kestrel/java/language/octal-integer-literals.lisp
+./kestrel/java/language/integer-literals.lisp
+./kestrel/java/language/boolean-literals-validation.lisp
+./kestrel/java/language/types.lisp
+./kestrel/java/language/decimal-digits.lisp
+./kestrel/java/language/package-names.lisp
+./kestrel/java/language/floating-point-literals.lisp
+./kestrel/java/language/octal-digits.lisp
+./kestrel/java/language/primitive-types.lisp
+./kestrel/java/language/grammar.lisp
+./kestrel/java/language/null-literal-validation.lisp
+./kestrel/java/language/hexadecimal-digits-std-strings-theorems.lisp
+./kestrel/java/language/hexadecimal-digits-validation.lisp
+./kestrel/java/language/hexadecimal-integer-literals.lisp
+./kestrel/java/language/octal-digits-validation.lisp
+./kestrel/java/language/primitive-operations.lisp
+./kestrel/java/language/reference-values.lisp
+./kestrel/java/language/floating-point-value-set-parameters.lisp
+./kestrel/java/language/octal-digits-std-strings-theorems.lisp
+./kestrel/java/language/unicode-input-characters.lisp
+./kestrel/java/language/hexadecimal-digits.lisp
+./kestrel/java/language/semantics.lisp
+./kestrel/java/language/decimal-digits-validation.lisp
+./kestrel/java/language/unicode-escapes.lisp
+./kestrel/java/language/boolean-literals.lisp
+./kestrel/java/language/null-literal.lisp
+./kestrel/java/language/literals.lisp
+./kestrel/java/language/primitive-conversions.lisp
+./kestrel/java/language/primitive-values.lisp
+./kestrel/untranslated-terms/top.lisp
+./kestrel/untranslated-terms/rename-functions.lisp
+./kestrel/untranslated-terms/rename-functions-tests.lisp
+./kestrel/bitcoin/base58-tests.lisp
+./kestrel/bitcoin/base58.lisp
+./kestrel/bitcoin/top.lisp
+./kestrel/bitcoin/crypto.lisp
+./kestrel/bitcoin/base58check.lisp
+./kestrel/bitcoin/bip44.lisp
+./kestrel/bitcoin/tests-top.lisp
+./kestrel/bitcoin/bip43.lisp
+./kestrel/bitcoin/bip39-english-words.lisp
+./kestrel/bitcoin/bip32-executable.lisp
+./kestrel/bitcoin/bip39.lisp
+./kestrel/bitcoin/bip39-tests.lisp
+./kestrel/bitcoin/bytes.lisp
+./kestrel/bitcoin/portcullis.lisp
+./kestrel/bitcoin/bip32.lisp
+./kestrel/number-theory/defprime-tests.lisp
+./kestrel/number-theory/top.lisp
+./kestrel/number-theory/tonelli-shanks-proof.lisp
+./kestrel/number-theory/divides.lisp
+./kestrel/number-theory/defprime.lisp
+./kestrel/number-theory/tonelli-shanks.lisp
+./kestrel/number-theory/primes.lisp
+./kestrel/number-theory/primep-def.lisp
+./kestrel/number-theory/euler2-support.lisp
+./kestrel/number-theory/quadratic-residue.lisp
+./kestrel/number-theory/mod-expt-fast.lisp
+./kestrel/number-theory/mod.lisp
+./kestrel/number-theory/portcullis.lisp
+./kestrel/unicode-light/compare.lisp
+./kestrel/unicode-light/top.lisp
+./kestrel/unicode-light/code-point-to-utf-8-chars.lisp
+./kestrel/unicode-light/hex-digit-chars-to-code-point.lisp
+./kestrel/unicode-light/hex-digit-chars-to-code-point-tests.lisp
+./kestrel/unicode-light/surrogates.lisp
+./misc/invariants.lisp
+./misc/check-acl2-exports.lisp
+./misc/beta-reduce.lisp
+./misc/simplify-thm.lisp
+./misc/hons-tests.lisp
+./misc/equal-by-g-help.lisp
+./misc/process-book-readme.lisp
+./misc/expander-tests.lisp
+./misc/untranslate-patterns.lisp
+./misc/check-state.lisp
+./misc/character-encoding-test.lisp
+./misc/records0.lisp
+./misc/profiling.lisp
+./misc/eliminate-irrelevance-tests.lisp
+./misc/enumerate.lisp
+./misc/equal-by-g.lisp
+./misc/mult.lisp
+./misc/bash-bsd.lisp
+./misc/hanoi.lisp
+./misc/fast-coerce.lisp
+./misc/expander.lisp
+./misc/definline.lisp
+./misc/wet.lisp
+./misc/records.lisp
+./misc/misc2/step-limits.lisp
+./misc/misc2/defpun-exec-domain-example.lisp
+./misc/misc2/misc.lisp
+./misc/misc2/reverse-by-separation.lisp
+./misc/misc2/ruler-extenders-tests.lisp
+./misc/disassemble.lisp
+./misc/rtl-untranslate.lisp
+./misc/defattach-example.lisp
+./misc/eval.lisp
+./misc/with-waterfall-parallelism.lisp
+./misc/integer-type-set-test.lisp
+./misc/fibonacci.lisp
+./misc/arithmetic-top-theory.lisp
+./misc/install-not-normalized.lisp
+./misc/radix.lisp
+./misc/hons-help.lisp
+./misc/hons-help2.lisp
+./misc/simp.lisp
+./misc/oprof.lisp
+./misc/seqw.lisp
+./misc/dijkstra-shortest-path.lisp
+./misc/goodstein.lisp
+./misc/evalable-printing.lisp
+./misc/csort.lisp
+./misc/records-bsd.lisp
+./misc/sort-symbols.lisp
+./misc/transfinite.lisp
+./misc/pigeonhole.lisp
+./misc/trace-star.lisp
+./misc/total-order.lisp
+./misc/total-order-bsd.lisp
+./misc/check-fn-inst.lisp
+./misc/redef-pkg.lisp
+./misc/priorities.lisp
+./misc/defpm.lisp
+./misc/defp.lisp
+./misc/without-waterfall-parallelism.lisp
+./misc/defopener.lisp
+./misc/meta-lemmas.lisp
+./misc/how-to-prove-thms.lisp
+./misc/book-checks.lisp
+./misc/dft-ex.lisp
+./misc/symbol-btree.lisp
+./misc/random.lisp
+./misc/int-division.lisp
+./misc/file-io.lisp
+./misc/hidden-defpkg-checks/top.lisp
+./misc/hidden-defpkg-checks/pkg1.lisp
+./misc/hidden-defpkg-checks/pkg2.lisp
+./misc/hidden-defpkg-checks/sub1.lisp
+./misc/hidden-defpkg-checks/sub2.lisp
+./misc/dump-events.lisp
+./misc/computed-hint.lisp
+./misc/problem13.lisp
+./misc/defpun.lisp
+./misc/computed-hint-rewrite.lisp
+./misc/defmac.lisp
+./misc/save-time.lisp
+./misc/dead-events.lisp
+./misc/sin-cos.lisp
+./misc/getprop.lisp
+./misc/dft.lisp
+./misc/simplify-defuns.lisp
+./misc/install-not-normalized-tests.lisp
+./misc/multi-v-uni.lisp
+./misc/find-events-tests.lisp
+./misc/callers-and-ancestors.lisp
+./misc/defun-plus.lisp
+./misc/defattach-bang.lisp
+./misc/bash.lisp
+./misc/gentle.lisp
+./misc/defproxy-test.lisp
+./misc/seq.lisp
+./misc/sticky-disable.lisp
+./misc/find-lemmas.lisp
+./misc/grcd.lisp
+./powerlists/sort.lisp
+./powerlists/algebra.lisp
+./powerlists/gray-code.lisp
+./powerlists/bitonic-sort.lisp
+./powerlists/batcher-sort.lisp
+./powerlists/simple.lisp
+./powerlists/prefix-sum.lisp
+./powerlists/merge-sort.lisp
+./powerlists/cla-adder.lisp
+./arithmetic-5/top.lisp
+./arithmetic-5/lib/basic-ops/banner.lisp
+./arithmetic-5/lib/basic-ops/we-are-here.lisp
+./arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp
+./arithmetic-5/lib/basic-ops/mini-theories.lisp
+./arithmetic-5/lib/basic-ops/common.lisp
+./arithmetic-5/lib/basic-ops/top.lisp
+./arithmetic-5/lib/basic-ops/simplify.lisp
+./arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp
+./arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp
+./arithmetic-5/lib/basic-ops/building-blocks-helper.lisp
+./arithmetic-5/lib/basic-ops/expt-helper.lisp
+./arithmetic-5/lib/basic-ops/forcing-types.lisp
+./arithmetic-5/lib/basic-ops/if-normalization.lisp
+./arithmetic-5/lib/basic-ops/types.lisp
+./arithmetic-5/lib/basic-ops/natp-posp.lisp
+./arithmetic-5/lib/basic-ops/elim-hint.lisp
+./arithmetic-5/lib/basic-ops/dynamic-e-d.lisp
+./arithmetic-5/lib/basic-ops/integerp-helper.lisp
+./arithmetic-5/lib/basic-ops/normalize.lisp
+./arithmetic-5/lib/basic-ops/integerp.lisp
+./arithmetic-5/lib/basic-ops/arithmetic-theory.lisp
+./arithmetic-5/lib/basic-ops/simplify-helper.lisp
+./arithmetic-5/lib/basic-ops/types-helper.lisp
+./arithmetic-5/lib/basic-ops/basic.lisp
+./arithmetic-5/lib/basic-ops/building-blocks.lisp
+./arithmetic-5/lib/basic-ops/expt.lisp
+./arithmetic-5/lib/basic-ops/distributivity.lisp
+./arithmetic-5/lib/basic-ops/default-hint.lisp
+./arithmetic-5/lib/basic-ops/collect.lisp
+./arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp
+./arithmetic-5/lib/basic-ops/integerp-meta.lisp
+./arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp
+./arithmetic-5/lib/floor-mod/top.lisp
+./arithmetic-5/lib/floor-mod/floor-mod-basic.lisp
+./arithmetic-5/lib/floor-mod/more-floor-mod.lisp
+./arithmetic-5/lib/floor-mod/floor-mod.lisp
+./arithmetic-5/lib/floor-mod/forcing-types.lisp
+./arithmetic-5/lib/floor-mod/if-normalization.lisp
+./arithmetic-5/lib/floor-mod/floor-mod-helper.lisp
+./arithmetic-5/lib/floor-mod/mod-expt-fast.lisp
+./arithmetic-5/lib/floor-mod/logand-helper.lisp
+./arithmetic-5/lib/floor-mod/logand.lisp
+./arithmetic-5/lib/floor-mod/truncate-rem.lisp
+./arithmetic-5/support/mini-theories.lisp
+./arithmetic-5/support/top.lisp
+./arithmetic-5/support/prefer-times.lisp
+./arithmetic-5/support/basic-arithmetic-helper.lisp
+./arithmetic-5/support/numerator-and-denominator.lisp
+./arithmetic-5/support/num-and-denom-helper.lisp
+./arithmetic-5/support/inequalities.lisp
+./arithmetic-5/support/expt-helper.lisp
+./arithmetic-5/support/basic-arithmetic.lisp
+./arithmetic-5/support/expt.lisp
+./arithmetic-5/support/non-linear.lisp
+./add-ons/hash-stobjs.lisp
+./defsort/defsort.lisp
+./defsort/remove-dups.lisp
+./defsort/duplicated-members.lisp
+./defsort/uniquep.lisp
+./defsort/generic.lisp
+./defsort/examples.lisp
+./models/y86/y86-basic/common/operations.lisp
+./models/y86/y86-basic/common/read-over-write-proofs.lisp
+./models/y86/y86-basic/common/read-over-write.lisp
+./models/y86/y86-basic/common/constants.lisp
+./models/y86/y86-basic/common/misc-events.lisp
+./models/y86/y86-basic/common/x86-state.lisp
+./models/y86/y86-basic/y86/y86-asm.lisp
+./models/y86/y86-basic/y86/y86-mem-init.lisp
+./models/y86/y86-basic/y86/y86.lisp
+./models/y86/y86-basic/py86/py86.lisp
+./models/y86/y86-basic/py86/popcount.lisp
+./models/y86/y86-basic/py86/py86-state.lisp
+./models/y86/y86-basic/py86/py86-mem-init.lisp
+./models/y86/y86-basic/py86/fib.lisp
+./models/y86/y86-two-level/common/operations.lisp
+./models/y86/y86-two-level/common/arithmetic-5++.lisp
+./models/y86/y86-two-level/common/constants.lisp
+./models/y86/y86-two-level/common/misc-events.lisp
+./models/y86/y86-two-level/common/x86-state.lisp
+./models/y86/y86-two-level/common/x86-memory-low.lisp
+./models/y86/y86-two-level/y86/y86-asm.lisp
+./models/y86/y86-two-level/y86/y86-mem-init.lisp
+./models/y86/y86-two-level/y86/y86.lisp
+./models/y86/y86-two-level-abs/common/operations.lisp
+./models/y86/y86-two-level-abs/common/x86-state-concrete.lisp
+./models/y86/y86-two-level-abs/common/arithmetic-5++.lisp
+./models/y86/y86-two-level-abs/common/constants.lisp
+./models/y86/y86-two-level-abs/common/misc-events.lisp
+./models/y86/y86-two-level-abs/common/x86-memory.lisp
+./models/y86/y86-two-level-abs/common/x86-state.lisp
+./models/y86/y86-two-level-abs/common/x86-memory-high.lisp
+./models/y86/y86-two-level-abs/common/x86-state-defabsstobj.lisp
+./models/y86/y86-two-level-abs/common/x86-memory-low.lisp
+./models/y86/y86-two-level-abs/examples/popcount-demo.lisp
+./models/y86/y86-two-level-abs/examples/popcount.lisp
+./models/y86/y86-two-level-abs/y86/y86-asm.lisp
+./models/y86/y86-two-level-abs/y86/y86-mem-init.lisp
+./models/y86/y86-two-level-abs/y86/y86.lisp
+./models/jvm/m1/even-solution-2.lisp
+./models/jvm/m1/m1-with-stobj.lisp
+./models/jvm/m1/alternating-sum-variant.lisp
+./models/jvm/m1/theorems-a-and-b.lisp
+./models/jvm/m1/lessp.lisp
+./models/jvm/m1/low-seven.lisp
+./models/jvm/m1/defsys.lisp
+./models/jvm/m1/find-k!.lisp
+./models/jvm/m1/magic.lisp
+./models/jvm/m1/alternating-sum.lisp
+./models/jvm/m1/template.lisp
+./models/jvm/m1/m1-half-via-inductive-assertions.lisp
+./models/jvm/m1/sumsq.lisp
+./models/jvm/m1/wormhole-abstraction.lisp
+./models/jvm/m1/defsys-utilities.lisp
+./models/jvm/m1/div.lisp
+./models/jvm/m1/m1-with-stobj-clock-example.lisp
+./models/jvm/m1/even-solution-1.lisp
+./models/jvm/m1/m1-fact-on-neg-runs-forever.lisp
+./models/jvm/m1/sum.lisp
+./models/jvm/m1/tmi-reductions.lisp
+./models/jvm/m1/fact.lisp
+./models/jvm/m1/bexpt.lisp
+./models/jvm/m1/sign.lisp
+./models/jvm/m1/expt.lisp
+./models/jvm/m1/implementation.lisp
+./models/jvm/m1/power.lisp
+./models/jvm/m1/fib.lisp
+./models/jvm/m1/m1.lisp
+./models/jvm/m1/funny-fact.lisp
+./models/jvm/m5/utilities.lisp
+./models/jvm/m5/apprentice.lisp
+./models/jvm/m5/idemo.lisp
+./models/jvm/m5/universal.lisp
+./models/jvm/m5/infinite-fair-schedule.lisp
+./models/jvm/m5/m5.lisp
+./models/jvm/m5/partial.lisp
+./models/jvm/m5/jvm-fact-setup.lisp
+./models/jvm/m5/isort.lisp
+./models/jvm/m5/perm.lisp
+./models/jvm/m5/apprentice-state.lisp
+./models/jvm/m5/demo.lisp
+./models/jvm/m5/universal-never-returns.lisp
+./models/jvm/m1-original/m1-story.lisp
+./models/jvm/m1-original/problem-set-1-answers.lisp
+./models/jvm/guard-verified-m1/good-statep.lisp
+./models/jvm/guard-verified-m1/even-solution-2.lisp
+./models/jvm/guard-verified-m1/alternating-sum-variant.lisp
+./models/jvm/guard-verified-m1/theorems-a-and-b.lisp
+./models/jvm/guard-verified-m1/lessp.lisp
+./models/jvm/guard-verified-m1/low-seven.lisp
+./models/jvm/guard-verified-m1/defsys.lisp
+./models/jvm/guard-verified-m1/find-k!.lisp
+./models/jvm/guard-verified-m1/magic.lisp
+./models/jvm/guard-verified-m1/alternating-sum.lisp
+./models/jvm/guard-verified-m1/template.lisp
+./models/jvm/guard-verified-m1/sumsq.lisp
+./models/jvm/guard-verified-m1/wormhole-abstraction.lisp
+./models/jvm/guard-verified-m1/defsys-utilities.lisp
+./models/jvm/guard-verified-m1/div.lisp
+./models/jvm/guard-verified-m1/use-when.lisp
+./models/jvm/guard-verified-m1/even-solution-1.lisp
+./models/jvm/guard-verified-m1/sum.lisp
+./models/jvm/guard-verified-m1/tmi-reductions.lisp
+./models/jvm/guard-verified-m1/fact.lisp
+./models/jvm/guard-verified-m1/bexpt.lisp
+./models/jvm/guard-verified-m1/verify-guards.lisp
+./models/jvm/guard-verified-m1/sign.lisp
+./models/jvm/guard-verified-m1/expt.lisp
+./models/jvm/guard-verified-m1/implementation.lisp
+./models/jvm/guard-verified-m1/power.lisp
+./models/jvm/guard-verified-m1/fib.lisp
+./models/jvm/guard-verified-m1/m1.lisp
+./models/jvm/guard-verified-m1/funny-fact.lisp
+./textbook/chap4/solutions-program-mode.lisp
+./textbook/chap4/solutions-logic-mode.lisp
+./textbook/chap10/tree.lisp
+./textbook/chap10/ac-example.lisp
+./textbook/chap10/adder.lisp
+./textbook/chap10/insertion-sort.lisp
+./textbook/chap10/fact.lisp
+./textbook/chap10/compiler.lisp
+./textbook/chap11/xtr2.lisp
+./textbook/chap11/qsort.lisp
+./textbook/chap11/starters.lisp
+./textbook/chap11/xtr.lisp
+./textbook/chap11/finite-sets.lisp
+./textbook/chap11/how-many-soln2.lisp
+./textbook/chap11/perm-append.lisp
+./textbook/chap11/summations-book.lisp
+./textbook/chap11/compress.lisp
+./textbook/chap11/mergesort.lisp
+./textbook/chap11/summations.lisp
+./textbook/chap11/encap.lisp
+./textbook/chap11/tautology.lisp
+./textbook/chap11/how-many-soln1.lisp
+./textbook/chap11/perm.lisp
+./textbook/chap5/solutions.lisp
+./textbook/chap6/selected-solutions.lisp
+./textbook/chap3/programs.lisp
+./arithmetic-3/bind-free/banner.lisp
+./arithmetic-3/bind-free/remove-weak-inequalities.lisp
+./arithmetic-3/bind-free/mini-theories.lisp
+./arithmetic-3/bind-free/common.lisp
+./arithmetic-3/bind-free/top.lisp
+./arithmetic-3/bind-free/simplify.lisp
+./arithmetic-3/bind-free/numerator-and-denominator.lisp
+./arithmetic-3/bind-free/basic-helper.lisp
+./arithmetic-3/bind-free/normalize.lisp
+./arithmetic-3/bind-free/integerp.lisp
+./arithmetic-3/bind-free/arithmetic-theory.lisp
+./arithmetic-3/bind-free/simplify-helper.lisp
+./arithmetic-3/bind-free/mini-theories-helper.lisp
+./arithmetic-3/bind-free/basic.lisp
+./arithmetic-3/bind-free/building-blocks.lisp
+./arithmetic-3/bind-free/default-hint.lisp
+./arithmetic-3/bind-free/collect.lisp
+./arithmetic-3/bind-free/integerp-meta.lisp
+./arithmetic-3/top.lisp
+./arithmetic-3/floor-mod/floor-mod.lisp
+./arithmetic-3/floor-mod/mod-expt-fast.lisp
+./arithmetic-3/pass1/mini-theories.lisp
+./arithmetic-3/pass1/top.lisp
+./arithmetic-3/pass1/prefer-times.lisp
+./arithmetic-3/pass1/basic-arithmetic-helper.lisp
+./arithmetic-3/pass1/numerator-and-denominator.lisp
+./arithmetic-3/pass1/num-and-denom-helper.lisp
+./arithmetic-3/pass1/inequalities.lisp
+./arithmetic-3/pass1/expt-helper.lisp
+./arithmetic-3/pass1/basic-arithmetic.lisp
+./arithmetic-3/pass1/expt.lisp
+./arithmetic-3/pass1/non-linear.lisp
+./arithmetic-3/extra/ext.lisp
+./arithmetic-3/extra/top-ext.lisp
+./arithmetic-3/extra/ext-compat.lisp
+./nonstd/arc-length/length-of-a-rectifiable-curve.lisp
+./nonstd/nsa/continuity.lisp
+./nonstd/nsa/overspill.lisp
+./nonstd/nsa/alternating-series.lisp
+./nonstd/nsa/equivalence-derivatives.lisp
+./nonstd/nsa/exp-sum.lisp
+./nonstd/nsa/sqrt.lisp
+./nonstd/nsa/inverses.lisp
+./nonstd/nsa/inner-sums.lisp
+./nonstd/nsa/overspill-test.lisp
+./nonstd/nsa/ln.lisp
+./nonstd/nsa/derivatives.lisp
+./nonstd/nsa/next-integer.lisp
+./nonstd/nsa/sqrt-iter.lisp
+./nonstd/nsa/factorial.lisp
+./nonstd/nsa/trig.lisp
+./nonstd/nsa/chain-rule.lisp
+./nonstd/nsa/nsa.lisp
+./nonstd/nsa/inverse-trig.lisp
+./nonstd/nsa/intervals.lisp
+./nonstd/nsa/trig-approx.lisp
+./nonstd/nsa/norm.lisp
+./nonstd/nsa/equivalence-continuity.lisp
+./nonstd/nsa/raise.lisp
+./nonstd/nsa/overspill-proof.lisp
+./nonstd/nsa/inverse-derivatives.lisp
+./nonstd/nsa/exp.lisp
+./nonstd/nsa/inverse-monotone.lisp
+./nonstd/nsa/sqrt-2.lisp
+./nonstd/nsa/derivatives-composition.lisp
+./nonstd/nsa/equivalence-derivatives-composition.lisp
+./nonstd/nsa/inverse-square.lisp
+./nonstd/nsa/continuity-product.lisp
+./nonstd/nsa/equivalence-limits.lisp
+./nonstd/nsa/complex-polar.lisp
+./nonstd/nsa/exp-continuous.lisp
+./nonstd/nsa/sine.lisp
+./nonstd/nsa/derivative-raise.lisp
+./nonstd/transcendentals/nested-intervals-revised.lisp
+./nonstd/transcendentals/nested-intervals.lisp
+./nonstd/transcendentals/reals-are-uncountable-2.lisp
+./nonstd/transcendentals/reals-are-uncountable-1.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/product-composition.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/defderivative.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/inverse-trig-ex.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/ln-derivative-real.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/chain-composition.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/inverse-trig-derivatives.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/nsa-ex.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/exp-properties.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/sqrt-derivative.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/differentiator.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/composition-elem.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/sin-cos-minimal.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/exp-minimal.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/composition-helpers.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/abs-derivative.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/inverse-square.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/inverse-derivative.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/inverse-composition.lisp
+./nonstd/workshops/2011/reid-gamboa-differentiator/support/sum-composition.lisp
+./nonstd/workshops/2017/cayley/cayley2.lisp
+./nonstd/workshops/2017/cayley/cayley1d.lisp
+./nonstd/workshops/2017/cayley/cayley1c.lisp
+./nonstd/workshops/2017/cayley/cayley5a.lisp
+./nonstd/workshops/2017/cayley/cayley5.lisp
+./nonstd/workshops/2017/cayley/cayley2a.lisp
+./nonstd/workshops/2017/cayley/cayley1b.lisp
+./nonstd/workshops/2017/cayley/cayley4.lisp
+./nonstd/workshops/2017/cayley/cayley1.lisp
+./nonstd/workshops/2017/cayley/cayley3.lisp
+./nonstd/workshops/2017/cayley/cayley1a.lisp
+./nonstd/workshops/2017/cayley/cayley4a.lisp
+./nonstd/workshops/2017/cayley/cayley3a.lisp
+./nonstd/workshops/2013/helms-gamboa-quantum/support/quantum.lisp
+./nonstd/workshops/1999/analysis/continuity.lisp
+./nonstd/workshops/1999/analysis/exercise8.lisp
+./nonstd/workshops/1999/analysis/derivatives.lisp
+./nonstd/workshops/1999/analysis/exercise7.lisp
+./nonstd/workshops/1999/analysis/exercise1.lisp
+./nonstd/workshops/1999/analysis/exercise3.lisp
+./nonstd/workshops/1999/analysis/exercise5.lisp
+./nonstd/workshops/1999/analysis/exercise6.lisp
+./nonstd/workshops/1999/analysis/exercise2.lisp
+./nonstd/workshops/1999/analysis/exercise4.lisp
+./nonstd/workshops/1999/calculus/solutions/mesh-make-partition.lisp
+./nonstd/workshops/1999/calculus/solutions/partition-defuns.lisp
+./nonstd/workshops/1999/calculus/solutions/partitionp-make-partition.lisp
+./nonstd/workshops/1999/calculus/solutions/partitionp-make-partition-rec.lisp
+./nonstd/workshops/1999/calculus/solutions/mesh-append.lisp
+./nonstd/workshops/1999/calculus/solutions/riemann-rcfn-helpers.lisp
+./nonstd/workshops/1999/calculus/book/nsa-lemmas.lisp
+./nonstd/workshops/1999/calculus/book/ftoc-lemma.lisp
+./nonstd/workshops/1999/calculus/book/riemann-sum-approximates-integral.lisp
+./nonstd/workshops/1999/calculus/book/defaxioms.lisp
+./nonstd/workshops/1999/calculus/book/min-max-x-rec-lemmas.lisp
+./nonstd/workshops/1999/calculus/book/equal-riemann-rcfn-refinement-reduction.lisp
+./nonstd/workshops/1999/calculus/book/riemann-lemmas.lisp
+./nonstd/workshops/1999/calculus/book/standard-part-preserves-between.lisp
+./nonstd/workshops/1999/calculus/book/between-limited-implies-limited.lisp
+./nonstd/workshops/1999/calculus/book/fundamental-theorem-of-calculus.lisp
+./nonstd/workshops/1999/calculus/book/riemann-rcfn-refinement-is-riemann-rcfn.lisp
+./nonstd/workshops/1999/calculus/book/make-partition.lisp
+./nonstd/workshops/1999/calculus/book/riemann-sum-approximates-integral-2.lisp
+./nonstd/workshops/1999/calculus/book/riemann-bound.lisp
+./nonstd/workshops/1999/calculus/book/riemann-rcfn-lower-bound.lisp
+./nonstd/workshops/1999/calculus/book/i-limited-rcfn.lisp
+./nonstd/workshops/1999/calculus/book/integral-rcfn-quotient-between-non-classical.lisp
+./nonstd/workshops/1999/calculus/book/between-i-close-implies-i-close.lisp
+./nonstd/workshops/1999/calculus/book/refinement-makes-i-small-change-1.lisp
+./nonstd/workshops/1999/calculus/book/nsa.lisp
+./nonstd/workshops/1999/calculus/book/two-times-r-is-not-less-than-standard-part.lisp
+./nonstd/workshops/1999/calculus/book/integral-rcfn-lemmas.lisp
+./nonstd/workshops/1999/calculus/book/next-gte-close.lisp
+./nonstd/workshops/1999/calculus/book/proof-outline.lisp
+./nonstd/workshops/1999/calculus/book/riemann-rcfn-upper-bound.lisp
+./nonstd/workshops/1999/calculus/book/standard-part-equal-if-i-close.lisp
+./nonstd/workshops/1999/calculus/book/rcfn-next-gte-close.lisp
+./nonstd/workshops/1999/calculus/book/max-and-min-attained.lisp
+./nonstd/workshops/1999/calculus/book/split-integral-by-subintervals.lisp
+./nonstd/workshops/1999/calculus/book/riemann-defuns.lisp
+./nonstd/workshops/1999/calculus/book/i-close-implies-abs-difference-small.lisp
+./nonstd/workshops/1999/calculus/book/i-small-maxlist-abslist-difflist-maps.lisp
+./nonstd/workshops/1999/calculus/book/min-x-and-max-x-lemmas.lisp
+./nonstd/workshops/1999/calculus/book/refinement-makes-i-small-change.lisp
+./nonstd/workshops/1999/calculus/book/standard-part-riemann-rcfn-is-standard.lisp
+./nonstd/workshops/1999/calculus/book/map-rcfn-close-to-map-rcfn-refinement.lisp
+./nonstd/workshops/1999/calculus/book/partitions-give-i-close-riemann-sum.lisp
+./nonstd/workshops/1999/calculus/book/min-x-between.lisp
+./nonstd/workshops/1999/calculus/book/top-with-meta.lisp
+./nonstd/workshops/1999/calculus/book/rcfn-standard-part.lisp
+./nonstd/workshops/1999/calculus/book/riemann-rcfn-between.lisp
+./nonstd/workshops/1999/calculus/book/integral-rcfn.lisp
+./nonstd/workshops/1999/calculus/book/max-x-between.lisp
+./nonstd/workshops/1999/calculus/book/map-rcfn-refinement-cdr-co-member.lisp
+./nonstd/workshops/1999/calculus/book/maxlist-abslist-difflist-maps-lt.lisp
+./nonstd/workshops/1999/calculus/book/integral-rcfn-equal-if-i-close.lisp
+./nonstd/workshops/1999/calculus/book/riemann.lisp
+./nonstd/workshops/1999/calculus/book/riemann-sum-approximates-integral-1.lisp
+./nonstd/fft/eval-poly.lisp
+./nonstd/fft/fft-trig.lisp
+./nonstd/fft/fft-omega.lisp
+./nonstd/fft/fft-trig-with-axioms.lisp
+./nonstd/circles/area-of-a-circle/area-of-a-circle-1.lisp
+./nonstd/circles/area-of-a-circle/area-of-a-circle-2.lisp
+./nonstd/circles/circumference-of-a-circle.lisp
+./nonstd/polynomials/polynomial-defuns.lisp
+./nonstd/polynomials/polynomial-lemmas.lisp
+./nonstd/polynomials/polynomial-calculus.lisp
+./nonstd/integrals/ftc-1.lisp
+./nonstd/integrals/make-partition.lisp
+./nonstd/integrals/integration-composition-equivalences.lisp
+./nonstd/integrals/continuous-function.lisp
+./nonstd/integrals/equivalence-continuous-function.lisp
+./nonstd/integrals/equivalence-ftc.lisp
+./nonstd/integrals/integrable-functions.lisp
+./nonstd/integrals/split-integral-by-subintervals.lisp
+./nonstd/integrals/ftc-2.lisp
+./nonstd/integrals/equivalence-integrals.lisp
+./nonstd/integrals/u-substitution.lisp
+./nonstd/integrals/integration-composition.lisp
+./nonstd/integrals/integral-of-polynomials.lisp
+./cowles/acl2-agp.lisp
+./cowles/acl2-crg.lisp
+./cowles/portcullis.lisp
+./cowles/acl2-asg.lisp
+./proofstyles/counterexamples/halt-flg.lisp
+./proofstyles/counterexamples/memory-clearing.lisp
+./proofstyles/counterexamples/realistic.lisp
+./proofstyles/completeness/clock-partial.lisp
+./proofstyles/completeness/stepwise-invariants-total.lisp
+./proofstyles/completeness/assertions-partial.lisp
+./proofstyles/completeness/assertions-total.lisp
+./proofstyles/completeness/generic-total.lisp
+./proofstyles/completeness/generic-partial.lisp
+./proofstyles/completeness/clock-total.lisp
+./proofstyles/completeness/stepwise-invariants-partial.lisp
+./proofstyles/soundness/clock-partial.lisp
+./proofstyles/soundness/stepwise-invariants-total.lisp
+./proofstyles/soundness/assertions-partial.lisp
+./proofstyles/soundness/assertions-total.lisp
+./proofstyles/soundness/clock-total.lisp
+./proofstyles/soundness/stepwise-invariants-partial.lisp
+./proofstyles/invclock/c2i/clock-to-inv.lisp
+./proofstyles/invclock/c2i/c2i-partial.lisp
+./proofstyles/invclock/c2i/c2i-total.lisp
+./proofstyles/invclock/compose/compose-c-c-partial.lisp
+./proofstyles/invclock/compose/compose-c-c-total.lisp
+./proofstyles/invclock/i2c/i2c-total.lisp
+./proofstyles/invclock/i2c/inv-to-clock.lisp
+./proofstyles/invclock/i2c/i2c-partial.lisp
+./meta/term-lemmas.lisp
+./meta/meta.lisp
+./meta/pseudo-termp-lemmas.lisp
+./meta/meta-times-equal.lisp
+./meta/meta-plus-lessp.lisp
+./meta/meta-plus-equal.lisp
+./meta/term-defuns.lisp
+./hints/merge-hint.lisp
+./hints/basic-tests.lisp
+./hints/huet-lang-algorithm-tests.lisp
+./hints/subgoalp.lisp
+./hints/consider-hint-tests.lisp
+./hints/huet-lang-algorithm.lisp
+./hints/use-pkg.lisp
+./hints/hint-wrapper.lisp
+./hints/consider-hint.lisp
+./tools/include-raw.lisp
+./tools/clone-stobj.lisp
+./tools/flag-tests.lisp
+./tools/deftuple.lisp
+./tools/prettygoals/top.lisp
+./tools/prettygoals/portcullis.lisp
+./tools/templates.lisp
+./tools/fake-event.lisp
+./tools/pattern-match.lisp
+./tools/types-misc.lisp
+./tools/flag.lisp
+./tools/remove-hyps.lisp
+./tools/case-splitting-rules.lisp
+./tools/with-arith5-help.lisp
+./tools/defevaluator-fast.lisp
+./tools/oracle-eval-real.lisp
+./tools/with-supporters-test-sub.lisp
+./tools/untranslate-for-exec-tests.lisp
+./tools/prove-dollar.lisp
+./tools/plev-ccl.lisp
+./tools/without-subsumption.lisp
+./tools/removable-runes.lisp
+./tools/match-tree.lisp
+./tools/defmacfun.lisp
+./tools/theory-tools.lisp
+./tools/in-raw-mode.lisp
+./tools/memoize-prover-fns.lisp
+./tools/rulesets.lisp
+./tools/prove-dollar-tests.lisp
+./tools/defined-const.lisp
+./tools/def-functional-instance.lisp
+./tools/do-not.lisp
+./tools/rewrite-dollar.lisp
+./tools/mv-nth.lisp
+./tools/book-conflicts/bookdata-types.lisp
+./tools/book-conflicts/conflicts.lisp
+./tools/oracle-eval.lisp
+./tools/oracle-timelimit-tests.lisp
+./tools/oracle-timelimit.lisp
+./tools/saved-errors.lisp
+./tools/er-soft-logic.lisp
+./tools/with-quoted-forms.lisp
+./tools/oracle-time-tests.lisp
+./tools/defthmg.lisp
+./tools/rewrite-dollar-book.lisp
+./tools/with-supporters.lisp
+./tools/include-an-arithmetic-book.lisp
+./tools/table-replay.lisp
+./tools/with-supporters-test-top.lisp
+./tools/with-arith1-help.lisp
+./tools/trivial-ancestors-check.lisp
+./tools/some-events.lisp
+./tools/plev.lisp
+./tools/last-theory-change.lisp
+./tools/oracle-time.lisp
+./tools/safe-case.lisp
+./tools/time-dollar-with-gc.lisp
+./tools/dead-events.lisp
+./tools/define-keyed-function.lisp
+./tools/bstar.lisp
+./tools/defttag-muffled.lisp
+./tools/run-script.lisp
+./tools/save-obligs.lisp
+./tools/rewrite-with-equality.lisp
+./tools/lint.lisp
+./tools/stobj-help.lisp
+./tools/symlet.lisp
+./tools/defsum.lisp
+./tools/nld.lisp
+./tools/stobj-frame.lisp
+./tools/easy-simplify.lisp
+./tools/untranslate-for-exec.lisp
+./tools/equality-with-hons-copy.lisp
+./tools/with-arith-help.lisp
+./tools/open-trace-file-bang.lisp
+./tools/advise.lisp
+./tools/k-induction.lisp
+./tools/cws.lisp
+./sorting/bsort.lisp
+./sorting/term-ordered-perms.lisp
+./sorting/sorts-equivalent2.lisp
+./sorting/qsort.lisp
+./sorting/orderedp.lisp
+./sorting/sorts-equivalent.lisp
+./sorting/convert-perm-to-how-many.lisp
+./sorting/ordered-perms.lisp
+./sorting/merge-sort-term-order.lisp
+./sorting/no-dups-qsort.lisp
+./sorting/msort.lisp
+./sorting/equisort.lisp
+./sorting/equisort2.lisp
+./sorting/isort.lisp
+./sorting/perm.lisp
+./sorting/equisort3.lisp
+./sorting/how-many.lisp
+./sorting/sorts-equivalent3.lisp
+./std/stobjs/bitarr.lisp
+./std/stobjs/1d-arr.lisp
+./std/stobjs/top.lisp
+./std/stobjs/2d-arr.lisp
+./std/stobjs/tests/1d-arr.lisp
+./std/stobjs/tests/2d-arr.lisp
+./std/stobjs/tests/clone.lisp
+./std/stobjs/updater-independence.lisp
+./std/stobjs/absstobjs.lisp
+./std/stobjs/natarr.lisp
+./std/stobjs/nicestobj.lisp
+./std/stobjs/nested-stobjs.lisp
+./std/stobjs/clone.lisp
+./std/bitsets/bitsets.lisp
+./std/bitsets/bits-between.lisp
+./std/bitsets/top.lisp
+./std/bitsets/bignum-extract.lisp
+./std/bitsets/bignum-extract-opt-tests.lisp
+./std/bitsets/sbitsets-tests.lisp
+./std/bitsets/bitsets-opt.lisp
+./std/bitsets/bitsets-tests.lisp
+./std/bitsets/sbitsets.lisp
+./std/bitsets/bignum-extract-opt.lisp
+./std/lists/intersectp.lisp
+./std/lists/true-listp.lisp
+./std/lists/resize-list.lisp
+./std/lists/list-defuns.lisp
+./std/lists/rev.lisp
+./std/lists/top.lisp
+./std/lists/acl2-count.lisp
+./std/lists/revappend.lisp
+./std/lists/mfc-utils.lisp
+./std/lists/intersection.lisp
+./std/lists/remove1-equal.lisp
+./std/lists/flatten.lisp
+./std/lists/same-lengthp.lisp
+./std/lists/update-nth.lisp
+./std/lists/all-equalp.lisp
+./std/lists/remove-duplicates.lisp
+./std/lists/sublistp.lisp
+./std/lists/append.lisp
+./std/lists/nthcdr.lisp
+./std/lists/bits-equiv.lisp
+./std/lists/repeat.lisp
+./std/lists/last.lisp
+./std/lists/no-duplicatesp.lisp
+./std/lists/abstract.lisp
+./std/lists/sets.lisp
+./std/lists/nats-equiv.lisp
+./std/lists/rcons.lisp
+./std/lists/set-difference.lisp
+./std/lists/len.lisp
+./std/lists/butlast.lisp
+./std/lists/reverse.lisp
+./std/lists/equiv.lisp
+./std/lists/index-of.lisp
+./std/lists/list-fix.lisp
+./std/lists/prefixp.lisp
+./std/lists/final-cdr.lisp
+./std/lists/union.lisp
+./std/lists/take.lisp
+./std/lists/subseq.lisp
+./std/lists/duplicity.lisp
+./std/lists/suffixp.lisp
+./std/lists/nth.lisp
+./std/lists/remove.lisp
+./std/top.lisp
+./std/system/top.lisp
+./std/system/acceptable-rewrite-rule-p.lisp
+./std/system/irrelevant-formals.lisp
+./std/system/irrelevant-formals-book.lisp
+./std/system/non-parallel-book.lisp
+./std/system/invariant-risk.lisp
+./std/basic/defs.lisp
+./std/basic/arith-equivs.lisp
+./std/basic/top.lisp
+./std/basic/inductions.lisp
+./std/basic/symbol-name-lst.lisp
+./std/basic/two-nats-measure.lisp
+./std/basic/bytep.lisp
+./std/basic/nibblep.lisp
+./std/basic/arith-equiv-defs.lisp
+./std/basic/intern-in-package-of-symbol.lisp
+./std/basic/pos-fix.lisp
+./std/obags/top.lisp
+./std/obags/core.lisp
+./std/obags/tests.lisp
+./std/obags/portcullis.lisp
+./std/obags/with-fixing-theorems.lisp
+./std/typed-alists/top.lisp
+./std/typed-alists/symbol-string-alistp-tests.lisp
+./std/typed-alists/symbol-symbollist-alistp.lisp
+./std/typed-alists/string-string-alistp-tests.lisp
+./std/typed-alists/symbol-nat-alistp-tests.lisp
+./std/typed-alists/cons-pos-alistp-tests.lisp
+./std/typed-alists/symbol-symbol-alistp-tests.lisp
+./std/typed-alists/symbol-nat-alistp.lisp
+./std/typed-alists/symbol-string-alistp.lisp
+./std/typed-alists/keyword-symbol-alistp-tests.lisp
+./std/typed-alists/cons-pos-alistp.lisp
+./std/typed-alists/keyword-symbol-alistp.lisp
+./std/typed-alists/keyword-to-keyword-value-list-alistp-tests.lisp
+./std/typed-alists/keyword-truelist-alistp.lisp
+./std/typed-alists/string-symbollist-alistp.lisp
+./std/typed-alists/symbol-pseudoterm-alistp.lisp
+./std/typed-alists/symbol-pseudoterm-alistp-tests.lisp
+./std/typed-alists/string-symbollist-alistp-tests.lisp
+./std/typed-alists/symbol-pos-alistp.lisp
+./std/typed-alists/keyword-to-keyword-value-list-alistp.lisp
+./std/typed-alists/string-string-alistp.lisp
+./std/typed-alists/symbol-symbol-alistp.lisp
+./std/typed-alists/symbol-truelist-alistp-tests.lisp
+./std/typed-alists/symbol-truelist-alistp.lisp
+./std/typed-alists/symbol-pos-alistp-tests.lisp
+./std/portcullis.lisp
+./std/util/returnspecs.lisp
+./std/util/top.lisp
+./std/util/add-io-pairs-tests-sub-2.lisp
+./std/util/support.lisp
+./std/util/generate-symbol.lisp
+./std/util/defredundant-tests.lisp
+./std/util/maybe-defthm.lisp
+./std/util/look-up.lisp
+./std/util/defenum-tests.lisp
+./std/util/defmapappend.lisp
+./std/util/maybe-defthm-tests.lisp
+./std/util/defretgen.lisp
+./std/util/defalist-base.lisp
+./std/util/add-io-pairs-tests-sub-1.lisp
+./std/util/defconsts.lisp
+./std/util/termhints.lisp
+./std/util/defaggregate.lisp
+./std/util/add-io-pairs.lisp
+./std/util/defret-mutual-generate.lisp
+./std/util/define-sk.lisp
+./std/util/deflist-aux.lisp
+./std/util/cons.lisp
+./std/util/define.lisp
+./std/util/def-bound-theorems.lisp
+./std/util/tests/utils.lisp
+./std/util/tests/top.lisp
+./std/util/tests/defmapappend.lisp
+./std/util/tests/defaggregate.lisp
+./std/util/tests/define-sk.lisp
+./std/util/tests/define.lisp
+./std/util/tests/defaggrify-defrec.lisp
+./std/util/tests/defalist.lisp
+./std/util/tests/defrule.lisp
+./std/util/tests/defval.lisp
+./std/util/tests/defprojection.lisp
+./std/util/tests/defredundant.lisp
+./std/util/tests/bstar.lisp
+./std/util/tests/defines.lisp
+./std/util/tests/deflist.lisp
+./std/util/defaggrify-defrec.lisp
+./std/util/look-up-tests.lisp
+./std/util/defalist.lisp
+./std/util/defrule.lisp
+./std/util/defval.lisp
+./std/util/defmvtypes.lisp
+./std/util/defprojection.lisp
+./std/util/defredundant.lisp
+./std/util/bstar.lisp
+./std/util/deflist-base.lisp
+./std/util/wizard.lisp
+./std/util/formals-tests.lisp
+./std/util/add-io-pairs-tests.lisp
+./std/util/defines.lisp
+./std/util/defenum.lisp
+./std/util/defsum.lisp
+./std/util/deflist.lisp
+./std/util/extensions/assert-return-thms.lisp
+./std/util/da-base.lisp
+./std/util/add-io-pairs-tests-sub.lisp
+./std/util/defmvtypes-tests.lisp
+./std/util/returnspecs-tests.lisp
+./std/util/formals.lisp
+./std/io/base.lisp
+./std/io/top.lisp
+./std/io/read-file-bytes.lisp
+./std/io/unsound-read.lisp
+./std/io/serialize-tests2.lisp
+./std/io/read-file-characters-no-error.lisp
+./std/io/serialize-tests.lisp
+./std/io/read-file-characters.lisp
+./std/io/take-bytes.lisp
+./std/io/file-measure.lisp
+./std/io/nthcdr-bytes.lisp
+./std/io/read-file-lines-no-newlines.lisp
+./std/io/open-channels.lisp
+./std/io/read-string.lisp
+./std/io/read-file-objects.lisp
+./std/io/read-string-tests.lisp
+./std/io/read-file-lines.lisp
+./std/io/read-ints.lisp
+./std/io/combine.lisp
+./std/io/print-objects.lisp
+./std/osets/cardinality.lisp
+./std/osets/sort.lisp
+./std/osets/computed-hints.lisp
+./std/osets/element-list.lisp
+./std/osets/difference.lisp
+./std/osets/top.lisp
+./std/osets/primitives.lisp
+./std/osets/quantify.lisp
+./std/osets/intersect.lisp
+./std/osets/outer.lisp
+./std/osets/delete.lisp
+./std/osets/map-tests.lisp
+./std/osets/under-set-equiv.lisp
+./std/osets/membership.lisp
+./std/osets/map.lisp
+./std/osets/quantify-tests.lisp
+./std/osets/union.lisp
+./std/osets/instance.lisp
+./std/misc/two-nats-measure.lisp
+./std/misc/intern-in-package-of-symbol.lisp
+./std/strings/defs.lisp
+./std/strings/ieqv.lisp
+./std/strings/pretty-defs.lisp
+./std/strings/url-encode.lisp
+./std/strings/stringify.lisp
+./std/strings/top.lisp
+./std/strings/url-encode-tests.lisp
+./std/strings/iless.lisp
+./std/strings/istrprefixp.lisp
+./std/strings/printtree-fix.lisp
+./std/strings/char-case.lisp
+./std/strings/charset-fns.lisp
+./std/strings/stringless.lisp
+./std/strings/decimal.lisp
+./std/strings/substrp.lisp
+./std/strings/pretty.lisp
+./std/strings/pad.lisp
+./std/strings/explode-nonnegative-integer.lisp
+./std/strings/hex-tests.lisp
+./std/strings/coerce.lisp
+./std/strings/binary.lisp
+./std/strings/strrpos.lisp
+./std/strings/octal-tests.lisp
+./std/strings/isubstrp.lisp
+./std/strings/char-fix.lisp
+./std/strings/strsplit-tests.lisp
+./std/strings/arithmetic.lisp
+./std/strings/strnatless.lisp
+./std/strings/octal.lisp
+./std/strings/hexify.lisp
+./std/strings/abbrevs.lisp
+./std/strings/strtok.lisp
+./std/strings/html-encode.lisp
+./std/strings/strsubst.lisp
+./std/strings/cat-base.lisp
+./std/strings/fast-cat.lisp
+./std/strings/pretty-program.lisp
+./std/strings/binary-tests.lisp
+./std/strings/defs-program.lisp
+./std/strings/pretty-defs-aux.lisp
+./std/strings/suffixp-tests.lisp
+./std/strings/strsubst-tests.lisp
+./std/strings/strpos.lisp
+./std/strings/charset.lisp
+./std/strings/strsplit.lisp
+./std/strings/base64.lisp
+./std/strings/strline-tests.lisp
+./std/strings/eqv.lisp
+./std/strings/case-conversion.lisp
+./std/strings/printtree.lisp
+./std/strings/strtok-tests.lisp
+./std/strings/base64-tests.lisp
+./std/strings/make-character-list.lisp
+./std/strings/digit-to-char.lisp
+./std/strings/explode-atom.lisp
+./std/strings/printtree-concat.lisp
+./std/strings/prefix-lines.lisp
+./std/strings/decimal-tests.lisp
+./std/strings/iprefixp.lisp
+./std/strings/istrpos.lisp
+./std/strings/symbols.lisp
+./std/strings/defs-aux.lisp
+./std/strings/isort.lisp
+./std/strings/cat.lisp
+./std/strings/hex.lisp
+./std/strings/firstn-chars.lisp
+./std/strings/strrange-equiv.lisp
+./std/strings/printtree-fty.lisp
+./std/strings/strline.lisp
+./std/strings/subseq.lisp
+./std/strings/suffixp.lisp
+./std/strings/pretty-tests.lisp
+./std/strings/strprefixp.lisp
+./std/alists/worth-hashing.lisp
+./std/alists/fal-extract-vals.lisp
+./std/alists/alist-defuns.lisp
+./std/alists/alist-equiv.lisp
+./std/alists/alist-fix.lisp
+./std/alists/top.lisp
+./std/alists/remove-assocs.lisp
+./std/alists/fal-all-boundp.lisp
+./std/alists/append-alist-vals.lisp
+./std/alists/fal-find-any.lisp
+./std/alists/fal-extract.lisp
+./std/alists/alist-vals.lisp
+./std/alists/append-alist-keys.lisp
+./std/alists/alist-map-keys.lisp
+./std/alists/hons-remove-assoc.lisp
+./std/alists/alist-map-vals.lisp
+./std/alists/alistp.lisp
+./std/alists/abstract.lisp
+./std/alists/pairlis.lisp
+./std/alists/strip-cdrs.lisp
+./std/alists/hons-assoc-equal.lisp
+./std/alists/strip-cars.lisp
+./std/alists/assoc.lisp
+./std/alists/hons-rassoc-equal.lisp
+./std/alists/remove-assoc-equal.lisp
+./std/alists/alists-compatible.lisp
+./std/alists/alist-keys.lisp
+./std/alists/fast-alist-clean.lisp
+./std/testing/must-fail-with-hard-error.lisp
+./std/testing/must-fail-local.lisp
+./std/testing/top.lisp
+./std/testing/must-be-table-key.lisp
+./std/testing/assert-equal.lisp
+./std/testing/assert-bang-stobj.lisp
+./std/testing/eval.lisp
+./std/testing/must-succeed.lisp
+./std/testing/assert-bang.lisp
+./std/testing/assert-equal-tests.lisp
+./std/testing/must-fail-local-tests.lisp
+./std/testing/must-succeed-star.lisp
+./std/testing/assert-bang-tests.lisp
+./std/testing/must-fail.lisp
+./std/testing/assert-qmark.lisp
+./std/testing/must-fail-tests.lisp
+./std/testing/assert.lisp
+./std/testing/must-prove.lisp
+./std/testing/must-eval-to.lisp
+./std/testing/must-fail-with-soft-error.lisp
+./std/testing/must-eval-to-t.lisp
+./std/testing/must-not-be-table-key.lisp
+./std/testing/must-fail-with-error.lisp
+./std/testing/assert-qmark-tests.lisp
+./std/testing/must-not-prove.lisp
+./std/testing/assert-bang-stobj-tests.lisp
+./std/testing/must-be-redundant.lisp
+./std/testing/must-be-redundant-tests.lisp
+./std/typed-lists/nat-listp.lisp
+./std/typed-lists/eqlable-listp.lisp
+./std/typed-lists/top.lisp
+./std/typed-lists/unsigned-byte-listp.lisp
+./std/typed-lists/cons-listp.lisp
+./std/typed-lists/rational-listp.lisp
+./std/typed-lists/boolean-listp.lisp
+./std/typed-lists/signed-byte-listp.lisp
+./std/typed-lists/integer-listp.lisp
+./std/typed-lists/string-or-symbol-listp.lisp
+./std/typed-lists/string-listp.lisp
+./std/typed-lists/atom-listp.lisp
+./std/typed-lists/symbol-listp.lisp
+./std/typed-lists/portcullis.lisp
+./std/typed-lists/character-listp.lisp
+./std/typed-lists/acl2-number-listp.lisp
+./std/typed-lists/pseudo-term-listp.lisp
+./arithmetic/nat-listp.lisp
+./arithmetic/rationals.lisp
+./arithmetic/realp.lisp
+./arithmetic/top.lisp
+./arithmetic/mod-gcd.lisp
+./arithmetic/factorial.lisp
+./arithmetic/inequalities.lisp
+./arithmetic/rational-listp.lisp
+./arithmetic/idiv.lisp
+./arithmetic/natp-posp.lisp
+./arithmetic/abs.lisp
+./arithmetic/binomial.lisp
+./arithmetic/real-listp.lisp
+./arithmetic/top-with-meta.lisp
+./arithmetic/sumlist.lisp
+./arithmetic/equalities.lisp
+./quicklisp/bordeaux.lisp
+./quicklisp/uiop.lisp
+./quicklisp/bundle/local-projects/fastnumio/write-hex.lisp
+./quicklisp/bundle/local-projects/fastnumio/packages.lisp
+./quicklisp/bundle/local-projects/fastnumio/read-hex.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-ecl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-mkcl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/pkgdcl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/condition-variables.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/bordeaux-threads.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-abcl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-scl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-lispworks.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/default-implementations.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-clisp.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-cmucl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-mcl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-sbcl.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-clozure.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-null.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-corman.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-lispworks-condition-variables.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/src/impl-allegro.lisp
+./quicklisp/bundle/local-projects/bordeaux-threads/test/bordeaux-threads-test.lisp
+./quicklisp/bundle/asdf.lisp
+./quicklisp/bundle/bundle.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/vector.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/list.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/extended-sequence.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/package.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/api.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/tests.lisp
+./quicklisp/bundle/software/split-sequence-v2.0.0/documentation.lisp
+./quicklisp/bundle/software/md5-20180228-git/md5.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/openmcl.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/fad.test.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/temporary-files.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/temporary-files.test.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/packages.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/corman.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/load.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/fad.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/packages.test.lisp
+./quicklisp/bundle/software/cl-fad-20200610-git/path.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/reply.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/session.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/request.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/easy-handlers.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/ssl.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/packages.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/mime-types.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/compat.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/lispworks.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/headers.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/misc.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/set-timeouts.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/acceptor.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/conditions.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/url-rewrite/primitives.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/url-rewrite/packages.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/url-rewrite/url-rewrite.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/url-rewrite/util.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/url-rewrite/specials.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/make-docstrings.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/test/test-handlers.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/test/packages.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/test/script.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/test/script-engine.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/util.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/run-test.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/specials.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/cookie.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/taskmaster.lisp
+./quicklisp/bundle/software/hunchentoot-v1.3.0/log.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-lispworks.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-corman.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-clasp.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-allegro.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-mezzano.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-mkcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-mocl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-sbcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-abcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-openmcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-mcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-ecl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-clisp.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-scl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-xcl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/src/tf-cmucl.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/tests/sysinfo.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/tests/package.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/tests/tests.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/tests/utsname.lisp
+./quicklisp/bundle/software/trivial-features-20200715-git/release.lisp
+./quicklisp/bundle/software/usocket-0.8.3/option.lisp
+./quicklisp/bundle/software/usocket-0.8.3/vendor/OpenTransportUDP.lisp
+./quicklisp/bundle/software/usocket-0.8.3/vendor/kqueue.lisp
+./quicklisp/bundle/software/usocket-0.8.3/package.lisp
+./quicklisp/bundle/software/usocket-0.8.3/server.lisp
+./quicklisp/bundle/software/usocket-0.8.3/usocket.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/mcl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/openmcl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/mezzano.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/mocl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/genera.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/clozure.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/ecl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/abcl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/allegro.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/sbcl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/lispworks.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/cmucl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/clasp.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/clisp.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/iolib.lisp
+./quicklisp/bundle/software/usocket-0.8.3/backend/scl.lisp
+./quicklisp/bundle/software/usocket-0.8.3/condition.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/test-usocket.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/wait-for-input.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/package.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/test-datagram.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/test-condition.lisp
+./quicklisp/bundle/software/usocket-0.8.3/test/udp-one-shot.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/arrays.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/hash-tables.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/numbers.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/control-flow.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/strings.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/io.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/macros.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/functions.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/package.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/types.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/definitions.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/lists.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/binding.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/tests.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/conditions.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/symbols.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/sequences.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-1/features.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/doc/docstrings.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-2/control-flow.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-2/package.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-2/lists.lisp
+./quicklisp/bundle/software/alexandria-20200715-git/alexandria-2/tests.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/utilities.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/mucking.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/backtrace.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/packages.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/map-backtrace.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/dev/fallback.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/test/packages.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/test/tests.lisp
+./quicklisp/bundle/software/trivial-backtrace-20200610-git/test/test-setup.lisp
+./quicklisp/bundle/software/uiop-3.3.4/run-program.lisp
+./quicklisp/bundle/software/uiop-3.3.4/image.lisp
+./quicklisp/bundle/software/uiop-3.3.4/lisp-build.lisp
+./quicklisp/bundle/software/uiop-3.3.4/stream.lisp
+./quicklisp/bundle/software/uiop-3.3.4/backward-driver.lisp
+./quicklisp/bundle/software/uiop-3.3.4/utility.lisp
+./quicklisp/bundle/software/uiop-3.3.4/filesystem.lisp
+./quicklisp/bundle/software/uiop-3.3.4/package.lisp
+./quicklisp/bundle/software/uiop-3.3.4/version.lisp
+./quicklisp/bundle/software/uiop-3.3.4/launch-program.lisp
+./quicklisp/bundle/software/uiop-3.3.4/os.lisp
+./quicklisp/bundle/software/uiop-3.3.4/pathname.lisp
+./quicklisp/bundle/software/uiop-3.3.4/debug.lisp
+./quicklisp/bundle/software/uiop-3.3.4/driver.lisp
+./quicklisp/bundle/software/uiop-3.3.4/common-lisp.lisp
+./quicklisp/bundle/software/uiop-3.3.4/configuration.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/streams.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/package.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/test/test-framework.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/test/package.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/test/test.lisp
+./quicklisp/bundle/software/trivial-gray-streams-20181018-git/test/run-on-many-lisps.lisp
+./quicklisp/bundle/software/cl-base64-20150923-git/encode.lisp
+./quicklisp/bundle/software/cl-base64-20150923-git/decode.lisp
+./quicklisp/bundle/software/cl-base64-20150923-git/package.lisp
+./quicklisp/bundle/software/cl-base64-20150923-git/tests.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-ecl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-mkcl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-mezzano.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/pkgdcl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/condition-variables.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/bordeaux-threads.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-abcl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-scl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-lispworks.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/default-implementations.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-clisp.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-cmucl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-mcl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-sbcl.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-clozure.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-null.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-genera.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-corman.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-lispworks-condition-variables.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-clasp.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/src/impl-allegro.lisp
+./quicklisp/bundle/software/bordeaux-threads-v0.8.8/test/bordeaux-threads-test.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/optimize.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/regex-class.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/convert.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/packages.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/parser.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/cl-ppcre-unicode/packages.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/cl-ppcre-unicode/resolver.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/chartest.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/api.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/scanner.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/charmap.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/charset.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/regex-class-util.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/errors.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/test/packages.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/test/tests.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/test/perl-tests.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/test/unicode-tests.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/util.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/lexer.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/specials.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/closures.lisp
+./quicklisp/bundle/software/cl-ppcre-20190521-git/repetition-closures.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/mapping.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/encode.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/enc-cn-tbl.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/output.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/stream.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/packages.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/strings.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/decode.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/io.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/length.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/external-format.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/ascii.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/code-pages.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/in-memory.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/conditions.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/lw-char-stream.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/test/packages.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/test/test.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/input.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/util.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/koi8-r.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/specials.lisp
+./quicklisp/bundle/software/flexi-streams-20200715-git/iso-8859.lisp
+./quicklisp/bundle/software/osicat-20200715-git/src/fd-streams.lisp
+./quicklisp/bundle/software/osicat-20200715-git/src/packages.lisp
+./quicklisp/bundle/software/osicat-20200715-git/src/osicat.lisp
+./quicklisp/bundle/software/osicat-20200715-git/src/time.lisp
+./quicklisp/bundle/software/osicat-20200715-git/src/osicat-sys.lisp
+./quicklisp/bundle/software/osicat-20200715-git/mach/package.lisp
+./quicklisp/bundle/software/osicat-20200715-git/mach/mach.lisp
+./quicklisp/bundle/software/osicat-20200715-git/windows/windows.lisp
+./quicklisp/bundle/software/osicat-20200715-git/windows/package.lisp
+./quicklisp/bundle/software/osicat-20200715-git/tests/osicat.lisp
+./quicklisp/bundle/software/osicat-20200715-git/tests/tests.lisp
+./quicklisp/bundle/software/osicat-20200715-git/tests/posix.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/wrappers.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/windows.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/linux.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/basic-unixint.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/packages.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/unixint.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/misc.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/basic-unix.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/early.lisp
+./quicklisp/bundle/software/osicat-20200715-git/posix/unix.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/ffi-buffer-clisp.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/reload.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/streams.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/ffi.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/package.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/ffi-buffer.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/x509.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/conditions.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/verify-hostname.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/random.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/ffi-buffer-all.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/bio.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/src/context.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/ssl-verify-test.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/dummy.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/sni.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/run-on-many-lisps-and-openssls/run-on-server.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/run-on-many-lisps-and-openssls/run-home.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/run-on-many-lisps-and-openssls/run-on-many-lisps-and-openssls.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/package.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/badssl-com.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/version.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/test/verify-hostname.lisp
+./quicklisp/bundle/software/cl+ssl-20200610-git/example.lisp
+./quicklisp/bundle/software/chunga-20200427-git/streams.lisp
+./quicklisp/bundle/software/chunga-20200427-git/read.lisp
+./quicklisp/bundle/software/chunga-20200427-git/output.lisp
+./quicklisp/bundle/software/chunga-20200427-git/packages.lisp
+./quicklisp/bundle/software/chunga-20200427-git/known-words.lisp
+./quicklisp/bundle/software/chunga-20200427-git/conditions.lisp
+./quicklisp/bundle/software/chunga-20200427-git/input.lisp
+./quicklisp/bundle/software/chunga-20200427-git/util.lisp
+./quicklisp/bundle/software/chunga-20200427-git/specials.lisp
+./quicklisp/bundle/software/rfc2388-20180831-git/packages.lisp
+./quicklisp/bundle/software/rfc2388-20180831-git/test.lisp
+./quicklisp/bundle/software/rfc2388-20180831-git/rfc2388.lisp
+./quicklisp/bundle/software/babel-20200715-git/scripts/release.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-cp1252.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/streams.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-gbk.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/encodings.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-ascii.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/packages.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/strings.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/external-format.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-cp437.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-ebcdic-int.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-iso-8859.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/sharp-backslash.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-ebcdic.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-jpn.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-koi8.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/jpn-table.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-unicode.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/gbk-map.lisp
+./quicklisp/bundle/software/babel-20200715-git/src/enc-cp1251.lisp
+./quicklisp/bundle/software/babel-20200715-git/tests/streams.lisp
+./quicklisp/bundle/software/babel-20200715-git/tests/tests.lisp
+./quicklisp/bundle/software/babel-20200715-git/tests/benchmarks.lisp
+./quicklisp/bundle/software/trivial-garbage-20200325-git/gendocs.lisp
+./quicklisp/bundle/software/trivial-garbage-20200325-git/tests.lisp
+./quicklisp/bundle/software/trivial-garbage-20200325-git/trivial-garbage.lisp
+./quicklisp/bundle/software/trivial-garbage-20200325-git/release.lisp
+./quicklisp/bundle/software/html-template-20171227-git/packages.lisp
+./quicklisp/bundle/software/html-template-20171227-git/template.lisp
+./quicklisp/bundle/software/html-template-20171227-git/api.lisp
+./quicklisp/bundle/software/html-template-20171227-git/test.lisp
+./quicklisp/bundle/software/html-template-20171227-git/load.lisp
+./quicklisp/bundle/software/html-template-20171227-git/errors.lisp
+./quicklisp/bundle/software/html-template-20171227-git/util.lisp
+./quicklisp/bundle/software/html-template-20171227-git/specials.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/src/packages.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/src/main.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/test/utils.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/test/top.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/test/kill.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/test/background.lisp
+./quicklisp/bundle/software/shellpool-20200610-git/test/basic.lisp
+./quicklisp/bundle/software/cffi_0.23.0/libffi/type-descriptors.lisp
+./quicklisp/bundle/software/cffi_0.23.0/libffi/libffi.lisp
+./quicklisp/bundle/software/cffi_0.23.0/libffi/libffi-types.lisp
+./quicklisp/bundle/software/cffi_0.23.0/libffi/libffi-functions.lisp
+./quicklisp/bundle/software/cffi_0.23.0/libffi/funcall.lisp
+./quicklisp/bundle/software/cffi_0.23.0/scripts/release.lisp
+./quicklisp/bundle/software/cffi_0.23.0/doc/colorize-lisp-examples.lisp
+./quicklisp/bundle/software/cffi_0.23.0/grovel/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/grovel/asdf.lisp
+./quicklisp/bundle/software/cffi_0.23.0/grovel/grovel.lisp
+./quicklisp/bundle/software/cffi_0.23.0/uffi-compat/uffi-compat.lisp
+./quicklisp/bundle/software/cffi_0.23.0/toolchain/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/toolchain/c-toolchain.lisp
+./quicklisp/bundle/software/cffi_0.23.0/toolchain/bundle.lisp
+./quicklisp/bundle/software/cffi_0.23.0/toolchain/static-link.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/grovel-example.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/mapping.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/main-example.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/wrapper-example.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/gethostname.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/translator-test.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/gettimeofday.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/run-examples.lisp
+./quicklisp/bundle/software/cffi_0.23.0/examples/examples.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/utils.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-scl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-allegro.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/libraries.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/strings.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-sbcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-corman.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/enum.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-gcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/functions.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/types.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/early-types.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-clisp.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-abcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/foreign-vars.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-cmucl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-openmcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/structures.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-mcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-ecl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-clasp.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/features.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-mkcl.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/c2ffi/generator.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/c2ffi/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/c2ffi/asdf.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/c2ffi/c2ffi.lisp
+./quicklisp/bundle/software/cffi_0.23.0/src/cffi-lispworks.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/arrays.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/struct.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/test-asdf.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/misc-types.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/strings.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/fsbv.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/bindings.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/enum.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/random-tester.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/package.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/defcfun.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/misc.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/grovel.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/memory.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/foreign-globals.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/union.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/callbacks.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/run-tests.lisp
+./quicklisp/bundle/software/cffi_0.23.0/tests/funcall.lisp
+./quicklisp/bundle/software/bt-semaphore-20180711-git/t/package.lisp
+./quicklisp/bundle/software/bt-semaphore-20180711-git/t/semaphore.lisp
+./quicklisp/bundle/software/bt-semaphore-20180711-git/src/package.lisp
+./quicklisp/bundle/software/bt-semaphore-20180711-git/src/semaphore.lisp
+./quicklisp/base.lisp
+./quicklisp/top.lisp
+./quicklisp/osicat.lisp
+./quicklisp/fastnumio.lisp
+./quicklisp/html-template.lisp
+./quicklisp/hunchentoot.lisp
+./quicklisp/cffi.lisp
+./quicklisp/bt-semaphore.lisp
+./quicklisp/cl-fad.lisp
+./quicklisp/shellpool.lisp
+./centaur/glmc/glmc-test.lisp
+./centaur/glmc/counter.lisp
+./centaur/glmc/shape-spec-invert.lisp
+./centaur/glmc/glmc.lisp
+./centaur/glmc/bfr-mcheck-abc.lisp
+./centaur/glmc/glmc-templates.lisp
+./centaur/glmc/portcullis.lisp
+./centaur/glmc/bfr-mcheck.lisp
+./centaur/glmc/glmc-generic-defs.lisp
+./centaur/glmc/glmc-generic-proof.lisp
+./centaur/lispfloat/top.lisp
+./centaur/lispfloat/portcullis.lisp
+./centaur/lispfloat/ops-logic.lisp
+./centaur/lispfloat/ops-exec.lisp
+./centaur/aignet/transform-stub.lisp
+./centaur/aignet/snodes.lisp
+./centaur/aignet/aignet-exec-thms.lisp
+./centaur/aignet/arrays.lisp
+./centaur/aignet/statsmgr.lisp
+./centaur/aignet/aignet-exec.lisp
+./centaur/aignet/rewrite.lisp
+./centaur/aignet/top.lisp
+./centaur/aignet/refcounts.lisp
+./centaur/aignet/unreachability.lisp
+./centaur/aignet/from-hons-aig-fast.lisp
+./centaur/aignet/from-hons-aig.lisp
+./centaur/aignet/aignet-absstobj.lisp
+./centaur/aignet/observability.lisp
+./centaur/aignet/cube-contradictionp.lisp
+./centaur/aignet/vecsim.lisp
+./centaur/aignet/supergate-construction.lisp
+./centaur/aignet/aiger.lisp
+./centaur/aignet/count.lisp
+./centaur/aignet/eval.lisp
+./centaur/aignet/axi-reductions.lisp
+./centaur/aignet/literal-sort-aignet.lisp
+./centaur/aignet/literal-sort.lisp
+./centaur/aignet/self-constprop.lisp
+./centaur/aignet/constprop.lisp
+./centaur/aignet/rwlib.lisp
+./centaur/aignet/lit-lists.lisp
+./centaur/aignet/raw-copy.lisp
+./centaur/aignet/construction.lisp
+./centaur/aignet/maybe-litp.lisp
+./centaur/aignet/equiv-classes.lisp
+./centaur/aignet/balance.lisp
+./centaur/aignet/bit-lemmas.lisp
+./centaur/aignet/transforms.lisp
+./centaur/aignet/deps.lisp
+./centaur/aignet/abc-wrappers.lisp
+./centaur/aignet/cuts4.lisp
+./centaur/aignet/mark-impls.lisp
+./centaur/aignet/levels.lisp
+./centaur/aignet/copying.lisp
+./centaur/aignet/abc.lisp
+./centaur/aignet/portcullis.lisp
+./centaur/aignet/cube-sat.lisp
+./centaur/aignet/stats.lisp
+./centaur/aignet/sweep.lisp
+./centaur/aignet/aignet-logic-interface.lisp
+./centaur/aignet/aig-sim.lisp
+./centaur/aignet/top-doc.lisp
+./centaur/aignet/simplify-marked.lisp
+./centaur/aignet/supergate.lisp
+./centaur/aignet/aignet-logic.lisp
+./centaur/aignet/fraig.lisp
+./centaur/aignet/obs-constprop.lisp
+./centaur/aignet/ipasir.lisp
+./centaur/aignet/eval-toggle.lisp
+./centaur/aignet/transform-utils.lisp
+./centaur/aignet/prune.lisp
+./centaur/aignet/dom-supergate-sweep.lisp
+./centaur/aignet/internal-observability-super.lisp
+./centaur/aignet/cnf.lisp
+./centaur/aignet/semantics.lisp
+./centaur/aignet/internal-observability.lisp
+./centaur/aignet/to-hons-aig.lisp
+./centaur/aignet/aig-cnf.lisp
+./centaur/aignet/rollback.lisp
+./centaur/aignet/litp.lisp
+./centaur/fgl/syntax-bind.lisp
+./centaur/fgl/congruence-rules.lisp
+./centaur/fgl/transform.lisp
+./centaur/fgl/constraint-db.lisp
+./centaur/fgl/aabf-nest.lisp
+./centaur/fgl/stack-transform.lisp
+./centaur/fgl/bfr.lisp
+./centaur/fgl/pathcond-base.lisp
+./centaur/fgl/svex.lisp
+./centaur/fgl/pathcond-fix.lisp
+./centaur/fgl/ubdd.lisp
+./centaur/fgl/scratch-isomorphic.lisp
+./centaur/fgl/clauseproc.lisp
+./centaur/fgl/mark-bfrs.lisp
+./centaur/fgl/top.lisp
+./centaur/fgl/simplify.lisp
+./centaur/fgl/pathcond-aig.lisp
+./centaur/fgl/fast-alists.lisp
+./centaur/fgl/logicman-transform.lisp
+./centaur/fgl/stack-import.lisp
+./centaur/fgl/primitives.lisp
+./centaur/fgl/primitive-lemmas.lisp
+./centaur/fgl/equivcheck-test.lisp
+./centaur/fgl/aabf.lisp
+./centaur/fgl/mark-bfrs-base.lisp
+./centaur/fgl/bfrs-replace.lisp
+./centaur/fgl/sat-binder.lisp
+./centaur/fgl/nat-var-aig.lisp
+./centaur/fgl/aig-eval.lisp
+./centaur/fgl/trace.lisp
+./centaur/fgl/fancy-ev.lisp
+./centaur/fgl/constraint-inst.lisp
+./centaur/fgl/gatecount.lisp
+./centaur/fgl/primitives-stub.lisp
+./centaur/fgl/interp-st-bfrs-ok.lisp
+./centaur/fgl/mark-bfrs-pathcond.lisp
+./centaur/fgl/stack-ev.lisp
+./centaur/fgl/scratchobj.lisp
+./centaur/fgl/contexts.lisp
+./centaur/fgl/pathcond-transform.lisp
+./centaur/fgl/interp.lisp
+./centaur/fgl/unify-defs.lisp
+./centaur/fgl/def-fgl-rewrite.lisp
+./centaur/fgl/greedy-max-sat.lisp
+./centaur/fgl/cgraph.lisp
+./centaur/fgl/sat-binder-defs.lisp
+./centaur/fgl/array-alist.lisp
+./centaur/fgl/add-primitives.lisp
+./centaur/fgl/tests-ipasir.lisp
+./centaur/fgl/satlink-sat.lisp
+./centaur/fgl/bitops-primitives.lisp
+./centaur/fgl/logicman.lisp
+./centaur/fgl/fgl-object.lisp
+./centaur/fgl/prof.lisp
+./centaur/fgl/pathcond-aignet-ipasir.lisp
+./centaur/fgl/checks.lisp
+./centaur/fgl/rules.lisp
+./centaur/fgl/tests.lisp
+./centaur/fgl/pathcond.lisp
+./centaur/fgl/pathcond-aignet.lisp
+./centaur/fgl/enums.lisp
+./centaur/fgl/arith-base.lisp
+./centaur/fgl/aig-pathcond-stobj.lisp
+./centaur/fgl/bvar-db-equivs.lisp
+./centaur/fgl/gatecount-base.lisp
+./centaur/fgl/sat-default.lisp
+./centaur/fgl/check-primitives.lisp
+./centaur/fgl/symbolic-arithmetic.lisp
+./centaur/fgl/portcullis.lisp
+./centaur/fgl/stack-logic.lisp
+./centaur/fgl/subst-functions.lisp
+./centaur/fgl/binder-rules.lisp
+./centaur/fgl/unify-thms.lisp
+./centaur/fgl/bitops.lisp
+./centaur/fgl/fgarrays.lisp
+./centaur/fgl/doc.lisp
+./centaur/fgl/ipasir-sat.lisp
+./centaur/fgl/bvar-db-bfrlist.lisp
+./centaur/fgl/top-doc.lisp
+./centaur/fgl/pathcond-stobj.lisp
+./centaur/fgl/bvar-db.lisp
+./centaur/fgl/aignet-pathcond-stobj.lisp
+./centaur/fgl/equivcheck.lisp
+./centaur/fgl/greedy-int-slice-diffs.lisp
+./centaur/fgl/casesplit.lisp
+./centaur/fgl/def-fgl-thm.lisp
+./centaur/fgl/stack.lisp
+./centaur/fgl/scratch-nontagidx.lisp
+./centaur/fgl/rule-types.lisp
+./centaur/fgl/ctrex-utils.lisp
+./centaur/fgl/member-equal.lisp
+./centaur/fgl/bfr-arithmetic.lisp
+./centaur/fgl/sat-stub.lisp
+./centaur/fgl/defapply.lisp
+./centaur/fgl/arith-lemmas.lisp
+./centaur/fgl/config.lisp
+./centaur/fgl/gatecount-stub.lisp
+./centaur/fgl/top-bare.lisp
+./centaur/fgl/theory.lisp
+./centaur/fgl/interp-st.lisp
+./centaur/satlink/varp.lisp
+./centaur/satlink/top.lisp
+./centaur/satlink/check-config.lisp
+./centaur/satlink/dimacs.lisp
+./centaur/satlink/dimacs-lits.lisp
+./centaur/satlink/lrat-interface.lisp
+./centaur/satlink/portcullis.lisp
+./centaur/satlink/benchmarks.lisp
+./centaur/satlink/cnf-basics.lisp
+./centaur/satlink/cnf.lisp
+./centaur/satlink/config.lisp
+./centaur/satlink/litp.lisp
+./centaur/svl/svl-flatten-simplify-lemmas.lisp
+./centaur/svl/svex-simplify-rule-list.lisp
+./centaur/svl/top.lisp
+./centaur/svl/4vec-lemmas.lisp
+./centaur/svl/svex-eval-wog.lisp
+./centaur/svl/svex-simplify.lisp
+./centaur/svl/svl-run-to-svex-alist.lisp
+./centaur/svl/macros.lisp
+./centaur/svl/tools.lisp
+./centaur/svl/svl-run.lisp
+./centaur/svl/svex-eval-wog-openers.lisp
+./centaur/svl/bits-sbits-defs.lisp
+./centaur/svl/portcullis.lisp
+./centaur/svl/svl-openers.lisp
+./centaur/svl/bits-sbits.lisp
+./centaur/svl/top-doc.lisp
+./centaur/svl/svexl/svexl.lisp
+./centaur/svl/svexl/svexl-fasteval.lisp
+./centaur/svl/svexl/svexl-correct.lisp
+./centaur/svl/svl-flatten.lisp
+./centaur/svl/meta/top.lisp
+./centaur/svl/meta/4vec-rsh-meta.lisp
+./centaur/svl/meta/svex-eval-wog-meta.lisp
+./centaur/svl/meta/bits-meta.lisp
+./centaur/svl/type-defs.lisp
+./centaur/bridge/top.lisp
+./centaur/bridge/to-json.lisp
+./centaur/bridge/portcullis.lisp
+./centaur/bigmem/concrete.lisp
+./centaur/bigmem/portcullis.lisp
+./centaur/bigmem/bigmem.lisp
+./centaur/clex/top.lisp
+./centaur/clex/sin.lisp
+./centaur/clex/arithmetic.lisp
+./centaur/clex/strin.lisp
+./centaur/clex/portcullis.lisp
+./centaur/clex/charlist-fix.lisp
+./centaur/clex/matchers.lisp
+./centaur/clex/example.lisp
+./centaur/clex/linecol.lisp
+./centaur/memoize/top.lisp
+./centaur/memoize/old/watch.lisp
+./centaur/memoize/old/profile.lisp
+./centaur/memoize/old/case.lisp
+./centaur/memoize/tests.lisp
+./centaur/memoize/portcullis.lisp
+./centaur/nrev/fast.lisp
+./centaur/nrev/portcullis.lisp
+./centaur/nrev/pure.lisp
+./centaur/nrev/demo.lisp
+./centaur/aig/g-aig-eval.lisp
+./centaur/aig/top.lisp
+./centaur/aig/accumulate-nodes-vars.lisp
+./centaur/aig/aiger-help.lisp
+./centaur/aig/faig-constructors.lisp
+./centaur/aig/faig-equivs.lisp
+./centaur/aig/aiger.lisp
+./centaur/aig/aig-base.lisp
+./centaur/aig/aig-equivs.lisp
+./centaur/aig/faig-purebool-p.lisp
+./centaur/aig/eval-restrict.lisp
+./centaur/aig/random-sim.lisp
+./centaur/aig/aig-vars-ext.lisp
+./centaur/aig/faig-base.lisp
+./centaur/aig/aig2c.lisp
+./centaur/aig/misc.lisp
+./centaur/aig/bddify-correct.lisp
+./centaur/aig/induction.lisp
+./centaur/aig/portcullis.lisp
+./centaur/aig/best-aig.lisp
+./centaur/aig/aig-vars.lisp
+./centaur/aig/bddify.lisp
+./centaur/aig/aig-sat-tests.lisp
+./centaur/aig/top-doc.lisp
+./centaur/aig/aig-print.lisp
+./centaur/aig/aig-vars-fast.lisp
+./centaur/aig/aig-sat.lisp
+./centaur/truth/dsd4-aignet.lisp
+./centaur/truth/truth.lisp
+./centaur/truth/perm4.lisp
+./centaur/truth/portcullis.lisp
+./centaur/truth/sizes.lisp
+./centaur/ubdds/witness.lisp
+./centaur/ubdds/core.lisp
+./centaur/ubdds/lite.lisp
+./centaur/ubdds/deps.lisp
+./centaur/ubdds/extra-operations.lisp
+./centaur/ubdds/param2.lisp
+./centaur/ubdds/sanity-check-macros.lisp
+./centaur/ubdds/subset.lisp
+./centaur/ubdds/param.lisp
+./centaur/esim/esim-cut.lisp
+./centaur/esim/steps.lisp
+./centaur/esim/esim-paths.lisp
+./centaur/esim/esim-spec.lisp
+./centaur/esim/follow-backwards.lisp
+./centaur/esim/esim-sexpr-support-thms.lisp
+./centaur/esim/esim-sexpr.lisp
+./centaur/esim/vcd/vcd.lisp
+./centaur/esim/vcd/esim-snapshot.lisp
+./centaur/esim/vcd/vcd-impl.lisp
+./centaur/esim/vcd/vcd-stub.lisp
+./centaur/esim/esim-vl.lisp
+./centaur/esim/stv/stv-debug.lisp
+./centaur/esim/stv/stv-decomp-proofs-even-better.lisp
+./centaur/esim/stv/stv-compile.lisp
+./centaur/esim/stv/stv-sim.lisp
+./centaur/esim/stv/stv-util.lisp
+./centaur/esim/stv/stv-top.lisp
+./centaur/esim/stv/stv2c/stv2c.lisp
+./centaur/esim/stv/stv2c/top.lisp
+./centaur/esim/stv/stv-run.lisp
+./centaur/esim/stv/stv-decomp-proofs-better.lisp
+./centaur/esim/stv/stv-decomp-proofs.lisp
+./centaur/esim/stv/stv-doc.lisp
+./centaur/esim/stv/stv-widen.lisp
+./centaur/esim/stv/stv-expand.lisp
+./centaur/esim/plist.lisp
+./centaur/esim/occform/compare.lisp
+./centaur/esim/occform/top.lisp
+./centaur/esim/occform/xdet.lisp
+./centaur/esim/occform/mul.lisp
+./centaur/esim/occform/simple.lisp
+./centaur/esim/occform/div.lisp
+./centaur/esim/occform/add.lisp
+./centaur/esim/occform/shr.lisp
+./centaur/esim/occform/select.lisp
+./centaur/esim/occform/shl.lisp
+./centaur/esim/tutorial/counter.lisp
+./centaur/esim/tutorial/booth-support.lisp
+./centaur/esim/tutorial/boothmul.lisp
+./centaur/esim/tutorial/alu16-book.lisp
+./centaur/esim/tutorial/intro.lisp
+./centaur/esim/esim-primitives.lisp
+./centaur/esim/patterns.lisp
+./centaur/esim/esim-sexpr-support.lisp
+./centaur/esim/tests/common.lisp
+./centaur/esim/tests/regs.lisp
+./centaur/esim/tests/idiv.lisp
+./centaur/esim/tests/add.lisp
+./centaur/esim/tests/divide.lisp
+./centaur/esim/tests/subtract.lisp
+./centaur/esim/tests/multiply.lisp
+./centaur/esim/local-theory.lisp
+./centaur/esim/esim-vcd.lisp
+./centaur/esim/portcullis.lisp
+./centaur/esim/top-doc.lisp
+./centaur/esim/vltoe/verilogify.lisp
+./centaur/esim/vltoe/top.lisp
+./centaur/esim/vltoe/add-res-modules.lisp
+./centaur/esim/vltoe/esim-lemmas.lisp
+./centaur/esim/vltoe/emodwire.lisp
+./centaur/esim/vltoe/wirealist.lisp
+./centaur/esim/vltoe/zdrivers.lisp
+./centaur/esim/vltoe/preliminary.lisp
+./centaur/esim/vltoe/eocc-allnames.lisp
+./centaur/esim/defmodules.lisp
+./centaur/esim/translation.lisp
+./centaur/esim/esim-sexpr-correct.lisp
+./centaur/depgraph/top.lisp
+./centaur/depgraph/mergesort-alist-values.lisp
+./centaur/depgraph/portcullis.lisp
+./centaur/depgraph/toposort.lisp
+./centaur/depgraph/transdeps.lisp
+./centaur/depgraph/invert.lisp
+./centaur/vl/loader/top.lisp
+./centaur/vl/loader/descriptions.lisp
+./centaur/vl/loader/inject-warnings.lisp
+./centaur/vl/loader/read-file.lisp
+./centaur/vl/loader/inject-comments.lisp
+./centaur/vl/loader/translateoff.lisp
+./centaur/vl/loader/lexer/utils.lisp
+./centaur/vl/loader/lexer/keywords.lisp
+./centaur/vl/loader/lexer/identifiers.lisp
+./centaur/vl/loader/lexer/top.lisp
+./centaur/vl/loader/lexer/numbers.lisp
+./centaur/vl/loader/lexer/strings.lisp
+./centaur/vl/loader/lexer/lexstate.lisp
+./centaur/vl/loader/lexer/defchar.lisp
+./centaur/vl/loader/lexer/tests.lisp
+./centaur/vl/loader/lexer/tokens.lisp
+./centaur/vl/loader/lexer/chartypes.lisp
+./centaur/vl/loader/preprocessor/top.lisp
+./centaur/vl/loader/preprocessor/print-defines.lisp
+./centaur/vl/loader/preprocessor/tests.lisp
+./centaur/vl/loader/preprocessor/defines.lisp
+./centaur/vl/loader/config.lisp
+./centaur/vl/loader/parser/utils.lisp
+./centaur/vl/loader/parser/timeunits.lisp
+./centaur/vl/loader/parser/covergroups.lisp
+./centaur/vl/loader/parser/top.lisp
+./centaur/vl/loader/parser/statements.lisp
+./centaur/vl/loader/parser/nets.lisp
+./centaur/vl/loader/parser/gates.lisp
+./centaur/vl/loader/parser/eventctrl.lisp
+./centaur/vl/loader/parser/asserts.lisp
+./centaur/vl/loader/parser/programs.lisp
+./centaur/vl/loader/parser/packages.lisp
+./centaur/vl/loader/parser/parsestate.lisp
+./centaur/vl/loader/parser/expressions.lisp
+./centaur/vl/loader/parser/properties.lisp
+./centaur/vl/loader/parser/functions.lisp
+./centaur/vl/loader/parser/dpi.lisp
+./centaur/vl/loader/parser/delays.lisp
+./centaur/vl/loader/parser/elements.lisp
+./centaur/vl/loader/parser/clocking.lisp
+./centaur/vl/loader/parser/modports.lisp
+./centaur/vl/loader/parser/tests/base.lisp
+./centaur/vl/loader/parser/tests/top.lisp
+./centaur/vl/loader/parser/tests/statements.lisp
+./centaur/vl/loader/parser/tests/nets.lisp
+./centaur/vl/loader/parser/tests/gates.lisp
+./centaur/vl/loader/parser/tests/eventctrl.lisp
+./centaur/vl/loader/parser/tests/writer.lisp
+./centaur/vl/loader/parser/tests/ranges.lisp
+./centaur/vl/loader/parser/tests/expressions.lisp
+./centaur/vl/loader/parser/tests/properties.lisp
+./centaur/vl/loader/parser/tests/functions.lisp
+./centaur/vl/loader/parser/tests/delays.lisp
+./centaur/vl/loader/parser/tests/clocking.lisp
+./centaur/vl/loader/parser/tests/insts.lisp
+./centaur/vl/loader/parser/tests/strengths.lisp
+./centaur/vl/loader/parser/tests/ports.lisp
+./centaur/vl/loader/parser/tests/paramdecls.lisp
+./centaur/vl/loader/parser/tests/imports.lisp
+./centaur/vl/loader/parser/tests/typedefs.lisp
+./centaur/vl/loader/parser/tests/blockitems.lisp
+./centaur/vl/loader/parser/assignments.lisp
+./centaur/vl/loader/parser/insts.lisp
+./centaur/vl/loader/parser/strengths.lisp
+./centaur/vl/loader/parser/datatypes.lisp
+./centaur/vl/loader/parser/ports.lisp
+./centaur/vl/loader/parser/interfaces.lisp
+./centaur/vl/loader/parser/paramdecls.lisp
+./centaur/vl/loader/parser/imports.lisp
+./centaur/vl/loader/parser/modules.lisp
+./centaur/vl/loader/parser/blockitems.lisp
+./centaur/vl/loader/parser/classes.lisp
+./centaur/vl/loader/parser/configs.lisp
+./centaur/vl/loader/parser/seq.lisp
+./centaur/vl/loader/parser/udps.lisp
+./centaur/vl/loader/find-file.lisp
+./centaur/vl/loader/filemap.lisp
+./centaur/vl/transforms/drop-blankports.lisp
+./centaur/vl/transforms/cn-hooks.lisp
+./centaur/vl/transforms/addnames.lisp
+./centaur/vl/transforms/annotate/top.lisp
+./centaur/vl/transforms/annotate/basicsanity.lisp
+./centaur/vl/transforms/annotate/udp-elim.lisp
+./centaur/vl/transforms/annotate/make-implicit-wires.lisp
+./centaur/vl/transforms/annotate/enumnames.lisp
+./centaur/vl/transforms/annotate/shadowcheck.lisp
+./centaur/vl/transforms/annotate/portdecl-sign.lisp
+./centaur/vl/transforms/annotate/port-resolve.lisp
+./centaur/vl/transforms/annotate/increment-elim.lisp
+./centaur/vl/transforms/annotate/argresolve.lisp
+./centaur/vl/transforms/annotate/bind.lisp
+./centaur/vl/transforms/annotate/type-disambiguation.lisp
+./centaur/vl/transforms/lintstub.lisp
+./centaur/vl/transforms/problem-mods.lisp
+./centaur/vl/transforms/clean-warnings.lisp
+./centaur/vl/transforms/eliminitial.lisp
+./centaur/vl/transforms/unparam/top.lisp
+./centaur/vl/transforms/unparam/override.lisp
+./centaur/vl/transforms/unparam/lineup.lisp
+./centaur/vl/portcullis.lisp
+./centaur/vl/mlib/immdeps.lisp
+./centaur/vl/mlib/remove-bad.lisp
+./centaur/vl/mlib/writer.lisp
+./centaur/vl/mlib/print-context.lisp
+./centaur/vl/mlib/print-warnings.lisp
+./centaur/vl/mlib/strip.lisp
+./centaur/vl/mlib/coretypes.lisp
+./centaur/vl/mlib/hier-measure.lisp
+./centaur/vl/mlib/range-tools.lisp
+./centaur/vl/mlib/json.lisp
+./centaur/vl/mlib/stmt-tools.lisp
+./centaur/vl/mlib/flat-warnings.lisp
+./centaur/vl/mlib/find.lisp
+./centaur/vl/mlib/scopestack.lisp
+./centaur/vl/mlib/syscalls.lisp
+./centaur/vl/mlib/relocate.lisp
+./centaur/vl/mlib/design-meta.lisp
+./centaur/vl/mlib/modname-sets.lisp
+./centaur/vl/mlib/typedecide.lisp
+./centaur/vl/mlib/filter.lisp
+./centaur/vl/mlib/mocktype.lisp
+./centaur/vl/mlib/reportcard.lisp
+./centaur/vl/mlib/namefactory.lisp
+./centaur/vl/mlib/lvalues.lisp
+./centaur/vl/mlib/elabindex.lisp
+./centaur/vl/mlib/allexprs.lisp
+./centaur/vl/mlib/port-tools.lisp
+./centaur/vl/mlib/expr-tools.lisp
+./centaur/vl/mlib/blocks.lisp
+./centaur/vl/mlib/atts.lisp
+./centaur/vl/mlib/arithclass.lisp
+./centaur/vl/mlib/hierarchy.lisp
+./centaur/vl/mlib/fmt.lisp
+./centaur/vl/mlib/hid-tools.lisp
+./centaur/vl/mlib/modnamespace.lisp
+./centaur/vl/mlib/datatype-tools.lisp
+./centaur/vl/mlib/ctxexprs.lisp
+./centaur/vl/mlib/comment-writer.lisp
+./centaur/vl/mlib/reorder.lisp
+./centaur/vl/mlib/selfsize.lisp
+./centaur/vl/mlib/allnames.lisp
+./centaur/vl/util/merge-indices.lisp
+./centaur/vl/util/defs.lisp
+./centaur/vl/util/printedlist.lisp
+./centaur/vl/util/osets.lisp
+./centaur/vl/util/warnings.lisp
+./centaur/vl/util/print.lisp
+./centaur/vl/util/default-hints.lisp
+./centaur/vl/util/cw-unformatted.lisp
+./centaur/vl/util/namedb.lisp
+./centaur/vl/util/cwtime.lisp
+./centaur/vl/util/arithmetic.lisp
+./centaur/vl/util/summarize-parts.lisp
+./centaur/vl/util/sum-nats.lisp
+./centaur/vl/util/subsetp-equal.lisp
+./centaur/vl/util/locations.lisp
+./centaur/vl/util/string-alists.lisp
+./centaur/vl/util/fmt-base.lisp
+./centaur/vl/util/character-list-listp.lisp
+./centaur/vl/util/commentmap.lisp
+./centaur/vl/util/echars.lisp
+./centaur/vl/util/gc.lisp
+./centaur/vl/util/bits.lisp
+./centaur/vl/util/print-htmlencode.lisp
+./centaur/vl/util/warningtree.lisp
+./centaur/vl/doc.lisp
+./centaur/vl/lint/drop-user-submodules.lisp
+./centaur/vl/lint/check-case.lisp
+./centaur/vl/lint/qmarksize-check.lisp
+./centaur/vl/lint/unpacked-range.lisp
+./centaur/vl/lint/arith-compare.lisp
+./centaur/vl/lint/selfassigns.lisp
+./centaur/vl/lint/alwaysstyle.lisp
+./centaur/vl/lint/condcheck.lisp
+./centaur/vl/lint/dupeinst-check.lisp
+./centaur/vl/lint/leftright.lisp
+./centaur/vl/lint/drop-missing-submodules.lisp
+./centaur/vl/lint/typo-detect.lisp
+./centaur/vl/lint/oddexpr.lisp
+./centaur/vl/lint/logicassign.lisp
+./centaur/vl/lint/lvaluecheck.lisp
+./centaur/vl/lint/duperhs.lisp
+./centaur/vl/lint/check-globalparams.lisp
+./centaur/vl/lint/suppress-warnings.lisp
+./centaur/vl/lint/use-set-report.lisp
+./centaur/vl/lint/check-namespace.lisp
+./centaur/vl/lint/skip-detect.lisp
+./centaur/vl/lint/duplicate-detect.lisp
+./centaur/vl/lint/lucid.lisp
+./centaur/vl/lint/ifdef-report.lisp
+./centaur/vl/lint/suppress-files.lisp
+./centaur/vl/top-doc.lisp
+./centaur/vl/parsetree.lisp
+./centaur/vl/simpconfig.lisp
+./centaur/vl/expr.lisp
+./centaur/vl/server/porttable.lisp
+./centaur/vl/server/showloc.lisp
+./centaur/vl/server/describe.lisp
+./centaur/vl/server/top.lisp
+./centaur/vl/server/file-layout.lisp
+./centaur/vl/server/command.lisp
+./centaur/vl/server/data.lisp
+./centaur/vl/kit/gather.lisp
+./centaur/vl/kit/top.lisp
+./centaur/vl/kit/zipfile.lisp
+./centaur/vl/kit/json.lisp
+./centaur/vl/kit/server.lisp
+./centaur/vl/kit/zip.lisp
+./centaur/vl/kit/lint.lisp
+./centaur/vl/kit/shell.lisp
+./centaur/vl/kit/progutils.lisp
+./centaur/getopt/top.lisp
+./centaur/getopt/demo2.lisp
+./centaur/getopt/portcullis.lisp
+./centaur/getopt/parsers.lisp
+./centaur/getopt/demo.lisp
+./centaur/vl2014/loader/top.lisp
+./centaur/vl2014/loader/descriptions.lisp
+./centaur/vl2014/loader/inject-warnings.lisp
+./centaur/vl2014/loader/read-file.lisp
+./centaur/vl2014/loader/inject-comments.lisp
+./centaur/vl2014/loader/lexer/utils.lisp
+./centaur/vl2014/loader/lexer/keywords.lisp
+./centaur/vl2014/loader/lexer/identifiers.lisp
+./centaur/vl2014/loader/lexer/numbers.lisp
+./centaur/vl2014/loader/lexer/strings.lisp
+./centaur/vl2014/loader/lexer/lexstate.lisp
+./centaur/vl2014/loader/lexer/defchar.lisp
+./centaur/vl2014/loader/lexer/tests.lisp
+./centaur/vl2014/loader/lexer/tokens.lisp
+./centaur/vl2014/loader/lexer/lexer.lisp
+./centaur/vl2014/loader/lexer/chartypes.lisp
+./centaur/vl2014/loader/preprocessor/print-defines.lisp
+./centaur/vl2014/loader/preprocessor/tests.lisp
+./centaur/vl2014/loader/preprocessor/defines.lisp
+./centaur/vl2014/loader/preprocessor/preprocessor.lisp
+./centaur/vl2014/loader/config.lisp
+./centaur/vl2014/loader/parser/utils.lisp
+./centaur/vl2014/loader/parser/statements.lisp
+./centaur/vl2014/loader/parser/nets.lisp
+./centaur/vl2014/loader/parser/gates.lisp
+./centaur/vl2014/loader/parser/eventctrl.lisp
+./centaur/vl2014/loader/parser/programs.lisp
+./centaur/vl2014/loader/parser/packages.lisp
+./centaur/vl2014/loader/parser/parsestate.lisp
+./centaur/vl2014/loader/parser/parser.lisp
+./centaur/vl2014/loader/parser/ranges.lisp
+./centaur/vl2014/loader/parser/expressions.lisp
+./centaur/vl2014/loader/parser/functions.lisp
+./centaur/vl2014/loader/parser/error.lisp
+./centaur/vl2014/loader/parser/delays.lisp
+./centaur/vl2014/loader/parser/elements.lisp
+./centaur/vl2014/loader/parser/lvalues.lisp
+./centaur/vl2014/loader/parser/modports.lisp
+./centaur/vl2014/loader/parser/tests/base.lisp
+./centaur/vl2014/loader/parser/tests/top.lisp
+./centaur/vl2014/loader/parser/tests/statements.lisp
+./centaur/vl2014/loader/parser/tests/nets.lisp
+./centaur/vl2014/loader/parser/tests/gates.lisp
+./centaur/vl2014/loader/parser/tests/eventctrl.lisp
+./centaur/vl2014/loader/parser/tests/writer.lisp
+./centaur/vl2014/loader/parser/tests/hids.lisp
+./centaur/vl2014/loader/parser/tests/ranges.lisp
+./centaur/vl2014/loader/parser/tests/expressions.lisp
+./centaur/vl2014/loader/parser/tests/functions.lisp
+./centaur/vl2014/loader/parser/tests/delays.lisp
+./centaur/vl2014/loader/parser/tests/insts.lisp
+./centaur/vl2014/loader/parser/tests/strengths.lisp
+./centaur/vl2014/loader/parser/tests/ports.lisp
+./centaur/vl2014/loader/parser/tests/paramdecls.lisp
+./centaur/vl2014/loader/parser/tests/sequences.lisp
+./centaur/vl2014/loader/parser/tests/imports.lisp
+./centaur/vl2014/loader/parser/tests/typedefs.lisp
+./centaur/vl2014/loader/parser/tests/blockitems.lisp
+./centaur/vl2014/loader/parser/insts.lisp
+./centaur/vl2014/loader/parser/strengths.lisp
+./centaur/vl2014/loader/parser/datatypes.lisp
+./centaur/vl2014/loader/parser/ports.lisp
+./centaur/vl2014/loader/parser/interfaces.lisp
+./centaur/vl2014/loader/parser/paramdecls.lisp
+./centaur/vl2014/loader/parser/sequences.lisp
+./centaur/vl2014/loader/parser/imports.lisp
+./centaur/vl2014/loader/parser/modules.lisp
+./centaur/vl2014/loader/parser/typedefs.lisp
+./centaur/vl2014/loader/parser/blockitems.lisp
+./centaur/vl2014/loader/parser/configs.lisp
+./centaur/vl2014/loader/parser/seq.lisp
+./centaur/vl2014/loader/parser/udps.lisp
+./centaur/vl2014/loader/find-file.lisp
+./centaur/vl2014/loader/filemap.lisp
+./centaur/vl2014/primitives.lisp
+./centaur/vl2014/wf-reasonable-p.lisp
+./centaur/vl2014/transforms/drop-blankports.lisp
+./centaur/vl2014/transforms/addinstnames.lisp
+./centaur/vl2014/transforms/oprewrite.lisp
+./centaur/vl2014/transforms/cn-hooks.lisp
+./centaur/vl2014/transforms/delayredux.lisp
+./centaur/vl2014/transforms/clean-selects.lisp
+./centaur/vl2014/transforms/annotate/designwires.lisp
+./centaur/vl2014/transforms/annotate/top.lisp
+./centaur/vl2014/transforms/annotate/udp-elim.lisp
+./centaur/vl2014/transforms/annotate/make-implicit-wires.lisp
+./centaur/vl2014/transforms/annotate/shadowcheck.lisp
+./centaur/vl2014/transforms/annotate/portdecl-sign.lisp
+./centaur/vl2014/transforms/annotate/argresolve.lisp
+./centaur/vl2014/transforms/annotate/resolve-indexing.lisp
+./centaur/vl2014/transforms/annotate/origexprs.lisp
+./centaur/vl2014/transforms/unused-vars.lisp
+./centaur/vl2014/transforms/assign-trunc.lisp
+./centaur/vl2014/transforms/inline.lisp
+./centaur/vl2014/transforms/expr-split.lisp
+./centaur/vl2014/transforms/problem-mods.lisp
+./centaur/vl2014/transforms/expr-size.lisp
+./centaur/vl2014/transforms/always/ifmerge.lisp
+./centaur/vl2014/transforms/always/edgesplit.lisp
+./centaur/vl2014/transforms/always/top.lisp
+./centaur/vl2014/transforms/always/stmttemps.lisp
+./centaur/vl2014/transforms/always/latchsynth.lisp
+./centaur/vl2014/transforms/always/combinational.lisp
+./centaur/vl2014/transforms/always/latchcode.lisp
+./centaur/vl2014/transforms/always/stmtrewrite.lisp
+./centaur/vl2014/transforms/always/caseelim.lisp
+./centaur/vl2014/transforms/always/conditions.lisp
+./centaur/vl2014/transforms/always/make-latch.lisp
+./centaur/vl2014/transforms/always/edgesynth.lisp
+./centaur/vl2014/transforms/always/eliminitial.lisp
+./centaur/vl2014/transforms/always/nedgeflop.lisp
+./centaur/vl2014/transforms/always/elimalways.lisp
+./centaur/vl2014/transforms/always/util.lisp
+./centaur/vl2014/transforms/always/unelse.lisp
+./centaur/vl2014/transforms/gatesplit.lisp
+./centaur/vl2014/transforms/elim-supply.lisp
+./centaur/vl2014/transforms/sizing.lisp
+./centaur/vl2014/transforms/selresolve.lisp
+./centaur/vl2014/transforms/expr-simp.lisp
+./centaur/vl2014/transforms/wildeq.lisp
+./centaur/vl2014/transforms/clean-warnings.lisp
+./centaur/vl2014/transforms/gate-elim.lisp
+./centaur/vl2014/transforms/expand-functions.lisp
+./centaur/vl2014/transforms/replicate-insts.lisp
+./centaur/vl2014/transforms/resolve-ranges.lisp
+./centaur/vl2014/transforms/weirdint-elim.lisp
+./centaur/vl2014/transforms/propagate.lisp
+./centaur/vl2014/transforms/unparam/top.lisp
+./centaur/vl2014/transforms/unparam/override.lisp
+./centaur/vl2014/transforms/unparam/scopesubst.lisp
+./centaur/vl2014/transforms/unparam/lineup.lisp
+./centaur/vl2014/transforms/propagate-help.lisp
+./centaur/vl2014/transforms/blankargs.lisp
+./centaur/vl2014/transforms/clean-params.lisp
+./centaur/vl2014/transforms/optimize-rw.lisp
+./centaur/vl2014/portcullis.lisp
+./centaur/vl2014/mlib/caremask.lisp
+./centaur/vl2014/mlib/immdeps.lisp
+./centaur/vl2014/mlib/namemangle.lisp
+./centaur/vl2014/mlib/clean-concats.lisp
+./centaur/vl2014/mlib/remove-bad.lisp
+./centaur/vl2014/mlib/modgen.lisp
+./centaur/vl2014/mlib/range-tools-legacy.lisp
+./centaur/vl2014/mlib/writer.lisp
+./centaur/vl2014/mlib/print-context.lisp
+./centaur/vl2014/mlib/consteval.lisp
+./centaur/vl2014/mlib/print-warnings.lisp
+./centaur/vl2014/mlib/strip.lisp
+./centaur/vl2014/mlib/coretypes.lisp
+./centaur/vl2014/mlib/hier-measure.lisp
+./centaur/vl2014/mlib/range-tools.lisp
+./centaur/vl2014/mlib/json.lisp
+./centaur/vl2014/mlib/stmt-tools.lisp
+./centaur/vl2014/mlib/flat-warnings.lisp
+./centaur/vl2014/mlib/find.lisp
+./centaur/vl2014/mlib/scopestack.lisp
+./centaur/vl2014/mlib/syscalls.lisp
+./centaur/vl2014/mlib/relocate.lisp
+./centaur/vl2014/mlib/design-meta.lisp
+./centaur/vl2014/mlib/welltyped.lisp
+./centaur/vl2014/mlib/expr-slice.lisp
+./centaur/vl2014/mlib/modname-sets.lisp
+./centaur/vl2014/mlib/typedecide.lisp
+./centaur/vl2014/mlib/filter.lisp
+./centaur/vl2014/mlib/reportcard.lisp
+./centaur/vl2014/mlib/namefactory.lisp
+./centaur/vl2014/mlib/lvalues.lisp
+./centaur/vl2014/mlib/expr-building.lisp
+./centaur/vl2014/mlib/allexprs.lisp
+./centaur/vl2014/mlib/port-tools.lisp
+./centaur/vl2014/mlib/expr-tools.lisp
+./centaur/vl2014/mlib/blocks.lisp
+./centaur/vl2014/mlib/atts.lisp
+./centaur/vl2014/mlib/delta.lisp
+./centaur/vl2014/mlib/hierarchy.lisp
+./centaur/vl2014/mlib/constint-bits.lisp
+./centaur/vl2014/mlib/fmt.lisp
+./centaur/vl2014/mlib/hid-tools.lisp
+./centaur/vl2014/mlib/modnamespace.lisp
+./centaur/vl2014/mlib/subst.lisp
+./centaur/vl2014/mlib/datatype-tools.lisp
+./centaur/vl2014/mlib/ctxexprs.lisp
+./centaur/vl2014/mlib/comment-writer.lisp
+./centaur/vl2014/mlib/reorder.lisp
+./centaur/vl2014/mlib/selfsize.lisp
+./centaur/vl2014/mlib/expr-parse.lisp
+./centaur/vl2014/util/position.lisp
+./centaur/vl2014/util/merge-indices.lisp
+./centaur/vl2014/util/defs.lisp
+./centaur/vl2014/util/printedlist.lisp
+./centaur/vl2014/util/osets.lisp
+./centaur/vl2014/util/warnings.lisp
+./centaur/vl2014/util/print.lisp
+./centaur/vl2014/util/default-hints.lisp
+./centaur/vl2014/util/cw-unformatted.lisp
+./centaur/vl2014/util/namedb.lisp
+./centaur/vl2014/util/cwtime.lisp
+./centaur/vl2014/util/print-urlencode.lisp
+./centaur/vl2014/util/arithmetic.lisp
+./centaur/vl2014/util/deftranssum.lisp
+./centaur/vl2014/util/sum-nats.lisp
+./centaur/vl2014/util/subsetp-equal.lisp
+./centaur/vl2014/util/string-alists.lisp
+./centaur/vl2014/util/next-power-of-2.lisp
+./centaur/vl2014/util/nat-alists.lisp
+./centaur/vl2014/util/character-list-listp.lisp
+./centaur/vl2014/util/intersectp-equal.lisp
+./centaur/vl2014/util/clean-alist.lisp
+./centaur/vl2014/util/prefix-hash.lisp
+./centaur/vl2014/util/commentmap.lisp
+./centaur/vl2014/util/prefixp.lisp
+./centaur/vl2014/util/echars.lisp
+./centaur/vl2014/util/gc.lisp
+./centaur/vl2014/util/defwellformed.lisp
+./centaur/vl2014/util/bits.lisp
+./centaur/vl2014/util/print-htmlencode.lisp
+./centaur/vl2014/util/defoption.lisp
+./centaur/vl2014/doc.lisp
+./centaur/vl2014/lint/drop-user-submodules.lisp
+./centaur/vl2014/lint/check-case.lisp
+./centaur/vl2014/lint/qmarksize-check.lisp
+./centaur/vl2014/lint/use-set-ignore.lisp
+./centaur/vl2014/lint/remove-toohard.lisp
+./centaur/vl2014/lint/selfassigns.lisp
+./centaur/vl2014/lint/condcheck.lisp
+./centaur/vl2014/lint/dupeinst-check.lisp
+./centaur/vl2014/lint/leftright.lisp
+./centaur/vl2014/lint/drop-missing-submodules.lisp
+./centaur/vl2014/lint/typo-detect.lisp
+./centaur/vl2014/lint/oddexpr.lisp
+./centaur/vl2014/lint/lint-stmt-rewrite.lisp
+./centaur/vl2014/lint/portcheck.lisp
+./centaur/vl2014/lint/use-set.lisp
+./centaur/vl2014/lint/duperhs.lisp
+./centaur/vl2014/lint/suppress-warnings.lisp
+./centaur/vl2014/lint/use-set-report.lisp
+./centaur/vl2014/lint/check-namespace.lisp
+./centaur/vl2014/lint/skip-detect.lisp
+./centaur/vl2014/lint/duplicate-detect.lisp
+./centaur/vl2014/lint/multidrive-detect.lisp
+./centaur/vl2014/lint/lucid.lisp
+./centaur/vl2014/top-doc.lisp
+./centaur/vl2014/parsetree.lisp
+./centaur/vl2014/simpconfig.lisp
+./centaur/vl2014/expr.lisp
+./centaur/vl2014/server/porttable.lisp
+./centaur/vl2014/server/showloc.lisp
+./centaur/vl2014/server/describe.lisp
+./centaur/vl2014/server/file-layout.lisp
+./centaur/vl2014/server/command.lisp
+./centaur/vl2014/server/data.lisp
+./centaur/vl2014/server/server.lisp
+./centaur/vl2014/wf-widthsfixed-p.lisp
+./centaur/vl2014/kit/gather.lisp
+./centaur/vl2014/kit/top.lisp
+./centaur/vl2014/kit/json.lisp
+./centaur/vl2014/kit/pp.lisp
+./centaur/vl2014/kit/model.lisp
+./centaur/vl2014/kit/server.lisp
+./centaur/vl2014/kit/lint.lisp
+./centaur/vl2014/kit/shell.lisp
+./centaur/vl2014/kit/progutils.lisp
+./centaur/misc/bitarr.lisp
+./centaur/misc/1d-arr.lisp
+./centaur/misc/alist-defs.lisp
+./centaur/misc/u32-listp.lisp
+./centaur/misc/load-stobj.lisp
+./centaur/misc/osets-witnessing.lisp
+./centaur/misc/evaluator-metatheorems.lisp
+./centaur/misc/arrays.lisp
+./centaur/misc/alist-equiv.lisp
+./centaur/misc/try-gl-concls.lisp
+./centaur/misc/sharedlibtest/app.lisp
+./centaur/misc/arith-equivs.lisp
+./centaur/misc/tshell.lisp
+./centaur/misc/witness-cp.lisp
+./centaur/misc/sharedlibs.lisp
+./centaur/misc/spacewalk.lisp
+./centaur/misc/top.lisp
+./centaur/misc/fast-alists.lisp
+./centaur/misc/fal-graphs.lisp
+./centaur/misc/prev-stobj-binding.lisp
+./centaur/misc/count-up.lisp
+./centaur/misc/stobj-swap.lisp
+./centaur/misc/interp-function-lookup.lisp
+./centaur/misc/intstack.lisp
+./centaur/misc/sneaky-load.lisp
+./centaur/misc/seed-random.lisp
+./centaur/misc/context-rw.lisp
+./centaur/misc/introduce-var.lisp
+./centaur/misc/hons-alphorder-merge.lisp
+./centaur/misc/load-stobj-tests.lisp
+./centaur/misc/2d-arr.lisp
+./centaur/misc/tailrec.lisp
+./centaur/misc/fast-cons-memo.lisp
+./centaur/misc/tarjan.lisp
+./centaur/misc/tshell-tests.lisp
+./centaur/misc/nth-nat-equiv.lisp
+./centaur/misc/intern-debugging.lisp
+./centaur/misc/hons-remove-dups.lisp
+./centaur/misc/graphviz.lisp
+./centaur/misc/starlogic.lisp
+./centaur/misc/iter.lisp
+./centaur/misc/nth-equiv.lisp
+./centaur/misc/lists.lisp
+./centaur/misc/stobj-swap-test.lisp
+./centaur/misc/alist-witness.lisp
+./centaur/misc/dag-measure-thms.lisp
+./centaur/misc/smm.lisp
+./centaur/misc/outer-local-tests.lisp
+./centaur/misc/nats-equiv.lisp
+./centaur/misc/outer-local.lisp
+./centaur/misc/u32arr.lisp
+./centaur/misc/filter-alist.lisp
+./centaur/misc/rewrite-rule.lisp
+./centaur/misc/hons-extra.lisp
+./centaur/misc/universal-equiv.lisp
+./centaur/misc/dfs-measure.lisp
+./centaur/misc/vecs-ints.lisp
+./centaur/misc/sparsemap-impl.lisp
+./centaur/misc/dag-measure.lisp
+./centaur/misc/absstobjs.lisp
+./centaur/misc/errmsg.lisp
+./centaur/misc/iffstar.lisp
+./centaur/misc/bound-rewriter.lisp
+./centaur/misc/remove-assoc.lisp
+./centaur/misc/arith-equiv-defs.lisp
+./centaur/misc/natarr.lisp
+./centaur/misc/equal-sets.lisp
+./centaur/misc/memory-mgmt-logic.lisp
+./centaur/misc/beta-reduce-full.lisp
+./centaur/misc/sparsemap.lisp
+./centaur/misc/fast-alist-pop.lisp
+./centaur/misc/nat-list-duplicates.lisp
+./centaur/misc/s32-listp.lisp
+./centaur/misc/defapply.lisp
+./centaur/misc/duplicates.lisp
+./centaur/misc/hons-sets.lisp
+./centaur/misc/memory-mgmt.lisp
+./centaur/misc/smm-impl.lisp
+./centaur/misc/numlist.lisp
+./centaur/misc/suffixp.lisp
+./centaur/misc/ap.lisp
+./centaur/misc/tuplep.lisp
+./centaur/misc/alist-canonicalize.lisp
+./centaur/defrstobj2/multityped-records.lisp
+./centaur/defrstobj2/def-multityped-record.lisp
+./centaur/defrstobj2/portcullis.lisp
+./centaur/defrstobj2/defrstobj.lisp
+./centaur/fty/bitstruct-theory.lisp
+./centaur/fty/fixequiv.lisp
+./centaur/fty/fixtype.lisp
+./centaur/fty/top.lisp
+./centaur/fty/fty-sum.lisp
+./centaur/fty/deftypes.lisp
+./centaur/fty/bitstruct.lisp
+./centaur/fty/baselists.lisp
+./centaur/fty/docgen.lisp
+./centaur/fty/typegraph.lisp
+./centaur/fty/fty-sum-casemacro.lisp
+./centaur/fty/fty-alist.lisp
+./centaur/fty/fty-transsum.lisp
+./centaur/fty/fty-list.lisp
+./centaur/fty/database.lisp
+./centaur/fty/tests/fixequiv.lisp
+./centaur/fty/tests/utils.lisp
+./centaur/fty/tests/top.lisp
+./centaur/fty/tests/bitstruct.lisp
+./centaur/fty/tests/terms.lisp
+./centaur/fty/tests/simple.lisp
+./centaur/fty/tests/deftranssum.lisp
+./centaur/fty/tests/defprod-scale.lisp
+./centaur/fty/tests/deftagsum-scale.lisp
+./centaur/fty/tests/doc.lisp
+./centaur/fty/tests/visitor.lisp
+./centaur/fty/portcullis.lisp
+./centaur/fty/fty-parseutils.lisp
+./centaur/fty/basetypes.lisp
+./centaur/fty/fty-sugar.lisp
+./centaur/fty/visitor.lisp
+./centaur/bitops/floor.lisp
+./centaur/bitops/ihsext-basics.lisp
+./centaur/bitops/top.lisp
+./centaur/bitops/logsaturate.lisp
+./centaur/bitops/congruences.lisp
+./centaur/bitops/width-find-rule.lisp
+./centaur/bitops/trailing-0-count.lisp
+./centaur/bitops/sparseint.lisp
+./centaur/bitops/floor-mod.lisp
+./centaur/bitops/fast-rotate.lisp
+./centaur/bitops/parity.lisp
+./centaur/bitops/fast-logrev.lisp
+./centaur/bitops/contrib/ash-of-a-constant.lisp
+./centaur/bitops/contrib/log2.lisp
+./centaur/bitops/extra-defs.lisp
+./centaur/bitops/equal-by-logbitp.lisp
+./centaur/bitops/ash-bounds.lisp
+./centaur/bitops/fast-logext.lisp
+./centaur/bitops/portcullis.lisp
+./centaur/bitops/logbitp-bounds.lisp
+./centaur/bitops/rotate.lisp
+./centaur/bitops/fast-part-select.lisp
+./centaur/bitops/merge.lisp
+./centaur/bitops/signed-byte-p.lisp
+./centaur/bitops/limited-shifts.lisp
+./centaur/bitops/logbitp-mismatch.lisp
+./centaur/bitops/ihs-extensions.lisp
+./centaur/bitops/part-select.lisp
+./centaur/bitops/saturate.lisp
+./centaur/bitops/part-install.lisp
+./centaur/bitops/defaults.lisp
+./centaur/bitops/install-bit.lisp
+./centaur/bitops/logrepeat.lisp
+./centaur/bitops/integer-length.lisp
+./centaur/sv/mods/lhs.lisp
+./centaur/sv/mods/moddb.lisp
+./centaur/sv/mods/top.lisp
+./centaur/sv/mods/address.lisp
+./centaur/sv/mods/alias-norm.lisp
+./centaur/sv/mods/path-string.lisp
+./centaur/sv/mods/svmods.lisp
+./centaur/sv/mods/compile.lisp
+./centaur/sv/top.lisp
+./centaur/sv/svex/rsh-concat.lisp
+./centaur/sv/svex/4vec-subtypes.lisp
+./centaur/sv/svex/svex.lisp
+./centaur/sv/svex/alist-equiv.lisp
+./centaur/sv/svex/a4vec-ops.lisp
+./centaur/sv/svex/compose.lisp
+./centaur/sv/svex/rewrite.lisp
+./centaur/sv/svex/4vmask.lisp
+./centaur/sv/svex/top.lisp
+./centaur/sv/svex/xeval.lisp
+./centaur/sv/svex/concat-rw.lisp
+./centaur/sv/svex/compose-theory-compose-steps.lisp
+./centaur/sv/svex/context-alist.lisp
+./centaur/sv/svex/s4vec.lisp
+./centaur/sv/svex/env-norm.lisp
+./centaur/sv/svex/eval.lisp
+./centaur/sv/svex/monotonify.lisp
+./centaur/sv/svex/freq.lisp
+./centaur/sv/svex/letabstract.lisp
+./centaur/sv/svex/compose-theory-compose-correct.lisp
+./centaur/sv/svex/argmasks.lisp
+./centaur/sv/svex/lattice.lisp
+./centaur/sv/svex/lists.lisp
+./centaur/sv/svex/svex-equivs.lisp
+./centaur/sv/svex/rewrite-base.lisp
+./centaur/sv/svex/4vec.lisp
+./centaur/sv/svex/a4vec.lisp
+./centaur/sv/svex/junk.lisp
+./centaur/sv/svex/aig-arith.lisp
+./centaur/sv/svex/gl-rules.lisp
+./centaur/sv/svex/env-ops.lisp
+./centaur/sv/svex/symbolic.lisp
+./centaur/sv/svex/nrev.lisp
+./centaur/sv/svex/vars.lisp
+./centaur/sv/svex/constraints.lisp
+./centaur/sv/svex/4vec-base.lisp
+./centaur/sv/svex/rewrite-trace.lisp
+./centaur/sv/svex/rewrite-rules.lisp
+./centaur/sv/svex/select.lisp
+./centaur/sv/svex/compose-theory-base.lisp
+./centaur/sv/svex/unroll.lisp
+./centaur/sv/svex/seval.lisp
+./centaur/sv/cosims/cosims.lisp
+./centaur/sv/svtv/preprocess.lisp
+./centaur/sv/svtv/svtv-stobj-defcycle.lisp
+./centaur/sv/svtv/design-fsm.lisp
+./centaur/sv/svtv/vcd.lisp
+./centaur/sv/svtv/top.lisp
+./centaur/sv/svtv/chase.lisp
+./centaur/sv/svtv/decomp.lisp
+./centaur/sv/svtv/print.lisp
+./centaur/sv/svtv/fsm-obj.lisp
+./centaur/sv/svtv/expand.lisp
+./centaur/sv/svtv/svex-env-to-alist.lisp
+./centaur/sv/svtv/process.lisp
+./centaur/sv/svtv/pipeline.lisp
+./centaur/sv/svtv/new-svtv-doc.lisp
+./centaur/sv/svtv/cycle-compile.lisp
+./centaur/sv/svtv/svtv-stobj-util.lisp
+./centaur/sv/svtv/fsm-base.lisp
+./centaur/sv/svtv/cycle-base.lisp
+./centaur/sv/svtv/chase-base.lisp
+./centaur/sv/svtv/compose-phases.lisp
+./centaur/sv/svtv/probe.lisp
+./centaur/sv/svtv/structure.lisp
+./centaur/sv/svtv/debug.lisp
+./centaur/sv/svtv/eval-phases.lisp
+./centaur/sv/svtv/svtv-stobj-phase.lisp
+./centaur/sv/svtv/doc.lisp
+./centaur/sv/svtv/resolve.lisp
+./centaur/sv/svtv/new-svtv-top.lisp
+./centaur/sv/svtv/svtv-stobj-pipeline.lisp
+./centaur/sv/svtv/svtv-stobj-export.lisp
+./centaur/sv/svtv/svtv-stobj-cycle.lisp
+./centaur/sv/svtv/svtv-stobj-debug.lisp
+./centaur/sv/svtv/svtv-stobj-rewrite.lisp
+./centaur/sv/svtv/svtv-stobj-defsvtv.lisp
+./centaur/sv/svtv/svtv-stobj.lisp
+./centaur/sv/svtv/assign.lisp
+./centaur/sv/svtv/fsm.lisp
+./centaur/sv/tutorial/support.lisp
+./centaur/sv/tutorial/counter.lisp
+./centaur/sv/tutorial/booth-support.lisp
+./centaur/sv/tutorial/alu.lisp
+./centaur/sv/tutorial/sums.lisp
+./centaur/sv/tutorial/boothpipe.lisp
+./centaur/sv/vl/elaborate.lisp
+./centaur/sv/vl/moddb.lisp
+./centaur/sv/vl/svstmt.lisp
+./centaur/sv/vl/top.lisp
+./centaur/sv/vl/literal.lisp
+./centaur/sv/vl/vl-svstmt.lisp
+./centaur/sv/vl/use-set.lisp
+./centaur/sv/vl/svstmt-compile.lisp
+./centaur/sv/vl/trunc.lisp
+./centaur/sv/vl/expr.lisp
+./centaur/sv/portcullis.lisp
+./centaur/sv/top-doc.lisp
+./centaur/ipasir/ipasir-logic.lisp
+./centaur/ipasir/ipasir-backend.lisp
+./centaur/ipasir/soundness-bug-fixed.lisp
+./centaur/ipasir/soundness-bug2-fixed.lisp
+./centaur/ipasir/portcullis.lisp
+./centaur/ipasir/ipasir-backend-extra.lisp
+./centaur/ipasir/ipasir-tools.lisp
+./centaur/ipasir/ipasir-tests.lisp
+./centaur/meta/lambda-measure.lisp
+./centaur/meta/equivalence.lisp
+./centaur/meta/reconstruct.lisp
+./centaur/meta/world-equiv.lisp
+./centaur/meta/def-formula-checks.lisp
+./centaur/meta/term-vars.lisp
+./centaur/meta/urewrite.lisp
+./centaur/meta/assoc-is-hons-assoc.lisp
+./centaur/meta/let-abs.lisp
+./centaur/meta/bindinglist.lisp
+./centaur/meta/resolve-flag-cp.lisp
+./centaur/meta/substitute.lisp
+./centaur/meta/congruence.lisp
+./centaur/meta/portcullis.lisp
+./centaur/meta/subst.lisp
+./centaur/meta/pseudo-rewrite-rule.lisp
+./centaur/meta/unify-strict.lisp
+./centaur/meta/parse-rewrite.lisp
+./centaur/bed/top.lisp
+./centaur/bed/print.lisp
+./centaur/bed/eval.lisp
+./centaur/bed/mk1.lisp
+./centaur/bed/portcullis.lisp
+./centaur/bed/aig.lisp
+./centaur/bed/up.lisp
+./centaur/bed/ops.lisp
+./centaur/gl/shape-spec-defs.lisp
+./centaur/gl/bvecs.lisp
+./centaur/gl/split-args.lisp
+./centaur/gl/rws.lisp
+./centaur/gl/constraint-db.lisp
+./centaur/gl/bfr.lisp
+./centaur/gl/gl-generic-interp-defs.lisp
+./centaur/gl/secondary-types.lisp
+./centaur/gl/run-gified-cp.lisp
+./centaur/gl/gobject-type-thms.lisp
+./centaur/gl/eval-f-i-cp.lisp
+./centaur/gl/gl.lisp
+./centaur/gl/glcp-geval.lisp
+./centaur/gl/g-always-equal.lisp
+./centaur/gl/gtypes.lisp
+./centaur/gl/g-assert.lisp
+./centaur/gl/ite-merge.lisp
+./centaur/gl/gl-generic-clause-proc.lisp
+./centaur/gl/glcp-unify-thms.lisp
+./centaur/gl/glcp-geval-thms.lisp
+./centaur/gl/general-objects.lisp
+./centaur/gl/auto-bindings.lisp
+./centaur/gl/rewrites.lisp
+./centaur/gl/g-if.lisp
+./centaur/gl/factor-fns.lisp
+./centaur/gl/g-truncate.lisp
+./centaur/gl/def-gl-clause-proc.lisp
+./centaur/gl/glcp-config.lisp
+./centaur/gl/shape-spec.lisp
+./centaur/gl/g-predicates.lisp
+./centaur/gl/bfr-sat.lisp
+./centaur/gl/eval-g-base-help.lisp
+./centaur/gl/eval-g-base.lisp
+./centaur/gl/glcp-rewrite-tables.lisp
+./centaur/gl/gobject-types.lisp
+./centaur/gl/always-equal-prep.lisp
+./centaur/gl/bfr-satlink.lisp
+./centaur/gl/g-make-fast-alist.lisp
+./centaur/gl/gtype-thms.lisp
+./centaur/gl/g-unary-concrete.lisp
+./centaur/gl/var-bounds.lisp
+./centaur/gl/gl-util.lisp
+./centaur/gl/g-lessthan.lisp
+./centaur/gl/pseudo-termp-lemmas.lisp
+./centaur/gl/bfr-param.lisp
+./centaur/gl/gl-generic-interp.lisp
+./centaur/gl/g-binary-+.lisp
+./centaur/gl/prof.lisp
+./centaur/gl/gify.lisp
+./centaur/gl/bfr-reasoning.lisp
+./centaur/gl/defagg.lisp
+./centaur/gl/g-binary-mult.lisp
+./centaur/gl/defthm-using-gl.lisp
+./centaur/gl/g-concretize.lisp
+./centaur/gl/gl-mbe.lisp
+./centaur/gl/and-star.lisp
+./centaur/gl/bfr-aig-bddify.lisp
+./centaur/gl/g-integer-length.lisp
+./centaur/gl/symbolic-arithmetic.lisp
+./centaur/gl/glcp-unify-defs.lisp
+./centaur/gl/portcullis.lisp
+./centaur/gl/gtests.lisp
+./centaur/gl/general-object-thms.lisp
+./centaur/gl/gify-thms.lisp
+./centaur/gl/glcp-templates.lisp
+./centaur/gl/g-coerce.lisp
+./centaur/gl/gl-misc-defs.lisp
+./centaur/gl/doc.lisp
+./centaur/gl/bfr-fraig-satlink.lisp
+./centaur/gl/top-doc.lisp
+./centaur/gl/bvar-db.lisp
+./centaur/gl/g-equal.lisp
+./centaur/gl/g-logops.lisp
+./centaur/gl/def-gl-rule.lisp
+./centaur/gl/try-gl.lisp
+./centaur/gl/ctrex-utils.lisp
+./centaur/gl/g-primitives-help.lisp
+./centaur/gl/g-ash.lisp
+./centaur/gl/hyp-fix.lisp
+./centaur/gl/gl-ttags.lisp
+./centaur/gl/g-logbitp.lisp
+./centaur/gl/constraint-db-deps.lisp
+./centaur/gl/tutorial.lisp
+./centaur/gl/g-unary--.lisp
+./centaur/gl/g-cons.lisp
+./centaur/gl/defapply.lisp
+./centaur/gl/arith-lemmas.lisp
+./centaur/gl/g-logapp.lisp
+./centaur/gl/g-hide.lisp
+./centaur/gl/def-gl-rewrite.lisp
+./centaur/gl/param.lisp
+./centaur/gl/rewrite-tables.lisp
+./centaur/gl/generic-geval.lisp
+./centaur/acre/parse.lisp
+./centaur/acre/top.lisp
+./centaur/acre/types.lisp
+./centaur/acre/tests.lisp
+./centaur/acre/portcullis.lisp
+./centaur/acre/match.lisp
+./centaur/quicklisp/bordeaux.lisp
+./centaur/quicklisp/uiop.lisp
+./centaur/quicklisp/base.lisp
+./centaur/quicklisp/top.lisp
+./centaur/quicklisp/osicat.lisp
+./centaur/quicklisp/fastnumio.lisp
+./centaur/quicklisp/html-template.lisp
+./centaur/quicklisp/hunchentoot.lisp
+./centaur/quicklisp/cffi.lisp
+./centaur/quicklisp/bt-semaphore.lisp
+./centaur/quicklisp/cl-fad.lisp
+./centaur/quicklisp/shellpool.lisp
+./centaur/defrstobj/typed-record-tests.lisp
+./centaur/defrstobj/basic-tests.lisp
+./centaur/defrstobj/def-typed-record.lisp
+./centaur/defrstobj/portcullis.lisp
+./centaur/defrstobj/generic.lisp
+./centaur/defrstobj/defrstobj.lisp
+./centaur/defrstobj/typed-records.lisp
+./centaur/4v-sexpr/sexpr-eval.lisp
+./centaur/4v-sexpr/sexpr-3v.lisp
+./centaur/4v-sexpr/sexpr-vars-1pass.lisp
+./centaur/4v-sexpr/sexpr-fixpoint-correct.lisp
+./centaur/4v-sexpr/compose-sexpr.lisp
+./centaur/4v-sexpr/top.lisp
+./centaur/4v-sexpr/sexpr-fixpoint-top.lisp
+./centaur/4v-sexpr/nsexprs.lisp
+./centaur/4v-sexpr/sexpr-loop-debug.lisp
+./centaur/4v-sexpr/sfaig.lisp
+./centaur/4v-sexpr/sexpr-advanced.lisp
+./centaur/4v-sexpr/sexpr-building.lisp
+./centaur/4v-sexpr/sexpr-freq.lisp
+./centaur/4v-sexpr/bitspecs.lisp
+./centaur/4v-sexpr/sexpr-booleval.lisp
+./centaur/4v-sexpr/sexpr-rewrites.lisp
+./centaur/4v-sexpr/4v-logic.lisp
+./centaur/4v-sexpr/g-sexpr-eval.lisp
+./centaur/4v-sexpr/sexpr-to-faig.lisp
+./centaur/4v-sexpr/sexpr-fixpoint.lisp
+./centaur/4v-sexpr/sexpr-equivs.lisp
+./centaur/4v-sexpr/portcullis.lisp
+./centaur/4v-sexpr/sexpr-vars.lisp
+./centaur/4v-sexpr/sexpr-purebool-p.lisp
+./centaur/4v-sexpr/sexpr-fixpoint-spec.lisp
+./centaur/4v-sexpr/sexpr-fixpoint-rewriting.lisp
+./centaur/4v-sexpr/svarmap.lisp
+./centaur/4v-sexpr/onehot-rewrite.lisp
+./build/ifdef.lisp
+./build/portcullis.lisp
+./build/doc.lisp
+./build/test/top.lisp
+./build/test/dollar$test$5.lisp
+./build/test/dollar-test3.$bar.lisp
+./build/test/dollar-test1$.lisp
+./build/test/dollar-test3.bar.lisp
+./build/test/ifdeftest/thm-base.lisp
+./build/test/ifdeftest/defs.lisp
+./build/test/ifdeftest/thms.lisp
+./build/test/dollar$test4.lisp
+./build/test/dollar-test1.lisp
+./build/test/dollar-test2.foo$.lisp
+./build/test/dollar-test2.foo.lisp
+./build/test/dollar$test$$6.lisp
Index: acl2-8.5dfsg/books/build/Makefile-features
===================================================================
--- /dev/null
+++ acl2-8.5dfsg/books/build/Makefile-features
@@ -0,0 +1 @@
+EXPORT_SHELL_ENV := $(foreach v,$(EXPORTED_VARS),$(v)='$($(v))')
Index: acl2-8.5dfsg/books/build/Makefile-features.out
===================================================================
--- /dev/null
+++ acl2-8.5dfsg/books/build/Makefile-features.out
@@ -0,0 +1 @@
+/bin/bash: line 1: /home/camm/acl2-8.4dfsg/saved_acl2: No such file or directory
Index: acl2-8.5dfsg/books/centaur/aignet/observability.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/aignet/observability.lisp
+++ acl2-8.5dfsg/books/centaur/aignet/observability.lisp
@@ -324,7 +324,7 @@
                                         (state))
   ;; Lit is a literal in aignet2.  Find a satisfying assignment for it if one
   ;; exists.  Update the copies of the PIs and regs of aignet to be new ones of
-  ;; the form: if (lit or dont-care in minimized counterex) then
+  ;; the form: if (lit or don't-care in minimized counterex) then
   ;; previous-copy-value, else satisfying-assign-value.
   ;; If unsat, map all inputs to false.  If sat check fails, don't remap the inputs.
 
Index: acl2-8.5dfsg/books/centaur/esim/occform/top.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/esim/occform/top.lisp
+++ acl2-8.5dfsg/books/centaur/esim/occform/top.lisp
@@ -761,7 +761,7 @@ module instance."
                        dangerous because whereas NCVerilog properly carries ~
                        out a comparison between 2's complement numbers, ~
                        Verilog-XL incorrectly uses an unsigned comparison.  ~
-                       We follow the Verilog-2005 standard and mimick ~
+                       We follow the Verilog-2005 standard and mimic ~
                        NCVerilog, but to ensure compatibility across Verilog ~
                        implementations, you should probably not use signed ~
                        comparisons.  Some typical causes of signedness are ~
Index: acl2-8.5dfsg/books/centaur/esim/stv/stv-compile.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/esim/stv/stv-compile.lisp
+++ acl2-8.5dfsg/books/centaur/esim/stv/stv-compile.lisp
@@ -192,12 +192,12 @@ turned into a list like @('(|opcode[0]|
                     bits wide." pnum name width))
         (or prev-val
             (raise "Phase ~x0 for ~x1: value ~~ is not legal here.  It must ~
-                    be preceeded by a constant true or false, so it cannot be ~
+                    be preceded by a constant true or false, so it cannot be ~
                     used at the start of a line." pnum name))
         (or (equal prev-val (list *4vt-sexpr*))
             (equal prev-val (list *4vf-sexpr*))
             (raise "Phase ~x0 for ~x1: value ~~ is not legal here.  It must ~
-                    be preceeded by a constant true or false, but the ~
+                    be preceded by a constant true or false, but the ~
                     previous value was ~x2." pnum name prev-val))
         (mv (if (equal prev-val (list *4vt-sexpr*))
                 (list *4vf-sexpr*)
Index: acl2-8.5dfsg/books/centaur/fgl/interp.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/fgl/interp.lisp
+++ acl2-8.5dfsg/books/centaur/fgl/interp.lisp
@@ -291,7 +291,7 @@
                       (if (or (consp err) (stringp err)) err "(no message)"))))
        ((unless (fgl-bfr-object-p val (interp-st-bfr-state)))
         (fgl-interp-error
-         :msg (fgl-msg "Syntax-bind error: ~x0 evaluted to an illformed symbolic object, saved as debug object."
+         :msg (fgl-msg "Syntax-bind error: ~x0 evaluated to an illformed symbolic object, saved as debug object."
                       (pseudo-term-quote->val untrans))
          :debug-obj val)))
     (fgl-interp-value val))
Index: acl2-8.5dfsg/books/centaur/ipasir/ipasir-interface-raw.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/ipasir/ipasir-interface-raw.lsp
+++ acl2-8.5dfsg/books/centaur/ipasir/ipasir-interface-raw.lsp
@@ -371,7 +371,7 @@
 (defun ipasir-val$c (ipasir lit)
   (let* ((dimacs-lit (satlink::satlink-to-dimacs-lit lit))
          (result-lit (ipasir-raw::ipasir-val (ipasir-get-raw ipasir) dimacs-lit)))
-    (cond ((int= result-lit 0) nil) ;; dont-care
+    (cond ((int= result-lit 0) nil) ;; don't-care
           ((int= result-lit (- dimacs-lit)) 0)
           ((int= result-lit dimacs-lit) 1)
           (t (er hard? 'ipasir-val
Index: acl2-8.5dfsg/books/centaur/memoize/old/watch-raw.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/memoize/old/watch-raw.lsp
+++ acl2-8.5dfsg/books/centaur/memoize/old/watch-raw.lsp
@@ -22,7 +22,7 @@
 
 (defmacro defn1 (f a &rest r)
   (when (intersection a lambda-list-keywords)
-    (error "DEFN1: ** In the defintion of ~s, the argument list ~s ~
+    (error "DEFN1: ** In the definition of ~s, the argument list ~s ~
             contains a member of lambda-list-keywords so do not ~
             use defn1."
            f a))
Index: acl2-8.5dfsg/books/centaur/sv/vl/vl-svstmt.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/sv/vl/vl-svstmt.lisp
+++ acl2-8.5dfsg/books/centaur/sv/vl/vl-svstmt.lisp
@@ -1149,7 +1149,7 @@ because... (BOZO)</p>
                                        x)))))
           (mv ok
               (warn :type :vl-delay-ignored
-                    :msg "Ignoring delay control on statment ~a0"
+                    :msg "Ignoring delay control on statement ~a0"
                     :args (list x))
               substmts))
         :vl-assertstmt
Index: acl2-8.5dfsg/books/centaur/vl/loader/parser/insts.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl/loader/parser/insts.lisp
+++ acl2-8.5dfsg/books/centaur/vl/loader/parser/insts.lisp
@@ -94,7 +94,7 @@ with no ports.  And a funny consequence
 a one-port module with a blank, unless named argument lists are used.</p>
 
 <p>Cadence's handling seems like the most sensible choice, and we are going to
-mimick it.  Because this is somewhat delicate, we also include a number of unit
+mimic it.  Because this is somewhat delicate, we also include a number of unit
 tests at the bottom of this file.</p>")
 
 ; list_of_port_connections ::=
Index: acl2-8.5dfsg/books/centaur/vl/server/public/lib/jquery-2.1.0.js
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl/server/public/lib/jquery-2.1.0.js
+++ acl2-8.5dfsg/books/centaur/vl/server/public/lib/jquery-2.1.0.js
@@ -1071,7 +1071,7 @@ setDocument = Sizzle.setDocument = funct
 
 	// Support: IE<10
 	// Check if getElementById returns elements by name
-	// The broken getElementById methods don't pick up programatically-set names,
+	// The broken getElementById methods don't pick up programmatically-set names,
 	// so use a roundabout getElementsByName test
 	support.getById = assert(function( div ) {
 		docElem.appendChild( div ).id = expando;
Index: acl2-8.5dfsg/books/centaur/vl/transforms/annotate/make-implicit-wires.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl/transforms/annotate/make-implicit-wires.lisp
+++ acl2-8.5dfsg/books/centaur/vl/transforms/annotate/make-implicit-wires.lisp
@@ -168,7 +168,7 @@ right-hand side of an @('assign') statem
 <p><b>#3</b>.  As expected, NCVerilog allows us to infer implicit nets from the
 left-hand sides of @('assign') elements.  Unfortunately, Verilog-XL complains
 about such wires, which seems to contradict the Verilog-2005 standard.  We
-choose to mimick NCVerilog and infer the implicit net.  Historically we also
+choose to mimic NCVerilog and infer the implicit net.  Historically we also
 issued warnings that other tools like Verilog-XL may not allow the construct,
 but these warnings seemed to be noise and we eventually decided that it would
 be better not to issue them.</p>
@@ -187,7 +187,7 @@ assign w = a;').</p>
 
 <p>This seems arguably incorrect: is not a procedural continuous assignment
 also a continuous assignment, whose LHS should therefore be able to contain
-implicit wires?  But we mimick these tools and disallow the implicit net, even
+implicit wires?  But we mimic these tools and disallow the implicit net, even
 thought the spec might perhaps be interpreted as allowing it.</p>
 
 <p>A nice consequence of disallowing implicit wires here is that it allows us
@@ -258,7 +258,7 @@ buf(c, c2);
 wire c;
 })
 
-<p>We try to be permissive and mimick NCVerilog, but add a (non-fatal) warning
+<p>We try to be permissive and mimic NCVerilog, but add a (non-fatal) warning
 if a wire's net declaration comes before its port declaration to explain that
 some other tools do not permit this.</p>
 
Index: acl2-8.5dfsg/books/centaur/vl2014/loader/parser/insts.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl2014/loader/parser/insts.lisp
+++ acl2-8.5dfsg/books/centaur/vl2014/loader/parser/insts.lisp
@@ -95,7 +95,7 @@ with no ports.  And a funny consequence
 a one-port module with a blank, unless named argument lists are used.</p>
 
 <p>Cadence's handling seems like the most sensible choice, and we are going to
-mimick it.  Because this is somewhat delicate, we also include a number of unit
+mimic it.  Because this is somewhat delicate, we also include a number of unit
 tests at the bottom of this file.</p>")
 
 ; list_of_port_connections ::=
Index: acl2-8.5dfsg/books/centaur/vl2014/server/public/lib/jquery-2.1.0.js
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl2014/server/public/lib/jquery-2.1.0.js
+++ acl2-8.5dfsg/books/centaur/vl2014/server/public/lib/jquery-2.1.0.js
@@ -1071,7 +1071,7 @@ setDocument = Sizzle.setDocument = funct
 
 	// Support: IE<10
 	// Check if getElementById returns elements by name
-	// The broken getElementById methods don't pick up programatically-set names,
+	// The broken getElementById methods don't pick up programmatically-set names,
 	// so use a roundabout getElementsByName test
 	support.getById = assert(function( div ) {
 		docElem.appendChild( div ).id = expando;
Index: acl2-8.5dfsg/books/centaur/vl2014/transforms/always/latchcode.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl2014/transforms/always/latchcode.lisp
+++ acl2-8.5dfsg/books/centaur/vl2014/transforms/always/latchcode.lisp
@@ -471,7 +471,7 @@ sanity checking."
        ((unless (posp width))
         (mv x cvtregs
             (dwarn :type :vl-latchcode-fail
-                   :msg "~a0: can't synthesize always block becasue the width ~
+                   :msg "~a0: can't synthesize always block because the width ~
                          of the lhs, ~a1, hasn't been computed or isn't a ~
                          positive number.  Its width is ~a2."
                    :args (list x lhs width))))
Index: acl2-8.5dfsg/books/centaur/vl2014/transforms/annotate/make-implicit-wires.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl2014/transforms/annotate/make-implicit-wires.lisp
+++ acl2-8.5dfsg/books/centaur/vl2014/transforms/annotate/make-implicit-wires.lisp
@@ -161,7 +161,7 @@ right-hand side of an @('assign') statem
 <p><b>#3</b>.  As expected, NCVerilog allows us to infer implicit nets from the
 left-hand sides of @('assign') elements.  Unfortunately, Verilog-XL complains
 about such wires, which seems to contradict the Verilog-2005 standard.  As a
-compromise, our approach is to mimick NCVerilog and infer the implicit net, but
+compromise, our approach is to mimic NCVerilog and infer the implicit net, but
 warn that some other tools like Verilog-XL may not allow the construct.</p>
 
 <p>A subtle case is, what if #2 and #3 overlap, i.e., an undeclared wire occurs
@@ -178,7 +178,7 @@ assign w = a;').  But this seems arguabl
 continuous assignment also a continuous assignment, whose LHS should therefore
 be able to contain implicit wires?</p>
 
-<p>We mimick these tools and disallow the implicit net, even thought the spec
+<p>We mimic these tools and disallow the implicit net, even thought the spec
 might perhaps be interpreted as allowing it, because it allows us to avoid
 certain scoping issues.  In particular, suppose we see a procedural continuous
 assignment statement, @('assign w = ...'), where @('w') is not declared.  If
@@ -247,7 +247,7 @@ buf(c, c2);
 wire c;
 })
 
-<p>We try to be permissive and mimick NCVerilog, but add a (non-fatal) warning
+<p>We try to be permissive and mimic NCVerilog, but add a (non-fatal) warning
 if a wire's net declaration comes before its port declaration to explain that
 some other tools do not permit this.</p>
 
Index: acl2-8.5dfsg/books/centaur/vl2014/transforms/expr-size.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/centaur/vl2014/transforms/expr-size.lisp
+++ acl2-8.5dfsg/books/centaur/vl2014/transforms/expr-size.lisp
@@ -356,7 +356,7 @@ instead, producing a final result of 1.
 
 <p>The implementations seem to agree that the types of these operands should
 not matter.  Since we think the spec is vague and does not say one way or
-another, we mimick their behavior.  However, we also issue warnings when we
+another, we mimic their behavior.  However, we also issue warnings when we
 encounter one of these operands with an unsigned self-determined operand and
 signed nonself-determined operands, since this is a case that other
 implementations might be confused about.  See @(see vl-expr-typedecide-aux) for
@@ -1593,7 +1593,7 @@ a signed value since Verilog-XL doesn't
                 follows the Verilog-2005 standard (5.1.12) and treats the ~
                 right-hand side as unsigned, Verilog-XL incorrectly treats ~
                 negative right-shifts as left-shifts.  We follow the ~
-                Verilog-2005 standard and mimick NCVerilog, but to ensure ~
+                Verilog-2005 standard and mimic NCVerilog, but to ensure ~
                 compatibility, you should probably rewrite this expression to ~
                 ensure that the right-hand side is unsigned.  For example, ~
                 you might wrap the right-hand side in a concatnation, e.g., ~
@@ -2354,7 +2354,7 @@ minor warning for assignments where the
                               (eq (vl-nonatom->op b) :vl-concat)))
                  (mv nil
                      (fatal :type :vl-programming-error
-                            :msg "~a0: multple concatenation's second argument ~
+                            :msg "~a0: multiple concatenation's second argument ~
                                isn't a concatenation?? ~a1"
                             :args (list ctx x))
                      x))
Index: acl2-8.5dfsg/books/coi/bags/bind-free-rules.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/coi/bags/bind-free-rules.lisp
+++ acl2-8.5dfsg/books/coi/bags/bind-free-rules.lisp
@@ -57,7 +57,7 @@
 
 ;we look through HYPS for a term of the form (subbagp x y)
 ;if such an item is found, we return (mv t y).  else, we return (mv nil nil)
-;what if multple such things might be found?
+;what if multiple such things might be found?
 (defun find-exact-subbagp-instance (x hyps)
   (declare (type t hyps)
            )
@@ -139,7 +139,7 @@
 ;what does this do?
 ;we look through HYPS for a term of the form (subbagp x BLAH)
 ;if such an item is found, we test whether BLAH equals y.  else, we return nil
-;what if multple such things might be found?
+;what if multiple such things might be found?
 (defun subbagp-instance (x y hyps)
   (declare (type t x y hyps))
   (met ((hit res) (find-exact-subbagp-instance x hyps))
@@ -1289,7 +1289,7 @@
       nil)))
 
 
-;local becasue the :meta rules that come later will be able to get this
+;local because the :meta rules that come later will be able to get this
 (local
  (defthm not-unique-doublet
    (not (bag::unique (list x x)))))
Index: acl2-8.5dfsg/books/coi/defstructure/defstructure.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/coi/defstructure/defstructure.lisp
+++ acl2-8.5dfsg/books/coi/defstructure/defstructure.lisp
@@ -3198,7 +3198,7 @@ For debugging.
         (CAPSULE
          "
 ;  We define the structure and all of the events (except the assertion theory)
-;  in the absoulte minimum theory possible in order to expedite the proofs
+;  in the absolute minimum theory possible in order to expedite the proofs
 ;  and guarantee that they will always work.  If you ever find a case where
 ;  one of these proof fails (except due to user syntax errors) please
 ;  report it as a bug in DEFSTRUCTURE.
Index: acl2-8.5dfsg/books/coi/super-ihs/logical-logops.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/coi/super-ihs/logical-logops.lisp
+++ acl2-8.5dfsg/books/coi/super-ihs/logical-logops.lisp
@@ -798,7 +798,7 @@
 ;;   :hints (("goal" :in-theory (enable logxor logeqv logorc1))))
 
 ;; ;; Perhaps we should just open logxor.  But for now, we'll open it
-;; ;; only when used in conjuction with logical bit-operations.
+;; ;; only when used in conjunction with logical bit-operations.
 ;; (defthm logxor-open
 ;;   (implies (and (integerp x)
 ;;                 (integerp y))
Index: acl2-8.5dfsg/books/coi/termination/assuming/compiler.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/coi/termination/assuming/compiler.lisp
+++ acl2-8.5dfsg/books/coi/termination/assuming/compiler.lisp
@@ -167,7 +167,7 @@
   (syn::or-fn args))
 
 ;; Here we define the function that actually rips apart the body of a
-;; function defintion and creates candidates for the stubbed out foo
+;; function definition and creates candidates for the stubbed out foo
 ;; functions.
 
 (defun lambda-bod (expr)
Index: acl2-8.5dfsg/books/data-structures/structures.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/data-structures/structures.lisp
+++ acl2-8.5dfsg/books/data-structures/structures.lisp
@@ -2720,7 +2720,7 @@ For debugging.
 	(CAPSULE
 	 "
 ;  We define the structure and all of the events (except the assertion theory)
-;  in the absoulte minimum theory possible in order to expedite the proofs
+;  in the absolute minimum theory possible in order to expedite the proofs
 ;  and guarantee that they will always work.  If you ever find a case where
 ;  one of these proof fails (except due to user syntax errors) please
 ;  report it as a bug in DEFSTRUCTURE.
Index: acl2-8.5dfsg/books/defexec/other-apps/qsort/intermediate-program.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/defexec/other-apps/qsort/intermediate-program.lisp
+++ acl2-8.5dfsg/books/defexec/other-apps/qsort/intermediate-program.lisp
@@ -64,7 +64,7 @@ should follow easily.
 
 ;; We need to prove something about the lower-part and upper-part functions we
 ;; defined simply to get ourselves to admit the definition of qsort we have in
-;; mind. This sucks big time, but I dont see a more elegant way of proving the
+;; mind. This sucks big time, but I don't see a more elegant way of proving the
 ;; theorems. It is a clean blow to my normal structured proof techniques where I
 ;; define functions separately and prove facts about them later, --- clearly an
 ;; indication that qsort even functionally is not an easy function to reason
Index: acl2-8.5dfsg/books/hints/huet-lang-algorithm.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/hints/huet-lang-algorithm.lisp
+++ acl2-8.5dfsg/books/hints/huet-lang-algorithm.lisp
@@ -2438,7 +2438,7 @@
 
 (defun lambda-free-vars (alist) ; from ACL2 Version_3.0
 
-; We compute the free variables occuring the the lambda expressions in
+; We compute the free variables occurring the the lambda expressions in
 ; the range of the translated functional substitution alist.
 
   (cond ((null alist) nil)
Index: acl2-8.5dfsg/books/interface/emacs/inf-acl2.el
===================================================================
--- acl2-8.5dfsg.orig/books/interface/emacs/inf-acl2.el
+++ acl2-8.5dfsg/books/interface/emacs/inf-acl2.el
@@ -325,7 +325,7 @@ of `inferior-acl2-program').  Runs the h
 	 (filename (temporary-filename (process-id process)))
 	 (in-package-form-written nil))
     
-    ;; Write any IN-PACKAGE form (occuring immediately after a linefeed) 
+    ;; Write any IN-PACKAGE form (occurring immediately after a linefeed)
     ;; preceeding this region. Bevier. 11/5/90
     (save-excursion
       (goto-char begin)
Index: acl2-8.5dfsg/books/interface/infix/infix.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/interface/infix/infix.lisp
+++ acl2-8.5dfsg/books/interface/infix/infix.lisp
@@ -275,7 +275,7 @@ Below is such a call with keywords suppl
 -
 -   :mode       - if not provided (thus defaulting to nil) we look for
 -                 "fl-theory.lisp" and load it if present.  If not, we use
--                 the mode of the last successfull call to infix-file or
+-                 the mode of the last successful call to infix-file or
 -                 query whether you want to use Scribe or Latex mode.
 -                 In this last case you will need to know where the basic
 -                 theory files are located.  Simplest is to create a trivial
@@ -3795,7 +3795,7 @@ In which case we don't want to print *no
   (pprinc " recursively.")
   (no-tab-command-trailer))
 
-(define-command-printer q "Quiting ACL2.")
+(define-command-printer q "Quitting ACL2.")
 (define-command-printer redef "Allow redefinition without undoing.")
 (define-command-printer redef!
  "!!! ACL2 system hacker's redefinition command:
Index: acl2-8.5dfsg/books/kestrel/alists-light/lookup-eq.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/kestrel/alists-light/lookup-eq.lisp
+++ acl2-8.5dfsg/books/kestrel/alists-light/lookup-eq.lisp
@@ -13,7 +13,7 @@
 
 ;; STATUS: In-progress
 
-(include-book "lookup-equal") ;; included becase we rewrite lookup-eq to lookup-eqal
+(include-book "lookup-equal") ;; included because we rewrite lookup-eq to lookup-eqal
 
 ;; Look up KEY in ALIST, using eq as the test.
 (defund lookup-eq (key alist)
Index: acl2-8.5dfsg/books/kestrel/alists-light/lookup.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/kestrel/alists-light/lookup.lisp
+++ acl2-8.5dfsg/books/kestrel/alists-light/lookup.lisp
@@ -13,7 +13,7 @@
 
 ;; STATUS: In-progress
 
-(include-book "lookup-equal") ;; included becase we rewrite lookup to lookup-eqal
+(include-book "lookup-equal") ;; included because we rewrite lookup to lookup-eqal
 
 ;; Look up KEY in ALIST, using eql as the test (like assoc).
 (defund lookup (key alist)
Index: acl2-8.5dfsg/books/kestrel/ethereum/addresses.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/kestrel/ethereum/addresses.lisp
+++ acl2-8.5dfsg/books/kestrel/ethereum/addresses.lisp
@@ -76,6 +76,6 @@
   (xdoc::topstring
    (xdoc::p
     "We calculate the public key from the private key,
-     and then use @(tsee public-key-to-address) to calculate the addres."))
+     and then use @(tsee public-key-to-address) to calculate the address."))
   (public-key-to-address (secp256k1-priv-to-pub priv-key))
   :hooks (:fix))
Index: acl2-8.5dfsg/books/kestrel/java/atj/tutorial.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/kestrel/java/atj/tutorial.lisp
+++ acl2-8.5dfsg/books/kestrel/java/atj/tutorial.lisp
@@ -1196,7 +1196,7 @@
   (atj-tutorial-section "Representation of the ACL2 Function Definitions")
 
   (xdoc::p
-   "AIJ represents ACL2 functions as decribed in @(see atj-tutorial-acl2-terms).
+   "AIJ represents ACL2 functions as described in @(see atj-tutorial-acl2-terms).
     The "
    (xdoc::seetopic "atj-tutorial-simplified-uml"
                    "simplified UML class diagram")
Index: acl2-8.5dfsg/books/kestrel/java/atj/types.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/kestrel/java/atj/types.lisp
+++ acl2-8.5dfsg/books/kestrel/java/atj/types.lisp
@@ -1453,7 +1453,7 @@
         ((booleanp val) (atj-type-acl2 (atj-atype-boolean)))
         ((symbolp val) (atj-type-acl2 (atj-atype-symbol)))
         ((consp val) (atj-type-acl2 (atj-atype-cons)))
-        (t (prog2$ (raise "Internal errror: ~
+        (t (prog2$ (raise "Internal error: ~
                            the value ~x0 is not a number, ~
                            a character, a string, a symbol, or a CONS."
                           val)
Index: acl2-8.5dfsg/books/misc/disassemble.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/misc/disassemble.lisp
+++ acl2-8.5dfsg/books/misc/disassemble.lisp
@@ -96,7 +96,7 @@
                     ((and stobj-function
                           (cltl-def-from-name1 sym stobj-function t wrld))
                      (progn (observation ctx
-                                         "Not dissassembling ~x0, because it ~
+                                         "Not disassembling ~x0, because it ~
                                           is a macro in raw Lisp: the ~
                                           defstobj event for ~x1 specified ~
                                           :inline t.~|~%"
Index: acl2-8.5dfsg/books/misc/expander.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/misc/expander.lisp
+++ acl2-8.5dfsg/books/misc/expander.lisp
@@ -1484,7 +1484,7 @@ as the examples shown above.</p>
 (defun simp-hyps (hyps state hints inhibit-output print-flg simp-flg)
   "Given a list of terms (hyps), return a list that is a subset
   of hyps. The conjunction of hyps should be equal to the
-  conjuction of the returned list. If simp-flg is :t, all we do
+  conjunction of the returned list. If simp-flg is :t, all we do
   is to remove elements of hyps that can be proven to simplify to
   t, assuming the rest of the elements in hyps hold. If simp-flg
   is :term-order, then we replace elements of hyps with what they
Index: acl2-8.5dfsg/books/misc/redef-pkg.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/misc/redef-pkg.lisp
+++ acl2-8.5dfsg/books/misc/redef-pkg.lisp
@@ -137,7 +137,7 @@
         (syms (if (symbolp syms) (list syms) syms)))
     (when (or (null pkg-entry0)
               (null pkg-entry1))
-      (error "Uknown pkg, ~s" pkg))
+      (error "Unknown pkg, ~s" pkg))
     (when (not (symbol-listp syms))
       (error "Not a symbol-listp: ~s" syms))
     (let ((imports0 (package-entry-imports pkg-entry0))
Index: acl2-8.5dfsg/books/nonstd/nsa/trig-approx.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/nonstd/nsa/trig-approx.lisp
+++ acl2-8.5dfsg/books/nonstd/nsa/trig-approx.lisp
@@ -64,7 +64,7 @@
 ;; part and a (non-infinitesimal) small part, based on the epsilon
 ;; precision argument.  We want to claim that both parts of the split
 ;; are limited.  For the first part, we need to show that if nterms is
-;; limited, then so is the sumlist of taylor-sincos-list upto nterms.
+;; limited, then so is the sumlist of taylor-sincos-list up to nterms.
 ;; For the second, we'll need the fact that taylor-sincos-list is an
 ;; alternating sequence "after a while".
 
Index: acl2-8.5dfsg/books/ordinals/ordinal-definitions.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/ordinals/ordinal-definitions.lisp
+++ acl2-8.5dfsg/books/ordinals/ordinal-definitions.lisp
@@ -20,14 +20,14 @@
     (dropn (1- n) (cdr a))))
 
 (defun wcmp (a b)
-  "A comparitor function for numbers"
+  "A comparator function for numbers"
   (declare (xargs :guard (and (rationalp a) (rationalp b))))
   (cond ((= a b) 'eq)
 	((< a b) 'lt)
 	(t 'gt)))
 
 (defun ocmp-aux (x y)
-  "The efficient version of the comparitor function for ordinals"
+  "The efficient version of the comparator function for ordinals"
   (declare (xargs :guard (and (o-p x) (o-p y))))
   (cond ((and (o-finp x)
 	      (o-finp y))
@@ -47,7 +47,7 @@
 	     cmp-fe)))))
 
 (defun ocmp (x y)
-  "An efficient comparitor function for ordinals"
+  "An efficient comparator function for ordinals"
   (declare (xargs :guard (and (o-p x) (o-p y))
 		  :verify-guards nil))
   (mbe :logic (cond ((o< x y) 'lt)
Index: acl2-8.5dfsg/books/parsers/earley/examples/oracle-grammar.txt
===================================================================
--- acl2-8.5dfsg.orig/books/parsers/earley/examples/oracle-grammar.txt
+++ acl2-8.5dfsg/books/parsers/earley/examples/oracle-grammar.txt
@@ -124,7 +124,7 @@
 
 <TypeList> ::= 
     <ReferenceType> 
-  | <ReferenceType> <COMMAD> <TypeList>
+  | <ReferenceType> <COMMAND> <TypeList>
 
 <TypeArgumentsOrDiamond> ::= 
     <LT> <GT> 
Index: acl2-8.5dfsg/books/projects/apply-model-2/apply.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/apply-model-2/apply.lisp
+++ acl2-8.5dfsg/books/projects/apply-model-2/apply.lisp
@@ -1203,7 +1203,7 @@
 (defun guess-ilks-alist (fn new-badge term ilk wrld alist)
 
 ; Fn is the name of a function being defined.  New-badge is either nil or a
-; proposed badge for fn and term is a term (initally the body of fn) occuring
+; proposed badge for fn and term is a term (initally the body of fn) occurring
 ; in a slot of ilk ilk.  Note: term contains no ACL2 lambda applications!  We
 ; try to determine the ilks of the free vars in term, extending alist to record
 ; what we find.  We return (mv msg alist'), where either msg is an error
Index: acl2-8.5dfsg/books/projects/apply-model/apply.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/apply-model/apply.lisp
+++ acl2-8.5dfsg/books/projects/apply-model/apply.lisp
@@ -1139,7 +1139,7 @@
 (defun guess-ilks-alist (fn new-badge term ilk wrld alist)
 
 ; Fn is the name of a function being defined.  New-badge is either nil or a
-; proposed badge for fn and term is a term (initally the body of fn) occuring
+; proposed badge for fn and term is a term (initally the body of fn) occurring
 ; in a slot of ilk ilk.  Note: term contains no lambda applications!  We try to
 ; determine the ilks of the free vars in term, extending alist to record what
 ; we find.  We return (mv msg alist'), where either msg is an error message and
Index: acl2-8.5dfsg/books/projects/avr-isa/avr8_isa.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/avr-isa/avr8_isa.lisp
+++ acl2-8.5dfsg/books/projects/avr-isa/avr8_isa.lisp
@@ -59,7 +59,7 @@
 ;; each flag is 1 for true and 0 for false
 ;; regs is a list of 32 registers
 ;; each register is an integer (assumed to be 8-bits, but unbounded for now.)
-;; memory is an alist (addr val) representing the memory. Every addres is an integer. 
+;; memory is an alist (addr val) representing the memory. Every address is an integer. 
 ;; We currently do not distinguish between data and program space or between I/, RAM, etc.
   (list pc regs flags stack program memory))
 
Index: acl2-8.5dfsg/books/projects/cache-coherence/german-protocol/german.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/cache-coherence/german-protocol/german.lisp
+++ acl2-8.5dfsg/books/projects/cache-coherence/german-protocol/german.lisp
@@ -79,7 +79,7 @@ session.  To include the book after cert
 ; Here is the murphy code for the protocol that I had once gotten from Thomas
 ; Wahl.  I suspect that it is different from the code that Anna showed me,
 ; since see showed me properties called ctrlpropinv and datapropinv which I
-; dont see in this version.  But I think possibly the basics of the two codes
+; don't see in this version.  But I think possibly the basics of the two codes
 ; are similar in the description of the protocols.
 
 
@@ -400,7 +400,7 @@ session.  To include the book after cert
           (t st)))))
 
 ;; And finally the initial state (init).  All state variables are nil other
-;; than the clients which are all :idle.  I dont know if this latter
+;; than the clients which are all :idle.  I don't know if this latter
 ;; restriction is important or not, but I tried to model it as per the Murphy
 ;; definition.
 
@@ -488,7 +488,7 @@ session.  To include the book after cert
 ;; All right back to work.  Whenever I define something using quantification I
 ;; disable the definition and all associated lemmas that were introduced,
 ;; because I want to have control on how they are used in a proof process.  For
-;; example I dont want to see a "witness" until I am ready and understand what
+;; example I don't want to see a "witness" until I am ready and understand what
 ;; the witness means in a context.  So I deal with quantifiers principally via
 ;; :use hints.
 
@@ -1099,7 +1099,7 @@ session.  To include the book after cert
 ;; if the client is not changed.  This is in fact an easier property than the
 ;; one we proved before, but we need to prove it anyways.  Maybe I could have
 ;; generalized the property above a little bit and saved myself this lemma.
-;; But I dont bother since I am lazy.
+;; But I don't bother since I am lazy.
 
 (local
  (defthm ch2-client-exclusive-after-arbitrary
@@ -1881,7 +1881,7 @@ session.  To include the book after cert
             (equal (g i hsl) t))))
 
 ;; I should look into this proof carefully later if time.  The proof works but
-;; it does double induction, and I dont like double induction.  So there might
+;; it does double induction, and I don't like double induction.  So there might
 ;; be something I can do about it.  Need to look at subgoal *1/2.
 
 (local
@@ -2262,7 +2262,7 @@ session.  To include the book after cert
                  (equal (action stimulus) :client-receives-shared))
             (invalidate-ack-clients-invariant (german-step st stimulus)))))
 
-;; Now the last case, which is client-receives-exclusive.  I dont like to think
+;; Now the last case, which is client-receives-exclusive.  I don't like to think
 ;; about this one right now --- I am tired after doing the rest of the cases.
 ;; But I am pretty sure that if there is an invalidate-ack somewhere then there
 ;; cannot be a :grant-exclusive.  So for now I posit that as a predicate and go
@@ -2489,7 +2489,7 @@ session.  To include the book after cert
 ;; quantification we would have used the cases hint and applied the
 ;; instantiation of the necc lemma on the first with the witness of the second.
 ;; But here we prove it using induction.  The cases hint we gave can be easily
-;; understood by looking at the failed proof.  But I dont go into that here.
+;; understood by looking at the failed proof.  But I don't go into that here.
 
 (local
  (defthm hsl-ch2-after-setting-hsl
@@ -2555,7 +2555,7 @@ session.  To include the book after cert
 
 ;; How does this work? I first know that if hil-hsl holds then every index in
 ;; hil must have hsl t.  When home-sends-invalidate, the hil is t and hence hsl
-;; is t.  Since hsl is T anyways I dont have to think about what is added to
+;; is t.  Since hsl is T anyways I don't have to think about what is added to
 ;; ch2.
 
 (local
@@ -3976,7 +3976,7 @@ session.  To include the book after cert
             (hil-invalidate-invariant (german-step st stimulus)))))
 
 ;; Now it must also be ok when home receives it.  Now it sets ch3 to something
-;; other than invalidate-ack so I dont have to prove anything.
+;; other than invalidate-ack so I don't have to prove anything.
 
 (local
  (defthm hil-invalidate-ack-set
@@ -4052,7 +4052,7 @@ session.  To include the book after cert
 
 (local
  (defun hil-invalidate-witness (hil ch3 keys)
-   (if (endp keys) nil ;; dont care
+   (if (endp keys) nil ;; don't care
      (if (and (equal (g (first keys) ch3) :invalidate-ack)
               (g (first keys) hil))
          (first keys)
@@ -4208,7 +4208,7 @@ session.  To include the book after cert
 
 (local
  (defun hil-invalidate-rwitness (hil ch2 keys)
-   (if (endp keys) nil ;; dont care
+   (if (endp keys) nil ;; don't care
      (if (and (equal (g (first keys) ch2) :invalidate)
               (g (first keys) hil))
          (first keys)
@@ -4468,7 +4468,7 @@ session.  To include the book after cert
 
 ;; Now I handle the hcm-invalidate-ack-invariant.  This says that if (not heg)
 ;; and hcm is equal to :req-shared-access then there is no invalidate-ack.
-;; This should be pretty trivial since under these conditions we dont send an
+;; This should be pretty trivial since under these conditions we don't send an
 ;; invalidate at all.
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -5027,7 +5027,7 @@ session.  To include the book after cert
                                  :home-grants-exclusive))))
             (hsl-client-ch2-invariant (german-step st stimulus)))))
 
-;; Well now if home sends invalidate then I dont have to prove anything.  But
+;; Well now if home sends invalidate then I don't have to prove anything.  But
 ;; first let me prove that it is ok.
 
 (local
@@ -5063,7 +5063,7 @@ session.  To include the book after cert
                  (equal (action stimulus) :home-receives-invalidate))
             (hsl-client-ch2-invariant (german-step st stimulus)))))
 
-;; When sharer invalidates cache it sets ch3 to invalidate-ack and hence I dont
+;; When sharer invalidates cache it sets ch3 to invalidate-ack and hence I don't
 ;; have to prove anything.
 
 (local
Index: acl2-8.5dfsg/books/projects/codewalker/codewalker.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/codewalker/codewalker.lisp
+++ acl2-8.5dfsg/books/projects/codewalker/codewalker.lisp
@@ -4209,7 +4209,7 @@ to be quoted evgs, but pc = ~x0; splitte
                  "The value supplied for :VAR-NAMES is ill-formed.  Each ~
                   element should be of the form (pattern fmt-string term_0 ~
                   ... term_n).  But your term_i involve variable~#0~[~/s~] ~
-                  ~&0 not occuring in the pattern, ~x1, that triggers ~
+                  ~&0 not occurring in the pattern, ~x1, that triggers ~
                   fmt-string ~x2."
                  (set-difference-eq (all-vars1-lst term-lst nil)
                                     (remove1-eq svar (all-vars pattern)))
Index: acl2-8.5dfsg/books/projects/codewalker/simplify-under-hyps.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/codewalker/simplify-under-hyps.lisp
+++ acl2-8.5dfsg/books/projects/codewalker/simplify-under-hyps.lisp
@@ -239,7 +239,7 @@
 
 (defun collect-if-tracker-triples (clauses)
 
-; We collect the ITTs corresponding to those IF-TRACKER literals occuring last
+; We collect the ITTs corresponding to those IF-TRACKER literals occurring last
 ; in each clause of clauses.  We cause an error if some clause does not
 ; conclude with a IF-TRACKER literal.  Such clauses shouldn't exist!
 
Index: acl2-8.5dfsg/books/projects/codewalker/terminatricks.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/codewalker/terminatricks.lisp
+++ acl2-8.5dfsg/books/projects/codewalker/terminatricks.lisp
@@ -1304,7 +1304,7 @@
 
 ; Measure is the measure term being suggested.
 
-; Vars is the list of variable symbols occuring freely in measure.
+; Vars is the list of variable symbols occurring freely in measure.
 
 ; Tests is the list of tests suggesting this measure.  Note: It is possible for
 ; a distilled test to mention a variable not occurring in the measure, as would
@@ -3511,7 +3511,7 @@
 (defun parse-base-from-fnname (fn)
 
 ; We look for a number as printed in one of the bases 2, 8, 10, or 16
-; (preceeded by B, nothing, O, or X) and delimited on the left by hyphen and on
+; (preceded by B, nothing, O, or X) and delimited on the left by hyphen and on
 ; the right by either hyphen or the end of the name.  If we find one, we return
 ; the base (2, 8, 10, or 16) of the leftmost one.  Otherwise, nil.  For
 ; example, SEM-XAB12F and CLK-B01010-CORRECT produce 16 and 2 respectively,
Index: acl2-8.5dfsg/books/projects/concurrent-programs/bakery/final-theorems.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/concurrent-programs/bakery/final-theorems.lisp
+++ acl2-8.5dfsg/books/projects/concurrent-programs/bakery/final-theorems.lisp
@@ -35,7 +35,7 @@ will be the facts that we claim about th
   :rule-classes nil)
 
 
-;; A step of the implementation is a step of the specification upto
+;; A step of the implementation is a step of the specification up to
 ;; stuttering:
 
 (DEFTHM >>-stutter1-b-c
Index: acl2-8.5dfsg/books/projects/concurrent-programs/bakery/initial-state.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/concurrent-programs/bakery/initial-state.lisp
+++ acl2-8.5dfsg/books/projects/concurrent-programs/bakery/initial-state.lisp
@@ -8,7 +8,7 @@
 In this book, we define an encapsulated function, initial-state, and show that
 the invariant inv holds for that state. Thus our stuttering bisimulation will
 claim that there exists an initial state such that if you run the program from
-that state then the execution of the program matches the spec upto finite
+that state then the execution of the program matches the spec up to finite
 stuttering.
 
 |#
Index: acl2-8.5dfsg/books/projects/concurrent-programs/bakery/programs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/concurrent-programs/bakery/programs.lisp
+++ acl2-8.5dfsg/books/projects/concurrent-programs/bakery/programs.lisp
@@ -6,7 +6,7 @@
   ~~~~~~~~~~~~~
 
 In this book, we define a "simplified" bakery implementation and an abstract
-spec. We will show that the implementation "matches" the spec upto finite
+spec. We will show that the implementation "matches" the spec up to finite
 stuttering. Notice that our implementation is "simpler than the exact bakery
 defined by Lamport. Lamport claims that bakery does not depend on any
 lower-level mutual exclusion. We however, still use a lower-level mutual
@@ -105,9 +105,9 @@ instruction often provided as atomic on
 
 
 ;; Comments on max: We could have chosen an implementation that resets
-;;                  max. However, I dont see how to do it and preserve
+;;                  max. However, I don't see how to do it and preserve
 ;;                  correctness, while still preserving boundedness of
-;;                  max. So I dont go that route and unduly complicate
+;;                  max. So I don't go that route and unduly complicate
 ;;                  matters. In short, I believe (without proof) that
 ;;                  unboundedness of max is a negative feature of the
 ;;                  bakery algorithm in general, and has nothing to do
Index: acl2-8.5dfsg/books/projects/filesystems/hifat-to-lofat-inversion.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/filesystems/hifat-to-lofat-inversion.lisp
+++ acl2-8.5dfsg/books/projects/filesystems/hifat-to-lofat-inversion.lisp
@@ -9409,7 +9409,7 @@
 ;; our guarantees that the transformation from lofat to hifat is
 ;; reversible. Then, the reasoning will involve the number of clusters
 ;; taken up for the on-disk representation of a lofat instance. That
-;; reasoning will also involve proving that we can allocate upto
+;; reasoning will also involve proving that we can allocate up to
 ;; (count-of-clusters fat32$c) clusters and no more.
 ;; But, this solution is not perfect - there still remains the problem
 ;; of clusters being shared across multiple files. So, if cluster 2
Index: acl2-8.5dfsg/books/projects/filesystems/test/stat-replicant.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/filesystems/test/stat-replicant.lisp
+++ acl2-8.5dfsg/books/projects/filesystems/test/stat-replicant.lisp
@@ -75,7 +75,7 @@
        (newline channel state)
        (princ$ "    ID: " channel state)
        ;; Choosing to print 0 as a constant here - rather than take it from the
-       ;; stat - becasue the coreutils version has some complicated rules for
+       ;; stat - because the coreutils version has some complicated rules for
        ;; printing the value in the f_fsid field
        (princ$ (fixed-width-print 0 8) channel state)
        (princ$ " Namelen: " channel state)
Index: acl2-8.5dfsg/books/projects/milawa/ACL2/bootstrap/proof-sizes.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/milawa/ACL2/bootstrap/proof-sizes.lsp
+++ acl2-8.5dfsg/books/projects/milawa/ACL2/bootstrap/proof-sizes.lsp
@@ -109,7 +109,7 @@
        (local (ACL2::table tactic-harness 'skeleton (tactic.initial-skeleton (list ',(rw.rule-clause rule)))))
 
 ; This is basically like %autoprove.  We get the hints that were given when the
-; proof was submitted, preceeded by any extra hints that we might want to give
+; proof was submitted, preceded by any extra hints that we might want to give
 ; to fix up theories, etc., then finally give %auto.
 
        (ACL2::value-triple (ACL2::cw "[%Reprove]> Trying to replay the proof.~%"))
Index: acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/evaluator-bldr.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/milawa/ACL2/rewrite/evaluator-bldr.lisp
+++ acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/evaluator-bldr.lisp
@@ -136,7 +136,7 @@
                           (and arg1-proof
                                (let ((arg1-prime (logic.=rhs (logic.conclusion arg1-proof))))
                                  (if (logic.unquote arg1-prime)
-                                     ;; Arg1 evaluted to a non-nil constant.
+                                     ;; Arg1 evaluated to a non-nil constant.
                                      (let ((arg2-proof (flag-generic-evaluator-bldr 'term (second args) defs n)))
                                        (and arg2-proof
                                             (eval-lemma-1-bldr arg1-proof arg2-proof (third args))))
@@ -218,7 +218,7 @@
               (cons t (cons first (cdr rest)))
             ;; FAILURE: couldn't evaluate some argument.
             nil))
-      ;; SUCCESS: the empty list can always be evaluted.
+      ;; SUCCESS: the empty list can always be evaluated.
       (cons t nil))))
 
 (definlined generic-evaluator-bldr (x defs n)
@@ -260,7 +260,7 @@
                              (and arg1-proof
                                   (let ((arg1-prime (logic.=rhs (logic.conclusion arg1-proof))))
                                     (if (logic.unquote arg1-prime)
-                                        ;; Arg1 evaluted to a non-nil constant.
+                                        ;; Arg1 evaluated to a non-nil constant.
                                         (let ((arg2-proof (generic-evaluator-bldr (second args) defs n)))
                                           (and arg2-proof
                                                (eval-lemma-1-bldr arg1-proof arg2-proof (third args))))
@@ -353,7 +353,7 @@
                    (cons t (cons first (cdr rest)))
                  ;; FAILURE: couldn't evaluate some argument.
                  nil))
-           ;; SUCCESS: the empty list can always be evaluted.
+           ;; SUCCESS: the empty list can always be evaluated.
            (cons t nil)))
   :rule-classes :definition
   :hints(("Goal"
Index: acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/evaluator.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/milawa/ACL2/rewrite/evaluator.lisp
+++ acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/evaluator.lisp
@@ -140,7 +140,7 @@
               (cons t (cons first (cdr rest)))
             ;; FAILURE: couldn't evaluate some argument.
             nil))
-      ;; SUCCESS: the empty list can always be evaluted.
+      ;; SUCCESS: the empty list can always be evaluated.
       (cons t nil))))
 
 (defund generic-evaluator (x defs n)
@@ -231,7 +231,7 @@
                    (cons t (cons first (cdr rest)))
                  ;; FAILURE: couldn't evaluate some argument.
                  nil))
-           ;; SUCCESS: the empty list can always be evaluted.
+           ;; SUCCESS: the empty list can always be evaluated.
            (cons t nil)))
   :rule-classes :definition
   :hints(("Goal" :in-theory (enable generic-evaluator
Index: acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/syntax-evaluator.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/milawa/ACL2/rewrite/syntax-evaluator.lisp
+++ acl2-8.5dfsg/books/projects/milawa/ACL2/rewrite/syntax-evaluator.lisp
@@ -287,7 +287,7 @@
               (cons t (cons first (cdr rest)))
             ;; FAILURE: couldn't evaluate some argument.
             nil))
-      ;; SUCCESS: the empty list can always be evaluted.
+      ;; SUCCESS: the empty list can always be evaluated.
       (cons t nil))))
 
 (defund rewrite.syntaxp-evaluator (x defs n)
@@ -378,7 +378,7 @@
                    (cons t (cons first (cdr rest)))
                  ;; FAILURE: couldn't evaluate some argument.
                  nil))
-           ;; SUCCESS: the empty list can always be evaluted.
+           ;; SUCCESS: the empty list can always be evaluated.
            (cons t nil)))
   :rule-classes :definition
   :hints(("Goal" :in-theory (enable rewrite.syntaxp-evaluator
Index: acl2-8.5dfsg/books/projects/milawa/ACL2/tactics/elim.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/milawa/ACL2/tactics/elim.lisp
+++ acl2-8.5dfsg/books/projects/milawa/ACL2/tactics/elim.lisp
@@ -207,7 +207,7 @@
 ;; implement a two-phase approach.  First we collect up all the variables which
 ;; have been car'd or cdr'd somewhere in the goal.  If there are any such
 ;; variables, we take the maximally-car/cdr'd variable and eliminate it.
-;; Otherwise, we try to choose the first occuring (consp v) hypothesis.
+;; Otherwise, we try to choose the first occurring (consp v) hypothesis.
 ;; Otherwise, we fail.
 
 (defund elim.flag-collect-destructed-variables (flag x acc)
Index: acl2-8.5dfsg/books/projects/paco/induct.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/paco/induct.lisp
+++ acl2-8.5dfsg/books/projects/paco/induct.lisp
@@ -1141,7 +1141,7 @@
 
 (defun induct-vars1 (lst wrld)
 
-; Lst is a list of terms.  We collect every variable symbol occuring in a
+; Lst is a list of terms.  We collect every variable symbol occurring in a
 ; controller slot of any term in lst.
 
   (cond ((endp lst) nil)
Index: acl2-8.5dfsg/books/projects/rac/lisp/translate.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rac/lisp/translate.lisp
+++ acl2-8.5dfsg/books/projects/rac/lisp/translate.lisp
@@ -135,7 +135,7 @@ are more than one).  The test of the IF
 
 )
 
-;; The following functions are used in conjuction with the built-in subst-var,
+;; The following functions are used in conjunction with the built-in subst-var,
 ;; which substitutes a term for each occurrence of a variable in an expression.
 
 ;; var-count counts the number of occurrences of a variable in an expression:
Index: acl2-8.5dfsg/books/projects/rp-rewriter/extract-formula.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rp-rewriter/extract-formula.lisp
+++ acl2-8.5dfsg/books/projects/rp-rewriter/extract-formula.lisp
@@ -533,7 +533,7 @@
                      (& (list rule-name))))) ;;unknown format. assign to rule-name so
            ;; that next test fails.  if rule-name exist on the rhs, then it is
            ;; a recursive function. We do not want to have that definition rule
-           ;; in the rewriter becasue it would be opened up nonstop.
+           ;; in the rewriter because it would be opened up nonstop.
            (if (rp-termp rhs);;for guard
                (not (include-fnc rhs rule-name))
              nil))))
Index: acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult/meta/pp-flatten-meta.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rp-rewriter/lib/mult/meta/pp-flatten-meta.lisp
+++ acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult/meta/pp-flatten-meta.lisp
@@ -561,7 +561,7 @@
             (true-listp x))))
 
 (local
- ;; auxilary function used only in the local lemmas for correctness proofs.
+ ;; auxiliary function used only in the local lemmas for correctness proofs.
  (define apply-sign-to-pp-lists (lst sign)
    :returns (res pp-lists-p
                  :hyp (pp-lists-p lst))
Index: acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-correct.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-correct.lisp
+++ acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-correct.lisp
@@ -865,7 +865,7 @@
                  `(binary-sum (-- ,cur) ,(pp-lists-to-term-p+ (cdr lst)))
                `(binary-sum ,cur ,(pp-lists-to-term-p+ (cdr lst))))))))
 
-  ;; auxilary function used only in the local lemmas for correctness proofs.
+  ;; auxiliary function used only in the local lemmas for correctness proofs.
   (local
    (define apply-sign-to-pp-lists (lst sign)
      :returns (res pp-lists-p
Index: acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-fncs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-fncs.lisp
+++ acl2-8.5dfsg/books/projects/rp-rewriter/lib/mult2/pp-flatten-meta-fncs.lisp
@@ -592,7 +592,7 @@
             (true-listp x))))
 
 (local
- ;; auxilary function used only in the local lemmas for correctness proofs.
+ ;; auxiliary function used only in the local lemmas for correctness proofs.
  (define apply-sign-to-pp-lists (lst sign)
    :returns (res pp-lists-p
                  :hyp (pp-lists-p lst))
Index: acl2-8.5dfsg/books/projects/rp-rewriter/rp-rewriter.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/rp-rewriter/rp-rewriter.lisp
+++ acl2-8.5dfsg/books/projects/rp-rewriter/rp-rewriter.lisp
@@ -909,7 +909,7 @@ returns (mv rule rules-rest bindings rp-
       (('fmt-to-comment-window ('quote &) ('quote &)
                                ('quote &) ('quote &) ('quote &))
        ;; if all arguments are quoted, then executable counterpart will be
-       ;; triggered anyways, so dont do anything.
+       ;; triggered anyways, so don't do anything.
        nil)
       (('fmt-to-comment-window ('quote str) ('acl2::pairlis2 &
                                                              list)
@@ -2288,7 +2288,7 @@ relieving the hypothesis for ~x1! You ca
                 (cond ((equal action ':error)
                        (hard-error
                         'preprocess-then-rp-rw
-                        "Error! rp-rewriter did not reduce the term to t! To supress this error run:
+                        "Error! rp-rewriter did not reduce the term to t! To suppress this error run:
 (set-not-simplified-action :warning) or (set-not-simplified-action :none)
 Resulting  term is:~% ~p0 ~%"
                         (list (cons #\0 res-))))
Index: acl2-8.5dfsg/books/projects/sidekick/public/lib/jquery-2.1.0.js
===================================================================
--- acl2-8.5dfsg.orig/books/projects/sidekick/public/lib/jquery-2.1.0.js
+++ acl2-8.5dfsg/books/projects/sidekick/public/lib/jquery-2.1.0.js
@@ -1071,7 +1071,7 @@ setDocument = Sizzle.setDocument = funct
 
 	// Support: IE<10
 	// Check if getElementById returns elements by name
-	// The broken getElementById methods don't pick up programatically-set names,
+	// The broken getElementById methods don't pick up programmatically-set names,
 	// so use a roundabout getElementsByName test
 	support.getById = assert(function( div ) {
 		docElem.appendChild( div ).id = expando;
Index: acl2-8.5dfsg/books/projects/symbolic/generic/defsimulate.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/generic/defsimulate.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/generic/defsimulate.lisp
@@ -31,7 +31,7 @@ these functions.
 2. The function run, if provided (see :define-run keyword in the macro for
 details of what I am talking about) must be a function of two arguments and the
 first argument must be the machine state. I should have changed it to last for
-lack of ambiguity, but since I have (run s n) ingrained in my brain I dont
+lack of ambiguity, but since I have (run s n) ingrained in my brain I don't
 think I can do the change reliably.
 
 ||#
@@ -100,7 +100,7 @@ think I can do the change reliably.
                 (prog2$ (cw "You have decided to use your own run function. ~
                              Please note that we will assume that your ~
                              function is of the form <run s n> where s is the ~
-                             machine-state paramter. If this is not how you ~
+                             machine-state parameter. If this is not how you ~
                              defined it, for example if your function is <run ~
                              n s>, please either abort the macro and redefine ~
                              it this way or call our macro with :define-run? ~
@@ -143,7 +143,7 @@ think I can do the change reliably.
 
            `(defun-nx ,run (,(lastval params) n)
               ;; I add the :non-executable argument in the declare because nextt
-              ;; might otherwise have stobjs or something like that and I dont
+              ;; might otherwise have stobjs or something like that and I don't
               ;; want to deal with them.
               (if (zp n) ,(lastval params)
                 (,run (,nextt ,(lastval params)) (1- n))))))
@@ -155,7 +155,7 @@ think I can do the change reliably.
       ;; theories. This is because I cannot indiscriminately open nextt when I
       ;; am proving the rules by symbolic simulation. For machines such as M5
       ;; and M6 it is vital that nextt is disabled and opened via openers;
-      ;; otherwise I dont know how long a proof might take. I achieve this by
+      ;; otherwise I don't know how long a proof might take. I achieve this by
       ;; storing the theory at the beginning of the events as a deftheory form.
 
       `(local (deftheory oldth (current-theory :here)))
@@ -270,7 +270,7 @@ think I can do the change reliably.
 
          (local (in-theory (theory 'minimal-theory)))
 
-         ;; These are theorems that should be trivial to prove. But I dont want
+         ;; These are theorems that should be trivial to prove. But I don't want
          ;; to needlessly risk symbolic simulation on the concrete
          ;; machine. Rather I know that I have already proved the generic
          ;; theorems so I will functionally instantiate them.
@@ -375,7 +375,7 @@ think I can do the change reliably.
       ;; blow up. This is because ACL2 has inside-out rewriting and hence all
       ;; the nextt would be opened up first before the assertions are
       ;; checked. This can happen (I think) if the code involves a large body
-      ;; of sequential code as complicated as apprentice.  But right now I dont
+      ;; of sequential code as complicated as apprentice.  But right now I don't
       ;; consider efficiency issues. Also I am right now relying on the fact if
       ;; we have the theorems for the two cases (cutpoint s) and (not (cutpoint
       ;; s)) then this theorem should just go through. Since ACL2 does very
@@ -425,7 +425,7 @@ think I can do the change reliably.
       ;; The job of assertion, cutpoint and nextt is done. So I disable them.
       `(local (in-theory (theory 'minimal-theory)))
 
-      ;; The final theorem. please dont be overawed by the number of :use
+      ;; The final theorem. please don't be overawed by the number of :use
       ;; hints. These would not have been required if I were doing theorem
       ;; proving. But here now I am specifying a macro and it better be that
       ;; when I do it I leave nothing to chance (read ACL2's heuristics...:->)
@@ -558,7 +558,7 @@ think I can do the change reliably.
                 (prog2$ (cw "You have decided to use your own run function. ~
                              Please note that we will assume that your ~
                              function is of the form <run s n> where s is the ~
-                             machine-state paramter. If this is not how you ~
+                             machine-state parameter. If this is not how you ~
                              defined it, for example if your function is <run ~
                              n s>, please either abort the macro and redefine ~
                              it this way or call our macro with :define-run? ~
@@ -601,7 +601,7 @@ think I can do the change reliably.
 
            `(defun-nx ,run (,(lastval params) n)
               ;; I add the :non-executable argument in the declare because nextt
-              ;; might otherwise have stobjs or something like that and I dont
+              ;; might otherwise have stobjs or something like that and I don't
               ;; want to deal with them.
               (if (zp n) ,(lastval params)
                 (,run (,nextt ,(lastval params)) (1- n))))))
@@ -731,7 +731,7 @@ think I can do the change reliably.
 
          (local (in-theory (theory 'minimal-theory)))
 
-         ;; These are theorems that should be trivial to prove. But I dont want
+         ;; These are theorems that should be trivial to prove. But I don't want
          ;; to needlessly risk symbolic simulation on the concrete
          ;; machine. Rather I know that I have already proved the generic
          ;; theorems so I will functionally instantiate them.
@@ -839,7 +839,7 @@ think I can do the change reliably.
       ;; blow up. This is because ACL2 has inside-out rewriting and hence all
       ;; the nextt would be opened up first before the assertions are
       ;; checked. This can happen (I think) if the code involves a large body
-      ;; of sequential code as complicated as apprentice.  But right now I dont
+      ;; of sequential code as complicated as apprentice.  But right now I don't
       ;; consider efficiency issues. Also I am right now relying on the fact if
       ;; we have the theorems for the two cases (cutpoint s) and (not (cutpoint
       ;; s)) then this theorem should just go through. Since ACL2 does very
@@ -1021,7 +1021,7 @@ think I can do the change reliably.
       `(local
         (include-book "projects/symbolic/generic/total-correctness" :dir :system))
 
-      ;; The final theorem. please dont be overawed by the number of :use
+      ;; The final theorem. please don't be overawed by the number of :use
       ;; hints. These would not have been required if I were doing theorem
       ;; proving. But here now I am specifying a macro and it better be that
       ;; when I do it I leave nothing to chance (read ACL2's heuristics...:->)
@@ -1231,7 +1231,7 @@ think I can do the change reliably.
 ;; theorems done suddenly start breaking. So I have the tendency of putting
 ;; bogus encapsulates for testing purposes. Maybe I will remove these to a
 ;; "testing book" but since this book takes very little time to certify even
-;; with the encapsulates below I dont bother.
+;; with the encapsulates below I don't bother.
 
 ;; Case 1: Partial correctness. Here is the first example:
 
Index: acl2-8.5dfsg/books/projects/symbolic/generic/factorial-jvm-correct.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/generic/factorial-jvm-correct.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/generic/factorial-jvm-correct.lisp
@@ -188,7 +188,7 @@ method referred to in "Inductive Asserti
 ;; You see why I added the thms and hints. If I simply
 ;; open up step to get what I want, but that is sometimes inefficient and
 ;; causes a huge case split. Especially in the context of a model like JVM you
-;; dont want to do that. You need specialized openers which are actually pretty
+;; don't want to do that. You need specialized openers which are actually pretty
 ;; mechanical. And here I show one. This opener is just specifying to open up
 ;; the function when the pc is known. Notice that I can also provide the right
 ;; hints to the macro. Isn't this cool? Of course this is just to show that
Index: acl2-8.5dfsg/books/projects/symbolic/generic/partial-correctness.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/generic/partial-correctness.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/generic/partial-correctness.lisp
@@ -340,7 +340,7 @@ that they do not depend much on which ar
                    (run s (+ m n))))))
 
 ;; The nextt rule is an ugly hack and I am almost doing it assuming I
-;; know what I am doing. If I dont use this theorem, the definition of
+;; know what I am doing. If I don't use this theorem, the definition of
 ;; run does not expand in circumstances I want it to. The theorem
 ;; always expands expressions of the form (run <some state> l) whereas
 ;; if it is not l the theorem does not fire. My intention here is that
@@ -702,7 +702,7 @@ that they do not depend much on which ar
 ;; holds for all steps < (big-steps (steps-to-exitpoint s)). But in
 ;; order to deal with the quantifier-free aspect of ACL2, I need a few
 ;; more tricks. Notice that I am trying hard here to curb my natural
-;; tendencies and just introduce a defun-sk. I dont do it since I dont
+;; tendencies and just introduce a defun-sk. I don't do it since I don't
 ;; see that necessary.
 
 ;; The trick that I am doing is to define a function falsifier that
Index: acl2-8.5dfsg/books/projects/symbolic/generic/tiny-fib-correct.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/generic/tiny-fib-correct.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/generic/tiny-fib-correct.lisp
@@ -23,7 +23,7 @@ represented.
 (include-book "../tiny-fib/fib-def")
 (include-book "ordinals/ordinals" :dir :system)
 
-;; I dont care about guards at the moment. So do not verify guards.
+;; I don't care about guards at the moment. So do not verify guards.
 
 (set-verify-guards-eagerness 0)
 
@@ -45,7 +45,7 @@ represented.
 
 ;; Maybe I should relax the restriction here. But my initial macro requires
 ;; that each of cutpoint, assertion, precondition, postcondition, etc. must
-;; have the same arity. I dont know a way to relax this restriction because
+;; have the same arity. I don't know a way to relax this restriction because
 ;; otherwise my macro needs to look at the state and then it would not remain
 ;; an embedded-event form. Otherwise I can ask the user to provide the arity of
 ;; each function which is no clumsier than this requirement.
@@ -61,8 +61,8 @@ represented.
   (declare (xargs :stobjs tiny-state))
    (and (program-loaded tiny-state *fib-prog* *prog-start-address*)
         (tiny-statep tiny-state)
-        ;; I dont know if the predicate (signed-byte-p *word-size* n) below is
-        ;; vital. The proofs dont go thru for the loop label otherwise (I
+        ;; I don't know if the predicate (signed-byte-p *word-size* n) below is
+        ;; vital. The proofs don't go thru for the loop label otherwise (I
         ;; think). But I have little understanding of the machine so feel free
         ;; to change this.
         (signed-byte-p *word-size* n)
Index: acl2-8.5dfsg/books/projects/symbolic/generic/total-correctness.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/generic/total-correctness.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/generic/total-correctness.lisp
@@ -383,7 +383,7 @@ what the heck!!
                    (run s (+ m n))))))
 
 ;; The nextt rule is an ugly hack and I am almost doing it assuming I
-;; know what I am doing. If I dont use this theorem, the definition of
+;; know what I am doing. If I don't use this theorem, the definition of
 ;; run does not expand in circumstances I want it to. The theorem
 ;; always expands expressions of the form (run <some state> l) whereas
 ;; if it is not l the theorem does not fire. My intention here is that
@@ -711,7 +711,7 @@ what the heck!!
 ;; holds for all steps < (big-steps (steps-to-exitpoint s)). But in
 ;; order to deal with the quantifier-free aspect of ACL2, I need a few
 ;; more tricks. Notice that I am trying hard here to curb my natural
-;; tendencies and just introduce a defun-sk. I dont do it since I dont
+;; tendencies and just introduce a defun-sk. I don't do it since I don't
 ;; see that necessary.
 
 ;; The trick that I am doing is to define a function falsifier that
@@ -852,7 +852,7 @@ what the heck!!
 
 
 ;; Just a little note on this theorem. I am surprised I never needed
-;; this for partial correctness. Maybe I did but I dont remember. This
+;; this for partial correctness. Maybe I did but I don't remember. This
 ;; says that if steps is indeed a number running that many steps leads
 ;; us to a cutpoint.
 
Index: acl2-8.5dfsg/books/projects/symbolic/tiny-triangle/tiny-triangle-correct.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/symbolic/tiny-triangle/tiny-triangle-correct.lisp
+++ acl2-8.5dfsg/books/projects/symbolic/tiny-triangle/tiny-triangle-correct.lisp
@@ -37,7 +37,7 @@ Based On Sandip's tiny-fib-correct.lisp
 
 ;; Maybe I should relax the restriction here. But my initial macro requires
 ;; that each of cutpoint, assertion, precondition, postcondition, etc. must
-;; have the same arity. I dont know a way to relax this restriction because
+;; have the same arity. I don't know a way to relax this restriction because
 ;; otherwise my macro needs to look at the state and then it would not remain
 ;; an embedded-event form. Otherwise I can ask the user to provide the arity of
 ;; each function which is no clumsier than this requirement.
Index: acl2-8.5dfsg/books/projects/x86isa/machine/environment-and-syscalls-raw.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/x86isa/machine/environment-and-syscalls-raw.lsp
+++ acl2-8.5dfsg/books/projects/x86isa/machine/environment-and-syscalls-raw.lsp
@@ -530,7 +530,7 @@
 
 (defun get-bytelist-from-ptr (ptr index size)
   ;; This function is used to retrieve a list of unsigned bytes from
-  ;; the location pointed to by the pointer ptr upto a maximum of
+  ;; the location pointed to by the pointer ptr up to a maximum of
   ;; size, with index being the current index.
   (declare (xargs :mode :program
 		  :guard (and (natp index)
Index: acl2-8.5dfsg/books/projects/x86isa/utils/paging-structures.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/projects/x86isa/utils/paging-structures.lisp
+++ acl2-8.5dfsg/books/projects/x86isa/utils/paging-structures.lisp
@@ -148,7 +148,7 @@
    (res1 bitp)    ;; Ignored
    (ps bitp)      ;; Page size (Must be 0)
    (res2 4bits)  ;; Ignored
-   (pd 40bits)   ;; Physical addres of 4-K aligned PD referenced by this entry
+   (pd 40bits)   ;; Physical address of 4-K aligned PD referenced by this entry
    (res3 11bits) ;; Ignored and/or Reserved
    (xd bitp))     ;; If IA32_EFER.NXE = 1, Execute disable;
   ;; otherwise 0 (reserved)
@@ -175,7 +175,7 @@
    (res1 3bits)  ;; Ignored
    (pat bitp)     ;; PAT
    (res2 8bits)  ;; Reserved
-   (page 31bits) ;; Physical addres of the 2MB page referenced by this entry
+   (page 31bits) ;; Physical address of the 2MB page referenced by this entry
    (res3 11bits) ;; Ignored and/or Reserved
    (xd bitp) ;; If IA32_EFER.NXE = 1, Execute disable; otherwise 0 (reserved)
    )
@@ -198,7 +198,7 @@
    (res1 bitp)    ;; Ignored
    (ps bitp)       ;; Page size (Must be 0)
    (res2 4bits)  ;; Ignored
-   (pt 40bits)    ;; Physical addres of the 4K-aligned
+   (pt 40bits)    ;; Physical address of the 4K-aligned
    ;; page table referenced by this entry
    (res3 11bits) ;; Ignored and/or Reserved
    (xd bitp)       ;; If IA32_EFER.NXE = 1, Execute
Index: acl2-8.5dfsg/books/proofstyles/invclock/c2i/c2i-total.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/invclock/c2i/c2i-total.lisp
+++ acl2-8.5dfsg/books/proofstyles/invclock/c2i/c2i-total.lisp
@@ -529,7 +529,7 @@ an inductive invariant proof.
                              (s p)
                              (n i)))))))
 
-;; Thus it must be that no-external holds for all the states upto the requisite
+;; Thus it must be that no-external holds for all the states up to the requisite
 ;; value.
 
 (local
Index: acl2-8.5dfsg/books/proofstyles/invclock/c2i/clock-to-inv.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/invclock/c2i/clock-to-inv.lisp
+++ acl2-8.5dfsg/books/proofstyles/invclock/c2i/clock-to-inv.lisp
@@ -116,7 +116,7 @@ generic theorems about clocks and invari
 
           (local (in-theory (disable ,m)))
 
-          ;; I dont need them any more.
+          ;; I don't need them any more.
           (local (in-theory (disable ,next ,pre ,post ,clock)))
 
           (defthm ,pre-has-inv
Index: acl2-8.5dfsg/books/proofstyles/invclock/i2c/i2c-partial.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/invclock/i2c/i2c-partial.lisp
+++ acl2-8.5dfsg/books/proofstyles/invclock/i2c/i2c-partial.lisp
@@ -130,7 +130,7 @@ state".
    (equal (run-partial (next-partial s) n)
           (next-partial (run-partial s n)))))
 
-;; Also prove that inv holds for every run upto find-external.
+;; Also prove that inv holds for every run up to find-external.
 
 (local
  (defthm inv-partial-to-external-partial
@@ -144,7 +144,7 @@ state".
                  (<= j (find-external-partial s n)))
             (inv-partial (run-partial s j)))))
 
-;; Now quantify this and say that forall-inv holds for all states upto an
+;; Now quantify this and say that forall-inv holds for all states up to an
 ;; external state.
 
 (local
@@ -205,7 +205,7 @@ state".
 ;; Now I prove that anything less than external-witness must not be
 ;; external.
 
-;; Comments: I dont like to have to always reason about this
+;; Comments: I don't like to have to always reason about this
 ;; thing. Here is what I mean. If there is a defun-sk then the witness gives me
 ;; one something that has the property that is desired in defun-sk. But it does
 ;; not give a minimal (or maximal) witness. Thus every time we do anything with
Index: acl2-8.5dfsg/books/proofstyles/invclock/i2c/inv-to-clock.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/invclock/i2c/inv-to-clock.lisp
+++ acl2-8.5dfsg/books/proofstyles/invclock/i2c/inv-to-clock.lisp
@@ -415,7 +415,7 @@ theorems about clocks and invariants to
 
 
 ;; Notice that to use the macro one might need to disable the bodies of the
-;; functions next, pre, post etc. So some theory creation is important. I dont
+;; functions next, pre, post etc. So some theory creation is important. I don't
 ;; do that since for all I know the body might have been stubbed out. But you
 ;; are pretty safe in a theory that keeps only the theorems specified as axioms.
 
Index: acl2-8.5dfsg/books/proofstyles/soundness/assertions-partial.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/soundness/assertions-partial.lisp
+++ acl2-8.5dfsg/books/proofstyles/soundness/assertions-partial.lisp
@@ -342,7 +342,7 @@ see a couple of lemmas, proving the fina
                    (run-fn s (+ m n))))))
 
 ;; The step-fn rule is an ugly hack and I am almost doing it assuming I
-;; know what I am doing. If I dont use this theorem, the definition of
+;; know what I am doing. If I don't use this theorem, the definition of
 ;; run-fn does not expand in circumstances I want it to. The theorem
 ;; always expands expressions of the form (run-fn <some state> l) whereas
 ;; if it is not l the theorem does not fire. My intention here is that
@@ -674,7 +674,7 @@ see a couple of lemmas, proving the fina
 ;; holds for all steps < (big-steps (steps-to-exitpoint s)). But in
 ;; order to deal with the quantifier-free aspect of ACL2, I need a few
 ;; more tricks. Notice that I am trying hard here to curb my natural
-;; tendencies and just introduce a defun-sk. I dont do it since I dont
+;; tendencies and just introduce a defun-sk. I don't do it since I don't
 ;; see that necessary.
 
 ;; The trick that I am doing is to define a function falsifier that
Index: acl2-8.5dfsg/books/proofstyles/soundness/assertions-total.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/proofstyles/soundness/assertions-total.lisp
+++ acl2-8.5dfsg/books/proofstyles/soundness/assertions-total.lisp
@@ -358,7 +358,7 @@ see a couple of lemmas, proving the fina
                    (run-fn s (+ m n))))))
 
 ;; The step-fn rule is an ugly hack and I am almost doing it assuming I
-;; know what I am doing. If I dont use this theorem, the definition of
+;; know what I am doing. If I don't use this theorem, the definition of
 ;; run-fn does not expand in circumstances I want it to. The theorem
 ;; always expands expressions of the form (run-fn <some state> l) whereas
 ;; if it is not l the theorem does not fire. My intention here is that
@@ -690,7 +690,7 @@ see a couple of lemmas, proving the fina
 ;; holds for all steps < (big-steps (steps-to-exitpoint s)). But in
 ;; order to deal with the quantifier-free aspect of ACL2, I need a few
 ;; more tricks. Notice that I am trying hard here to curb my natural
-;; tendencies and just introduce a defun-sk. I dont do it since I dont
+;; tendencies and just introduce a defun-sk. I don't do it since I don't
 ;; see that necessary.
 
 ;; The trick that I am doing is to define a function falsifier that
@@ -908,7 +908,7 @@ see a couple of lemmas, proving the fina
 
 
 ;; Just a little note on this theorem. I am surprised I never needed
-;; this for partial correctness. Maybe I did but I dont remember. This
+;; this for partial correctness. Maybe I did but I don't remember. This
 ;; says that if steps is indeed a number run-fnning that many steps leads
 ;; us to a cutpoint.
 
@@ -939,7 +939,7 @@ see a couple of lemmas, proving the fina
 
 
 ;; Just a little note on this theorem. I am surprised I never needed
-;; this for partial correctness. Maybe I did but I dont remember. This
+;; this for partial correctness. Maybe I did but I don't remember. This
 ;; says that if steps is indeed a number run-fnning that many steps leads
 ;; us to a cutpoint.
 
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo-proofs.lisp
@@ -309,7 +309,7 @@
 
 (in-theory (disable EXPO-2**N)) ;why?
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 (defthm expo-expt2
   (equal (expo (expt 2 i))
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/arithmetic/expo.lisp
@@ -147,7 +147,7 @@
            (equal (expo (expt 2 n))
                   n)))
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 ;This rule, together with expt-compare allows any comparison using <, >, <=, or >= of two terms which have the
 ;form of powers of 2 to be rewritten to a claim about the exponents.  actually, we need a rule about (expo (/ <powerof2>))
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/lib/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/lib/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/lib/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib1/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib1/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib1/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new-proofs.lisp
@@ -490,7 +490,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits_alt x
 i j) when x is negative.  However, bits_alt behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-new.lisp
@@ -400,7 +400,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits_alt x
 i j) when x is negative.  However, bits_alt behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl-proofs.lisp
@@ -539,7 +539,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2.delta1/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib2/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib2/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib3/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/lib3/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/lib3/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/support/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel11/rel9-rtl-pkg/support/support/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel11/rel9-rtl-pkg/support/support/rtl.lisp
@@ -341,7 +341,7 @@ Most of the functions introduced are dis
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel4/arithmetic/expo-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel4/arithmetic/expo-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel4/arithmetic/expo-proofs.lisp
@@ -282,7 +282,7 @@
 
 (in-theory (disable EXPO-2**N)) ;why?
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 (defthm expo-expt2
   (equal (expo (expt 2 i))
Index: acl2-8.5dfsg/books/rtl/rel4/arithmetic/expo.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel4/arithmetic/expo.lisp
+++ acl2-8.5dfsg/books/rtl/rel4/arithmetic/expo.lisp
@@ -120,7 +120,7 @@
            (equal (expo (expt 2 n))
                   n)))
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 ;This rule, together with expt-compare allows any comparison using <, >, <=, or >= of two terms which have the
 ;form of powers of 2 to be rewritten to a claim about the exponents.  actually, we need a rule about (expo (/ <powerof2>))
Index: acl2-8.5dfsg/books/rtl/rel4/lib/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel4/lib/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel4/lib/rtl.lisp
@@ -346,7 +346,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel4/support/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel4/support/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel4/support/rtl.lisp
@@ -324,7 +324,7 @@ Most of the functions introduced are dis
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/arithmetic/expo-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/arithmetic/expo-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/arithmetic/expo-proofs.lisp
@@ -294,7 +294,7 @@
 
 (in-theory (disable EXPO-2**N)) ;why?
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 (defthm expo-expt2
   (equal (expo (expt 2 i))
Index: acl2-8.5dfsg/books/rtl/rel9/arithmetic/expo.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/arithmetic/expo.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/arithmetic/expo.lisp
@@ -132,7 +132,7 @@
            (equal (expo (expt 2 n))
                   n)))
 
-;dont export?
+;don't export?
 ;like EXPO-2**N but better (now hypothesis-free)
 ;This rule, together with expt-compare allows any comparison using <, >, <=, or >= of two terms which have the
 ;form of powers of 2 to be rewritten to a claim about the exponents.  actually, we need a rule about (expo (/ <powerof2>))
Index: acl2-8.5dfsg/books/rtl/rel9/lib/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/lib/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/lib/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib1/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib1/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib1/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-new-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib2.delta1/rtl-new-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-new-proofs.lisp
@@ -490,7 +490,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits_alt x
 i j) when x is negative.  However, bits_alt behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-new.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib2.delta1/rtl-new.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-new.lisp
@@ -400,7 +400,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits_alt x
 i j) when x is negative.  However, bits_alt behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-proofs.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib2.delta1/rtl-proofs.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl-proofs.lisp
@@ -539,7 +539,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib2.delta1/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib2.delta1/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib2/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib2/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib2/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/lib3/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/lib3/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/lib3/rtl.lisp
@@ -393,7 +393,7 @@
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/rtl/rel9/support/support/rtl.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/rtl/rel9/support/support/rtl.lisp
+++ acl2-8.5dfsg/books/rtl/rel9/support/support/rtl.lisp
@@ -336,7 +336,7 @@ Most of the functions introduced are dis
 #|
 Note: We recently changed mod-.  This definition is a little weird, since it may rely on the value of (bits x
 i j) when x is negative.  However, bits behaves properly in this case.  In fact, Eric proved this theorem
-about the old defintion of mod-:
+about the old definition of mod-:
 
 (thm
  (implies (and (bvecp x n)
Index: acl2-8.5dfsg/books/system/cantor-pairing-bijective.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/system/cantor-pairing-bijective.lisp
+++ acl2-8.5dfsg/books/system/cantor-pairing-bijective.lisp
@@ -11,7 +11,7 @@
 
 (local (include-book "arithmetic-5/top" :dir :system))
 
-; The cantor pairing function uses n*(n+1)/2, which is the sum of numbers upto n.
+; The cantor pairing function uses n*(n+1)/2, which is the sum of numbers up to n.
 ; Rather than working with *,/ arith ops, I prefer +, 1- and recursion.
 (defun sum (n)
   "find sum of first n numbers"
Index: acl2-8.5dfsg/books/system/doc/acl2-doc.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/system/doc/acl2-doc.lisp
+++ acl2-8.5dfsg/books/system/doc/acl2-doc.lisp
@@ -20610,7 +20610,7 @@ subtree of X with T, without duplication
 
  <p>(Of interest only to users of @(tsee apply$).)  Special handling is applied
  when attempting to attach to a so-called <i>warrant</i>, which is produced by
- an appication of @(tsee defwarrant) (or @(tsee defun$)).  In that case it is
+ an application of @(tsee defwarrant) (or @(tsee defun$)).  In that case it is
  legal to attach the function @('true-apply$-warrant') to the warrant, without
  any proof obligation.  This attachment is actually performed automatically by
  @('defwarrant'), so users (even users of @('apply$')) need not deal
@@ -22101,7 +22101,7 @@ subtree of X with T, without duplication
   event of failure to admit it, and trying to expand the class of
   @('loop$')-recursive functions that can be successfully handled.  We have not
   yet even looked at inductions for @('ON') @('loop$')s and @('FROM/TO/BY')
-  @('loop$')s, so that might be easy.  Induction for @('loop$')s over arbtrary
+  @('loop$')s, so that might be easy.  Induction for @('loop$')s over arbitrary
   target expressions may be infeasible!  We just need more examples of
   @('loop$')-recursive functions and successful (hand-written) induction hints
   for them.</p>")
@@ -48582,7 +48582,7 @@ tables in the current Hons Space."
   @('fn').</p>
 
   <p>By the way, both @('collect$') and @('always$') are pre-defined in
-  ACL2 because they are part of the support for the @(tsee loop$) statment.</p>
+  ACL2 because they are part of the support for the @(tsee loop$) statement.</p>
 
   <p><b>Lesson 6:</b> You can run scions on warranted function symbols:</p>
 
@@ -57555,7 +57555,7 @@ forms allowed for a @('let') form are  @
   @('loop$') bodies.  (We also generate conjectures for the recursive calls the
   other @('loop$')-expression components, e.g., the @('WHEN') clause, exactly
   analogously, but we speak of the @('loop$') body only below.  We also focus
-  on simple @('loop$')s here but the conjectures decribed generalize to fancy
+  on simple @('loop$')s here but the conjectures described generalize to fancy
   @('loop$')s.)  Given a recursive call inside the body of a @('loop$') with
   iteration variable <i>v</i>, we first generate a new variable symbol,
   <i>v'</i>.  Certain terms, e.g., tests and arguments to recursive calls, will
@@ -92345,7 +92345,7 @@ it."
  a single variable when building a context (a so-called @(see type-alist)).
  (By a ``strong compound-recognizer call'' we mean a unary function that
  recognizes a union of primitive ACL2 types and has, either explicitly or
- implicity, a corresponding @(see compound-recognizer) rule; examples include
+ implicitly, a corresponding @(see compound-recognizer) rule; examples include
  @(tsee stringp), @(tsee integerp), and @(tsee true-listp).)  In particular,
  this change can strengthen the result of @(see forward-chaining).  Thanks to
  Eric Smith, who raised this issue by providing an example that we include in a
@@ -106652,7 +106652,7 @@ arithmetic) for libraries of @(see books
  returned @(tsee state) is the same as the world of the input state even if the
  evaluation of @('form') modifies the world of the input state.</p>
 
- <p>To see @('revert-world') in action, consider the following defintion.</p>
+ <p>To see @('revert-world') in action, consider the following definition.</p>
 
  @({
  (defun test-revert-world (state)
@@ -118362,7 +118362,7 @@ arithmetic) for libraries of @(see books
  see @(see set-inhibit-output-lst) &mdash; or if you prefer, you may inhibit
  just specified component of the summary &mdash; see @(see
  set-inhibited-summary-types).  The components are listed in the constant
- @('*summary-types*') and most are available programatically: see @(see
+ @('*summary-types*') and most are available programmatically: see @(see
  get-event-data).  Some are omitted, however, if they would otherwise be empty.
  Here is a brief summary of the components, listed alphabetically.  Most are
  printed with an initial field indicator, e.g., ``@('Rules: ')''; a few, as
@@ -132298,7 +132298,7 @@ introduction-to-the-tau-system) for more
  @('(verify-guards name)') to be successful.  If the guards of some @('LAMBDA')
  object requires hints to prove, the hints may be supplied to
  @('verify-guards') as you would for any other failing guard obligation in
- @('name').  When successfull, the @('LAMBDA') objects thus verified are added,
+ @('name').  When successful, the @('LAMBDA') objects thus verified are added,
  behind the scenes, to the compiled lambda cache (see @(tsee print-cl-cache))
  to speed up @('apply$') in the evaluation theory.</p>
 
Index: acl2-8.5dfsg/books/workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
+++ acl2-8.5dfsg/books/workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
@@ -82,7 +82,7 @@
 (in-theory (disable statementp))
 
 ;;---------------
-;; index-of-name gets the index of a label statment so that
+;; index-of-name gets the index of a label statement so that
 ;; we can set the program counter when we execute goto, call, and
 ;; branch statements.
 
Index: acl2-8.5dfsg/books/workshops/2000/ruiz/multiset/multiset.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/ruiz/multiset/multiset.lisp
+++ acl2-8.5dfsg/books/workshops/2000/ruiz/multiset/multiset.lisp
@@ -472,7 +472,7 @@
 ;;; 2.3 An interesting congruence.
 ;;; ----------------------------------------------------------------------------
 
-;;; These rules are used in conjuction with rewite rules that simplify
+;;; These rules are used in conjunction with rewite rules that simplify
 ;;; multiset differences (w.r.t equal or equal-set)
 
 ;;; REMARK: These two congruence rules will be instantiated by every
Index: acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
+++ acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
@@ -131,7 +131,7 @@
 
 #|----------------------------------------------------------------------------|#
 
-;;;; BEGIN invariant defintion ;;;;
+;;;; BEGIN invariant definition ;;;;
 
 (DEFUN inv (st) (declare (ignore st)) t)
 
Index: acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
+++ acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
@@ -313,7 +313,7 @@
 
 #|----------------------------------------------------------------------------|#
 
-;;;; BEGIN invariant defintion ;;;;
+;;;; BEGIN invariant definition ;;;;
 
 ;; a few more macros for predicates for defining the
 ;; current "state" of the deque.
Index: acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
+++ acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
@@ -135,7 +135,7 @@
 
 #|----------------------------------------------------------------------------|#
 
-;;;; BEGIN invariant defintion ;;;;
+;;;; BEGIN invariant definition ;;;;
 
 (DEFUN inv (st) (declare (ignore st)) t)
 
Index: acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
+++ acl2-8.5dfsg/books/workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
@@ -343,7 +343,7 @@
 
 #|----------------------------------------------------------------------------|#
 
-;;;; BEGIN invariant defintion ;;;;
+;;;; BEGIN invariant definition ;;;;
 
 (defthm get-top-nil-implies-atom
   (implies (not (get-top x)) (not (consp x))))
Index: acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
+++ acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
@@ -277,7 +277,7 @@ restricted to C.
 
 ;; ACL2 is really stupid in arithmetic. I just add Robert's collection of
 ;; arithmetic books to get it thru with what I want. I need arithmetic really for
-;; very weird reasons, but well, what the heck, I dont want to deal with
+;; very weird reasons, but well, what the heck, I don't want to deal with
 ;; arithmetic myself any ways.
 
 (local
Index: acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/certify.lsp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2003/ray-matthews-tuttle/support/certify.lsp
+++ acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/certify.lsp
@@ -20,7 +20,7 @@ this file and do the ld.
 (ubt! 1)
 
 ;; This is simply Pete's total order book. I have it in the directory so that I
-;; dont have to change the path-names in the different books that call it.
+;; don't have to change the path-names in the different books that call it.
 
 (certify-book "total-order")
 (u)
Index: acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
+++ acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
@@ -29,7 +29,7 @@ restricted by vars.
                 (<- q (first vars)))
          (evaluation-eq p q (rest vars)))))
 
-;; We prove evaluation-eq is symmetric here, but I dont want to deal with loop
+;; We prove evaluation-eq is symmetric here, but I don't want to deal with loop
 ;; stoppers so we prove it only for the purpose of use hints.
 
 (defthm evaluation-eq-is-symmetric
Index: acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/sets.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2003/ray-matthews-tuttle/support/sets.lisp
+++ acl2-8.5dfsg/books/workshops/2003/ray-matthews-tuttle/support/sets.lisp
@@ -7,7 +7,7 @@
 
 In this book, we discuss the basic theory of flat sets. We define the functions
 subset, set-intersect, set-union and set-equal, and prove properties of these
-functions. I include the records book here, just so that I dont have two
+functions. I include the records book here, just so that I don't have two
 set-memberp functions. I do not know if this is going to be useful, but now I
 am not feeling like I want to do much (what with feeling drowsy and depressed
 and all) and so I thought this would just be an interesting exercise and be
Index: acl2-8.5dfsg/books/workshops/2004/davis/support/fast.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2004/davis/support/fast.lisp
+++ acl2-8.5dfsg/books/workshops/2004/davis/support/fast.lisp
@@ -43,7 +43,7 @@
 ;   (1) produces a set, and
 ;   (2) has the correct membership properties
 ;
-; These facts can then be used to make an equal-by-membership argu- ment with
+; These facts can then be used to make an equal-by-membership argument with
 ; the simple versions as required by MBE.
 ;
 ; Note that this file is very ugly.  There are many factors that con- tribute
Index: acl2-8.5dfsg/books/workshops/2004/legato/support/nqthm/modularithmetic-98.events
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2004/legato/support/nqthm/modularithmetic-98.events
+++ acl2-8.5dfsg/books/workshops/2004/legato/support/nqthm/modularithmetic-98.events
@@ -763,7 +763,7 @@
 ;;; they would conflict with plus-difference-commutes-meta.  Furthermore,
 ;;; there is a natural normalization which occurs when plus is expanded.
 ;;; As plus-commutes-meta moves litatoms to the left, expansion of plus will
-;;; tend to distribute sub1's uniformly over all litatoms occuring with the
+;;; tend to distribute sub1's uniformly over all litatoms occurring with the
 ;;; plus nest.
 
 ;;; canonical (needed to avoid "expand" hints)
Index: acl2-8.5dfsg/books/workshops/2004/ray/support/defcoerce.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2004/ray/support/defcoerce.lisp
+++ acl2-8.5dfsg/books/workshops/2004/ray/support/defcoerce.lisp
@@ -29,7 +29,7 @@ implement it.
 Known issues:
 
 1. The macro does not work for stobjs with no array field at all. (In
-the defpun-exec with defcoerce I dont use the macro unless there is
+the defpun-exec with defcoerce I don't use the macro unless there is
 some array field, which is why the negligence.)
 
 2.It also does not work with types T for arrays. I think I will be
Index: acl2-8.5dfsg/books/workshops/2004/ray/support/defpun-exec.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2004/ray/support/defpun-exec.lisp
+++ acl2-8.5dfsg/books/workshops/2004/ray/support/defpun-exec.lisp
@@ -119,7 +119,7 @@ the value is (ebody x)
 (4) If possible do it without changing the defpun macro provided by Manolios
 and Moore.
 
-(5) If guards are provided but the verification fails, I dont want anything to
+(5) If guards are provided but the verification fails, I don't want anything to
 be in the ACL2 universe.
 
 (6) If :ebody is not provided, then a :ebody of (lbody x) is assumed. Hence
@@ -131,7 +131,7 @@ Assumptions and acknowledgments:
 -------------------------------
 
 (1) The book defpun.lisp needs top be on the directory for this book to be
-certified. Note: If you dont want that, simply put the two forms (other than
+certified. Note: If you don't want that, simply put the two forms (other than
 the ; (include-book "defpun") form at the bottom of the defpun.lisp file and
 recertify that book.
 
@@ -517,7 +517,7 @@ described below to make :expand hints na
 
       ;; When I first did this, I was dissatisfied by the following:
       ;;
-      ;; Once the definition rule is present you would think that you dont want
+      ;; Once the definition rule is present you would think that you don't want
       ;; anything to do with foo-logic. So I would not like to have the logical
       ;; body of foo enabled, but rather I would simply have the definition
       ;; rule foo-def above to do what we want with foo. Unfortunately, if the
@@ -552,7 +552,7 @@ described below to make :expand hints na
       (in-theory (disable ,fname (:definition ,(packn (list lfname '-def)))))
 
       ;; I think some form of theory invariants should be present here, since I
-      ;; dont quite like the body of foo and definition foo-def to be both
+      ;; don't quite like the body of foo and definition foo-def to be both
       ;; enabled, because then foo-def ought never to be used. (foo is
       ;; non-recursive.) Of course it is not a big point to have a theory
       ;; invariant, but here is what I am thinking. A user can either use
@@ -643,7 +643,7 @@ described below to make :expand hints na
 Testing
 =======
 
-(1) I dont verify the guard below. So it will produce the logic definition and
+(1) I don't verify the guard below. So it will produce the logic definition and
 the definition rule, but will produce a guard of nil, and hence in effect
 disable the executable counterpart. This has the precise effect of simply
 providing a defpun.
@@ -783,7 +783,7 @@ ACL2 !>(defun foop-exec (foo)
 ;; we had to actually expand out all the stobj calls. This is because defpun
 ;; cannot handle let and let*. I presume it will, at some future time. But
 ;; either way, defpun-exec has no real problem with let and let* (although I
-;; dont support mv-let yet). Anyway, this example shows that you can now do a
+;; don't support mv-let yet). Anyway, this example shows that you can now do a
 ;; slow execution.
 
 ACL2 !>(defpun-exec bar (x foo)
Index: acl2-8.5dfsg/books/workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp
+++ acl2-8.5dfsg/books/workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp
@@ -25,7 +25,7 @@
 
 ;we look through HYPS for a term of the form (subbagp x y)
 ;if such an item is found, we return (mv t y).  else, we return (mv nil nil)
-;what if multple such things might be found?
+;what if multiple such things might be found?
 (defun find-exact-subbagp-instance (x hyps)
   (declare (type t hyps)
            )
@@ -107,7 +107,7 @@
 ;what does this do?
 ;we look through HYPS for a term of the form (subbagp x BLAH)
 ;if such an item is found, we test whether BLAH equals y.  else, we return nil
-;what if multple such things might be found?
+;what if multiple such things might be found?
 (defun subbagp-instance (x y hyps)
   (declare (type t x y hyps))
   (met ((hit res) (find-exact-subbagp-instance x hyps))
Index: acl2-8.5dfsg/books/workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp
+++ acl2-8.5dfsg/books/workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp
@@ -3320,7 +3320,7 @@ To certify this book, first, create a wo
 			   (mv-nth 0 (Bezout1 x y n)))
 		     (**_e y
 			   (mv-nth 1 (Bezout1 x y n))))
-   is nonzero, and the size of the linear conbination is n."
+   is nonzero, and the size of the linear combination is n."
   (declare (xargs :measure (let ((n (nfix n)))
 			            (nfix (- (Size x) n)))))
   (if (and (edp x)
Index: acl2-8.5dfsg/books/workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp
+++ acl2-8.5dfsg/books/workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp
@@ -196,7 +196,7 @@ To certify this book, first, create a wo
   =P (x y)
   "A polynomial is a true list of momomials.
    Determine if x and y are the same list of monomials,
-   upto monomial equivalence."
+   up to monomial equivalence."
   (if (consp x)
       (and (consp y)
 	   (FUMON::= (primero x)
Index: acl2-8.5dfsg/books/workshops/2007/rubio/support/multisets/multiset.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2007/rubio/support/multisets/multiset.lisp
+++ acl2-8.5dfsg/books/workshops/2007/rubio/support/multisets/multiset.lisp
@@ -469,7 +469,7 @@
 ;;; 2.3 An interesting congruence.
 ;;; ----------------------------------------------------------------------------
 
-;;; These rules are used in conjuction with rewite rules that simplify
+;;; These rules are used in conjunction with rewite rules that simplify
 ;;; multiset differences (w.r.t equal or equal-set)
 
 ;;; REMARK: These two congruence rules will be instantiated by every
Index: acl2-8.5dfsg/books/workshops/2011/krug-et-al/support/Symbolic/vanilla-partial-correctness.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2011/krug-et-al/support/Symbolic/vanilla-partial-correctness.lisp
+++ acl2-8.5dfsg/books/workshops/2011/krug-et-al/support/Symbolic/vanilla-partial-correctness.lisp
@@ -346,7 +346,7 @@ package].
                    (run-fn s (+ m n))))))
 
 ;; The next-state rule is an ugly hack and I am almost doing it assuming I
-;; know what I am doing. If I dont use this theorem, the definition of
+;; know what I am doing. If I don't use this theorem, the definition of
 ;; run-fn does not expand in circumstances I want it to. The theorem
 ;; always expands expressions of the form (run-fn <some state> l) whereas
 ;; if it is not l the theorem does not fire. My intention here is that
@@ -668,7 +668,7 @@ package].
 ;; holds for all steps < (big-steps (steps-to-exitpoint s)). But in
 ;; order to deal with the quantifier-free aspect of ACL2, I need a few
 ;; more tricks. Notice that I am trying hard here to curb my natural
-;; tendencies and just introduce a defun-sk. I dont do it since I dont
+;; tendencies and just introduce a defun-sk. I don't do it since I don't
 ;; see that necessary.
 
 ;; The trick that I am doing is to define a function falsifier that
Index: acl2-8.5dfsg/books/workshops/2011/verbeek-schmaltz/sources/perm.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2011/verbeek-schmaltz/sources/perm.lisp
+++ acl2-8.5dfsg/books/workshops/2011/verbeek-schmaltz/sources/perm.lisp
@@ -3,7 +3,7 @@
 
 (in-package "ACL2")
 
-;; The following book contains the defintion of del.
+;; The following book contains the definition of del.
 ;; We load this book, to prevent mutliple defintions,
 ;; of the same function.
 (include-book "meta/term-defuns" :dir :system)
Index: acl2-8.5dfsg/books/workshops/2013/van-gastel-schmaltz/books/perm.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2013/van-gastel-schmaltz/books/perm.lisp
+++ acl2-8.5dfsg/books/workshops/2013/van-gastel-schmaltz/books/perm.lisp
@@ -3,7 +3,7 @@
 
 (in-package "ACL2")
 
-;; The following book contains the defintion of del.
+;; The following book contains the definition of del.
 ;; We load this book, to prevent mutliple defintions,
 ;; of the same function.
 (include-book "meta/term-defuns" :dir :system)
Index: acl2-8.5dfsg/books/workshops/2014/russinoff-oleary/support/translate.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2014/russinoff-oleary/support/translate.lisp
+++ acl2-8.5dfsg/books/workshops/2014/russinoff-oleary/support/translate.lisp
@@ -135,7 +135,7 @@ are more than one).  The test of the IF
 
 )
 
-;; The following functions are used in conjuction with the built-in subst-var,
+;; The following functions are used in conjunction with the built-in subst-var,
 ;; which substitutes a term for each occurrence of a variable in an expression.
 
 ;; var-count counts the number of occurrences of a variable in an expression:
Index: acl2-8.5dfsg/books/workshops/2017/sumners/support/bakery.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2017/sumners/support/bakery.lisp
+++ acl2-8.5dfsg/books/workshops/2017/sumners/support/bakery.lisp
@@ -59,7 +59,7 @@ conditions sufficient to prove the remai
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;; bakery specification defintion
+;;;; bakery specification definition
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (in-theory (enable o-p o<))
@@ -132,7 +132,7 @@ conditions sufficient to prove the remai
 
 (def-tr-system-defs bake-spec)
 
-;;;; bakery implementation defintion
+;;;; bakery implementation definition
 
 (defun lex< (p q r s)
   (or (< p r) (and (equal p r) (< q s))))
Index: acl2-8.5dfsg/books/workshops/2018/kwan-greenstreet/nesterov-3.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2018/kwan-greenstreet/nesterov-3.lisp
+++ acl2-8.5dfsg/books/workshops/2018/kwan-greenstreet/nesterov-3.lisp
@@ -1281,7 +1281,7 @@
 		 :use ((:instance lemma-14)
 		       (:instance metric-commutativity (vec1 y) (vec2 x)))))))
 
-;; beginning to simplify || z - y || to alpha^2 || y - x || or || x - y || idr doesnt matter
+;; beginning to simplify || z - y || to alpha^2 || y - x || or || x - y || idr doesn't matter
 (local (defthm lemma-16
  (implies (and (real-listp x) (real-listp y) (= (len x) (DIM)) (= (len y) (len x))
 	       (realp alpha) (<= 0 alpha) (<= alpha 1))
Index: acl2-8.5dfsg/books/workshops/2020/sumners/bakery.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2020/sumners/bakery.lisp
+++ acl2-8.5dfsg/books/workshops/2020/sumners/bakery.lisp
@@ -11,7 +11,7 @@
 (include-book "centaur/gl/shape-spec" :dir :system)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;; bakery specification defintion
+;;;; bakery specification definition
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defmacro make-signed-byte-type (name size)
Index: acl2-8.5dfsg/books/workshops/2020/sumners/gl-fin-set.lisp
===================================================================
--- acl2-8.5dfsg.orig/books/workshops/2020/sumners/gl-fin-set.lisp
+++ acl2-8.5dfsg/books/workshops/2020/sumners/gl-fin-set.lisp
@@ -18,7 +18,7 @@ This book defines the following GL-based
 Takes a concl and g-bindings (shape specs) similar to def-gl-thm but in
 addition for a specified variable in the g-bindings (i.e. one of the free
 variables), compute-finite-values will produce a finite number of solutions for
-the specified free variable upto some specified limit or potentially a complete
+the specified free variable up to some specified limit or potentially a complete
 set. We use existing GL->AIG->CNF conversion to get a CNF and variable
 correlation through sat-lits and this is then loaded into IPASIR incremental
 SAT state and then iterated on with incremental SAT to find the different
Index: acl2-8.5dfsg/books/xdoc/fancy/lib/jquery-2.1.0.js
===================================================================
--- acl2-8.5dfsg.orig/books/xdoc/fancy/lib/jquery-2.1.0.js
+++ acl2-8.5dfsg/books/xdoc/fancy/lib/jquery-2.1.0.js
@@ -1071,7 +1071,7 @@ setDocument = Sizzle.setDocument = funct
 
 	// Support: IE<10
 	// Check if getElementById returns elements by name
-	// The broken getElementById methods don't pick up programatically-set names,
+	// The broken getElementById methods don't pick up programmatically-set names,
 	// so use a roundabout getElementsByName test
 	support.getById = assert(function( div ) {
 		docElem.appendChild( div ).id = expando;
Index: acl2-8.5dfsg/doc.lisp
===================================================================
--- acl2-8.5dfsg.orig/doc.lisp
+++ acl2-8.5dfsg/doc.lisp
@@ -23812,7 +23812,7 @@ Miscellaneous Remarks, with discussion o
 
   (Of interest only to users of [apply$].)  Special handling is applied
   when attempting to attach to a so-called warrant, which is produced
-  by an appication of [defwarrant] (or [defun$]).  In that case it is
+  by an application of [defwarrant] (or [defun$]).  In that case it is
   legal to attach the function true-apply$-warrant to the warrant,
   without any proof obligation.  This attachment is actually
   performed automatically by defwarrant, so users (even users of
@@ -25270,7 +25270,7 @@ Restrictions
   class of loop$-recursive functions that can be successfully
   handled.  We have not yet even looked at inductions for ON loop$s
   and FROM/TO/BY loop$s, so that might be easy.  Induction for loop$s
-  over arbtrary target expressions may be infeasible!  We just need
+  over arbitrary target expressions may be infeasible!  We just need
   more examples of loop$-recursive functions and successful
   (hand-written) induction hints for them.")
  (DEFINE-PC-HELP
@@ -52116,7 +52116,7 @@ Subtopics
   It checks that every element of lst satisfies its :FN argument fn.
 
   By the way, both collect$ and always$ are pre-defined in ACL2 because
-  they are part of the support for the [loop$] statment.
+  they are part of the support for the [loop$] statement.
 
   Lesson 6: You can run scions on warranted function symbols:
 
@@ -61629,7 +61629,7 @@ Measure Conjectures
   loop$ bodies.  (We also generate conjectures for the recursive
   calls the other loop$-expression components, e.g., the WHEN clause,
   exactly analogously, but we speak of the loop$ body only below.  We
-  also focus on simple loop$s here but the conjectures decribed
+  also focus on simple loop$s here but the conjectures described
   generalize to fancy loop$s.)  Given a recursive call inside the
   body of a loop$ with iteration variable v, we first generate a new
   variable symbol, v'.  Certain terms, e.g., tests and arguments to
@@ -90459,7 +90459,7 @@ Heuristic and Efficiency Improvements
   calls on a single variable when building a context (a so-called
   [type-alist]).  (By a ``strong compound-recognizer call'' we mean a
   unary function that recognizes a union of primitive ACL2 types and
-  has, either explicitly or implicity, a corresponding
+  has, either explicitly or implicitly, a corresponding
   [compound-recognizer] rule; examples include [stringp], [integerp],
   and [true-listp].)  In particular, this change can strengthen the
   result of [forward-chaining].  Thanks to Eric Smith, who raised
@@ -107521,7 +107521,7 @@ Subtopics
   returned [state] is the same as the world of the input state even
   if the evaluation of form modifies the world of the input state.
 
-  To see revert-world in action, consider the following defintion.
+  To see revert-world in action, consider the following definition.
 
     (defun test-revert-world (state)
      (declare (xargs :mode :program :stobjs state))
@@ -119337,7 +119337,7 @@ Subtopics
   avoided --- see [set-inhibit-output-lst] --- or if you prefer, you
   may inhibit just specified component of the summary --- see
   [set-inhibited-summary-types].  The components are listed in the
-  constant *summary-types* and most are available programatically:
+  constant *summary-types* and most are available programmatically:
   see [get-event-data].  Some are omitted, however, if they would
   otherwise be empty.  Here is a brief summary of the components,
   listed alphabetically.  Most are printed with an initial field
@@ -132994,7 +132994,7 @@ Remarks
   for name and all must be proved for (verify-guards name) to be
   successful.  If the guards of some LAMBDA object requires hints to
   prove, the hints may be supplied to verify-guards as you would for
-  any other failing guard obligation in name.  When successfull, the
+  any other failing guard obligation in name.  When successful, the
   LAMBDA objects thus verified are added, behind the scenes, to the
   compiled lambda cache (see [print-cl-cache]) to speed up apply$ in
   the evaluation theory.
Index: acl2-8.5dfsg/history-management.lisp
===================================================================
--- acl2-8.5dfsg.orig/history-management.lisp
+++ acl2-8.5dfsg/history-management.lisp
@@ -12068,7 +12068,7 @@
 ; ruled by hyps2.  Note that the only free vars in lam-body are gv and iv.  But
 ; gv is always bound to globals as the fancy loop$ scion iterates across
 ; target.  Meanwhile, iv might occur outside the lambda and must be renamed.
-; So iv' be a new variable not occuring in hyps1 and let s be the substitution
+; So iv' be a new variable not occurring in hyps1 and let s be the substitution
 ; {gv <-- globals, iv <-- iv'}.  Then the measure conjecture generated for this
 ; call of (fn d1 ... dn) in lam-body is
 
Index: acl2-8.5dfsg/other-events.lisp
===================================================================
--- acl2-8.5dfsg.orig/other-events.lisp
+++ acl2-8.5dfsg/other-events.lisp
@@ -32381,7 +32381,7 @@
 ; 'macros-with-raw-code, but that also seems the right thing to do.
 
 ; Thus, this function is essentially (eval form), except that instead of
-; returning the value(s) from that evaluation, it retuns a new state where the
+; returning the value(s) from that evaluation, it returns a new state where the
 ; xxx-with-raw-code state globals are extended, according to the definitions of
 ; ACL2 macros and functions that have changed when form is evaluated.
 
Index: acl2-8.5dfsg/translate.lisp
===================================================================
--- acl2-8.5dfsg.orig/translate.lisp
+++ acl2-8.5dfsg/translate.lisp
@@ -12751,7 +12751,7 @@
 ; is tail-recursive counterpart.
 
 ;;; Possible Future Work on Loop$: CLTL supports from/downfrom/upfrom and
-;;; to/downto/upto/below/above.  Eventually we should change the parse-loop$ to
+;;; to/downto/up to/below/above.  Eventually we should change the parse-loop$ to
 ;;; parse those and provide the necessary translation, defuns of the necessary
 ;;; enumerators, and proof support.
 
