diff --git a/books/bookvol9.pamphlet b/books/bookvol9.pamphlet
index 7090eff..b78a285 100644
--- a/books/bookvol9.pamphlet
+++ b/books/bookvol9.pamphlet
@@ -6420,6 +6420,168 @@ $\rightarrow$
 
 \end{chunk}
 
+\defun{compDefineLisplib}{compDefineLisplib}
+\calls{compDefineLisplib}{sayMSG}
+\calls{compDefineLisplib}{fillerSpaces}
+\calls{compDefineLisplib}{getConstructorAbbreviation}
+\calls{compDefineLisplib}{compileDocumentation}
+\calls{compDefineLisplib}{bright}
+\calls{compDefineLisplib}{finalizeLisplib}
+\calls{compDefineLisplib}{rshut}
+\calls{compDefineLisplib}{lisplibDoRename}
+\calls{compDefineLisplib}{filep}
+\calls{compDefineLisplib}{rpackfile}
+\calls{compDefineLisplib}{unloadOneConstructor}
+\calls{compDefineLisplib}{localdatabase}
+\calls{compDefineLisplib}{getdatabase}
+\calls{compDefineLisplib}{updateCategoryFrameForCategory}
+\calls{compDefineLisplib}{updateCategoryFrameForConstructor}
+\refsdollar{compDefineLisplib}{compileDocumentation}
+\refsdollar{compDefineLisplib}{filep}
+\refsdollar{compDefineLisplib}{spadLibFT}
+\refsdollar{compDefineLisplib}{algebraOutputStream}
+\refsdollar{compDefineLisplib}{newConlist}
+\refsdollar{compDefineLisplib}{lisplibKind}
+\defsdollar{compDefineLisplib}{lisplib}
+\defsdollar{compDefineLisplib}{op}
+\defsdollar{compDefineLisplib}{lisplibParents}
+\defsdollar{compDefineLisplib}{lisplibPredicates}
+\defsdollar{compDefineLisplib}{lisplibCategoriesExtended}
+\defsdollar{compDefineLisplib}{lisplibForm}
+\defsdollar{compDefineLisplib}{lisplibKind}
+\defsdollar{compDefineLisplib}{lisplibAbbreviation}
+\defsdollar{compDefineLisplib}{lisplibAncestors}
+\defsdollar{compDefineLisplib}{lisplibModemap}
+\defsdollar{compDefineLisplib}{lisplibModemapAlist}
+\defsdollar{compDefineLisplib}{lisplibSlot1}
+\defsdollar{compDefineLisplib}{lisplibOperationAlist}
+\defsdollar{compDefineLisplib}{lisplibSuperDomain}
+\defsdollar{compDefineLisplib}{libFile}
+\defsdollar{compDefineLisplib}{lisplibVariableAlist}
+\defsdollar{compDefineLisplib}{lisplibCategory}
+\defsdollar{compDefineLisplib}{newConlist}
+\begin{chunk}{defun compDefineLisplib}
+(defun |compDefineLisplib| (df m env prefix fal fn)
+ (let ($LISPLIB |$op| |$lisplibAttributes| |$lisplibPredicates|
+       |$lisplibCategoriesExtended| |$lisplibForm| |$lisplibKind|
+       |$lisplibAbbreviation| |$lisplibParents| |$lisplibAncestors| 
+       |$lisplibModemap| |$lisplibModemapAlist| |$lisplibSlot1|
+       |$lisplibOperationAlist| |$lisplibSuperDomain| |$libFile|
+       |$lisplibVariableAlist| |$lisplibCategory| op libname res ok filearg)
+ (declare (special $lisplib |$op| |$lisplibAttributes| |$newConlist|
+                   |$lisplibPredicates| |$lisplibCategoriesExtended|
+                   |$lisplibForm| |$lisplibKind| |$algebraOutputStream|
+                   |$lisplibAbbreviation| |$lisplibParents| |$spadLibFT|
+                   |$lisplibAncestors| |$lisplibModemap| $filep
+                   |$lisplibModemapAlist| |$lisplibSlot1|
+                   |$lisplibOperationAlist| |$lisplibSuperDomain|
+                   |$libFile| |$lisplibVariableAlist| 
+                   |$lisplibCategory| |$compileDocumentation|))
+  (when (eq (car df) 'def) (car df))
+  (setq op (caadr df))
+  (|sayMSG| (|fillerSpaces| 72 "-"))
+  (setq $lisplib t)
+  (setq |$op| op)
+  (setq |$lisplibAttributes| nil)
+  (setq |$lisplibPredicates| nil)
+  (setq |$lisplibCategoriesExtended| nil)
+  (setq |$lisplibForm| nil)
+  (setq |$lisplibKind| nil)
+  (setq |$lisplibAbbreviation| nil)
+  (setq |$lisplibParents| nil)
+  (setq |$lisplibAncestors| nil)
+  (setq |$lisplibModemap| nil)
+  (setq |$lisplibModemapAlist| nil)
+  (setq |$lisplibSlot1| nil)
+  (setq |$lisplibOperationAlist| nil)
+  (setq |$lisplibSuperDomain| nil)
+  (setq |$libFile| nil)
+  (setq |$lisplibVariableAlist| nil)
+  (setq |$lisplibCategory| nil)
+  (setq libname (|getConstructorAbbreviation| op))
+  (cond
+   ((and (boundp '|$compileDocumentation|) |$compileDocumentation|)
+      (|compileDocumentation| libname))
+   (t
+    (|sayMSG| (cons "   initializing " (cons |$spadLibFT|
+              (append (|bright| libname) (cons "for" (|bright| op))))))
+    (|initializeLisplib| libname)
+    (|sayMSG|
+     (cons "   compiling into " (cons |$spadLibFT| (|bright| libname))))
+    (setq ok nil)
+    (unwind-protect
+     (progn
+      (setq res (funcall fn df m env prefix fal))
+      (|sayMSG| (cons "   finalizing " (cons |$spadLibFT| (|bright| libname))))
+      (|finalizeLisplib| libname)
+      (setq ok t))
+      (rshut |$libFile|))
+    (when ok (|lisplibDoRename| libname))
+    (setq filearg ($filep libname |$spadLibFT| 'a))
+    (rpackfile filearg)
+    (fresh-line |$algebraOutputStream|)
+    (|sayMSG| (|fillerSpaces| 72 "-"))
+    (|unloadOneConstructor| op libname)
+    (localdatabase (list (getdatabase op 'abbreviation)) nil)
+    (setq |$newConlist| (cons op |$newConlist|))
+    (cond (eq |$lisplibKind| '|category|)
+     (|updateCategoryFrameForCategory| op)
+     (|updateCategoryFrameForConstructor| op))
+    res))))
+
+\end{chunk}
+
+\defun{initializeLisplib}{initializeLisplib}
+\calls{initializeLisplib}{erase}
+\calls{initializeLisplib}{writeLib1}
+\calls{initializeLisplib}{addoptions}
+\calls{initializeLisplib}{pathnameTypeId}
+\calls{initializeLisplib}{LAM,FILEACTQ}
+\refsdollar{initializeLisplib}{erase}
+\refsdollar{initializeLisplib}{libFile}
+\defsdollar{initializeLisplib}{libFile}
+\defsdollar{initializeLisplib}{lisplibForm}
+\defsdollar{initializeLisplib}{lisplibModemap}
+\defsdollar{initializeLisplib}{lisplibKind}
+\defsdollar{initializeLisplib}{lisplibModemapAlist}
+\defsdollar{initializeLisplib}{lisplibAbbreviation}
+\defsdollar{initializeLisplib}{lisplibAncestors}
+\defsdollar{initializeLisplib}{lisplibOpAlist}
+\defsdollar{initializeLisplib}{lisplibOperationAlist}
+\defsdollar{initializeLisplib}{lisplibSuperDomain}
+\defsdollar{initializeLisplib}{lisplibVariableAlist}
+\defsdollar{initializeLisplib}{lisplibSignatureAlist}
+\uses{initializeLisplib}{/editfile}
+\uses{initializeLisplib}{/major-version}
+\uses{initializeLisplib}{errors}
+\begin{chunk}{defun initializeLisplib}
+(defun |initializeLisplib| (libName)
+  (declare (special $erase |$libFile| |$lisplibForm|
+                    |$lisplibModemap| |$lisplibKind| |$lisplibModemapAlist|
+                    |$lisplibAbbreviation| |$lisplibAncestors|
+                    |$lisplibOpAlist| |$lisplibOperationAlist|
+                    |$lisplibSuperDomain| |$lisplibVariableAlist|
+                    |$lisplibSignatureAlist| /editfile /major-version errors))
+   ($erase libName 'errorlib 'a)
+   (setq errors 0)
+   (setq |$libFile| (|writeLib1| libname 'errorlib 'a))
+   (addoptions 'file |$libFile|)
+   (setq |$lisplibForm| nil)
+   (setq |$lisplibModemap| nil)
+   (setq |$lisplibKind| nil)
+   (setq |$lisplibModemapAlist| nil)
+   (setq |$lisplibAbbreviation| nil)
+   (setq |$lisplibAncestors| nil)
+   (setq |$lisplibOpAlist| nil)
+   (setq |$lisplibOperationAlist| nil)
+   (setq |$lisplibSuperDomain| nil)
+   (setq |$lisplibVariableAlist| nil)
+   (setq |$lisplibSignatureAlist| nil)
+   (when (eq (|pathnameTypeId| /editfile) 'spad)
+     (|LAM,FILEACTQ| 'version (list '/versioncheck /major-version))))
+
+\end{chunk}
+
 \defun{compDefineFunctor}{compDefineFunctor}
 \calls{compDefineFunctor}{compDefineLisplib}
 \calls{compDefineFunctor}{compDefineFunctor1}
@@ -17043,6 +17205,7 @@ if \verb|$InteractiveMode| then use a null outputstream
 \getchunk{defun compDefineCategory2}
 \getchunk{defun compDefineFunctor}
 \getchunk{defun compDefineFunctor1}
+\getchunk{defun compDefineLisplib}
 \getchunk{defun compDefWhereClause}
 \getchunk{defun compElt}
 \getchunk{defun compExit}
@@ -17153,6 +17316,7 @@ if \verb|$InteractiveMode| then use a null outputstream
 \getchunk{defun initialize-preparse}
 \getchunk{defun initial-substring}
 \getchunk{defun initial-substring-p}
+\getchunk{defun initializeLisplib}
 \getchunk{defun is-console}
 \getchunk{defun isListConstructor}
 \getchunk{defun isSuperDomain}
diff --git a/changelog b/changelog
index 6af8def..231027e 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,6 @@
+20110716 tpd src/axiom-website/patches.html 20110716.01.tpd.patch
+20110716 tpd src/interp/lisplib.lisp treeshake compiler
+20110716 tpd books/bookvol9 treeshake compiler
 20110715 tpd src/axiom-website/patches.html 20110715.02.tpd.patch
 20110715 tpd src/interp/database.lisp treeshake interpreter
 20110715 tpd src/interp/lisplib.lisp treeshake interpreter
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 9a730e9..58aee9d 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -3546,5 +3546,7 @@ src/interp/axext_l.lisp removed<br/>
 src/interp/Makefile add (si::reset-sys-paths) per Camm<br/>
 <a href="patches/20110715.02.tpd.patch">20110715.02.tpd.patch</a>
 books/bookvol5 treeshake interpreter<br/>
+<a href="patches/20110716.01.tpd.patch">20110716.01.tpd.patch</a>
+books/bookvol9 treeshake compiler<br/>
  </body>
 </html>
diff --git a/src/interp/lisplib.lisp.pamphlet b/src/interp/lisplib.lisp.pamphlet
index 7c66f8a..49a44f5 100644
--- a/src/interp/lisplib.lisp.pamphlet
+++ b/src/interp/lisplib.lisp.pamphlet
@@ -73,14 +73,6 @@
         (|LAM,FILEACTQ| |key| |form|))
     ('T NIL)))
 
-;getLisplibNoCache(name,id) ==
-;  -- this version does not cache the returned value
-;  getFileProperty(name,$spadLibFT,id,false)
-
-(DEFUN |getLisplibNoCache| (|name| |id|)
-  (declare (special |$spadLibFT|))
-  (|getFileProperty| |name| |$spadLibFT| |id| NIL))
-
 ;getFileProperty(fn,ft,id,cache) ==
 ;  fn in '(DOMAIN SUBDOM MODE) => nil
 ;  p := pathname [fn,ft,'"*"]
@@ -230,11 +222,6 @@
 
 (DEFUN |loadIfNecessary| (|u|) (|loadLibIfNecessary| |u| 'T))
 
-;loadIfNecessaryAndExists u == loadLibIfNecessary(u,nil)
-
-(DEFUN |loadIfNecessaryAndExists| (|u|)
-  (|loadLibIfNecessary| |u| NIL))
-
 ;loadLibIfNecessary(u,mustExist) ==
 ;  u = '$EmptyMode => u
 ;  null atom u => loadLibIfNecessary(first u,mustExist)
@@ -757,144 +744,6 @@
                      |editFlag| |traceFlag|))
         |val|))))
 
-;compDefineLisplib(df:=["DEF",[op,:.],:.],m,e,prefix,fal,fn) ==
-;  --fn= compDefineCategory OR compDefineFunctor
-;  sayMSG fillerSpaces(72,'"-")
-;  $LISPLIB: local := 'T
-;  $op: local := op
-;  $lisplibAttributes: local := NIL
-;  $lisplibPredicates: local := NIL -- set by makePredicateBitVector
-;  $lisplibCategoriesExtended: local := NIL -- this is always nil. why? (tpd)
-;  $lisplibForm: local := NIL
-;  $lisplibKind: local := NIL
-;  $lisplibAbbreviation: local := NIL
-;  $lisplibParents: local := NIL
-;  $lisplibAncestors: local := NIL
-;  $lisplibModemap: local := NIL
-;  $lisplibModemapAlist: local := NIL
-;  $lisplibSlot1 : local := NIL   -- used by NRT mechanisms
-;  $lisplibOperationAlist: local := NIL
-;  $lisplibSuperDomain: local := NIL
-;  $libFile: local := NIL
-;  $lisplibVariableAlist: local := NIL
-;--  $lisplibRelatedDomains: local := NIL   --from ++ Related Domains: see c-doc
-;  $lisplibCategory: local := nil
-;  --for categories, is rhs of definition; otherwise, is target of functor
-;  --will eventually become the "constructorCategory" property in lisplib
-;  --set in compDefineCategory1 if category, otherwise in finalizeLisplib
-;  libName := getConstructorAbbreviation op
-;  BOUNDP '$compileDocumentation and $compileDocumentation =>
-;     compileDocumentation libName
-;  sayMSG ['"   initializing ",$spadLibFT,:bright libName,
-;    '"for",:bright op]
-;  initializeLisplib libName
-;  sayMSG ['"   compiling into ",$spadLibFT,:bright libName]
-;  -- res:= FUNCALL(fn,df,m,e,prefix,fal)
-;  -- sayMSG ['"   finalizing ",$spadLibFT,:bright libName]
-;  -- finalizeLisplib libName
-;  -- following guarantee's compiler output files get closed.
-;  ok := false;
-;  UNWIND_-PROTECT(
-;      PROGN(res:= FUNCALL(fn,df,m,e,prefix,fal),
-;            sayMSG ['"   finalizing ",$spadLibFT,:bright libName],
-;            finalizeLisplib libName,
-;            ok := true),
-;      RSHUT $libFile)
-;  if ok then lisplibDoRename(libName)
-;  filearg := $FILEP(libName,$spadLibFT,'a)
-;  RPACKFILE filearg
-;  FRESH_-LINE $algebraOutputStream
-;  sayMSG fillerSpaces(72,'"-")
-;  unloadOneConstructor(op,libName)
-;  LOCALDATABASE(LIST GETDATABASE(op,'ABBREVIATION),NIL)
-;  $newConlist := [op, :$newConlist]  ---------->  bound in function "compiler"
-;  if $lisplibKind = 'category
-;    then updateCategoryFrameForCategory op
-;     else updateCategoryFrameForConstructor op
-;  res
-
-(DEFUN |compDefineLisplib| (|df| |m| |e| |prefix| |fal| |fn|)
-  (PROG ($LISPLIB |$op| |$lisplibAttributes| |$lisplibPredicates|
-            |$lisplibCategoriesExtended| |$lisplibForm| |$lisplibKind|
-            |$lisplibAbbreviation| |$lisplibParents|
-            |$lisplibAncestors| |$lisplibModemap|
-            |$lisplibModemapAlist| |$lisplibSlot1|
-            |$lisplibOperationAlist| |$lisplibSuperDomain| |$libFile|
-            |$lisplibVariableAlist| |$lisplibCategory| |op| |libName|
-            |res| |ok| |filearg|)
-    (DECLARE (SPECIAL $LISPLIB |$op| |$lisplibAttributes| |$newConlist|
-                      |$lisplibPredicates| |$lisplibCategoriesExtended|
-                      |$lisplibForm| |$lisplibKind| |$algebraOutputStream|
-                      |$lisplibAbbreviation| |$lisplibParents| |$spadLibFT|
-                      |$lisplibAncestors| |$lisplibModemap| $FILEP
-                      |$lisplibModemapAlist| |$lisplibSlot1|
-                      |$lisplibOperationAlist| |$lisplibSuperDomain|
-                      |$libFile| |$lisplibVariableAlist| 
-                      |$lisplibCategory| |$compileDocumentation|))
-    (RETURN
-      (PROGN
-        (COND ((EQ (CAR |df|) 'DEF) (CAR |df|)))
-        (SPADLET |op| (CAADR |df|))
-        (|sayMSG| (|fillerSpaces| 72 "-"))
-        (SPADLET $LISPLIB 'T)
-        (SPADLET |$op| |op|)
-        (SPADLET |$lisplibAttributes| NIL)
-        (SPADLET |$lisplibPredicates| NIL)
-        (SPADLET |$lisplibCategoriesExtended| NIL)
-        (SPADLET |$lisplibForm| NIL)
-        (SPADLET |$lisplibKind| NIL)
-        (SPADLET |$lisplibAbbreviation| NIL)
-        (SPADLET |$lisplibParents| NIL)
-        (SPADLET |$lisplibAncestors| NIL)
-        (SPADLET |$lisplibModemap| NIL)
-        (SPADLET |$lisplibModemapAlist| NIL)
-        (SPADLET |$lisplibSlot1| NIL)
-        (SPADLET |$lisplibOperationAlist| NIL)
-        (SPADLET |$lisplibSuperDomain| NIL)
-        (SPADLET |$libFile| NIL)
-        (SPADLET |$lisplibVariableAlist| NIL)
-        (SPADLET |$lisplibCategory| NIL)
-        (SPADLET |libName| (|getConstructorAbbreviation| |op|))
-        (COND
-          ((AND (BOUNDP '|$compileDocumentation|)
-                |$compileDocumentation|)
-           (|compileDocumentation| |libName|))
-          ('T
-           (|sayMSG|
-               (CONS "   initializing "
-                     (CONS |$spadLibFT|
-                           (APPEND (|bright| |libName|)
-                                   (CONS "for"
-                                    (|bright| |op|))))))
-           (|initializeLisplib| |libName|)
-           (|sayMSG|
-               (CONS "   compiling into "
-                     (CONS |$spadLibFT| (|bright| |libName|))))
-           (SPADLET |ok| NIL)
-           (UNWIND-PROTECT
-             (PROGN
-               (SPADLET |res|
-                        (FUNCALL |fn| |df| |m| |e| |prefix| |fal|))
-               (|sayMSG|
-                   (CONS "   finalizing "
-                         (CONS |$spadLibFT| (|bright| |libName|))))
-               (|finalizeLisplib| |libName|)
-               (SPADLET |ok| 'T))
-             (RSHUT |$libFile|))
-           (COND (|ok| (|lisplibDoRename| |libName|)))
-           (SPADLET |filearg|
-                    ($FILEP |libName| |$spadLibFT| 'a))
-           (RPACKFILE |filearg|) (FRESH-LINE |$algebraOutputStream|)
-           (|sayMSG| (|fillerSpaces| 72 "-"))
-           (|unloadOneConstructor| |op| |libName|)
-           (LOCALDATABASE (LIST (GETDATABASE |op| 'ABBREVIATION)) NIL)
-           (SPADLET |$newConlist| (CONS |op| |$newConlist|))
-           (COND
-             ((BOOT-EQUAL |$lisplibKind| '|category|)
-              (|updateCategoryFrameForCategory| |op|))
-             ('T (|updateCategoryFrameForConstructor| |op|)))
-           |res|))))))
-
 ;compileDocumentation libName ==
 ;  filename := MAKE_-INPUT_-FILENAME(libName,$spadLibFT)
 ;  $FCOPY(filename,[libName,'DOCLB])
@@ -928,77 +777,6 @@
             (CONS |libName| (CONS 'DOCLB NIL)))
         (CONS '|dummy| (CONS |$EmptyMode| (CONS |$e| NIL)))))))
 
-;getLisplibVersion libName ==
-;  stream := RDEFIOSTREAM [['FILE,libName,$spadLibFT],['MODE, :'I]]
-;  version:= CADR rread('VERSION, stream,nil)
-;  RSHUT(stream)
-;  version
-
-(DEFUN |getLisplibVersion| (|libName|)
-  (PROG (|stream| |version|)
-  (declare (special |$spadLibFT|))
-    (RETURN
-      (PROGN
-        (SPADLET |stream|
-                 (RDEFIOSTREAM
-                     (CONS (CONS 'FILE
-                                 (CONS |libName|
-                                       (CONS |$spadLibFT| NIL)))
-                           (CONS (CONS 'MODE 'I) NIL))))
-        (SPADLET |version| (CADR (|rread| 'VERSION |stream| NIL)))
-        (RSHUT |stream|)
-        |version|))))
-
-;initializeLisplib libName ==
-;  _$ERASE(libName,'ERRORLIB,'a)
-;  SETQ(ERRORS,0) -- ERRORS is a fluid variable for the compiler
-;  $libFile:= writeLib1(libName,'ERRORLIB,'a)
-;  ADDOPTIONS('FILE,$libFile)
-;  $lisplibForm := nil             --defining form for lisplib
-;  $lisplibModemap := nil          --modemap for constructor form
-;  $lisplibKind := nil             --category, domain, or package
-;  $lisplibModemapAlist := nil  --changed in "augmentLisplibModemapsFromCategory"
-;  $lisplibAbbreviation := nil
-;  $lisplibAncestors := nil
-;  $lisplibOpAlist := nil  --operations alist for new runtime system
-;  $lisplibOperationAlist := nil   --old list of operations for functor/package
-;  $lisplibSuperDomain:= nil
-;  -- next var changed in "augmentLisplibDependents"
-;  $lisplibVariableAlist := nil    --this and the next are used by "luke"
-;  $lisplibSignatureAlist := nil
-;  if pathnameTypeId(_/EDITFILE) = 'SPAD
-;    then LAM_,FILEACTQ('VERSION,['_/VERSIONCHECK,_/MAJOR_-VERSION])
-
-(DEFUN |initializeLisplib| (|libName|)
-  (declare (special $ERASE |$libFile| |$lisplibForm|
-                    |$lisplibModemap| |$lisplibKind| |$lisplibModemapAlist|
-                    |$lisplibAbbreviation| |$lisplibAncestors|
-                    |$lisplibOpAlist| |$lisplibOperationAlist|
-                    |$lisplibSuperDomain| |$lisplibVariableAlist|
-                    |$lisplibSignatureAlist| /EDITFILE /MAJOR-VERSION ERRORS))
-  (PROGN
-    ($ERASE |libName| 'ERRORLIB 'a)
-    (SETQ ERRORS 0)
-    (SPADLET |$libFile|
-             (|writeLib1| |libName| 'ERRORLIB 'a))
-    (ADDOPTIONS 'FILE |$libFile|)
-    (SPADLET |$lisplibForm| NIL)
-    (SPADLET |$lisplibModemap| NIL)
-    (SPADLET |$lisplibKind| NIL)
-    (SPADLET |$lisplibModemapAlist| NIL)
-    (SPADLET |$lisplibAbbreviation| NIL)
-    (SPADLET |$lisplibAncestors| NIL)
-    (SPADLET |$lisplibOpAlist| NIL)
-    (SPADLET |$lisplibOperationAlist| NIL)
-    (SPADLET |$lisplibSuperDomain| NIL)
-    (SPADLET |$lisplibVariableAlist| NIL)
-    (SPADLET |$lisplibSignatureAlist| NIL)
-    (COND
-      ((BOOT-EQUAL (|pathnameTypeId| /EDITFILE) 'SPAD)
-       (|LAM,FILEACTQ| 'VERSION
-           (CONS '/VERSIONCHECK (CONS /MAJOR-VERSION NIL))))
-      ('T NIL))))
-
 ;finalizeLisplib libName ==
 ;  lisplibWrite('"constructorForm",removeZeroOne $lisplibForm,$libFile)
 ;  lisplibWrite('"constructorKind",kind:=removeZeroOne $lisplibKind,$libFile)
