Import Upstream version 2a6upstream/2a6

1 files changed, 570 insertions, 0 deletions

diff --git a/slib.info-8 b/slib.info-8
new file mode 100644
index 0000000..670e9c1
--- /dev/null
+++ b/slib.info-8
@@ -0,0 +1,570 @@
+This is Info file slib.info, produced by Makeinfo-1.64 from the input
+file slib.texi.
+
+  This file documents SLIB, the portable Scheme library.
+
+  Copyright (C) 1993 Todd R. Eigenschink Copyright (C) 1993, 1994, 1995
+Aubrey Jaffer
+
+  Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+  Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided that the
+entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+
+  Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that this permission notice may be stated in a
+translation approved by the author.
+
+
+File: slib.info,  Node: Procedure and Macro Index,  Next: Variable Index,  Prev: Optional SLIB Packages,  Up: Top
+
+Procedure and Macro Index
+*************************
+
+  This is an alphabetical list of all the procedures and macros in SLIB.
+
+* Menu:
+
+* -:                                    Multi-argument / and -.
+* -1+:                                  Rev2 Procedures.
+* /:                                    Multi-argument / and -.
+* 1+:                                   Rev2 Procedures.
+* <=?:                                  Rev2 Procedures.
+* <?:                                   Rev2 Procedures.
+* =?:                                   Rev2 Procedures.
+* >=?:                                  Rev2 Procedures.
+* >?:                                   Rev2 Procedures.
+* TAG:                                  Structures.
+* add-domain:                           Database Utilities.
+* add-process!:                         Multi-Processing.
+* add-setter:                           Setters.
+* adjoin:                               Lists as sets.
+* adjoin-parameters!:                   Parameter lists.
+* alist->wt-tree:                       Construction of Weight-Balanced Trees.
+* alist-associator:                     Association Lists.
+* alist-for-each:                       Association Lists.
+* alist-inquirer:                       Association Lists.
+* alist-map:                            Association Lists.
+* alist-remover:                        Association Lists.
+* and?:                                 Non-List functions.
+* any?:                                 Collections.
+* append!:                              Rev2 Procedures.
+* apply:                                Multi-argument Apply.
+* array-1d-ref:                         Arrays.
+* array-1d-set!:                        Arrays.
+* array-2d-ref:                         Arrays.
+* array-2d-set!:                        Arrays.
+* array-3d-ref:                         Arrays.
+* array-3d-set!:                        Arrays.
+* array-copy!:                          Array Mapping.
+* array-dimensions:                     Arrays.
+* array-for-each:                       Array Mapping.
+* array-in-bounds?:                     Arrays.
+* array-indexes:                        Array Mapping.
+* array-map!:                           Array Mapping.
+* array-rank:                           Arrays.
+* array-ref:                            Arrays.
+* array-set!:                           Arrays.
+* array-shape:                          Arrays.
+* array?:                               Arrays.
+* asctime:                              Time.
+* ash:                                  Bit-Twiddling.
+* atom?:                                Non-List functions.
+* batch:apply-chop-to-fit:              Batch.
+* batch:call-with-output-script:        Batch.
+* batch:comment:                        Batch.
+* batch:delete-file:                    Batch.
+* batch:initialize!:                    Batch.
+* batch:lines->file:                    Batch.
+* batch:rename-file:                    Batch.
+* batch:run-script:                     Batch.
+* batch:system:                         Batch.
+* batch:try-system:                     Batch.
+* bit-extract:                          Bit-Twiddling.
+* break:                                Breakpoints.
+* break-all:                            Debug.
+* breakf:                               Breakpoints.
+* breakpoint:                           Breakpoints.
+* butlast:                              Lists as sequences.
+* call-with-dynamic-binding:            Dynamic Data Type.
+* call-with-input-string:               String Ports.
+* call-with-output-string:              String Ports.
+* call-with-values:                     Values.
+* capture-syntactic-environment:        Syntactic Closures.
+* cart-prod-tables:                     Relational Database Operations.
+* chap:next-string:                     Chapter Ordering.
+* chap:string<=?:                       Chapter Ordering.
+* chap:string<?:                        Chapter Ordering.
+* chap:string>=?:                       Chapter Ordering.
+* chap:string>?:                        Chapter Ordering.
+* check-parameters:                     Parameter lists.
+* close-base:                           Base Table.
+* close-database:                       Relational Database Operations.
+* close-table:                          Table Operations.
+* coerce:                               Non-List functions.
+* collection?:                          Collections.
+* continue:                             Breakpoints.
+* copy-list:                            List construction.
+* copy-tree:                            Tree Operations.
+* create-database <1>:                  Database Utilities.
+* create-database:                      Creating and Opening Relational Databases.
+* create-report:                        Database Utilities.
+* create-table:                         Relational Database Operations.
+* create-view:                          Relational Database Operations.
+* ctime:                                Time.
+* current-error-port:                   Input/Output.
+* current-time:                         Time.
+* debug:breakf:                         Breakpoints.
+* debug:tracef:                         Trace.
+* debug:unbreakf:                       Breakpoints.
+* debug:untracef:                       Trace.
+* decode-universal-time:                CLTime.
+* define-access-operation:              Setters.
+* define-operation:                     Yasos interface.
+* define-predicate:                     Yasos interface.
+* define-record:                        Structures.
+* define-syntax:                        Macro by Example.
+* define-tables:                        Database Utilities.
+* defmacro:                             Defmacro.
+* defmacro:eval:                        Defmacro.
+* defmacro:expand*:                     Defmacro.
+* defmacro:load:                        Defmacro.
+* defmacro?:                            Defmacro.
+* delete <1>:                           Destructive list operations.
+* delete:                               Base Table.
+* delete-domain:                        Database Utilities.
+* delete-file:                          Input/Output.
+* delete-if:                            Destructive list operations.
+* delete-if-not:                        Destructive list operations.
+* delete-table:                         Relational Database Operations.
+* dequeue!:                             Queues.
+* difftime:                             Time.
+* do-elts:                              Collections.
+* do-keys:                              Collections.
+* domain-checker:                       Database Utilities.
+* dynamic-ref:                          Dynamic Data Type.
+* dynamic-set!:                         Dynamic Data Type.
+* dynamic-wind:                         Dynamic-Wind.
+* dynamic?:                             Dynamic Data Type.
+* empty?:                               Collections.
+* encode-universal-time:                CLTime.
+* enquque!:                             Queues.
+* every:                                Lists as sets.
+* every?:                               Collections.
+* extended-euclid:                      Modular Arithmetic.
+* factor:                               Prime Factorization.
+* file-exists?:                         Input/Output.
+* fill-empty-parameters:                Parameter lists.
+* find-if:                              Lists as sets.
+* find-string-from-port?:               String Search.
+* fluid-let:                            Fluid-Let.
+* for-each-elt:                         Collections.
+* for-each-key <1>:                     Base Table.
+* for-each-key:                         Collections.
+* for-each-row:                         Table Operations.
+* force-output:                         Input/Output.
+* format:                               Format Interface.
+* fprintf:                              Standard Formatted Output.
+* fscanf:                               Standard Formatted Input.
+* generic-write:                        Generic-Write.
+* gentemp:                              Defmacro.
+* get:                                  Table Operations.
+* get*:                                 Table Operations.
+* get-decoded-time:                     CLTime.
+* get-method:                           Object.
+* get-universal-time:                   CLTime.
+* getenv:                               System Interface.
+* getopt:                               Getopt.
+* getopt-:                              Getopt.
+* getopt->arglist:                      Parameter lists.
+* getopt->parameter-list:               Parameter lists.
+* gmtime:                               Time.
+* has-duplicates?:                      Lists as sets.
+* hash:                                 Hashing.
+* hash-associator:                      Hash Tables.
+* hash-for-each:                        Hash Tables.
+* hash-inquirer:                        Hash Tables.
+* hash-map:                             Hash Tables.
+* hash-remover:                         Hash Tables.
+* hashq:                                Hashing.
+* hashv:                                Hashing.
+* heap-extract-max!:                    Priority Queues.
+* heap-insert!:                         Priority Queues.
+* heap-length:                          Priority Queues.
+* identifier=?:                         Syntactic Closures.
+* identifier?:                          Syntactic Closures.
+* identity:                             Legacy.
+* implementation-vicinity:              Vicinity.
+* in-vicinity:                          Vicinity.
+* init-debug:                           Breakpoints.
+* integer-expt:                         Bit-Twiddling.
+* integer-length:                       Bit-Twiddling.
+* integer-sqrt:                         Root Finding.
+* intersection:                         Lists as sets.
+* jacobi-symbol:                        Prime Factorization.
+* kill-process!:                        Multi-Processing.
+* kill-table:                           Base Table.
+* laguerre:find-polynomial-root:        Root Finding.
+* laguerre:find-root:                   Root Finding.
+* last:                                 Lists as sequences.
+* last-pair:                            Legacy.
+* library-vicinity:                     Vicinity.
+* list*:                                List construction.
+* list->string:                         Rev4 Optional Procedures.
+* list->vector:                         Rev4 Optional Procedures.
+* list-tail:                            Rev4 Optional Procedures.
+* load-option:                          Weight-Balanced Trees.
+* localtime:                            Time.
+* logand:                               Bit-Twiddling.
+* logbit?:                              Bit-Twiddling.
+* logcount:                             Bit-Twiddling.
+* logior:                               Bit-Twiddling.
+* lognot:                               Bit-Twiddling.
+* logtest:                              Bit-Twiddling.
+* logxor:                               Bit-Twiddling.
+* macro:eval <1>:                       Syntax-Case Macros.
+* macro:eval <2>:                       Syntactic Closures.
+* macro:eval <3>:                       Macros That Work.
+* macro:eval:                           R4RS Macros.
+* macro:expand <1>:                     Syntax-Case Macros.
+* macro:expand <2>:                     Syntactic Closures.
+* macro:expand <3>:                     Macros That Work.
+* macro:expand:                         R4RS Macros.
+* macro:load <1>:                       Syntax-Case Macros.
+* macro:load <2>:                       Syntactic Closures.
+* macro:load <3>:                       Macros That Work.
+* macro:load:                           R4RS Macros.
+* macroexpand:                          Defmacro.
+* macroexpand-1:                        Defmacro.
+* macwork:eval:                         Macros That Work.
+* macwork:expand:                       Macros That Work.
+* macwork:load:                         Macros That Work.
+* make-:                                Structures.
+* make-array:                           Arrays.
+* make-base:                            Base Table.
+* make-command-server:                  Database Utilities.
+* make-dynamic:                         Dynamic Data Type.
+* make-generic-method:                  Object.
+* make-generic-predicate:               Object.
+* make-getter:                          Base Table.
+* make-hash-table:                      Hash Tables.
+* make-heap:                            Priority Queues.
+* make-key->list:                       Base Table.
+* make-key-extractor:                   Base Table.
+* make-keyifier-1:                      Base Table.
+* make-list:                            List construction.
+* make-list-keyifier:                   Base Table.
+* make-method!:                         Object.
+* make-object:                          Object.
+* make-parameter-list:                  Parameter lists.
+* make-port-crc:                        Cyclic Checksum.
+* make-predicate!:                      Object.
+* make-promise:                         Promises.
+* make-putter:                          Base Table.
+* make-queue:                           Queues.
+* make-random-state:                    Random Numbers.
+* make-record-type:                     Records.
+* make-relational-system:               Creating and Opening Relational Databases.
+* make-shared-array:                    Arrays.
+* make-sierpinski-indexer:              Hashing.
+* make-syntactic-closure:               Syntactic Closures.
+* make-table:                           Base Table.
+* make-vicinity:                        Vicinity.
+* make-wt-tree:                         Construction of Weight-Balanced Trees.
+* make-wt-tree-type:                    Construction of Weight-Balanced Trees.
+* map-elts:                             Collections.
+* map-key:                              Base Table.
+* map-keys:                             Collections.
+* member-if:                            Lists as sets.
+* merge:                                Sorting.
+* merge!:                               Sorting.
+* mktime:                               Time.
+* modular::                             Modular Arithmetic.
+* modular:*:                            Modular Arithmetic.
+* modular:+:                            Modular Arithmetic.
+* modular:expt:                         Modular Arithmetic.
+* modular:invert:                       Modular Arithmetic.
+* modular:invertable?:                  Modular Arithmetic.
+* modular:negate:                       Modular Arithmetic.
+* modular:normalize:                    Modular Arithmetic.
+* modulus->integer:                     Modular Arithmetic.
+* must-be-first:                        Batch.
+* must-be-last:                         Batch.
+* nconc:                                Destructive list operations.
+* newton:find-root:                     Root Finding.
+* newtown:find-integer-root:            Root Finding.
+* notany:                               Lists as sets.
+* notevery:                             Lists as sets.
+* nreverse:                             Destructive list operations.
+* nthcdr:                               Lists as sequences.
+* object:                               Yasos interface.
+* object->string:                       Object-To-String.
+* object-with-ancestors:                Yasos interface.
+* object?:                              Object.
+* offset-time:                          Time.
+* open-base:                            Base Table.
+* open-database <1>:                    Database Utilities.
+* open-database:                        Creating and Opening Relational Databases.
+* open-database!:                       Database Utilities.
+* open-table <1>:                       Relational Database Operations.
+* open-table:                           Base Table.
+* operate-as:                           Yasos interface.
+* or?:                                  Non-List functions.
+* ordered-for-each-key:                 Base Table.
+* os->batch-dialect:                    Batch.
+* output-port-height:                   Input/Output.
+* output-port-width:                    Input/Output.
+* parameter-list->arglist:              Parameter lists.
+* parameter-list-expand:                Parameter lists.
+* parameter-list-ref:                   Parameter lists.
+* plot!:                                Plotting.
+* position:                             Lists as sequences.
+* pprint-file:                          Pretty-Print.
+* pprint-filter-file:                   Pretty-Print.
+* predicate->asso:                      Association Lists.
+* predicate->hash:                      Hash Tables.
+* predicate->hash-asso:                 Hash Tables.
+* present?:                             Base Table.
+* pretty-print:                         Pretty-Print.
+* prime:trials:                         Prime Factorization.
+* prime?:                               Prime Factorization.
+* primes<:                              Prime Testing and Generation.
+* primes>:                              Prime Testing and Generation.
+* print:                                Yasos interface.
+* printf:                               Standard Formatted Output.
+* probably-prime?:                      Prime Testing and Generation.
+* process:schedule!:                    Multi-Processing.
+* program-vicinity:                     Vicinity.
+* project-table:                        Relational Database Operations.
+* provide:                              Require.
+* provided?:                            Require.
+* qp:                                   Quick Print.
+* qpn:                                  Quick Print.
+* qpr:                                  Quick Print.
+* queue-empty?:                         Queues.
+* queue-front:                          Queues.
+* queue-pop!:                           Queues.
+* queue-push!:                          Queues.
+* queue-rear:                           Queues.
+* queue?:                               Queues.
+* random:                               Random Numbers.
+* random:exp:                           Random Numbers.
+* random:hollow-sphere!:                Random Numbers.
+* random:normal:                        Random Numbers.
+* random:normal-vector!:                Random Numbers.
+* random:solid-sphere!:                 Random Numbers.
+* random:uniform:                       Random Numbers.
+* rationalize:                          Rationalize.
+* read-command:                         Command Line.
+* read-line:                            Line I/O.
+* read-line!:                           Line I/O.
+* record-accessor:                      Records.
+* record-constructor:                   Records.
+* record-modifier:                      Records.
+* record-predicate:                     Records.
+* record-type-descriptor:               Records.
+* record-type-field-names:              Records.
+* record-type-name:                     Records.
+* record?:                              Records.
+* reduce <1>:                           Lists as sequences.
+* reduce:                               Collections.
+* reduce-init:                          Lists as sequences.
+* remove:                               Lists as sets.
+* remove-if:                            Lists as sets.
+* remove-if-not:                        Lists as sets.
+* remove-setter-for:                    Setters.
+* repl:quit:                            Repl.
+* repl:top-level:                       Repl.
+* replace-suffix:                       Batch.
+* require:                              Require.
+* require:feature->path:                Require.
+* restrict-table:                       Relational Database Operations.
+* row:delete:                           Table Operations.
+* row:delete*:                          Table Operations.
+* row:insert:                           Table Operations.
+* row:insert*:                          Table Operations.
+* row:remove:                           Table Operations.
+* row:remove*:                          Table Operations.
+* row:retrieve:                         Table Operations.
+* row:retrieve*:                        Table Operations.
+* row:update:                           Table Operations.
+* row:update*:                          Table Operations.
+* scanf:                                Standard Formatted Input.
+* scanf-read-list:                      Standard Formatted Input.
+* set:                                  Setters.
+* set-:                                 Structures.
+* set-difference:                       Lists as sets.
+* setter:                               Setters.
+* Setter:                               Collections.
+* singleton-wt-tree:                    Construction of Weight-Balanced Trees.
+* size <1>:                             Yasos interface.
+* size:                                 Collections.
+* slib:error:                           System.
+* slib:eval:                            System.
+* slib:eval-load:                       System.
+* slib:exit:                            System.
+* slib:load:                            System.
+* slib:load-compiled:                   System.
+* slib:load-source:                     System.
+* slib:report:                          Configuration.
+* slib:report-version:                  Configuration.
+* software-type:                        Configuration.
+* some:                                 Lists as sets.
+* sort:                                 Sorting.
+* sort!:                                Sorting.
+* sorted?:                              Sorting.
+* soundex:                              Hashing.
+* sprintf:                              Standard Formatted Output.
+* sscanf:                               Standard Formatted Input.
+* string->list:                         Rev4 Optional Procedures.
+* string-capitalize:                    String-Case.
+* string-captialize!:                   String-Case.
+* string-copy:                          Rev4 Optional Procedures.
+* string-downcase:                      String-Case.
+* string-downcase!:                     String-Case.
+* string-fill!:                         Rev4 Optional Procedures.
+* string-index:                         String Search.
+* string-join:                          Batch.
+* string-null?:                         Rev2 Procedures.
+* string-upcase:                        String-Case.
+* string-upcase!:                       String-Case.
+* sub-vicinity:                         Vicinity.
+* subst:                                Tree Operations.
+* substq:                               Tree Operations.
+* substring-fill!:                      Rev2 Procedures.
+* substring-move-left!:                 Rev2 Procedures.
+* substring-move-right!:                Rev2 Procedures.
+* substring?:                           String Search.
+* substv:                               Tree Operations.
+* supported-key-type?:                  Base Table.
+* supported-type?:                      Base Table.
+* symmetric:modulus:                    Modular Arithmetic.
+* sync-base:                            Base Table.
+* syncase:eval:                         Syntax-Case Macros.
+* syncase:expand:                       Syntax-Case Macros.
+* syncase:load:                         Syntax-Case Macros.
+* synclo:eval:                          Syntactic Closures.
+* synclo:expand:                        Syntactic Closures.
+* synclo:load:                          Syntactic Closures.
+* syntax-rules:                         Macro by Example.
+* system:                               System Interface.
+* table-exists?:                        Relational Database Operations.
+* tek40:draw:                           Tektronix Graphics Support.
+* tek40:graphics:                       Tektronix Graphics Support.
+* tek40:init:                           Tektronix Graphics Support.
+* tek40:linetype:                       Tektronix Graphics Support.
+* tek40:move:                           Tektronix Graphics Support.
+* tek40:put-text:                       Tektronix Graphics Support.
+* tek40:reset:                          Tektronix Graphics Support.
+* tek40:text:                           Tektronix Graphics Support.
+* tek41:draw:                           Tektronix Graphics Support.
+* tek41:encode-int:                     Tektronix Graphics Support.
+* tek41:encode-x-y:                     Tektronix Graphics Support.
+* tek41:graphics:                       Tektronix Graphics Support.
+* tek41:init:                           Tektronix Graphics Support.
+* tek41:move:                           Tektronix Graphics Support.
+* tek41:point:                          Tektronix Graphics Support.
+* tek41:reset:                          Tektronix Graphics Support.
+* tmpnam:                               Input/Output.
+* topological-sort:                     Topological Sort.
+* trace:                                Trace.
+* trace-all:                            Debug.
+* tracef:                               Trace.
+* transcript-off:                       Transcripts.
+* transcript-on:                        Transcripts.
+* transformer:                          Syntactic Closures.
+* tsort:                                Topological Sort.
+* two-arg:-:                            Multi-argument / and -.
+* two-arg:/:                            Multi-argument / and -.
+* two-arg:apply:                        Multi-argument Apply.
+* type-of:                              Non-List functions.
+* tzset:                                Time.
+* unbreak:                              Breakpoints.
+* unbreakf:                             Breakpoints.
+* union:                                Lists as sets.
+* unmake-method!:                       Object.
+* untrace:                              Trace.
+* untracef:                             Trace.
+* user-vicinity:                        Vicinity.
+* values:                               Values.
+* variant-case:                         Structures.
+* vector->list:                         Rev4 Optional Procedures.
+* vector-fill!:                         Rev4 Optional Procedures.
+* with-input-from-file:                 With-File.
+* with-output-to-file:                  With-File.
+* write-base:                           Base Table.
+* write-database:                       Relational Database Operations.
+* write-line:                           Line I/O.
+* wt-tree/add:                          Basic Operations on Weight-Balanced Trees.
+* wt-tree/add!:                         Basic Operations on Weight-Balanced Trees.
+* wt-tree/delete:                       Basic Operations on Weight-Balanced Trees.
+* wt-tree/delete!:                      Basic Operations on Weight-Balanced Trees.
+* wt-tree/delete-min:                   Indexing Operations on Weight-Balanced Trees.
+* wt-tree/delete-min!:                  Indexing Operations on Weight-Balanced Trees.
+* wt-tree/difference:                   Advanced Operations on Weight-Balanced Trees.
+* wt-tree/empty?:                       Basic Operations on Weight-Balanced Trees.
+* wt-tree/fold:                         Advanced Operations on Weight-Balanced Trees.
+* wt-tree/for-each:                     Advanced Operations on Weight-Balanced Trees.
+* wt-tree/index:                        Indexing Operations on Weight-Balanced Trees.
+* wt-tree/index-datum:                  Indexing Operations on Weight-Balanced Trees.
+* wt-tree/index-pair:                   Indexing Operations on Weight-Balanced Trees.
+* wt-tree/intersection:                 Advanced Operations on Weight-Balanced Trees.
+* wt-tree/lookup:                       Basic Operations on Weight-Balanced Trees.
+* wt-tree/member?:                      Basic Operations on Weight-Balanced Trees.
+* wt-tree/min:                          Indexing Operations on Weight-Balanced Trees.
+* wt-tree/min-datum:                    Indexing Operations on Weight-Balanced Trees.
+* wt-tree/min-pair:                     Indexing Operations on Weight-Balanced Trees.
+* wt-tree/rank:                         Indexing Operations on Weight-Balanced Trees.
+* wt-tree/set-equal?:                   Advanced Operations on Weight-Balanced Trees.
+* wt-tree/size:                         Basic Operations on Weight-Balanced Trees.
+* wt-tree/split<:                       Advanced Operations on Weight-Balanced Trees.
+* wt-tree/split>:                       Advanced Operations on Weight-Balanced Trees.
+* wt-tree/subset?:                      Advanced Operations on Weight-Balanced Trees.
+* wt-tree/union:                        Advanced Operations on Weight-Balanced Trees.
+* wt-tree?:                             Basic Operations on Weight-Balanced Trees.
+
+
+File: slib.info,  Node: Variable Index,  Prev: Procedure and Macro Index,  Up: Top
+
+Variable Index
+**************
+
+  This is an alphabetical list of all the global variables in SLIB.
+
+* Menu:
+
+* *catalog*:                            Require.
+* *features*:                           Require.
+* *modules*:                            Require.
+* *optarg*:                             Getopt.
+* *optind*:                             Getopt.
+* *qp-width*:                           Quick Print.
+* *random-state*:                       Random Numbers.
+* *timezone*:                           Time.
+* batch:platform:                       Batch.
+* catalog-id:                           Base Table.
+* char-code-limit:                      Configuration.
+* charplot:height:                      Plotting.
+* charplot:width:                       Plotting.
+* column-domains:                       Table Operations.
+* column-foreigns:                      Table Operations.
+* column-names:                         Table Operations.
+* column-types:                         Table Operations.
+* most-positive-fixnum:                 Configuration.
+* nil:                                  Legacy.
+* number-wt-type:                       Construction of Weight-Balanced Trees.
+* primary-limit:                        Table Operations.
+* slib:form-feed:                       Configuration.
+* slib:tab:                             Configuration.
+* stderr:                               Standard Formatted I/O.
+* stdin:                                Standard Formatted I/O.
+* stdout:                               Standard Formatted I/O.
+* string-wt-type:                       Construction of Weight-Balanced Trees.
+* t:                                    Legacy.
+
+