Use ShallowlyMutableAggregate.

1 files changed, 33 insertions, 33 deletions

diff --git a/src/share/algebra/browse.daase b/src/share/algebra/browse.daase
index 57cf8293..8a5e3dbc 100644
--- a/src/share/algebra/browse.daase
+++ b/src/share/algebra/browse.daase
@@ -1,11 +1,11 @@
 
-(1965754 . 3577976436)       
+(1968719 . 3577992038)       
 (-18 A S) 
-((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) 
+((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the shallowly mutable property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) 
 NIL 
 NIL 
 (-19 S) 
-((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) 
+((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the shallowly mutable property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) 
 ((-3998 . T)) 
 NIL 
 (-20 S) 
@@ -111,7 +111,7 @@ NIL
 (-45 |Key| |Entry|) 
 ((|constructor| (NIL "\\spadtype{AssociationList} implements association lists. These may be viewed as lists of pairs where the first part is a key and the second is the stored value. For example,{} the key might be a string with a persons employee identification number and the value might be a record with personnel data."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757)))) (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014))))) (OR (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-553 (-773)))) (|HasCategory| |#2| (QUOTE (-553 (-773))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-554 (-474)))) (-12 (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| |#2| (|%list| (QUOTE -260) (|devaluate| |#2|)))) (OR (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (OR (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72))) (OR (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (OR (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72)))) (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| |#2| (QUOTE (-553 (-773)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-553 (-773)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014))) (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (-12 (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#2|)))) (-12 (|HasCategory| $ (|%list| (QUOTE -318) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72)))) (|HasCategory| $ (|%list| (QUOTE -318) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|)))))) 
+((OR (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757)))) (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014))))) (OR (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-553 (-773)))) (|HasCategory| |#2| (QUOTE (-553 (-773))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-554 (-474)))) (-12 (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| |#2| (|%list| (QUOTE -260) (|devaluate| |#2|)))) (OR (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (OR (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72))) (OR (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (OR (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72)))) (|HasCategory| |#2| (QUOTE (-1014))) (|HasCategory| |#2| (QUOTE (-553 (-773)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-553 (-773)))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014))) (-12 (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (|%list| (QUOTE -260) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-1014)))) (-12 (|HasCategory| |#2| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#2|)))) (-12 (|HasCategory| $ (|%list| (QUOTE -1036) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-757)))) (-12 (|HasCategory| $ (|%list| (QUOTE -318) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3862 |#1|) (|:| |entry| |#2|)) (QUOTE (-72)))) (|HasCategory| $ (|%list| (QUOTE -318) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|))))) (|HasCategory| $ (|%list| (QUOTE -1036) (|%list| (QUOTE -2) (|%list| (QUOTE |:|) (QUOTE -3862) (|devaluate| |#1|)) (|%list| (QUOTE |:|) (QUOTE |entry|) (|devaluate| |#2|)))))) 
 (-46 S R E) 
 ((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i,{} elements of the ordered abelian monoid,{} are thought of as exponents or monomials. The monomials commute with each other,{} and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least,{} only the non-zero terms are ever operated on.")) (/ (($ $ |#2|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c}.")) (|coefficient| ((|#2| $ |#3|) "\\spad{coefficient(p,e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p},{} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#2| |#3|) "\\spad{monomial(r,e)} makes a term from a coefficient \\spad{r} and an exponent \\spad{e}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|map| (($ (|Mapping| |#2| |#2|) $) "\\spad{map(fn,u)} maps function \\spad{fn} onto the coefficients of the non-zero monomials of \\spad{u}.")) (|degree| ((|#3| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p}.")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#2| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p}."))) 
 NIL 
@@ -163,7 +163,7 @@ NIL
 (-58 S) 
 ((|constructor| (NIL "This is the domain of 1-based one dimensional arrays")) (|oneDimensionalArray| (($ (|NonNegativeInteger|) |#1|) "\\spad{oneDimensionalArray(n,s)} creates an array from \\spad{n} copies of element \\spad{s}") (($ (|List| |#1|)) "\\spad{oneDimensionalArray(l)} creates an array from a list of elements \\spad{l}"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-59 A B) 
 ((|constructor| (NIL "\\indented{1}{This package provides tools for operating on one-dimensional arrays} with unary and binary functions involving different underlying types")) (|map| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1|) (|OneDimensionalArray| |#1|)) "\\spad{map(f,a)} applies function \\spad{f} to each member of one-dimensional array \\spad{a} resulting in a new one-dimensional array over a possibly different underlying domain.")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\spad{reduce(f,a,r)} applies function \\spad{f} to each successive element of the one-dimensional array \\spad{a} and an accumulant initialized to \\spad{r}. For example,{} \\spad{reduce(_+\\$Integer,[1,2,3],0)} does \\spad{3+(2+(1+0))}. Note: third argument \\spad{r} may be regarded as the identity element for the function \\spad{f}.")) (|scan| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\spad{scan(f,a,r)} successively applies \\spad{reduce(f,x,r)} to more and more leading sub-arrays \\spad{x} of one-dimensional array \\spad{a}. More precisely,{} if \\spad{a} is \\spad{[a1,a2,...]},{} then \\spad{scan(f,a,r)} returns \\spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}."))) 
 NIL 
@@ -223,7 +223,7 @@ NIL
 (-73 S) 
 ((|constructor| (NIL "\\spadtype{BalancedBinaryTree(S)} is the domain of balanced binary trees (bbtree). A balanced binary tree of \\spad{2**k} leaves,{} for some \\spad{k > 0},{} is symmetric,{} that is,{} the left and right subtree of each interior node have identical shape. In general,{} the left and right subtree of a given node can differ by at most leaf node.")) (|mapDown!| (($ $ |#1| (|Mapping| (|List| |#1|) |#1| |#1| |#1|)) "\\spad{mapDown!(t,p,f)} returns \\spad{t} after traversing \\spad{t} in \"preorder\" (node then left then right) fashion replacing the successive interior nodes as follows. Let \\spad{l} and \\spad{r} denote the left and right subtrees of \\spad{t}. The root value \\spad{x} of \\spad{t} is replaced by \\spad{p}. Then \\spad{f}(value \\spad{l},{} value \\spad{r},{} \\spad{p}),{} where \\spad{l} and \\spad{r} denote the left and right subtrees of \\spad{t},{} is evaluated producing two values pl and pr. Then \\spad{mapDown!(l,pl,f)} and \\spad{mapDown!(l,pr,f)} are evaluated.") (($ $ |#1| (|Mapping| |#1| |#1| |#1|)) "\\spad{mapDown!(t,p,f)} returns \\spad{t} after traversing \\spad{t} in \"preorder\" (node then left then right) fashion replacing the successive interior nodes as follows. The root value \\spad{x} is replaced by \\spad{q} := \\spad{f}(\\spad{p},{}\\spad{x}). The mapDown!(\\spad{l},{}\\spad{q},{}\\spad{f}) and mapDown!(\\spad{r},{}\\spad{q},{}\\spad{f}) are evaluated for the left and right subtrees \\spad{l} and \\spad{r} of \\spad{t}.")) (|mapUp!| (($ $ $ (|Mapping| |#1| |#1| |#1| |#1| |#1|)) "\\spad{mapUp!(t,t1,f)} traverses \\spad{t} in an \"endorder\" (left then right then node) fashion returning \\spad{t} with the value at each successive interior node of \\spad{t} replaced by \\spad{f}(\\spad{l},{}\\spad{r},{}\\spad{l1},{}\\spad{r1}) where \\spad{l} and \\spad{r} are the values at the immediate left and right nodes. Values \\spad{l1} and \\spad{r1} are values at the corresponding nodes of a balanced binary tree \\spad{t1},{} of identical shape at \\spad{t}.") ((|#1| $ (|Mapping| |#1| |#1| |#1|)) "\\spad{mapUp!(t,f)} traverses balanced binary tree \\spad{t} in an \"endorder\" (left then right then node) fashion returning \\spad{t} with the value at each successive interior node of \\spad{t} replaced by \\spad{f}(\\spad{l},{}\\spad{r}) where \\spad{l} and \\spad{r} are the values at the immediate left and right nodes.")) (|setleaves!| (($ $ (|List| |#1|)) "\\spad{setleaves!(t, ls)} sets the leaves of \\spad{t} in left-to-right order to the elements of ls.")) (|balancedBinaryTree| (($ (|NonNegativeInteger|) |#1|) "\\spad{balancedBinaryTree(n, s)} creates a balanced binary tree with \\spad{n} nodes each with value \\spad{s}."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-74 R UP M |Row| |Col|) 
 ((|constructor| (NIL "\\spadtype{BezoutMatrix} contains functions for computing resultants and discriminants using Bezout matrices.")) (|bezoutDiscriminant| ((|#1| |#2|) "\\spad{bezoutDiscriminant(p)} computes the discriminant of a polynomial \\spad{p} by computing the determinant of a Bezout matrix.")) (|bezoutResultant| ((|#1| |#2| |#2|) "\\spad{bezoutResultant(p,q)} computes the resultant of the two polynomials \\spad{p} and \\spad{q} by computing the determinant of a Bezout matrix.")) (|bezoutMatrix| ((|#3| |#2| |#2|) "\\spad{bezoutMatrix(p,q)} returns the Bezout matrix for the two polynomials \\spad{p} and \\spad{q}.")) (|sylvesterMatrix| ((|#3| |#2| |#2|) "\\spad{sylvesterMatrix(p,q)} returns the Sylvester matrix for the two polynomials \\spad{p} and \\spad{q}."))) 
 NIL 
@@ -255,7 +255,7 @@ NIL
 (-81) 
 ((|constructor| (NIL "\\spadtype{Bits} provides logical functions for Indexed Bits.")) (|bits| (($ (|NonNegativeInteger|) (|Boolean|)) "\\spad{bits(n,b)} creates bits with \\spad{n} values of \\spad{b}"))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| (-85) (QUOTE (-260 (-85)))) (|HasCategory| (-85) (QUOTE (-1014)))) (|HasCategory| (-85) (QUOTE (-554 (-474)))) (|HasCategory| (-85) (QUOTE (-757))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-85) (QUOTE (-72))) (|HasCategory| (-85) (QUOTE (-553 (-773)))) (|HasCategory| (-85) (QUOTE (-1014))) (|HasCategory| $ (QUOTE (-318 (-85)))) (-12 (|HasCategory| $ (QUOTE (-318 (-85)))) (|HasCategory| (-85) (QUOTE (-72))))) 
+((-12 (|HasCategory| (-85) (QUOTE (-260 (-85)))) (|HasCategory| (-85) (QUOTE (-1014)))) (|HasCategory| (-85) (QUOTE (-554 (-474)))) (|HasCategory| (-85) (QUOTE (-757))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-85) (QUOTE (-72))) (|HasCategory| (-85) (QUOTE (-553 (-773)))) (|HasCategory| (-85) (QUOTE (-1014))) (-12 (|HasCategory| $ (QUOTE (-1036 (-85)))) (|HasCategory| (-85) (QUOTE (-757)))) (|HasCategory| $ (QUOTE (-1036 (-85)))) (|HasCategory| $ (QUOTE (-318 (-85)))) (-12 (|HasCategory| $ (QUOTE (-318 (-85)))) (|HasCategory| (-85) (QUOTE (-72))))) 
 (-82 R S) 
 ((|constructor| (NIL "A \\spadtype{BiModule} is both a left and right module with respect to potentially different rings. \\blankline")) (|rightUnitary| ((|attribute|) "\\spad{x * 1 = x}")) (|leftUnitary| ((|attribute|) "\\spad{1 * x = x}"))) 
 ((-3992 . T) (-3991 . T)) 
@@ -295,7 +295,7 @@ NIL
 (-91 A S) 
 ((|constructor| (NIL "A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,x)} sets the right child of \\spad{t} to be \\spad{x}.")) (|setleft!| (($ $ $) "\\spad{setleft!(a,b)} sets the left child of \\axiom{a} to be \\spad{b}.")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,\"right\",b)} (also written \\axiom{\\spad{b} . right := \\spad{b}}) is equivalent to \\axiom{setright!(a,{}\\spad{b})}.") (($ $ "left" $) "\\spad{setelt(a,\"left\",b)} (also written \\axiom{a . left := \\spad{b}}) is equivalent to \\axiom{setleft!(a,{}\\spad{b})}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) 
 NIL 
-((|HasAttribute| |#1| (QUOTE -3998))) 
+((|HasCategory| |#1| (|%list| (QUOTE -1036) (|devaluate| |#2|)))) 
 (-92 S) 
 ((|constructor| (NIL "A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,x)} sets the right child of \\spad{t} to be \\spad{x}.")) (|setleft!| (($ $ $) "\\spad{setleft!(a,b)} sets the left child of \\axiom{a} to be \\spad{b}.")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,\"right\",b)} (also written \\axiom{\\spad{b} . right := \\spad{b}}) is equivalent to \\axiom{setright!(a,{}\\spad{b})}.") (($ $ "left" $) "\\spad{setelt(a,\"left\",b)} (also written \\axiom{a . left := \\spad{b}}) is equivalent to \\axiom{setleft!(a,{}\\spad{b})}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) 
 NIL 
@@ -307,7 +307,7 @@ NIL
 (-94 S) 
 ((|constructor| (NIL "BinarySearchTree(\\spad{S}) is the domain of a binary trees where elements are ordered across the tree. A binary search tree is either empty or has a value which is an \\spad{S},{} and a right and left which are both BinaryTree(\\spad{S}) Elements are ordered across the tree.")) (|split| (((|Record| (|:| |less| $) (|:| |greater| $)) |#1| $) "\\spad{split(x,b)} splits binary tree \\spad{b} into two trees,{} one with elements greater than \\spad{x},{} the other with elements less than \\spad{x}.")) (|insertRoot!| (($ |#1| $) "\\spad{insertRoot!(x,b)} inserts element \\spad{x} as a root of binary search tree \\spad{b}.")) (|insert!| (($ |#1| $) "\\spad{insert!(x,b)} inserts element \\spad{x} as leaves into binary search tree \\spad{b}.")) (|binarySearchTree| (($ (|List| |#1|)) "\\spad{binarySearchTree(l)} \\undocumented"))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-95 S) 
 ((|constructor| (NIL "The bit aggregate category models aggregates representing large quantities of Boolean data.")) (|xor| (($ $ $) "\\spad{xor(a,b)} returns the logical {\\em exclusive-or} of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nor| (($ $ $) "\\spad{nor(a,b)} returns the logical {\\em nor} of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nand| (($ $ $) "\\spad{nand(a,b)} returns the logical {\\em nand} of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}."))) 
 NIL 
@@ -327,11 +327,11 @@ NIL
 (-99 S) 
 ((|constructor| (NIL "\\spadtype{BinaryTournament(S)} is the domain of binary trees where elements are ordered down the tree. A binary search tree is either empty or is a node containing a \\spadfun{value} of type \\spad{S},{} and a \\spadfun{right} and a \\spadfun{left} which are both \\spadtype{BinaryTree(S)}")) (|insert!| (($ |#1| $) "\\spad{insert!(x,b)} inserts element \\spad{x} as leaves into binary tournament \\spad{b}.")) (|binaryTournament| (($ (|List| |#1|)) "\\spad{binaryTournament(ls)} creates a binary tournament with the elements of \\spad{ls} as values at the nodes."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-100 S) 
 ((|constructor| (NIL "\\spadtype{BinaryTree(S)} is the domain of all binary trees. A binary tree over \\spad{S} is either empty or has a \\spadfun{value} which is an \\spad{S} and a \\spadfun{right} and \\spadfun{left} which are both binary trees.")) (|binaryTree| (($ $ |#1| $) "\\spad{binaryTree(l,v,r)} creates a binary tree with value \\spad{v} with left subtree \\spad{l} and right subtree \\spad{r}.") (($ |#1|) "\\spad{binaryTree(v)} is an non-empty binary tree with value \\spad{v},{} and left and right empty."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-101) 
 ((|constructor| (NIL "Byte is the datatype of 8-bit sized unsigned integer values.")) (|sample| (($) "\\spad{sample} gives a sample datum of type Byte.")) (|bitior| (($ $ $) "bitor(\\spad{x},{}\\spad{y}) returns the bitwise `inclusive or' of `x' and `y'.")) (|bitand| (($ $ $) "\\spad{bitand(x,y)} returns the bitwise `and' of `x' and `y'.")) (|byte| (($ (|NonNegativeInteger|)) "\\spad{byte(x)} injects the unsigned integer value `v' into the Byte algebra. `v' must be non-negative and less than 256."))) 
 NIL 
@@ -339,7 +339,7 @@ NIL
 (-102) 
 ((|constructor| (NIL "ByteBuffer provides datatype for buffers of bytes. This domain differs from PrimitiveArray Byte in that it is not as rigid as PrimitiveArray Byte. That is,{} the typical use of ByteBuffer is to pre-allocate a vector of Byte of some capacity `n'. The array can then store up to `n' bytes. The actual interesting bytes count (the length of the buffer) is therefore different from the capacity. The length is no more than the capacity,{} but it can be set dynamically as needed. This functionality is used for example when reading bytes from input/output devices where we use buffers to transfer data in and out of the system. Note: a value of type ByteBuffer is 0-based indexed,{} as opposed \\indented{6}{Vector,{} but not unlike PrimitiveArray Byte.}")) (|setLength!| (((|NonNegativeInteger|) $ (|NonNegativeInteger|)) "\\spad{setLength!(buf,n)} sets the number of active bytes in the `buf'. Error if `n' is more than the capacity.")) (|capacity| (((|NonNegativeInteger|) $) "\\spad{capacity(buf)} returns the pre-allocated maximum size of `buf'.")) (|byteBuffer| (($ (|NonNegativeInteger|)) "\\spad{byteBuffer(n)} creates a buffer of capacity \\spad{n},{} and length 0."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-757)))) (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-1014))))) (|HasCategory| (-101) (QUOTE (-553 (-773)))) (|HasCategory| (-101) (QUOTE (-554 (-474)))) (OR (|HasCategory| (-101) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-1014)))) (|HasCategory| (-101) (QUOTE (-757))) (OR (|HasCategory| (-101) (QUOTE (-72))) (|HasCategory| (-101) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-72))) (|HasCategory| (-101) (QUOTE (-1014))) (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-1014)))) (-12 (|HasCategory| $ (QUOTE (-318 (-101)))) (|HasCategory| (-101) (QUOTE (-72)))) (|HasCategory| $ (QUOTE (-318 (-101))))) 
+((OR (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-757)))) (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-1014))))) (|HasCategory| (-101) (QUOTE (-553 (-773)))) (|HasCategory| (-101) (QUOTE (-554 (-474)))) (OR (|HasCategory| (-101) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-1014)))) (|HasCategory| (-101) (QUOTE (-757))) (OR (|HasCategory| (-101) (QUOTE (-72))) (|HasCategory| (-101) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-101) (QUOTE (-72))) (|HasCategory| (-101) (QUOTE (-1014))) (-12 (|HasCategory| (-101) (QUOTE (-260 (-101)))) (|HasCategory| (-101) (QUOTE (-1014)))) (-12 (|HasCategory| $ (QUOTE (-318 (-101)))) (|HasCategory| (-101) (QUOTE (-72)))) (|HasCategory| $ (QUOTE (-318 (-101)))) (|HasCategory| $ (QUOTE (-1036 (-101)))) (-12 (|HasCategory| $ (QUOTE (-1036 (-101)))) (|HasCategory| (-101) (QUOTE (-757))))) 
 (-103) 
 ((|constructor| (NIL "This datatype describes byte order of machine values stored memory.")) (|unknownEndian| (($) "\\spad{unknownEndian} for none of the above.")) (|bigEndian| (($) "\\spad{bigEndian} describes big endian host")) (|littleEndian| (($) "\\spad{littleEndian} describes little endian host"))) 
 NIL 
@@ -743,7 +743,7 @@ NIL
 (-203 S) 
 ((|constructor| (NIL "This domain provides some nice functions on lists")) (|elt| (((|NonNegativeInteger|) $ "count") "\\axiom{\\spad{l}.\"count\"} returns the number of elements in \\axiom{\\spad{l}}.") (($ $ "sort") "\\axiom{\\spad{l}.sort} returns \\axiom{\\spad{l}} with elements sorted. Note: \\axiom{\\spad{l}.sort = sort(\\spad{l})}") (($ $ "unique") "\\axiom{\\spad{l}.unique} returns \\axiom{\\spad{l}} with duplicates removed. Note: \\axiom{\\spad{l}.unique = removeDuplicates(\\spad{l})}.")) (|datalist| (($ (|List| |#1|)) "\\spad{datalist(l)} creates a datalist from \\spad{l}"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-204 M) 
 ((|constructor| (NIL "DiscreteLogarithmPackage implements help functions for discrete logarithms in monoids using small cyclic groups.")) (|shanksDiscLogAlgorithm| (((|Union| (|NonNegativeInteger|) "failed") |#1| |#1| (|NonNegativeInteger|)) "\\spad{shanksDiscLogAlgorithm(b,a,p)} computes \\spad{s} with \\spad{b**s = a} for assuming that \\spad{a} and \\spad{b} are elements in a 'small' cyclic group of order \\spad{p} by Shank's algorithm. Note: this is a subroutine of the function \\spadfun{discreteLog}.")) (** ((|#1| |#1| (|Integer|)) "\\spad{x ** n} returns \\spad{x} raised to the integer power \\spad{n}"))) 
 NIL 
@@ -1043,7 +1043,7 @@ NIL
 (-278 S) 
 ((|constructor| (NIL "\\indented{1}{A FlexibleArray is the notion of an array intended to allow for growth} at the end only. Hence the following efficient operations \\indented{2}{\\spad{append(x,a)} meaning append item \\spad{x} at the end of the array \\spad{a}} \\indented{2}{\\spad{delete(a,n)} meaning delete the last item from the array \\spad{a}} Flexible arrays support the other operations inherited from \\spadtype{ExtensibleLinearAggregate}. However,{} these are not efficient. Flexible arrays combine the \\spad{O(1)} access time property of arrays with growing and shrinking at the end in \\spad{O(1)} (average) time. This is done by using an ordinary array which may have zero or more empty slots at the end. When the array becomes full it is copied into a new larger (50\\% larger) array. Conversely,{} when the array becomes less than 1/2 full,{} it is copied into a smaller array. Flexible arrays provide for an efficient implementation of many data structures in particular heaps,{} stacks and sets."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-279 S -3094) 
 ((|constructor| (NIL "FiniteAlgebraicExtensionField {\\em F} is the category of fields which are finite algebraic extensions of the field {\\em F}. If {\\em F} is finite then any finite algebraic extension of {\\em F} is finite,{} too. Let {\\em K} be a finite algebraic extension of the finite field {\\em F}. The exponentiation of elements of {\\em K} defines a \\spad{Z}-module structure on the multiplicative group of {\\em K}. The additive group of {\\em K} becomes a module over the ring of polynomials over {\\em F} via the operation \\spadfun{linearAssociatedExp}(a:K,{}f:SparseUnivariatePolynomial \\spad{F}) which is linear over {\\em F},{} \\spadignore{i.e.} for elements {\\em a} from {\\em K},{} {\\em c,d} from {\\em F} and {\\em f,g} univariate polynomials over {\\em F} we have \\spadfun{linearAssociatedExp}(a,{}cf+dg) equals {\\em c} times \\spadfun{linearAssociatedExp}(a,{}\\spad{f}) plus {\\em d} times \\spadfun{linearAssociatedExp}(a,{}\\spad{g}). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\\em F[X]}: \\spadfun{linearAssociatedExp}(a,{}monomial(1,{}\\spad{k})\\$SUP(\\spad{F})) is defined to be \\spadfun{Frobenius}(a,{}\\spad{k}) which is {\\em a**(q**k)} where {\\em q=size()\\$F}. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog},{} respectively.")) (|linearAssociatedLog| (((|Union| (|SparseUnivariatePolynomial| |#2|) "failed") $ $) "\\spad{linearAssociatedLog(b,a)} returns a polynomial {\\em g},{} such that the \\spadfun{linearAssociatedExp}(\\spad{b},{}\\spad{g}) equals {\\em a}. If there is no such polynomial {\\em g},{} then \\spadfun{linearAssociatedLog} fails.") (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{linearAssociatedLog(a)} returns a polynomial {\\em g},{} such that \\spadfun{linearAssociatedExp}(normalElement(),{}\\spad{g}) equals {\\em a}.")) (|linearAssociatedOrder| (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{linearAssociatedOrder(a)} retruns the monic polynomial {\\em g} of least degree,{} such that \\spadfun{linearAssociatedExp}(a,{}\\spad{g}) is 0.")) (|linearAssociatedExp| (($ $ (|SparseUnivariatePolynomial| |#2|)) "\\spad{linearAssociatedExp(a,f)} is linear over {\\em F},{} \\spadignore{i.e.} for elements {\\em a} from {\\em \\$},{} {\\em c,d} form {\\em F} and {\\em f,g} univariate polynomials over {\\em F} we have \\spadfun{linearAssociatedExp}(a,{}cf+dg) equals {\\em c} times \\spadfun{linearAssociatedExp}(a,{}\\spad{f}) plus {\\em d} times \\spadfun{linearAssociatedExp}(a,{}\\spad{g}). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\\em F[X]}: \\spadfun{linearAssociatedExp}(a,{}monomial(1,{}\\spad{k})\\$SUP(\\spad{F})) is defined to be \\spadfun{Frobenius}(a,{}\\spad{k}) which is {\\em a**(q**k)},{} where {\\em q=size()\\$F}.")) (|generator| (($) "\\spad{generator()} returns a root of the defining polynomial. This element generates the field as an algebra over the ground field.")) (|normal?| (((|Boolean|) $) "\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F},{} \\spadignore{i.e.} \\spad{a**(q**i), 0 <= i <= extensionDegree()-1} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39.")) (|normalElement| (($) "\\spad{normalElement()} returns a element,{} normal over the ground field \\spad{F},{} \\spadignore{i.e.} \\spad{a**(q**i), 0 <= i < extensionDegree()} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. At the first call,{} the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls,{} the element is retrieved by referencing the global variable.")) (|createNormalElement| (($) "\\spad{createNormalElement()} computes a normal element over the ground field \\spad{F},{} that is,{} \\spad{a**(q**i), 0 <= i < extensionDegree()} is an \\spad{F}-basis,{} where \\spad{q = size()\\$F}. Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35.")) (|trace| (($ $ (|PositiveInteger|)) "\\spad{trace(a,d)} computes the trace of \\spad{a} with respect to the field of extension degree \\spad{d} over the ground field of size \\spad{q}. Error: if \\spad{d} does not divide the extension degree of \\spad{a}. Note: \\spad{trace(a,d) = reduce(+,[a**(q**(d*i)) for i in 0..n/d])}.") ((|#2| $) "\\spad{trace(a)} computes the trace of \\spad{a} with respect to the field considered as an algebra with 1 over the ground field \\spad{F}.")) (|norm| (($ $ (|PositiveInteger|)) "\\spad{norm(a,d)} computes the norm of \\spad{a} with respect to the field of extension degree \\spad{d} over the ground field of size. Error: if \\spad{d} does not divide the extension degree of \\spad{a}. Note: norm(a,{}\\spad{d}) = reduce(*,{}[a**(q**(d*i)) for \\spad{i} in 0..n/d])") ((|#2| $) "\\spad{norm(a)} computes the norm of \\spad{a} with respect to the field considered as an algebra with 1 over the ground field \\spad{F}.")) (|degree| (((|PositiveInteger|) $) "\\spad{degree(a)} returns the degree of the minimal polynomial of an element \\spad{a} over the ground field \\spad{F}.")) (|extensionDegree| (((|PositiveInteger|)) "\\spad{extensionDegree()} returns the degree of field extension.")) (|definingPolynomial| (((|SparseUnivariatePolynomial| |#2|)) "\\spad{definingPolynomial()} returns the polynomial used to define the field extension.")) (|minimalPolynomial| (((|SparseUnivariatePolynomial| $) $ (|PositiveInteger|)) "\\spad{minimalPolynomial(x,n)} computes the minimal polynomial of \\spad{x} over the field of extension degree \\spad{n} over the ground field \\spad{F}.") (((|SparseUnivariatePolynomial| |#2|) $) "\\spad{minimalPolynomial(a)} returns the minimal polynomial of an element \\spad{a} over the ground field \\spad{F}.")) (|represents| (($ (|Vector| |#2|)) "\\spad{represents([a1,..,an])} returns \\spad{a1*v1 + ... + an*vn},{} where \\spad{v1},{}...,{}vn are the elements of the fixed basis.")) (|coordinates| (((|Matrix| |#2|) (|Vector| $)) "\\spad{coordinates([v1,...,vm])} returns the coordinates of the \\spad{vi}'s with to the fixed basis. The coordinates of \\spad{vi} are contained in the \\spad{i}th row of the matrix returned by this function.") (((|Vector| |#2|) $) "\\spad{coordinates(a)} returns the coordinates of \\spad{a} with respect to the fixed \\spad{F}-vectorspace basis.")) (|basis| (((|Vector| $) (|PositiveInteger|)) "\\spad{basis(n)} returns a fixed basis of a subfield of \\$ as \\spad{F}-vectorspace.") (((|Vector| $)) "\\spad{basis()} returns a fixed basis of \\$ as \\spad{F}-vectorspace."))) 
 NIL 
@@ -1223,7 +1223,7 @@ NIL
 (-323 A S) 
 ((|constructor| (NIL "A finite linear aggregate is a linear aggregate of finite length. The finite property of the aggregate adds several exports to the list of exports from \\spadtype{LinearAggregate} such as \\spadfun{reverse},{} \\spadfun{sort},{} and so on.")) (|sort!| (($ $) "\\spad{sort!(u)} returns \\spad{u} with its elements in ascending order.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sort!(p,u)} returns \\spad{u} with its elements ordered by \\spad{p}.")) (|reverse!| (($ $) "\\spad{reverse!(u)} returns \\spad{u} with its elements in reverse order.")) (|copyInto!| (($ $ $ (|Integer|)) "\\spad{copyInto!(u,v,i)} returns aggregate \\spad{u} containing a copy of \\spad{v} inserted at element \\spad{i}.")) (|position| (((|Integer|) |#2| $ (|Integer|)) "\\spad{position(x,a,n)} returns the index \\spad{i} of the first occurrence of \\spad{x} in \\axiom{a} where \\axiom{\\spad{i} >= \\spad{n}},{} and \\axiom{minIndex(a) - 1} if no such \\spad{x} is found.") (((|Integer|) |#2| $) "\\spad{position(x,a)} returns the index \\spad{i} of the first occurrence of \\spad{x} in a,{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.") (((|Integer|) (|Mapping| (|Boolean|) |#2|) $) "\\spad{position(p,a)} returns the index \\spad{i} of the first \\spad{x} in \\axiom{a} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true},{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.")) (|sorted?| (((|Boolean|) $) "\\spad{sorted?(u)} tests if the elements of \\spad{u} are in ascending order.") (((|Boolean|) (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sorted?(p,a)} tests if \\axiom{a} is sorted according to predicate \\spad{p}.")) (|sort| (($ $) "\\spad{sort(u)} returns an \\spad{u} with elements in ascending order. Note: \\axiom{sort(\\spad{u}) = sort(<=,{}\\spad{u})}.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $) "\\spad{sort(p,a)} returns a copy of \\axiom{a} sorted using total ordering predicate \\spad{p}.")) (|reverse| (($ $) "\\spad{reverse(a)} returns a copy of \\axiom{a} with elements in reverse order.")) (|merge| (($ $ $) "\\spad{merge(u,v)} merges \\spad{u} and \\spad{v} in ascending order. Note: \\axiom{merge(\\spad{u},{}\\spad{v}) = merge(<=,{}\\spad{u},{}\\spad{v})}.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $ $) "\\spad{merge(p,a,b)} returns an aggregate \\spad{c} which merges \\axiom{a} and \\spad{b}. The result is produced by examining each element \\spad{x} of \\axiom{a} and \\spad{y} of \\spad{b} successively. If \\axiom{\\spad{p}(\\spad{x},{}\\spad{y})} is \\spad{true},{} then \\spad{x} is inserted into the result; otherwise \\spad{y} is inserted. If \\spad{x} is chosen,{} the next element of \\axiom{a} is examined,{} and so on. When all the elements of one aggregate are examined,{} the remaining elements of the other are appended. For example,{} \\axiom{merge(<,{}[1,{}3],{}[2,{}7,{}5])} returns \\axiom{[1,{}2,{}3,{}7,{}5]}."))) 
 NIL 
-((|HasAttribute| |#1| (QUOTE -3998)) (|HasCategory| |#2| (QUOTE (-757))) (|HasCategory| |#2| (QUOTE (-72)))) 
+((|HasCategory| |#1| (|%list| (QUOTE -1036) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-757))) (|HasCategory| |#2| (QUOTE (-72)))) 
 (-324 S) 
 ((|constructor| (NIL "A finite linear aggregate is a linear aggregate of finite length. The finite property of the aggregate adds several exports to the list of exports from \\spadtype{LinearAggregate} such as \\spadfun{reverse},{} \\spadfun{sort},{} and so on.")) (|sort!| (($ $) "\\spad{sort!(u)} returns \\spad{u} with its elements in ascending order.") (($ (|Mapping| (|Boolean|) |#1| |#1|) $) "\\spad{sort!(p,u)} returns \\spad{u} with its elements ordered by \\spad{p}.")) (|reverse!| (($ $) "\\spad{reverse!(u)} returns \\spad{u} with its elements in reverse order.")) (|copyInto!| (($ $ $ (|Integer|)) "\\spad{copyInto!(u,v,i)} returns aggregate \\spad{u} containing a copy of \\spad{v} inserted at element \\spad{i}.")) (|position| (((|Integer|) |#1| $ (|Integer|)) "\\spad{position(x,a,n)} returns the index \\spad{i} of the first occurrence of \\spad{x} in \\axiom{a} where \\axiom{\\spad{i} >= \\spad{n}},{} and \\axiom{minIndex(a) - 1} if no such \\spad{x} is found.") (((|Integer|) |#1| $) "\\spad{position(x,a)} returns the index \\spad{i} of the first occurrence of \\spad{x} in a,{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.") (((|Integer|) (|Mapping| (|Boolean|) |#1|) $) "\\spad{position(p,a)} returns the index \\spad{i} of the first \\spad{x} in \\axiom{a} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true},{} and \\axiom{minIndex(a) - 1} if there is no such \\spad{x}.")) (|sorted?| (((|Boolean|) $) "\\spad{sorted?(u)} tests if the elements of \\spad{u} are in ascending order.") (((|Boolean|) (|Mapping| (|Boolean|) |#1| |#1|) $) "\\spad{sorted?(p,a)} tests if \\axiom{a} is sorted according to predicate \\spad{p}.")) (|sort| (($ $) "\\spad{sort(u)} returns an \\spad{u} with elements in ascending order. Note: \\axiom{sort(\\spad{u}) = sort(<=,{}\\spad{u})}.") (($ (|Mapping| (|Boolean|) |#1| |#1|) $) "\\spad{sort(p,a)} returns a copy of \\axiom{a} sorted using total ordering predicate \\spad{p}.")) (|reverse| (($ $) "\\spad{reverse(a)} returns a copy of \\axiom{a} with elements in reverse order.")) (|merge| (($ $ $) "\\spad{merge(u,v)} merges \\spad{u} and \\spad{v} in ascending order. Note: \\axiom{merge(\\spad{u},{}\\spad{v}) = merge(<=,{}\\spad{u},{}\\spad{v})}.") (($ (|Mapping| (|Boolean|) |#1| |#1|) $ $) "\\spad{merge(p,a,b)} returns an aggregate \\spad{c} which merges \\axiom{a} and \\spad{b}. The result is produced by examining each element \\spad{x} of \\axiom{a} and \\spad{y} of \\spad{b} successively. If \\axiom{\\spad{p}(\\spad{x},{}\\spad{y})} is \\spad{true},{} then \\spad{x} is inserted into the result; otherwise \\spad{y} is inserted. If \\spad{x} is chosen,{} the next element of \\axiom{a} is examined,{} and so on. When all the elements of one aggregate are examined,{} the remaining elements of the other are appended. For example,{} \\axiom{merge(<,{}[1,{}3],{}[2,{}7,{}5])} returns \\axiom{[1,{}2,{}3,{}7,{}5]}."))) 
 NIL 
@@ -1675,7 +1675,7 @@ NIL
 (-436 S |mn|) 
 ((|constructor| (NIL "\\indented{1}{Author Micheal Monagan \\spad{Aug/87}} This is the basic one dimensional array data type."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-437 R |Row| |Col|) 
 ((|constructor| (NIL "\\indented{1}{This is an internal type which provides an implementation of} 2-dimensional arrays as PrimitiveArray's of PrimitiveArray's."))) 
 ((-3998 . T)) 
@@ -1691,7 +1691,7 @@ NIL
 (-440 |mn|) 
 ((|constructor| (NIL "\\spadtype{IndexedBits} is a domain to compactly represent large quantities of Boolean data."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| (-85) (QUOTE (-260 (-85)))) (|HasCategory| (-85) (QUOTE (-1014)))) (|HasCategory| (-85) (QUOTE (-554 (-474)))) (|HasCategory| (-85) (QUOTE (-757))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-85) (QUOTE (-72))) (|HasCategory| (-85) (QUOTE (-553 (-773)))) (|HasCategory| (-85) (QUOTE (-1014))) (|HasCategory| $ (QUOTE (-318 (-85)))) (-12 (|HasCategory| $ (QUOTE (-318 (-85)))) (|HasCategory| (-85) (QUOTE (-72))))) 
+((-12 (|HasCategory| (-85) (QUOTE (-260 (-85)))) (|HasCategory| (-85) (QUOTE (-1014)))) (|HasCategory| (-85) (QUOTE (-554 (-474)))) (|HasCategory| (-85) (QUOTE (-757))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-85) (QUOTE (-72))) (|HasCategory| (-85) (QUOTE (-553 (-773)))) (|HasCategory| (-85) (QUOTE (-1014))) (-12 (|HasCategory| $ (QUOTE (-1036 (-85)))) (|HasCategory| (-85) (QUOTE (-757)))) (|HasCategory| $ (QUOTE (-1036 (-85)))) (|HasCategory| $ (QUOTE (-318 (-85)))) (-12 (|HasCategory| $ (QUOTE (-318 (-85)))) (|HasCategory| (-85) (QUOTE (-72))))) 
 (-441 K R UP L) 
 ((|constructor| (NIL "IntegralBasisPolynomialTools provides functions for \\indented{1}{mapping functions on the coefficients of univariate and bivariate} \\indented{1}{polynomials.}")) (|mapBivariate| (((|SparseUnivariatePolynomial| (|SparseUnivariatePolynomial| |#4|)) (|Mapping| |#4| |#1|) |#3|) "\\spad{mapBivariate(f,p(x,y))} applies the function \\spad{f} to the coefficients of \\spad{p(x,y)}.")) (|mapMatrixIfCan| (((|Union| (|Matrix| |#2|) "failed") (|Mapping| (|Union| |#1| "failed") |#4|) (|Matrix| (|SparseUnivariatePolynomial| |#4|))) "\\spad{mapMatrixIfCan(f,mat)} applies the function \\spad{f} to the coefficients of the entries of \\spad{mat} if possible,{} and returns \\spad{\"failed\"} otherwise.")) (|mapUnivariateIfCan| (((|Union| |#2| "failed") (|Mapping| (|Union| |#1| "failed") |#4|) (|SparseUnivariatePolynomial| |#4|)) "\\spad{mapUnivariateIfCan(f,p(x))} applies the function \\spad{f} to the coefficients of \\spad{p(x)},{} if possible,{} and returns \\spad{\"failed\"} otherwise.")) (|mapUnivariate| (((|SparseUnivariatePolynomial| |#4|) (|Mapping| |#4| |#1|) |#2|) "\\spad{mapUnivariate(f,p(x))} applies the function \\spad{f} to the coefficients of \\spad{p(x)}.") ((|#2| (|Mapping| |#1| |#4|) (|SparseUnivariatePolynomial| |#4|)) "\\spad{mapUnivariate(f,p(x))} applies the function \\spad{f} to the coefficients of \\spad{p(x)}."))) 
 NIL 
@@ -1763,7 +1763,7 @@ NIL
 (-458 S |mn|) 
 ((|constructor| (NIL "\\indented{1}{Author: Michael Monagan \\spad{July/87},{} modified SMW \\spad{June/91}} A FlexibleArray is the notion of an array intended to allow for growth at the end only. Hence the following efficient operations \\indented{2}{\\spad{append(x,a)} meaning append item \\spad{x} at the end of the array \\spad{a}} \\indented{2}{\\spad{delete(a,n)} meaning delete the last item from the array \\spad{a}} Flexible arrays support the other operations inherited from \\spadtype{ExtensibleLinearAggregate}. However,{} these are not efficient. Flexible arrays combine the \\spad{O(1)} access time property of arrays with growing and shrinking at the end in \\spad{O(1)} (average) time. This is done by using an ordinary array which may have zero or more empty slots at the end. When the array becomes full it is copied into a new larger (50\\% larger) array. Conversely,{} when the array becomes less than 1/2 full,{} it is copied into a smaller array. Flexible arrays provide for an efficient implementation of many data structures in particular heaps,{} stacks and sets.")) (|shrinkable| (((|Boolean|) (|Boolean|)) "\\spad{shrinkable(b)} sets the shrinkable attribute of flexible arrays to \\spad{b} and returns the previous value")) (|physicalLength!| (($ $ (|Integer|)) "\\spad{physicalLength!(x,n)} changes the physical length of \\spad{x} to be \\spad{n} and returns the new array.")) (|physicalLength| (((|NonNegativeInteger|) $) "\\spad{physicalLength(x)} returns the number of elements \\spad{x} can accomodate before growing")) (|flexibleArray| (($ (|List| |#1|)) "\\spad{flexibleArray(l)} creates a flexible array from the list of elements \\spad{l}"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-459) 
 ((|constructor| (NIL "This domain represents AST for conditional expressions.")) (|elseBranch| (((|SpadAst|) $) "thenBranch(\\spad{e}) returns the `else-branch' of `e'.")) (|thenBranch| (((|SpadAst|) $) "\\spad{thenBranch(e)} returns the `then-branch' of `e'.")) (|condition| (((|SpadAst|) $) "\\spad{condition(e)} returns the condition of the if-expression `e'."))) 
 NIL 
@@ -1775,11 +1775,11 @@ NIL
 (-461 R |Row| |Col| M) 
 ((|constructor| (NIL "\\spadtype{InnerMatrixLinearAlgebraFunctions} is an internal package which provides standard linear algebra functions on domains in \\spad{MatrixCategory}")) (|inverse| (((|Union| |#4| "failed") |#4|) "\\spad{inverse(m)} returns the inverse of the matrix \\spad{m}. If the matrix is not invertible,{} \"failed\" is returned. Error: if the matrix is not square.")) (|generalizedInverse| ((|#4| |#4|) "\\spad{generalizedInverse(m)} returns the generalized (Moore--Penrose) inverse of the matrix \\spad{m},{} \\spadignore{i.e.} the matrix \\spad{h} such that m*h*m=h,{} h*m*h=m,{} m*h and h*m are both symmetric matrices.")) (|determinant| ((|#1| |#4|) "\\spad{determinant(m)} returns the determinant of the matrix \\spad{m}. an error message is returned if the matrix is not square.")) (|nullSpace| (((|List| |#3|) |#4|) "\\spad{nullSpace(m)} returns a basis for the null space of the matrix \\spad{m}.")) (|nullity| (((|NonNegativeInteger|) |#4|) "\\spad{nullity(m)} returns the mullity of the matrix \\spad{m}. This is the dimension of the null space of the matrix \\spad{m}.")) (|rank| (((|NonNegativeInteger|) |#4|) "\\spad{rank(m)} returns the rank of the matrix \\spad{m}.")) (|rowEchelon| ((|#4| |#4|) "\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m}."))) 
 NIL 
-((|HasAttribute| |#3| (QUOTE -3998))) 
+((|HasCategory| |#3| (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-462 R |Row| |Col| M QF |Row2| |Col2| M2) 
 ((|constructor| (NIL "\\spadtype{InnerMatrixQuotientFieldFunctions} provides functions on matrices over an integral domain which involve the quotient field of that integral domain. The functions rowEchelon and inverse return matrices with entries in the quotient field.")) (|nullSpace| (((|List| |#3|) |#4|) "\\spad{nullSpace(m)} returns a basis for the null space of the matrix \\spad{m}.")) (|inverse| (((|Union| |#8| "failed") |#4|) "\\spad{inverse(m)} returns the inverse of the matrix \\spad{m}. If the matrix is not invertible,{} \"failed\" is returned. Error: if the matrix is not square. Note: the result will have entries in the quotient field.")) (|rowEchelon| ((|#8| |#4|) "\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m}. the result will have entries in the quotient field."))) 
 NIL 
-((|HasAttribute| |#7| (QUOTE -3998))) 
+((|HasCategory| |#7| (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-463) 
 ((|constructor| (NIL "This domain represents an `import' of types.")) (|imports| (((|List| (|TypeAst|)) $) "\\spad{imports(x)} returns the list of imported types.")) (|coerce| (($ (|List| (|TypeAst|))) "ts::ImportAst constructs an ImportAst for the list if types `ts'."))) 
 NIL 
@@ -2267,7 +2267,7 @@ NIL
 (-584 S) 
 ((|constructor| (NIL "\\spadtype{List} implements singly-linked lists that are addressable by indices; the index of the first element is 1. this constructor provides some LISP-like functions such as \\spadfun{null} and \\spadfun{cons}.")) (|setDifference| (($ $ $) "\\spad{setDifference(u1,u2)} returns a list of the elements of \\spad{u1} that are not also in \\spad{u2}. The order of elements in the resulting list is unspecified.")) (|setIntersection| (($ $ $) "\\spad{setIntersection(u1,u2)} returns a list of the elements that lists \\spad{u1} and \\spad{u2} have in common. The order of elements in the resulting list is unspecified.")) (|setUnion| (($ $ $) "\\spad{setUnion(u1,u2)} appends the two lists \\spad{u1} and \\spad{u2},{} then removes all duplicates. The order of elements in the resulting list is unspecified.")) (|append| (($ $ $) "\\spad{append(u1,u2)} appends the elements of list \\spad{u1} onto the front of list \\spad{u2}. This new list and \\spad{u2} will share some structure.")) (|cons| (($ |#1| $) "\\spad{cons(element,u)} appends \\spad{element} onto the front of list \\spad{u} and returns the new list. This new list and the old one will share some structure.")) (|null| (((|Boolean|) $) "\\spad{null(u)} tests if list \\spad{u} is the empty list.")) (|nil| (($) "\\spad{nil} is the empty list."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-585 A B) 
 ((|constructor| (NIL "\\spadtype{ListFunctions2} implements utility functions that operate on two kinds of lists,{} each with a possibly different type of element.")) (|map| (((|List| |#2|) (|Mapping| |#2| |#1|) (|List| |#1|)) "\\spad{map(fn,u)} applies \\spad{fn} to each element of list \\spad{u} and returns a new list with the results. For example \\spad{map(square,[1,2,3]) = [1,4,9]}.")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|List| |#1|) |#2|) "\\spad{reduce(fn,u,ident)} successively uses the binary function \\spad{fn} on the elements of list \\spad{u} and the result of previous applications. \\spad{ident} is returned if the \\spad{u} is empty. Note the order of application in the following examples: \\spad{reduce(fn,[1,2,3],0) = fn(3,fn(2,fn(1,0)))} and \\spad{reduce(*,[2,3],1) = 3 * (2 * 1)}.")) (|scan| (((|List| |#2|) (|Mapping| |#2| |#1| |#2|) (|List| |#1|) |#2|) "\\spad{scan(fn,u,ident)} successively uses the binary function \\spad{fn} to reduce more and more of list \\spad{u}. \\spad{ident} is returned if the \\spad{u} is empty. The result is a list of the reductions at each step. See \\spadfun{reduce} for more information. Examples: \\spad{scan(fn,[1,2],0) = [fn(2,fn(1,0)),fn(1,0)]} and \\spad{scan(*,[2,3],1) = [2 * 1, 3 * (2 * 1)]}."))) 
 NIL 
@@ -3183,7 +3183,7 @@ NIL
 (-813 S) 
 ((|constructor| (NIL "\\indented{1}{A PendantTree(\\spad{S})is either a leaf? and is an \\spad{S} or has} a left and a right both PendantTree(\\spad{S})'s")) (|ptree| (($ $ $) "\\spad{ptree(x,y)} \\undocumented") (($ |#1|) "\\spad{ptree(s)} is a leaf? pendant tree"))) 
 NIL 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-814 S) 
 ((|constructor| (NIL "Permutation(\\spad{S}) implements the group of all bijections \\indented{2}{on a set \\spad{S},{} which move only a finite number of points.} \\indented{2}{A permutation is considered as a map from \\spad{S} into \\spad{S}. In particular} \\indented{2}{multiplication is defined as composition of maps:} \\indented{2}{{\\em pi1 * pi2 = pi1 o pi2}.} \\indented{2}{The internal representation of permuatations are two lists} \\indented{2}{of equal length representing preimages and images.}")) (|coerceImages| (($ (|List| |#1|)) "\\spad{coerceImages(ls)} coerces the list {\\em ls} to a permutation whose image is given by {\\em ls} and the preimage is fixed to be {\\em [1,...,n]}. Note: {coerceImages(\\spad{ls})=coercePreimagesImages([1,{}...,{}\\spad{n}],{}\\spad{ls})}. We assume that both preimage and image do not contain repetitions.")) (|fixedPoints| (((|Set| |#1|) $) "\\spad{fixedPoints(p)} returns the points fixed by the permutation \\spad{p}.")) (|sort| (((|List| $) (|List| $)) "\\spad{sort(lp)} sorts a list of permutations {\\em lp} according to cycle structure first according to length of cycles,{} second,{} if \\spad{S} has \\spadtype{Finite} or \\spad{S} has \\spadtype{OrderedSet} according to lexicographical order of entries in cycles of equal length.")) (|odd?| (((|Boolean|) $) "\\spad{odd?(p)} returns \\spad{true} if and only if \\spad{p} is an odd permutation \\spadignore{i.e.} {\\em sign(p)} is {\\em -1}.")) (|even?| (((|Boolean|) $) "\\spad{even?(p)} returns \\spad{true} if and only if \\spad{p} is an even permutation,{} \\spadignore{i.e.} {\\em sign(p)} is 1.")) (|sign| (((|Integer|) $) "\\spad{sign(p)} returns the signum of the permutation \\spad{p},{} \\spad{+1} or \\spad{-1}.")) (|numberOfCycles| (((|NonNegativeInteger|) $) "\\spad{numberOfCycles(p)} returns the number of non-trivial cycles of the permutation \\spad{p}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of a permutation \\spad{p} as a group element.")) (|cyclePartition| (((|Partition|) $) "\\spad{cyclePartition(p)} returns the cycle structure of a permutation \\spad{p} including cycles of length 1 only if \\spad{S} is finite.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} retuns the number of points moved by the permutation \\spad{p}.")) (|coerceListOfPairs| (($ (|List| (|List| |#1|))) "\\spad{coerceListOfPairs(lls)} coerces a list of pairs {\\em lls} to a permutation. Error: if not consistent,{} \\spadignore{i.e.} the set of the first elements coincides with the set of second elements. coerce(\\spad{p}) generates output of the permutation \\spad{p} with domain OutputForm.")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce(ls)} coerces a cycle {\\em ls},{} \\spadignore{i.e.} a list with not repetitions to a permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list. Error: if repetitions occur.") (($ (|List| (|List| |#1|))) "\\spad{coerce(lls)} coerces a list of cycles {\\em lls} to a permutation,{} each cycle being a list with no repetitions,{} is coerced to the permutation,{} which maps {\\em ls.i} to {\\em ls.i+1},{} indices modulo the length of the list,{} then these permutations are mutiplied. Error: if repetitions occur in one cycle.")) (|coercePreimagesImages| (($ (|List| (|List| |#1|))) "\\spad{coercePreimagesImages(lls)} coerces the representation {\\em lls} of a permutation as a list of preimages and images to a permutation. We assume that both preimage and image do not contain repetitions.")) (|listRepresentation| (((|Record| (|:| |preimage| (|List| |#1|)) (|:| |image| (|List| |#1|))) $) "\\spad{listRepresentation(p)} produces a representation {\\em rep} of the permutation \\spad{p} as a list of preimages and images,{} \\spad{i}.\\spad{e} \\spad{p} maps {\\em (rep.preimage).k} to {\\em (rep.image).k} for all indices \\spad{k}. Elements of \\spad{S} not in {\\em (rep.preimage).k} are fixed points,{} and these are the only fixed points of the permutation."))) 
 ((-3994 . T)) 
@@ -3351,7 +3351,7 @@ NIL
 (-855 R) 
 ((|constructor| (NIL "This domain implements points in coordinate space"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-23))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-664))) (|HasCategory| |#1| (QUOTE (-962))) (-12 (|HasCategory| |#1| (QUOTE (-916))) (|HasCategory| |#1| (QUOTE (-962)))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-23))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-664))) (|HasCategory| |#1| (QUOTE (-962))) (-12 (|HasCategory| |#1| (QUOTE (-916))) (|HasCategory| |#1| (QUOTE (-962)))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-856 |lv| R) 
 ((|constructor| (NIL "Package with the conversion functions among different kind of polynomials")) (|pToDmp| (((|DistributedMultivariatePolynomial| |#1| |#2|) (|Polynomial| |#2|)) "\\spad{pToDmp(p)} converts \\spad{p} from a \\spadtype{POLY} to a \\spadtype{DMP}.")) (|dmpToP| (((|Polynomial| |#2|) (|DistributedMultivariatePolynomial| |#1| |#2|)) "\\spad{dmpToP(p)} converts \\spad{p} from a \\spadtype{DMP} to a \\spadtype{POLY}.")) (|hdmpToP| (((|Polynomial| |#2|) (|HomogeneousDistributedMultivariatePolynomial| |#1| |#2|)) "\\spad{hdmpToP(p)} converts \\spad{p} from a \\spadtype{HDMP} to a \\spadtype{POLY}.")) (|pToHdmp| (((|HomogeneousDistributedMultivariatePolynomial| |#1| |#2|) (|Polynomial| |#2|)) "\\spad{pToHdmp(p)} converts \\spad{p} from a \\spadtype{POLY} to a \\spadtype{HDMP}.")) (|hdmpToDmp| (((|DistributedMultivariatePolynomial| |#1| |#2|) (|HomogeneousDistributedMultivariatePolynomial| |#1| |#2|)) "\\spad{hdmpToDmp(p)} converts \\spad{p} from a \\spadtype{HDMP} to a \\spadtype{DMP}.")) (|dmpToHdmp| (((|HomogeneousDistributedMultivariatePolynomial| |#1| |#2|) (|DistributedMultivariatePolynomial| |#1| |#2|)) "\\spad{dmpToHdmp(p)} converts \\spad{p} from a \\spadtype{DMP} to a \\spadtype{HDMP}."))) 
 NIL 
@@ -3411,7 +3411,7 @@ NIL
 (-870 S) 
 ((|constructor| (NIL "\\indented{1}{This provides a fast array type with no bound checking on elt's.} Minimum index is 0 in this type,{} cannot be changed"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-871 A B) 
 ((|constructor| (NIL "\\indented{1}{This package provides tools for operating on primitive arrays} with unary and binary functions involving different underlying types")) (|map| (((|PrimitiveArray| |#2|) (|Mapping| |#2| |#1|) (|PrimitiveArray| |#1|)) "\\spad{map(f,a)} applies function \\spad{f} to each member of primitive array \\spad{a} resulting in a new primitive array over a possibly different underlying domain.")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|PrimitiveArray| |#1|) |#2|) "\\spad{reduce(f,a,r)} applies function \\spad{f} to each successive element of the primitive array \\spad{a} and an accumulant initialized to \\spad{r}. For example,{} \\spad{reduce(_+\\$Integer,[1,2,3],0)} does \\spad{3+(2+(1+0))}. Note: third argument \\spad{r} may be regarded as the identity element for the function \\spad{f}.")) (|scan| (((|PrimitiveArray| |#2|) (|Mapping| |#2| |#1| |#2|) (|PrimitiveArray| |#1|) |#2|) "\\spad{scan(f,a,r)} successively applies \\spad{reduce(f,x,r)} to more and more leading sub-arrays \\spad{x} of primitive array \\spad{a}. More precisely,{} if \\spad{a} is \\spad{[a1,a2,...]},{} then \\spad{scan(f,a,r)} returns \\spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}."))) 
 NIL 
@@ -3623,7 +3623,7 @@ NIL
 (-923 A S) 
 ((|constructor| (NIL "A recursive aggregate over a type \\spad{S} is a model for a a directed graph containing values of type \\spad{S}. Recursively,{} a recursive aggregate is a {\\em node} consisting of a \\spadfun{value} from \\spad{S} and 0 or more \\spadfun{children} which are recursive aggregates. A node with no children is called a \\spadfun{leaf} node. A recursive aggregate may be cyclic for which some operations as noted may go into an infinite loop.")) (|setvalue!| ((|#2| $ |#2|) "\\spad{setvalue!(u,x)} sets the value of node \\spad{u} to \\spad{x}.")) (|setelt| ((|#2| $ "value" |#2|) "\\spad{setelt(a,\"value\",x)} (also written \\axiom{a . value := \\spad{x}}) is equivalent to \\axiom{setvalue!(a,{}\\spad{x})}")) (|setchildren!| (($ $ (|List| $)) "\\spad{setchildren!(u,v)} replaces the current children of node \\spad{u} with the members of \\spad{v} in left-to-right order.")) (|node?| (((|Boolean|) $ $) "\\spad{node?(u,v)} tests if node \\spad{u} is contained in node \\spad{v} (either as a child,{} a child of a child,{} etc.).")) (|child?| (((|Boolean|) $ $) "\\spad{child?(u,v)} tests if node \\spad{u} is a child of node \\spad{v}.")) (|distance| (((|Integer|) $ $) "\\spad{distance(u,v)} returns the path length (an integer) from node \\spad{u} to \\spad{v}.")) (|leaves| (((|List| |#2|) $) "\\spad{leaves(t)} returns the list of values in obtained by visiting the nodes of tree \\axiom{\\spad{t}} in left-to-right order.")) (|cyclic?| (((|Boolean|) $) "\\spad{cyclic?(u)} tests if \\spad{u} has a cycle.")) (|elt| ((|#2| $ "value") "\\spad{elt(u,\"value\")} (also written: \\axiom{a. value}) is equivalent to \\axiom{value(a)}.")) (|value| ((|#2| $) "\\spad{value(u)} returns the value of the node \\spad{u}.")) (|leaf?| (((|Boolean|) $) "\\spad{leaf?(u)} tests if \\spad{u} is a terminal node.")) (|nodes| (((|List| $) $) "\\spad{nodes(u)} returns a list of all of the nodes of aggregate \\spad{u}.")) (|children| (((|List| $) $) "\\spad{children(u)} returns a list of the children of aggregate \\spad{u}."))) 
 NIL 
-((|HasAttribute| |#1| (QUOTE -3998)) (|HasCategory| |#2| (QUOTE (-72)))) 
+((|HasCategory| |#1| (|%list| (QUOTE -1036) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-72)))) 
 (-924 S) 
 ((|constructor| (NIL "A recursive aggregate over a type \\spad{S} is a model for a a directed graph containing values of type \\spad{S}. Recursively,{} a recursive aggregate is a {\\em node} consisting of a \\spadfun{value} from \\spad{S} and 0 or more \\spadfun{children} which are recursive aggregates. A node with no children is called a \\spadfun{leaf} node. A recursive aggregate may be cyclic for which some operations as noted may go into an infinite loop.")) (|setvalue!| ((|#1| $ |#1|) "\\spad{setvalue!(u,x)} sets the value of node \\spad{u} to \\spad{x}.")) (|setelt| ((|#1| $ "value" |#1|) "\\spad{setelt(a,\"value\",x)} (also written \\axiom{a . value := \\spad{x}}) is equivalent to \\axiom{setvalue!(a,{}\\spad{x})}")) (|setchildren!| (($ $ (|List| $)) "\\spad{setchildren!(u,v)} replaces the current children of node \\spad{u} with the members of \\spad{v} in left-to-right order.")) (|node?| (((|Boolean|) $ $) "\\spad{node?(u,v)} tests if node \\spad{u} is contained in node \\spad{v} (either as a child,{} a child of a child,{} etc.).")) (|child?| (((|Boolean|) $ $) "\\spad{child?(u,v)} tests if node \\spad{u} is a child of node \\spad{v}.")) (|distance| (((|Integer|) $ $) "\\spad{distance(u,v)} returns the path length (an integer) from node \\spad{u} to \\spad{v}.")) (|leaves| (((|List| |#1|) $) "\\spad{leaves(t)} returns the list of values in obtained by visiting the nodes of tree \\axiom{\\spad{t}} in left-to-right order.")) (|cyclic?| (((|Boolean|) $) "\\spad{cyclic?(u)} tests if \\spad{u} has a cycle.")) (|elt| ((|#1| $ "value") "\\spad{elt(u,\"value\")} (also written: \\axiom{a. value}) is equivalent to \\axiom{value(a)}.")) (|value| ((|#1| $) "\\spad{value(u)} returns the value of the node \\spad{u}.")) (|leaf?| (((|Boolean|) $) "\\spad{leaf?(u)} tests if \\spad{u} is a terminal node.")) (|nodes| (((|List| $) $) "\\spad{nodes(u)} returns a list of all of the nodes of aggregate \\spad{u}.")) (|children| (((|List| $) $) "\\spad{children(u)} returns a list of the children of aggregate \\spad{u}."))) 
 NIL 
@@ -4155,7 +4155,7 @@ NIL
 (-1056 V C) 
 ((|constructor| (NIL "This domain exports a modest implementation of splitting trees. Spliiting trees are needed when the evaluation of some quantity under some hypothesis requires to split the hypothesis into sub-cases. For instance by adding some new hypothesis on one hand and its negation on another hand. The computations are terminated is a splitting tree \\axiom{a} when \\axiom{status(value(a))} is \\axiom{\\spad{true}}. Thus,{} if for the splitting tree \\axiom{a} the flag \\axiom{status(value(a))} is \\axiom{\\spad{true}},{} then \\axiom{status(value(\\spad{d}))} is \\axiom{\\spad{true}} for any subtree \\axiom{\\spad{d}} of \\axiom{a}. This property of splitting trees is called the termination condition. If no vertex in a splitting tree \\axiom{a} is equal to another,{} \\axiom{a} is said to satisfy the no-duplicates condition. The splitting tree \\axiom{a} will satisfy this condition if nodes are added to \\axiom{a} by mean of \\axiom{splitNodeOf!} and if \\axiom{construct} is only used to create the root of \\axiom{a} with no children.")) (|splitNodeOf!| (($ $ $ (|List| (|SplittingNode| |#1| |#2|)) (|Mapping| (|Boolean|) |#2| |#2|)) "\\axiom{splitNodeOf!(\\spad{l},{}a,{}ls,{}sub?)} returns \\axiom{a} where the children list of \\axiom{\\spad{l}} has been set to \\axiom{[[\\spad{s}]\\$\\% for \\spad{s} in ls | not subNodeOf?(\\spad{s},{}a,{}sub?)]}. Thus,{} if \\axiom{\\spad{l}} is not a node of \\axiom{a},{} this latter splitting tree is unchanged.") (($ $ $ (|List| (|SplittingNode| |#1| |#2|))) "\\axiom{splitNodeOf!(\\spad{l},{}a,{}ls)} returns \\axiom{a} where the children list of \\axiom{\\spad{l}} has been set to \\axiom{[[\\spad{s}]\\$\\% for \\spad{s} in ls | not nodeOf?(\\spad{s},{}a)]}. Thus,{} if \\axiom{\\spad{l}} is not a node of \\axiom{a},{} this latter splitting tree is unchanged.")) (|remove!| (($ (|SplittingNode| |#1| |#2|) $) "\\axiom{remove!(\\spad{s},{}a)} replaces a by remove(\\spad{s},{}a)")) (|remove| (($ (|SplittingNode| |#1| |#2|) $) "\\axiom{remove(\\spad{s},{}a)} returns the splitting tree obtained from a by removing every sub-tree \\axiom{\\spad{b}} such that \\axiom{value(\\spad{b})} and \\axiom{\\spad{s}} have the same value,{} condition and status.")) (|subNodeOf?| (((|Boolean|) (|SplittingNode| |#1| |#2|) $ (|Mapping| (|Boolean|) |#2| |#2|)) "\\axiom{subNodeOf?(\\spad{s},{}a,{}sub?)} returns \\spad{true} iff for some node \\axiom{\\spad{n}} in \\axiom{a} we have \\axiom{\\spad{s} = \\spad{n}} or \\axiom{status(\\spad{n})} and \\axiom{subNode?(\\spad{s},{}\\spad{n},{}sub?)}.")) (|nodeOf?| (((|Boolean|) (|SplittingNode| |#1| |#2|) $) "\\axiom{nodeOf?(\\spad{s},{}a)} returns \\spad{true} iff some node of \\axiom{a} is equal to \\axiom{\\spad{s}}")) (|result| (((|List| (|Record| (|:| |val| |#1|) (|:| |tower| |#2|))) $) "\\axiom{result(a)} where \\axiom{ls} is the leaves list of \\axiom{a} returns \\axiom{[[value(\\spad{s}),{}condition(\\spad{s})]\\$VT for \\spad{s} in ls]} if the computations are terminated in \\axiom{a} else an error is produced.")) (|conditions| (((|List| |#2|) $) "\\axiom{conditions(a)} returns the list of the conditions of the leaves of a")) (|construct| (($ |#1| |#2| |#1| (|List| |#2|)) "\\axiom{construct(\\spad{v1},{}\\spad{t},{}\\spad{v2},{}lt)} creates a splitting tree with value (\\spadignore{i.e.} root vertex) given by \\axiom{[\\spad{v},{}\\spad{t}]\\$\\spad{S}} and with children list given by \\axiom{[[[\\spad{v},{}\\spad{t}]\\$\\spad{S}]\\$\\% for \\spad{s} in ls]}.") (($ |#1| |#2| (|List| (|SplittingNode| |#1| |#2|))) "\\axiom{construct(\\spad{v},{}\\spad{t},{}ls)} creates a splitting tree with value (\\spadignore{i.e.} root vertex) given by \\axiom{[\\spad{v},{}\\spad{t}]\\$\\spad{S}} and with children list given by \\axiom{[[\\spad{s}]\\$\\% for \\spad{s} in ls]}.") (($ |#1| |#2| (|List| $)) "\\axiom{construct(\\spad{v},{}\\spad{t},{}la)} creates a splitting tree with value (\\spadignore{i.e.} root vertex) given by \\axiom{[\\spad{v},{}\\spad{t}]\\$\\spad{S}} and with \\axiom{la} as children list.") (($ (|SplittingNode| |#1| |#2|)) "\\axiom{construct(\\spad{s})} creates a splitting tree with value (\\spadignore{i.e.} root vertex) given by \\axiom{\\spad{s}} and no children. Thus,{} if the status of \\axiom{\\spad{s}} is \\spad{false},{} \\axiom{[\\spad{s}]} represents the starting point of the evaluation \\axiom{value(\\spad{s})} under the hypothesis \\axiom{condition(\\spad{s})}.")) (|updateStatus!| (($ $) "\\axiom{updateStatus!(a)} returns a where the status of the vertices are updated to satisfy the \"termination condition\".")) (|extractSplittingLeaf| (((|Union| $ "failed") $) "\\axiom{extractSplittingLeaf(a)} returns the left most leaf (as a tree) whose status is \\spad{false} if any,{} else \"failed\" is returned."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| (-1055 |#1| |#2|) (|%list| (QUOTE -260) (|%list| (QUOTE -1055) (|devaluate| |#1|) (|devaluate| |#2|)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014))) (OR (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-72))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-553 (-773)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-72)))) 
+((-12 (|HasCategory| (-1055 |#1| |#2|) (|%list| (QUOTE -260) (|%list| (QUOTE -1055) (|devaluate| |#1|) (|devaluate| |#2|)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014))) (OR (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-72))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-1014)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-553 (-773)))) (|HasCategory| (-1055 |#1| |#2|) (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|%list| (QUOTE -1055) (|devaluate| |#1|) (|devaluate| |#2|))))) 
 (-1057 |ndim| R) 
 ((|constructor| (NIL "\\spadtype{SquareMatrix} is a matrix domain of square matrices,{} where the number of rows (= number of columns) is a parameter of the type.")) (|unitsKnown| ((|attribute|) "the invertible matrices are simply the matrices whose determinants are units in the Ring \\spad{R}.")) (|central| ((|attribute|) "the elements of the Ring \\spad{R},{} viewed as diagonal matrices,{} commute with all matrices and,{} indeed,{} are the only matrices which commute with all matrices.")) (|squareMatrix| (($ (|Matrix| |#2|)) "\\spad{squareMatrix(m)} converts a matrix of type \\spadtype{Matrix} to a matrix of type \\spadtype{SquareMatrix}.")) (|transpose| (($ $) "\\spad{transpose(m)} returns the transpose of the matrix \\spad{m}.")) (|new| (($ |#2|) "\\spad{new(c)} constructs a new \\spadtype{SquareMatrix} object of dimension \\spad{ndim} with initial entries equal to \\spad{c}."))) 
 ((-3994 . T) (-3986 |has| |#2| (-6 (-3999 "*"))) (-3991 . T) (-3992 . T)) 
@@ -4209,9 +4209,9 @@ NIL
 NIL 
 NIL 
 (-1070 S) 
-((|constructor| (NIL "A stream is an implementation of an infinite sequence using a list of terms that have been computed and a function closure to compute additional terms when needed.")) (|filterUntil| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{filterUntil(p,s)} returns \\spad{[x0,x1,...,x(n)]} where \\spad{s = [x0,x1,x2,..]} and \\spad{n} is the smallest index such that \\spad{p(xn) = true}.")) (|filterWhile| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{filterWhile(p,s)} returns \\spad{[x0,x1,...,x(n-1)]} where \\spad{s = [x0,x1,x2,..]} and \\spad{n} is the smallest index such that \\spad{p(xn) = false}.")) (|generate| (($ (|Mapping| |#1| |#1|) |#1|) "\\spad{generate(f,x)} creates an infinite stream whose first element is \\spad{x} and whose \\spad{n}th element (\\spad{n > 1}) is \\spad{f} applied to the previous element. Note: \\spad{generate(f,x) = [x,f(x),f(f(x)),...]}.") (($ (|Mapping| |#1|)) "\\spad{generate(f)} creates an infinite stream all of whose elements are equal to \\spad{f()}. Note: \\spad{generate(f) = [f(),f(),f(),...]}.")) (|setrest!| (($ $ (|Integer|) $) "\\spad{setrest!(x,n,y)} sets rest(\\spad{x},{}\\spad{n}) to \\spad{y}. The function will expand cycles if necessary.")) (|showAll?| (((|Boolean|)) "\\spad{showAll?()} returns \\spad{true} if all computed entries of streams will be displayed.")) (|showAllElements| (((|OutputForm|) $) "\\spad{showAllElements(s)} creates an output form which displays all computed elements.")) (|output| (((|Void|) (|Integer|) $) "\\spad{output(n,st)} computes and displays the first \\spad{n} entries of \\spad{st}.")) (|cons| (($ |#1| $) "\\spad{cons(a,s)} returns a stream whose \\spad{first} is \\spad{a} and whose \\spad{rest} is \\spad{s}. Note: \\spad{cons(a,s) = concat(a,s)}.")) (|delay| (($ (|Mapping| $)) "\\spad{delay(f)} creates a stream with a lazy evaluation defined by function \\spad{f}. Caution: This function can only be called in compiled code.")) (|findCycle| (((|Record| (|:| |cycle?| (|Boolean|)) (|:| |prefix| (|NonNegativeInteger|)) (|:| |period| (|NonNegativeInteger|))) (|NonNegativeInteger|) $) "\\spad{findCycle(n,st)} determines if \\spad{st} is periodic within \\spad{n}.")) (|repeating?| (((|Boolean|) (|List| |#1|) $) "\\spad{repeating?(l,s)} returns \\spad{true} if a stream \\spad{s} is periodic with period \\spad{l},{} and \\spad{false} otherwise.")) (|repeating| (($ (|List| |#1|)) "\\spad{repeating(l)} is a repeating stream whose period is the list \\spad{l}.")) (|shallowlyMutable| ((|attribute|) "one may destructively alter a stream by assigning new values to its entries."))) 
+((|constructor| (NIL "A stream is an implementation of an infinite sequence using a list of terms that have been computed and a function closure to compute additional terms when needed.")) (|filterUntil| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{filterUntil(p,s)} returns \\spad{[x0,x1,...,x(n)]} where \\spad{s = [x0,x1,x2,..]} and \\spad{n} is the smallest index such that \\spad{p(xn) = true}.")) (|filterWhile| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{filterWhile(p,s)} returns \\spad{[x0,x1,...,x(n-1)]} where \\spad{s = [x0,x1,x2,..]} and \\spad{n} is the smallest index such that \\spad{p(xn) = false}.")) (|generate| (($ (|Mapping| |#1| |#1|) |#1|) "\\spad{generate(f,x)} creates an infinite stream whose first element is \\spad{x} and whose \\spad{n}th element (\\spad{n > 1}) is \\spad{f} applied to the previous element. Note: \\spad{generate(f,x) = [x,f(x),f(f(x)),...]}.") (($ (|Mapping| |#1|)) "\\spad{generate(f)} creates an infinite stream all of whose elements are equal to \\spad{f()}. Note: \\spad{generate(f) = [f(),f(),f(),...]}.")) (|setrest!| (($ $ (|Integer|) $) "\\spad{setrest!(x,n,y)} sets rest(\\spad{x},{}\\spad{n}) to \\spad{y}. The function will expand cycles if necessary.")) (|showAll?| (((|Boolean|)) "\\spad{showAll?()} returns \\spad{true} if all computed entries of streams will be displayed.")) (|showAllElements| (((|OutputForm|) $) "\\spad{showAllElements(s)} creates an output form which displays all computed elements.")) (|output| (((|Void|) (|Integer|) $) "\\spad{output(n,st)} computes and displays the first \\spad{n} entries of \\spad{st}.")) (|cons| (($ |#1| $) "\\spad{cons(a,s)} returns a stream whose \\spad{first} is \\spad{a} and whose \\spad{rest} is \\spad{s}. Note: \\spad{cons(a,s) = concat(a,s)}.")) (|delay| (($ (|Mapping| $)) "\\spad{delay(f)} creates a stream with a lazy evaluation defined by function \\spad{f}. Caution: This function can only be called in compiled code.")) (|findCycle| (((|Record| (|:| |cycle?| (|Boolean|)) (|:| |prefix| (|NonNegativeInteger|)) (|:| |period| (|NonNegativeInteger|))) (|NonNegativeInteger|) $) "\\spad{findCycle(n,st)} determines if \\spad{st} is periodic within \\spad{n}.")) (|repeating?| (((|Boolean|) (|List| |#1|) $) "\\spad{repeating?(l,s)} returns \\spad{true} if a stream \\spad{s} is periodic with period \\spad{l},{} and \\spad{false} otherwise.")) (|repeating| (($ (|List| |#1|)) "\\spad{repeating(l)} is a repeating stream whose period is the list \\spad{l}."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))))) 
 (-1071 S) 
 ((|constructor| (NIL "Functions defined on streams with entries in one set.")) (|concat| (((|Stream| |#1|) (|Stream| (|Stream| |#1|))) "\\spad{concat(u)} returns the left-to-right concatentation of the streams in \\spad{u}. Note: \\spad{concat(u) = reduce(concat,u)}."))) 
 NIL 
@@ -4227,7 +4227,7 @@ NIL
 (-1074) 
 ((|constructor| (NIL "This is the domain of character strings.")) (|string| (($ (|Identifier|)) "\\spad{string id} is the string representation of the identifier \\spad{id}") (($ (|DoubleFloat|)) "\\spad{string f} returns the decimal representation of \\spad{f} in a string") (($ (|Integer|)) "\\spad{string i} returns the decimal representation of \\spad{i} in a string"))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-757)))) (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-1014))))) (|HasCategory| (-117) (QUOTE (-553 (-773)))) (|HasCategory| (-117) (QUOTE (-554 (-474)))) (OR (|HasCategory| (-117) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-1014)))) (|HasCategory| (-117) (QUOTE (-757))) (OR (|HasCategory| (-117) (QUOTE (-72))) (|HasCategory| (-117) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-72))) (|HasCategory| (-117) (QUOTE (-1014))) (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-1014)))) (-12 (|HasCategory| $ (QUOTE (-318 (-117)))) (|HasCategory| (-117) (QUOTE (-72)))) (|HasCategory| $ (QUOTE (-318 (-117))))) 
+((OR (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-757)))) (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-1014))))) (|HasCategory| (-117) (QUOTE (-553 (-773)))) (|HasCategory| (-117) (QUOTE (-554 (-474)))) (OR (|HasCategory| (-117) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-1014)))) (|HasCategory| (-117) (QUOTE (-757))) (OR (|HasCategory| (-117) (QUOTE (-72))) (|HasCategory| (-117) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| (-117) (QUOTE (-72))) (|HasCategory| (-117) (QUOTE (-1014))) (-12 (|HasCategory| (-117) (QUOTE (-260 (-117)))) (|HasCategory| (-117) (QUOTE (-1014)))) (-12 (|HasCategory| $ (QUOTE (-318 (-117)))) (|HasCategory| (-117) (QUOTE (-72)))) (|HasCategory| $ (QUOTE (-318 (-117)))) (|HasCategory| $ (QUOTE (-1036 (-117)))) (-12 (|HasCategory| $ (QUOTE (-1036 (-117)))) (|HasCategory| (-117) (QUOTE (-757))))) 
 (-1075 |Entry|) 
 ((|constructor| (NIL "This domain provides tables where the keys are strings. A specialized hash function for strings is used."))) 
 ((-3998 . T)) 
@@ -4399,7 +4399,7 @@ NIL
 (-1117 S) 
 ((|constructor| (NIL "\\spadtype{Tree(S)} is a basic domains of tree structures. Each tree is either empty or else is a {\\it node} consisting of a value and a list of (sub)trees.")) (|cyclicParents| (((|List| $) $) "\\spad{cyclicParents(t)} returns a list of cycles that are parents of \\spad{t}.")) (|cyclicEqual?| (((|Boolean|) $ $) "\\spad{cyclicEqual?(t1, t2)} tests of two cyclic trees have the same structure.")) (|cyclicEntries| (((|List| $) $) "\\spad{cyclicEntries(t)} returns a list of top-level cycles in tree \\spad{t}.")) (|cyclicCopy| (($ $) "\\spad{cyclicCopy(l)} makes a copy of a (possibly) cyclic tree \\spad{l}.")) (|cyclic?| (((|Boolean|) $) "\\spad{cyclic?(t)} tests if \\spad{t} is a cyclic tree.")) (|tree| (($ |#1|) "\\spad{tree(nd)} creates a tree with value \\spad{nd},{} and no children") (($ (|List| |#1|)) "\\spad{tree(ls)} creates a tree from a list of elements of \\spad{s}.") (($ |#1| (|List| $)) "\\spad{tree(nd,ls)} creates a tree with value \\spad{nd},{} and children \\spad{ls}."))) 
 ((-3998 . T)) 
-((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72)))) 
+((-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (|HasCategory| |#1| (QUOTE (-1014))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|)))) 
 (-1118 S) 
 ((|constructor| (NIL "Category for the trigonometric functions.")) (|tan| (($ $) "\\spad{tan(x)} returns the tangent of \\spad{x}.")) (|sin| (($ $) "\\spad{sin(x)} returns the sine of \\spad{x}.")) (|sec| (($ $) "\\spad{sec(x)} returns the secant of \\spad{x}.")) (|csc| (($ $) "\\spad{csc(x)} returns the cosecant of \\spad{x}.")) (|cot| (($ $) "\\spad{cot(x)} returns the cotangent of \\spad{x}.")) (|cos| (($ $) "\\spad{cos(x)} returns the cosine of \\spad{x}."))) 
 NIL 
@@ -4603,7 +4603,7 @@ NIL
 (-1168 A S) 
 ((|constructor| (NIL "A unary-recursive aggregate is a one where nodes may have either 0 or 1 children. This aggregate models,{} though not precisely,{} a linked list possibly with a single cycle. A node with one children models a non-empty list,{} with the \\spadfun{value} of the list designating the head,{} or \\spadfun{first},{} of the list,{} and the child designating the tail,{} or \\spadfun{rest},{} of the list. A node with no child then designates the empty list. Since these aggregates are recursive aggregates,{} they may be cyclic.")) (|split!| (($ $ (|Integer|)) "\\spad{split!(u,n)} splits \\spad{u} into two aggregates: \\axiom{\\spad{v} = rest(\\spad{u},{}\\spad{n})} and \\axiom{\\spad{w} = first(\\spad{u},{}\\spad{n})},{} returning \\axiom{\\spad{v}}. Note: afterwards \\axiom{rest(\\spad{u},{}\\spad{n})} returns \\axiom{empty()}.")) (|setlast!| ((|#2| $ |#2|) "\\spad{setlast!(u,x)} destructively changes the last element of \\spad{u} to \\spad{x}.")) (|setrest!| (($ $ $) "\\spad{setrest!(u,v)} destructively changes the rest of \\spad{u} to \\spad{v}.")) (|setelt| ((|#2| $ "last" |#2|) "\\spad{setelt(u,\"last\",x)} (also written: \\axiom{\\spad{u}.last := \\spad{b}}) is equivalent to \\axiom{setlast!(\\spad{u},{}\\spad{v})}.") (($ $ "rest" $) "\\spad{setelt(u,\"rest\",v)} (also written: \\axiom{\\spad{u}.rest := \\spad{v}}) is equivalent to \\axiom{setrest!(\\spad{u},{}\\spad{v})}.") ((|#2| $ "first" |#2|) "\\spad{setelt(u,\"first\",x)} (also written: \\axiom{\\spad{u}.first := \\spad{x}}) is equivalent to \\axiom{setfirst!(\\spad{u},{}\\spad{x})}.")) (|setfirst!| ((|#2| $ |#2|) "\\spad{setfirst!(u,x)} destructively changes the first element of a to \\spad{x}.")) (|cycleSplit!| (($ $) "\\spad{cycleSplit!(u)} splits the aggregate by dropping off the cycle. The value returned is the cycle entry,{} or nil if none exists. For example,{} if \\axiom{\\spad{w} = concat(\\spad{u},{}\\spad{v})} is the cyclic list where \\spad{v} is the head of the cycle,{} \\axiom{cycleSplit!(\\spad{w})} will drop \\spad{v} off \\spad{w} thus destructively changing \\spad{w} to \\spad{u},{} and returning \\spad{v}.")) (|concat!| (($ $ |#2|) "\\spad{concat!(u,x)} destructively adds element \\spad{x} to the end of \\spad{u}. Note: \\axiom{concat!(a,{}\\spad{x}) = setlast!(a,{}[\\spad{x}])}.") (($ $ $) "\\spad{concat!(u,v)} destructively concatenates \\spad{v} to the end of \\spad{u}. Note: \\axiom{concat!(\\spad{u},{}\\spad{v}) = setlast!(\\spad{u},{}\\spad{v})}.")) (|cycleTail| (($ $) "\\spad{cycleTail(u)} returns the last node in the cycle,{} or empty if none exists.")) (|cycleLength| (((|NonNegativeInteger|) $) "\\spad{cycleLength(u)} returns the length of a top-level cycle contained in aggregate \\spad{u},{} or 0 is \\spad{u} has no such cycle.")) (|cycleEntry| (($ $) "\\spad{cycleEntry(u)} returns the head of a top-level cycle contained in aggregate \\spad{u},{} or \\axiom{empty()} if none exists.")) (|third| ((|#2| $) "\\spad{third(u)} returns the third element of \\spad{u}. Note: \\axiom{third(\\spad{u}) = first(rest(rest(\\spad{u})))}.")) (|second| ((|#2| $) "\\spad{second(u)} returns the second element of \\spad{u}. Note: \\axiom{second(\\spad{u}) = first(rest(\\spad{u}))}.")) (|tail| (($ $) "\\spad{tail(u)} returns the last node of \\spad{u}. Note: if \\spad{u} is \\axiom{shallowlyMutable},{} \\axiom{setrest(tail(\\spad{u}),{}\\spad{v}) = concat(\\spad{u},{}\\spad{v})}.")) (|last| (($ $ (|NonNegativeInteger|)) "\\spad{last(u,n)} returns a copy of the last \\spad{n} (\\axiom{\\spad{n} >= 0}) nodes of \\spad{u}. Note: \\axiom{last(\\spad{u},{}\\spad{n})} is a list of \\spad{n} elements.") ((|#2| $) "\\spad{last(u)} resturn the last element of \\spad{u}. Note: for lists,{} \\axiom{last(\\spad{u}) = \\spad{u} . (maxIndex \\spad{u}) = \\spad{u} . (\\# \\spad{u} - 1)}.")) (|rest| (($ $ (|NonNegativeInteger|)) "\\spad{rest(u,n)} returns the \\axiom{\\spad{n}}th (\\spad{n} >= 0) node of \\spad{u}. Note: \\axiom{rest(\\spad{u},{}0) = \\spad{u}}.") (($ $) "\\spad{rest(u)} returns an aggregate consisting of all but the first element of \\spad{u} (equivalently,{} the next node of \\spad{u}).")) (|elt| ((|#2| $ "last") "\\spad{elt(u,\"last\")} (also written: \\axiom{\\spad{u} . last}) is equivalent to last \\spad{u}.") (($ $ "rest") "\\spad{elt(\\%,\"rest\")} (also written: \\axiom{\\spad{u}.rest}) is equivalent to \\axiom{rest \\spad{u}}.") ((|#2| $ "first") "\\spad{elt(u,\"first\")} (also written: \\axiom{\\spad{u} . first}) is equivalent to first \\spad{u}.")) (|first| (($ $ (|NonNegativeInteger|)) "\\spad{first(u,n)} returns a copy of the first \\spad{n} (\\axiom{\\spad{n} >= 0}) elements of \\spad{u}.") ((|#2| $) "\\spad{first(u)} returns the first element of \\spad{u} (equivalently,{} the value at the current node).")) (|concat| (($ |#2| $) "\\spad{concat(x,u)} returns aggregate consisting of \\spad{x} followed by the elements of \\spad{u}. Note: if \\axiom{\\spad{v} = concat(\\spad{x},{}\\spad{u})} then \\axiom{\\spad{x} = first \\spad{v}} and \\axiom{\\spad{u} = rest \\spad{v}}.") (($ $ $) "\\spad{concat(u,v)} returns an aggregate \\spad{w} consisting of the elements of \\spad{u} followed by the elements of \\spad{v}. Note: \\axiom{\\spad{v} = rest(\\spad{w},{}\\#a)}."))) 
 NIL 
-((|HasAttribute| |#1| (QUOTE -3998))) 
+((|HasCategory| |#1| (|%list| (QUOTE -1036) (|devaluate| |#2|)))) 
 (-1169 S) 
 ((|constructor| (NIL "A unary-recursive aggregate is a one where nodes may have either 0 or 1 children. This aggregate models,{} though not precisely,{} a linked list possibly with a single cycle. A node with one children models a non-empty list,{} with the \\spadfun{value} of the list designating the head,{} or \\spadfun{first},{} of the list,{} and the child designating the tail,{} or \\spadfun{rest},{} of the list. A node with no child then designates the empty list. Since these aggregates are recursive aggregates,{} they may be cyclic.")) (|split!| (($ $ (|Integer|)) "\\spad{split!(u,n)} splits \\spad{u} into two aggregates: \\axiom{\\spad{v} = rest(\\spad{u},{}\\spad{n})} and \\axiom{\\spad{w} = first(\\spad{u},{}\\spad{n})},{} returning \\axiom{\\spad{v}}. Note: afterwards \\axiom{rest(\\spad{u},{}\\spad{n})} returns \\axiom{empty()}.")) (|setlast!| ((|#1| $ |#1|) "\\spad{setlast!(u,x)} destructively changes the last element of \\spad{u} to \\spad{x}.")) (|setrest!| (($ $ $) "\\spad{setrest!(u,v)} destructively changes the rest of \\spad{u} to \\spad{v}.")) (|setelt| ((|#1| $ "last" |#1|) "\\spad{setelt(u,\"last\",x)} (also written: \\axiom{\\spad{u}.last := \\spad{b}}) is equivalent to \\axiom{setlast!(\\spad{u},{}\\spad{v})}.") (($ $ "rest" $) "\\spad{setelt(u,\"rest\",v)} (also written: \\axiom{\\spad{u}.rest := \\spad{v}}) is equivalent to \\axiom{setrest!(\\spad{u},{}\\spad{v})}.") ((|#1| $ "first" |#1|) "\\spad{setelt(u,\"first\",x)} (also written: \\axiom{\\spad{u}.first := \\spad{x}}) is equivalent to \\axiom{setfirst!(\\spad{u},{}\\spad{x})}.")) (|setfirst!| ((|#1| $ |#1|) "\\spad{setfirst!(u,x)} destructively changes the first element of a to \\spad{x}.")) (|cycleSplit!| (($ $) "\\spad{cycleSplit!(u)} splits the aggregate by dropping off the cycle. The value returned is the cycle entry,{} or nil if none exists. For example,{} if \\axiom{\\spad{w} = concat(\\spad{u},{}\\spad{v})} is the cyclic list where \\spad{v} is the head of the cycle,{} \\axiom{cycleSplit!(\\spad{w})} will drop \\spad{v} off \\spad{w} thus destructively changing \\spad{w} to \\spad{u},{} and returning \\spad{v}.")) (|concat!| (($ $ |#1|) "\\spad{concat!(u,x)} destructively adds element \\spad{x} to the end of \\spad{u}. Note: \\axiom{concat!(a,{}\\spad{x}) = setlast!(a,{}[\\spad{x}])}.") (($ $ $) "\\spad{concat!(u,v)} destructively concatenates \\spad{v} to the end of \\spad{u}. Note: \\axiom{concat!(\\spad{u},{}\\spad{v}) = setlast!(\\spad{u},{}\\spad{v})}.")) (|cycleTail| (($ $) "\\spad{cycleTail(u)} returns the last node in the cycle,{} or empty if none exists.")) (|cycleLength| (((|NonNegativeInteger|) $) "\\spad{cycleLength(u)} returns the length of a top-level cycle contained in aggregate \\spad{u},{} or 0 is \\spad{u} has no such cycle.")) (|cycleEntry| (($ $) "\\spad{cycleEntry(u)} returns the head of a top-level cycle contained in aggregate \\spad{u},{} or \\axiom{empty()} if none exists.")) (|third| ((|#1| $) "\\spad{third(u)} returns the third element of \\spad{u}. Note: \\axiom{third(\\spad{u}) = first(rest(rest(\\spad{u})))}.")) (|second| ((|#1| $) "\\spad{second(u)} returns the second element of \\spad{u}. Note: \\axiom{second(\\spad{u}) = first(rest(\\spad{u}))}.")) (|tail| (($ $) "\\spad{tail(u)} returns the last node of \\spad{u}. Note: if \\spad{u} is \\axiom{shallowlyMutable},{} \\axiom{setrest(tail(\\spad{u}),{}\\spad{v}) = concat(\\spad{u},{}\\spad{v})}.")) (|last| (($ $ (|NonNegativeInteger|)) "\\spad{last(u,n)} returns a copy of the last \\spad{n} (\\axiom{\\spad{n} >= 0}) nodes of \\spad{u}. Note: \\axiom{last(\\spad{u},{}\\spad{n})} is a list of \\spad{n} elements.") ((|#1| $) "\\spad{last(u)} resturn the last element of \\spad{u}. Note: for lists,{} \\axiom{last(\\spad{u}) = \\spad{u} . (maxIndex \\spad{u}) = \\spad{u} . (\\# \\spad{u} - 1)}.")) (|rest| (($ $ (|NonNegativeInteger|)) "\\spad{rest(u,n)} returns the \\axiom{\\spad{n}}th (\\spad{n} >= 0) node of \\spad{u}. Note: \\axiom{rest(\\spad{u},{}0) = \\spad{u}}.") (($ $) "\\spad{rest(u)} returns an aggregate consisting of all but the first element of \\spad{u} (equivalently,{} the next node of \\spad{u}).")) (|elt| ((|#1| $ "last") "\\spad{elt(u,\"last\")} (also written: \\axiom{\\spad{u} . last}) is equivalent to last \\spad{u}.") (($ $ "rest") "\\spad{elt(\\%,\"rest\")} (also written: \\axiom{\\spad{u}.rest}) is equivalent to \\axiom{rest \\spad{u}}.") ((|#1| $ "first") "\\spad{elt(u,\"first\")} (also written: \\axiom{\\spad{u} . first}) is equivalent to first \\spad{u}.")) (|first| (($ $ (|NonNegativeInteger|)) "\\spad{first(u,n)} returns a copy of the first \\spad{n} (\\axiom{\\spad{n} >= 0}) elements of \\spad{u}.") ((|#1| $) "\\spad{first(u)} returns the first element of \\spad{u} (equivalently,{} the value at the current node).")) (|concat| (($ |#1| $) "\\spad{concat(x,u)} returns aggregate consisting of \\spad{x} followed by the elements of \\spad{u}. Note: if \\axiom{\\spad{v} = concat(\\spad{x},{}\\spad{u})} then \\axiom{\\spad{x} = first \\spad{v}} and \\axiom{\\spad{u} = rest \\spad{v}}.") (($ $ $) "\\spad{concat(u,v)} returns an aggregate \\spad{w} consisting of the elements of \\spad{u} followed by the elements of \\spad{v}. Note: \\axiom{\\spad{v} = rest(\\spad{w},{}\\#a)}."))) 
 NIL 
@@ -4651,7 +4651,7 @@ NIL
 (-1180 R) 
 ((|constructor| (NIL "This type represents vector like objects with varying lengths and indexed by a finite segment of integers starting at 1.")) (|vector| (($ (|List| |#1|)) "\\spad{vector(l)} converts the list \\spad{l} to a vector."))) 
 ((-3998 . T)) 
-((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-23))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-664))) (|HasCategory| |#1| (QUOTE (-962))) (-12 (|HasCategory| |#1| (QUOTE (-916))) (|HasCategory| |#1| (QUOTE (-962)))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) 
+((OR (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|))))) (|HasCategory| |#1| (QUOTE (-553 (-773)))) (|HasCategory| |#1| (QUOTE (-554 (-474)))) (OR (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| |#1| (QUOTE (-757))) (OR (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-1014)))) (|HasCategory| (-485) (QUOTE (-757))) (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-23))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-664))) (|HasCategory| |#1| (QUOTE (-962))) (-12 (|HasCategory| |#1| (QUOTE (-916))) (|HasCategory| |#1| (QUOTE (-962)))) (|HasCategory| |#1| (QUOTE (-1014))) (-12 (|HasCategory| |#1| (QUOTE (-1014))) (|HasCategory| |#1| (|%list| (QUOTE -260) (|devaluate| |#1|)))) (-12 (|HasCategory| |#1| (QUOTE (-72))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|)))) (|HasCategory| $ (|%list| (QUOTE -318) (|devaluate| |#1|))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (QUOTE (-757))) (|HasCategory| $ (|%list| (QUOTE -1036) (|devaluate| |#1|))))) 
 (-1181 A B) 
 ((|constructor| (NIL "\\indented{2}{This package provides operations which all take as arguments} vectors of elements of some type \\spad{A} and functions from \\spad{A} to another of type \\spad{B}. The operations all iterate over their vector argument and either return a value of type \\spad{B} or a vector over \\spad{B}.")) (|map| (((|Union| (|Vector| |#2|) "failed") (|Mapping| (|Union| |#2| "failed") |#1|) (|Vector| |#1|)) "\\spad{map(f, v)} applies the function \\spad{f} to every element of the vector \\spad{v} producing a new vector containing the values or \\spad{\"failed\"}.") (((|Vector| |#2|) (|Mapping| |#2| |#1|) (|Vector| |#1|)) "\\spad{map(f, v)} applies the function \\spad{f} to every element of the vector \\spad{v} producing a new vector containing the values.")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|Vector| |#1|) |#2|) "\\spad{reduce(func,vec,ident)} combines the elements in \\spad{vec} using the binary function \\spad{func}. Argument \\spad{ident} is returned if \\spad{vec} is empty.")) (|scan| (((|Vector| |#2|) (|Mapping| |#2| |#1| |#2|) (|Vector| |#1|) |#2|) "\\spad{scan(func,vec,ident)} creates a new vector whose elements are the result of applying reduce to the binary function \\spad{func},{} increasing initial subsequences of the vector \\spad{vec},{} and the element \\spad{ident}."))) 
 NIL 
@@ -4788,4 +4788,4 @@ NIL
 NIL 
 NIL 
 NIL 
-((-3 NIL 1965734 1965739 1965744 1965749) (-2 NIL 1965714 1965719 1965724 1965729) (-1 NIL 1965694 1965699 1965704 1965709) (0 NIL 1965674 1965679 1965684 1965689) (-1210 "ZMOD.spad" 1965483 1965496 1965612 1965669) (-1209 "ZLINDEP.spad" 1964581 1964592 1965473 1965478) (-1208 "ZDSOLVE.spad" 1954542 1954564 1964571 1964576) (-1207 "YSTREAM.spad" 1954037 1954048 1954532 1954537) (-1206 "YDIAGRAM.spad" 1953671 1953680 1954027 1954032) (-1205 "XRPOLY.spad" 1952891 1952911 1953527 1953596) (-1204 "XPR.spad" 1950686 1950699 1952609 1952708) (-1203 "XPOLYC.spad" 1950005 1950021 1950612 1950681) (-1202 "XPOLY.spad" 1949560 1949571 1949861 1949930) (-1201 "XPBWPOLY.spad" 1948031 1948051 1949366 1949435) (-1200 "XFALG.spad" 1945079 1945095 1947957 1948026) (-1199 "XF.spad" 1943542 1943557 1944981 1945074) (-1198 "XF.spad" 1941985 1942002 1943426 1943431) (-1197 "XEXPPKG.spad" 1941244 1941270 1941975 1941980) (-1196 "XDPOLY.spad" 1940858 1940874 1941100 1941169) (-1195 "XALG.spad" 1940526 1940537 1940814 1940853) (-1194 "WUTSET.spad" 1936380 1936397 1940011 1940026) (-1193 "WP.spad" 1935587 1935631 1936238 1936305) (-1192 "WHILEAST.spad" 1935385 1935394 1935577 1935582) (-1191 "WHEREAST.spad" 1935056 1935065 1935375 1935380) (-1190 "WFFINTBS.spad" 1932719 1932741 1935046 1935051) (-1189 "WEIER.spad" 1930941 1930952 1932709 1932714) (-1188 "VSPACE.spad" 1930614 1930625 1930909 1930936) (-1187 "VSPACE.spad" 1930307 1930320 1930604 1930609) (-1186 "VOID.spad" 1929984 1929993 1930297 1930302) (-1185 "VIEWDEF.spad" 1925185 1925194 1929974 1929979) (-1184 "VIEW3D.spad" 1909146 1909155 1925175 1925180) (-1183 "VIEW2D.spad" 1897045 1897054 1909136 1909141) (-1182 "VIEW.spad" 1894765 1894774 1897035 1897040) (-1181 "VECTOR2.spad" 1893404 1893417 1894755 1894760) (-1180 "VECTOR.spad" 1891974 1891985 1892225 1892240) (-1179 "VECTCAT.spad" 1889898 1889909 1891954 1891969) (-1178 "VECTCAT.spad" 1887619 1887632 1889677 1889682) (-1177 "VARIABLE.spad" 1887399 1887414 1887609 1887614) (-1176 "UTYPE.spad" 1887043 1887052 1887389 1887394) (-1175 "UTSODETL.spad" 1886338 1886362 1886999 1887004) (-1174 "UTSODE.spad" 1884554 1884574 1886328 1886333) (-1173 "UTSCAT.spad" 1882033 1882049 1884452 1884549) (-1172 "UTSCAT.spad" 1879180 1879198 1881601 1881606) (-1171 "UTS2.spad" 1878775 1878810 1879170 1879175) (-1170 "UTS.spad" 1873787 1873815 1877307 1877404) (-1169 "URAGG.spad" 1868508 1868519 1873777 1873782) (-1168 "URAGG.spad" 1863193 1863206 1868464 1868469) (-1167 "UPXSSING.spad" 1860961 1860987 1862397 1862530) (-1166 "UPXSCONS.spad" 1858779 1858799 1859152 1859301) (-1165 "UPXSCCA.spad" 1857350 1857370 1858625 1858774) (-1164 "UPXSCCA.spad" 1856063 1856085 1857340 1857345) (-1163 "UPXSCAT.spad" 1854652 1854668 1855909 1856058) (-1162 "UPXS2.spad" 1854195 1854248 1854642 1854647) (-1161 "UPXS.spad" 1851550 1851578 1852386 1852535) (-1160 "UPSQFREE.spad" 1849965 1849979 1851540 1851545) (-1159 "UPSCAT.spad" 1847760 1847784 1849863 1849960) (-1158 "UPSCAT.spad" 1845256 1845282 1847361 1847366) (-1157 "UPOLYC2.spad" 1844727 1844746 1845246 1845251) (-1156 "UPOLYC.spad" 1839807 1839818 1844569 1844722) (-1155 "UPOLYC.spad" 1834805 1834818 1839569 1839574) (-1154 "UPMP.spad" 1833737 1833750 1834795 1834800) (-1153 "UPDIVP.spad" 1833302 1833316 1833727 1833732) (-1152 "UPDECOMP.spad" 1831563 1831577 1833292 1833297) (-1151 "UPCDEN.spad" 1830780 1830796 1831553 1831558) (-1150 "UP2.spad" 1830144 1830165 1830770 1830775) (-1149 "UP.spad" 1827614 1827629 1828001 1828154) (-1148 "UNISEG2.spad" 1827111 1827124 1827570 1827575) (-1147 "UNISEG.spad" 1826464 1826475 1827030 1827035) (-1146 "UNIFACT.spad" 1825567 1825579 1826454 1826459) (-1145 "ULSCONS.spad" 1819413 1819433 1819783 1819932) (-1144 "ULSCCAT.spad" 1817150 1817170 1819259 1819408) (-1143 "ULSCCAT.spad" 1814995 1815017 1817106 1817111) (-1142 "ULSCAT.spad" 1813235 1813251 1814841 1814990) (-1141 "ULS2.spad" 1812749 1812802 1813225 1813230) (-1140 "ULS.spad" 1804782 1804810 1805727 1806150) (-1139 "UINT8.spad" 1804659 1804668 1804772 1804777) (-1138 "UINT64.spad" 1804535 1804544 1804649 1804654) (-1137 "UINT32.spad" 1804411 1804420 1804525 1804530) (-1136 "UINT16.spad" 1804287 1804296 1804401 1804406) (-1135 "UFD.spad" 1803352 1803361 1804213 1804282) (-1134 "UFD.spad" 1802479 1802490 1803342 1803347) (-1133 "UDVO.spad" 1801360 1801369 1802469 1802474) (-1132 "UDPO.spad" 1798941 1798952 1801316 1801321) (-1131 "TYPEAST.spad" 1798860 1798869 1798931 1798936) (-1130 "TYPE.spad" 1798792 1798801 1798850 1798855) (-1129 "TWOFACT.spad" 1797444 1797459 1798782 1798787) (-1128 "TUPLE.spad" 1796951 1796962 1797356 1797361) (-1127 "TUBETOOL.spad" 1793818 1793827 1796941 1796946) (-1126 "TUBE.spad" 1792465 1792482 1793808 1793813) (-1125 "TSETCAT.spad" 1780548 1780565 1792445 1792460) (-1124 "TSETCAT.spad" 1768605 1768624 1780504 1780509) (-1123 "TS.spad" 1767233 1767249 1768199 1768296) (-1122 "TRMANIP.spad" 1761597 1761614 1766921 1766926) (-1121 "TRIMAT.spad" 1760560 1760585 1761587 1761592) (-1120 "TRIGMNIP.spad" 1759087 1759104 1760550 1760555) (-1119 "TRIGCAT.spad" 1758599 1758608 1759077 1759082) (-1118 "TRIGCAT.spad" 1758109 1758120 1758589 1758594) (-1117 "TREE.spad" 1756761 1756772 1757793 1757808) (-1116 "TRANFUN.spad" 1756600 1756609 1756751 1756756) (-1115 "TRANFUN.spad" 1756437 1756448 1756590 1756595) (-1114 "TOPSP.spad" 1756111 1756120 1756427 1756432) (-1113 "TOOLSIGN.spad" 1755774 1755785 1756101 1756106) (-1112 "TEXTFILE.spad" 1754335 1754344 1755764 1755769) (-1111 "TEX1.spad" 1753891 1753902 1754325 1754330) (-1110 "TEX.spad" 1751085 1751094 1753881 1753886) (-1109 "TBCMPPK.spad" 1749186 1749209 1751075 1751080) (-1108 "TBAGG.spad" 1748441 1748464 1749166 1749181) (-1107 "TBAGG.spad" 1747704 1747729 1748431 1748436) (-1106 "TANEXP.spad" 1747112 1747123 1747694 1747699) (-1105 "TALGOP.spad" 1746836 1746847 1747102 1747107) (-1104 "TABLEAU.spad" 1746317 1746328 1746826 1746831) (-1103 "TABLE.spad" 1744078 1744101 1744348 1744363) (-1102 "TABLBUMP.spad" 1740857 1740868 1744068 1744073) (-1101 "SYSTEM.spad" 1740085 1740094 1740847 1740852) (-1100 "SYSSOLP.spad" 1737568 1737579 1740075 1740080) (-1099 "SYSPTR.spad" 1737467 1737476 1737558 1737563) (-1098 "SYSNNI.spad" 1736690 1736701 1737457 1737462) (-1097 "SYSINT.spad" 1736094 1736105 1736680 1736685) (-1096 "SYNTAX.spad" 1732428 1732437 1736084 1736089) (-1095 "SYMTAB.spad" 1730496 1730505 1732418 1732423) (-1094 "SYMS.spad" 1726525 1726534 1730486 1730491) (-1093 "SYMPOLY.spad" 1725658 1725669 1725740 1725867) (-1092 "SYMFUNC.spad" 1725159 1725170 1725648 1725653) (-1091 "SYMBOL.spad" 1722654 1722663 1725149 1725154) (-1090 "SUTS.spad" 1719767 1719795 1721186 1721283) (-1089 "SUPXS.spad" 1717109 1717137 1717958 1718107) (-1088 "SUPFRACF.spad" 1716214 1716232 1717099 1717104) (-1087 "SUP2.spad" 1715606 1715619 1716204 1716209) (-1086 "SUP.spad" 1712690 1712701 1713463 1713616) (-1085 "SUMRF.spad" 1711664 1711675 1712680 1712685) (-1084 "SUMFS.spad" 1711293 1711310 1711654 1711659) (-1083 "SULS.spad" 1703313 1703341 1704271 1704694) (-1082 "syntax.spad" 1703082 1703091 1703303 1703308) (-1081 "SUCH.spad" 1702772 1702787 1703072 1703077) (-1080 "SUBSPACE.spad" 1694903 1694918 1702762 1702767) (-1079 "SUBRESP.spad" 1694073 1694087 1694859 1694864) (-1078 "STTFNC.spad" 1690541 1690557 1694063 1694068) (-1077 "STTF.spad" 1686640 1686656 1690531 1690536) (-1076 "STTAYLOR.spad" 1679317 1679328 1686547 1686552) (-1075 "STRTBL.spad" 1677241 1677258 1677390 1677405) (-1074 "STRING.spad" 1675998 1676007 1676383 1676398) (-1073 "STREAM3.spad" 1675571 1675586 1675988 1675993) (-1072 "STREAM2.spad" 1674699 1674712 1675561 1675566) (-1071 "STREAM1.spad" 1674405 1674416 1674689 1674694) (-1070 "STREAM.spad" 1671300 1671311 1673907 1673922) (-1069 "STINPROD.spad" 1670236 1670252 1671290 1671295) (-1068 "STEPAST.spad" 1669470 1669479 1670226 1670231) (-1067 "STEP.spad" 1668787 1668796 1669460 1669465) (-1066 "STBL.spad" 1666651 1666679 1666818 1666833) (-1065 "STAGG.spad" 1665350 1665361 1666641 1666646) (-1064 "STAGG.spad" 1664047 1664060 1665340 1665345) (-1063 "STACK.spad" 1663481 1663492 1663731 1663746) (-1062 "SRING.spad" 1663241 1663250 1663471 1663476) (-1061 "SREGSET.spad" 1660824 1660841 1662726 1662741) (-1060 "SRDCMPK.spad" 1659401 1659421 1660814 1660819) (-1059 "SRAGG.spad" 1654596 1654605 1659381 1659396) (-1058 "SRAGG.spad" 1649799 1649810 1654586 1654591) (-1057 "SQMATRIX.spad" 1647488 1647506 1648404 1648479) (-1056 "SPLTREE.spad" 1642242 1642255 1647038 1647053) (-1055 "SPLNODE.spad" 1638862 1638875 1642232 1642237) (-1054 "SPFCAT.spad" 1637671 1637680 1638852 1638857) (-1053 "SPECOUT.spad" 1636223 1636232 1637661 1637666) (-1052 "SPADXPT.spad" 1628314 1628323 1636213 1636218) (-1051 "spad-parser.spad" 1627779 1627788 1628304 1628309) (-1050 "SPADAST.spad" 1627480 1627489 1627769 1627774) (-1049 "SPACEC.spad" 1611695 1611706 1627470 1627475) (-1048 "SPACE3.spad" 1611471 1611482 1611685 1611690) (-1047 "SORTPAK.spad" 1611020 1611033 1611427 1611432) (-1046 "SOLVETRA.spad" 1608783 1608794 1611010 1611015) (-1045 "SOLVESER.spad" 1607239 1607250 1608773 1608778) (-1044 "SOLVERAD.spad" 1603265 1603276 1607229 1607234) (-1043 "SOLVEFOR.spad" 1601727 1601745 1603255 1603260) (-1042 "SNTSCAT.spad" 1601339 1601356 1601707 1601722) (-1041 "SMTS.spad" 1599656 1599682 1600933 1601030) (-1040 "SMP.spad" 1597464 1597484 1597854 1597981) (-1039 "SMITH.spad" 1596309 1596334 1597454 1597459) (-1038 "SMATCAT.spad" 1594439 1594469 1596265 1596304) (-1037 "SMATCAT.spad" 1592489 1592521 1594317 1594322) (-1036 "aggcat.spad" 1592165 1592176 1592469 1592484) (-1035 "SKAGG.spad" 1591146 1591157 1592145 1592160) (-1034 "SINT.spad" 1590445 1590454 1591012 1591141) (-1033 "SIMPAN.spad" 1590173 1590182 1590435 1590440) (-1032 "SIGNRF.spad" 1589298 1589309 1590163 1590168) (-1031 "SIGNEF.spad" 1588584 1588601 1589288 1589293) (-1030 "syntax.spad" 1588001 1588010 1588574 1588579) (-1029 "SIG.spad" 1587363 1587372 1587991 1587996) (-1028 "SHP.spad" 1585307 1585322 1587319 1587324) (-1027 "SHDP.spad" 1574711 1574738 1575228 1575313) (-1026 "SGROUP.spad" 1574319 1574328 1574701 1574706) (-1025 "SGROUP.spad" 1573925 1573936 1574309 1574314) (-1024 "catdef.spad" 1573635 1573647 1573746 1573920) (-1023 "catdef.spad" 1573191 1573203 1573456 1573630) (-1022 "SGCF.spad" 1566330 1566339 1573181 1573186) (-1021 "SFRTCAT.spad" 1565288 1565305 1566310 1566325) (-1020 "SFRGCD.spad" 1564351 1564371 1565278 1565283) (-1019 "SFQCMPK.spad" 1559164 1559184 1564341 1564346) (-1018 "SEXOF.spad" 1559007 1559047 1559154 1559159) (-1017 "SEXCAT.spad" 1556835 1556875 1558997 1559002) (-1016 "SEX.spad" 1556727 1556736 1556825 1556830) (-1015 "SETMN.spad" 1555187 1555204 1556717 1556722) (-1014 "SETCAT.spad" 1554672 1554681 1555177 1555182) (-1013 "SETCAT.spad" 1554155 1554166 1554662 1554667) (-1012 "SETAGG.spad" 1550704 1550715 1554135 1554150) (-1011 "SETAGG.spad" 1547261 1547274 1550694 1550699) (-1010 "SET.spad" 1545419 1545430 1546518 1546545) (-1009 "syntax.spad" 1545122 1545131 1545409 1545414) (-1008 "SEGXCAT.spad" 1544278 1544291 1545112 1545117) (-1007 "SEGCAT.spad" 1543203 1543214 1544268 1544273) (-1006 "SEGBIND2.spad" 1542901 1542914 1543193 1543198) (-1005 "SEGBIND.spad" 1542659 1542670 1542848 1542853) (-1004 "SEGAST.spad" 1542389 1542398 1542649 1542654) (-1003 "SEG2.spad" 1541824 1541837 1542345 1542350) (-1002 "SEG.spad" 1541637 1541648 1541743 1541748) (-1001 "SDVAR.spad" 1540913 1540924 1541627 1541632) (-1000 "SDPOL.spad" 1538605 1538616 1538896 1539023) (-999 "SCPKG.spad" 1536695 1536705 1538595 1538600) (-998 "SCOPE.spad" 1535873 1535881 1536685 1536690) (-997 "SCACHE.spad" 1534570 1534580 1535863 1535868) (-996 "SASTCAT.spad" 1534480 1534488 1534560 1534565) (-995 "SAOS.spad" 1534353 1534361 1534470 1534475) (-994 "SAERFFC.spad" 1534067 1534086 1534343 1534348) (-993 "SAEFACT.spad" 1533769 1533788 1534057 1534062) (-992 "SAE.spad" 1531420 1531435 1532030 1532165) (-991 "RURPK.spad" 1529080 1529095 1531410 1531415) (-990 "RULESET.spad" 1528534 1528557 1529070 1529075) (-989 "RULECOLD.spad" 1528387 1528399 1528524 1528529) (-988 "RULE.spad" 1526636 1526659 1528377 1528382) (-987 "RTVALUE.spad" 1526372 1526380 1526626 1526631) (-986 "syntax.spad" 1526090 1526098 1526362 1526367) (-985 "RSETGCD.spad" 1522533 1522552 1526080 1526085) (-984 "RSETCAT.spad" 1512514 1512530 1522513 1522528) (-983 "RSETCAT.spad" 1502503 1502521 1512504 1512509) (-982 "RSDCMPK.spad" 1501004 1501023 1502493 1502498) (-981 "RRCC.spad" 1499389 1499418 1500994 1500999) (-980 "RRCC.spad" 1497772 1497803 1499379 1499384) (-979 "RPTAST.spad" 1497475 1497483 1497762 1497767) (-978 "RPOLCAT.spad" 1476980 1476994 1497343 1497470) (-977 "RPOLCAT.spad" 1456278 1456294 1476643 1476648) (-976 "ROMAN.spad" 1455607 1455615 1456144 1456273) (-975 "ROIRC.spad" 1454688 1454719 1455597 1455602) (-974 "RNS.spad" 1453665 1453673 1454590 1454683) (-973 "RNS.spad" 1452728 1452738 1453655 1453660) (-972 "RNGBIND.spad" 1451889 1451902 1452683 1452688) (-971 "RNG.spad" 1451498 1451506 1451879 1451884) (-970 "RNG.spad" 1451105 1451115 1451488 1451493) (-969 "RMODULE.spad" 1450887 1450897 1451095 1451100) (-968 "RMCAT2.spad" 1450308 1450364 1450877 1450882) (-967 "RMATRIX.spad" 1449130 1449148 1449472 1449499) (-966 "RMATCAT.spad" 1444780 1444810 1449098 1449125) (-965 "RMATCAT.spad" 1440308 1440340 1444628 1444633) (-964 "RLINSET.spad" 1440013 1440023 1440298 1440303) (-963 "RINTERP.spad" 1439902 1439921 1440003 1440008) (-962 "RING.spad" 1439373 1439381 1439882 1439897) (-961 "RING.spad" 1438852 1438862 1439363 1439368) (-960 "RIDIST.spad" 1438245 1438253 1438842 1438847) (-959 "RGCHAIN.spad" 1436502 1436517 1437395 1437410) (-958 "RGBCSPC.spad" 1436292 1436303 1436492 1436497) (-957 "RGBCMDL.spad" 1435855 1435866 1436282 1436287) (-956 "RFFACTOR.spad" 1435318 1435328 1435845 1435850) (-955 "RFFACT.spad" 1435054 1435065 1435308 1435313) (-954 "RFDIST.spad" 1434051 1434059 1435044 1435049) (-953 "RF.spad" 1431726 1431736 1434041 1434046) (-952 "RETSOL.spad" 1431146 1431158 1431716 1431721) (-951 "RETRACT.spad" 1430575 1430585 1431136 1431141) (-950 "RETRACT.spad" 1430002 1430014 1430565 1430570) (-949 "RETAST.spad" 1429815 1429823 1429992 1429997) (-948 "RESRING.spad" 1429163 1429209 1429753 1429810) (-947 "RESLATC.spad" 1428488 1428498 1429153 1429158) (-946 "REPSQ.spad" 1428220 1428230 1428478 1428483) (-945 "REPDB.spad" 1427928 1427938 1428210 1428215) (-944 "REP2.spad" 1417643 1417653 1427770 1427775) (-943 "REP1.spad" 1411864 1411874 1417593 1417598) (-942 "REP.spad" 1409419 1409427 1411854 1411859) (-941 "REGSET.spad" 1407096 1407112 1408904 1408919) (-940 "REF.spad" 1406615 1406625 1407086 1407091) (-939 "REDORDER.spad" 1405822 1405838 1406605 1406610) (-938 "RECLOS.spad" 1404719 1404738 1405422 1405515) (-937 "REALSOLV.spad" 1403860 1403868 1404709 1404714) (-936 "REAL0Q.spad" 1401159 1401173 1403850 1403855) (-935 "REAL0.spad" 1398004 1398018 1401149 1401154) (-934 "REAL.spad" 1397877 1397885 1397994 1397999) (-933 "RDUCEAST.spad" 1397599 1397607 1397867 1397872) (-932 "RDIV.spad" 1397255 1397279 1397589 1397594) (-931 "RDIST.spad" 1396823 1396833 1397245 1397250) (-930 "RDETRS.spad" 1395688 1395705 1396813 1396818) (-929 "RDETR.spad" 1393828 1393845 1395678 1395683) (-928 "RDEEFS.spad" 1392928 1392944 1393818 1393823) (-927 "RDEEF.spad" 1391939 1391955 1392918 1392923) (-926 "RCFIELD.spad" 1389158 1389166 1391841 1391934) (-925 "RCFIELD.spad" 1386463 1386473 1389148 1389153) (-924 "RCAGG.spad" 1384400 1384410 1386453 1386458) (-923 "RCAGG.spad" 1382266 1382278 1384321 1384326) (-922 "RATRET.spad" 1381627 1381637 1382256 1382261) (-921 "RATFACT.spad" 1381320 1381331 1381617 1381622) (-920 "RANDSRC.spad" 1380640 1380648 1381310 1381315) (-919 "RADUTIL.spad" 1380397 1380405 1380630 1380635) (-918 "RADIX.spad" 1377442 1377455 1378987 1379080) (-917 "RADFF.spad" 1375359 1375395 1375477 1375633) (-916 "RADCAT.spad" 1374955 1374963 1375349 1375354) (-915 "RADCAT.spad" 1374549 1374559 1374945 1374950) (-914 "QUEUE.spad" 1373975 1373985 1374233 1374248) (-913 "QUATCT2.spad" 1373596 1373614 1373965 1373970) (-912 "QUATCAT.spad" 1371767 1371777 1373526 1373591) (-911 "QUATCAT.spad" 1369703 1369715 1371464 1371469) (-910 "QUAT.spad" 1368310 1368320 1368652 1368717) (-909 "QUAGG.spad" 1367156 1367166 1368290 1368305) (-908 "QQUTAST.spad" 1366925 1366933 1367146 1367151) (-907 "QFORM.spad" 1366544 1366558 1366915 1366920) (-906 "QFCAT2.spad" 1366237 1366253 1366534 1366539) (-905 "QFCAT.spad" 1364940 1364950 1366139 1366232) (-904 "QFCAT.spad" 1363276 1363288 1364477 1364482) (-903 "QEQUAT.spad" 1362835 1362843 1363266 1363271) (-902 "QCMPACK.spad" 1357750 1357769 1362825 1362830) (-901 "QALGSET2.spad" 1355746 1355764 1357740 1357745) (-900 "QALGSET.spad" 1351851 1351883 1355660 1355665) (-899 "PWFFINTB.spad" 1349267 1349288 1351841 1351846) (-898 "PUSHVAR.spad" 1348606 1348625 1349257 1349262) (-897 "PTRANFN.spad" 1344742 1344752 1348596 1348601) (-896 "PTPACK.spad" 1341830 1341840 1344732 1344737) (-895 "PTFUNC2.spad" 1341653 1341667 1341820 1341825) (-894 "PTCAT.spad" 1340920 1340930 1341633 1341648) (-893 "PSQFR.spad" 1340235 1340259 1340910 1340915) (-892 "PSEUDLIN.spad" 1339121 1339131 1340225 1340230) (-891 "PSETPK.spad" 1325826 1325842 1338999 1339004) (-890 "PSETCAT.spad" 1320236 1320259 1325816 1325821) (-889 "PSETCAT.spad" 1314610 1314635 1320192 1320197) (-888 "PSCURVE.spad" 1313609 1313617 1314600 1314605) (-887 "PSCAT.spad" 1312392 1312421 1313507 1313604) (-886 "PSCAT.spad" 1311265 1311296 1312382 1312387) (-885 "PRTITION.spad" 1309963 1309971 1311255 1311260) (-884 "PRTDAST.spad" 1309682 1309690 1309953 1309958) (-883 "PRS.spad" 1299300 1299317 1309638 1309643) (-882 "PRQAGG.spad" 1298747 1298757 1299280 1299295) (-881 "PROPLOG.spad" 1298351 1298359 1298737 1298742) (-880 "PROPFUN2.spad" 1297974 1297987 1298341 1298346) (-879 "PROPFUN1.spad" 1297380 1297391 1297964 1297969) (-878 "PROPFRML.spad" 1295948 1295959 1297370 1297375) (-877 "PROPERTY.spad" 1295444 1295452 1295938 1295943) (-876 "PRODUCT.spad" 1293141 1293153 1293425 1293480) (-875 "PRINT.spad" 1292893 1292901 1293131 1293136) (-874 "PRIMES.spad" 1291154 1291164 1292883 1292888) (-873 "PRIMELT.spad" 1289275 1289289 1291144 1291149) (-872 "PRIMCAT.spad" 1288918 1288926 1289265 1289270) (-871 "PRIMARR2.spad" 1287685 1287697 1288908 1288913) (-870 "PRIMARR.spad" 1286591 1286601 1286761 1286776) (-869 "PREASSOC.spad" 1285973 1285985 1286581 1286586) (-868 "PR.spad" 1284491 1284503 1285190 1285317) (-867 "PPCURVE.spad" 1283628 1283636 1284481 1284486) (-866 "PORTNUM.spad" 1283419 1283427 1283618 1283623) (-865 "POLYROOT.spad" 1282268 1282290 1283375 1283380) (-864 "POLYLIFT.spad" 1281533 1281556 1282258 1282263) (-863 "POLYCATQ.spad" 1279659 1279681 1281523 1281528) (-862 "POLYCAT.spad" 1273161 1273182 1279527 1279654) (-861 "POLYCAT.spad" 1266183 1266206 1272551 1272556) (-860 "POLY2UP.spad" 1265635 1265649 1266173 1266178) (-859 "POLY2.spad" 1265232 1265244 1265625 1265630) (-858 "POLY.spad" 1262900 1262910 1263415 1263542) (-857 "POLUTIL.spad" 1261865 1261894 1262856 1262861) (-856 "POLTOPOL.spad" 1260613 1260628 1261855 1261860) (-855 "POINT.spad" 1259347 1259357 1259434 1259449) (-854 "PNTHEORY.spad" 1256049 1256057 1259337 1259342) (-853 "PMTOOLS.spad" 1254824 1254838 1256039 1256044) (-852 "PMSYM.spad" 1254373 1254383 1254814 1254819) (-851 "PMQFCAT.spad" 1253964 1253978 1254363 1254368) (-850 "PMPREDFS.spad" 1253426 1253448 1253954 1253959) (-849 "PMPRED.spad" 1252913 1252927 1253416 1253421) (-848 "PMPLCAT.spad" 1251990 1252008 1252842 1252847) (-847 "PMLSAGG.spad" 1251575 1251589 1251980 1251985) (-846 "PMKERNEL.spad" 1251154 1251166 1251565 1251570) (-845 "PMINS.spad" 1250734 1250744 1251144 1251149) (-844 "PMFS.spad" 1250311 1250329 1250724 1250729) (-843 "PMDOWN.spad" 1249601 1249615 1250301 1250306) (-842 "PMASSFS.spad" 1248576 1248592 1249591 1249596) (-841 "PMASS.spad" 1247594 1247602 1248566 1248571) (-840 "PLOTTOOL.spad" 1247374 1247382 1247584 1247589) (-839 "PLOT3D.spad" 1243838 1243846 1247364 1247369) (-838 "PLOT1.spad" 1243011 1243021 1243828 1243833) (-837 "PLOT.spad" 1237934 1237942 1243001 1243006) (-836 "PLEQN.spad" 1225336 1225363 1237924 1237929) (-835 "PINTERPA.spad" 1225120 1225136 1225326 1225331) (-834 "PINTERP.spad" 1224742 1224761 1225110 1225115) (-833 "PID.spad" 1223716 1223724 1224668 1224737) (-832 "PICOERCE.spad" 1223373 1223383 1223706 1223711) (-831 "PI.spad" 1222990 1222998 1223347 1223368) (-830 "PGROEB.spad" 1221599 1221613 1222980 1222985) (-829 "PGE.spad" 1213272 1213280 1221589 1221594) (-828 "PGCD.spad" 1212226 1212243 1213262 1213267) (-827 "PFRPAC.spad" 1211375 1211385 1212216 1212221) (-826 "PFR.spad" 1208078 1208088 1211277 1211370) (-825 "PFOTOOLS.spad" 1207336 1207352 1208068 1208073) (-824 "PFOQ.spad" 1206706 1206724 1207326 1207331) (-823 "PFO.spad" 1206125 1206152 1206696 1206701) (-822 "PFECAT.spad" 1203835 1203843 1206051 1206120) (-821 "PFECAT.spad" 1201573 1201583 1203791 1203796) (-820 "PFBRU.spad" 1199461 1199473 1201563 1201568) (-819 "PFBR.spad" 1197021 1197044 1199451 1199456) (-818 "PF.spad" 1196595 1196607 1196826 1196919) (-817 "PERMGRP.spad" 1191365 1191375 1196585 1196590) (-816 "PERMCAT.spad" 1190026 1190036 1191345 1191360) (-815 "PERMAN.spad" 1188582 1188596 1190016 1190021) (-814 "PERM.spad" 1184392 1184402 1188415 1188430) (-813 "PENDTREE.spad" 1183806 1183816 1184086 1184091) (-812 "PDSPC.spad" 1182619 1182629 1183796 1183801) (-811 "PDSPC.spad" 1181430 1181442 1182609 1182614) (-810 "PDRING.spad" 1181272 1181282 1181410 1181425) (-809 "PDMOD.spad" 1181088 1181100 1181240 1181267) (-808 "PDECOMP.spad" 1180558 1180575 1181078 1181083) (-807 "PDDOM.spad" 1179996 1180009 1180548 1180553) (-806 "PDDOM.spad" 1179432 1179447 1179986 1179991) (-805 "PCOMP.spad" 1179285 1179298 1179422 1179427) (-804 "PBWLB.spad" 1177883 1177900 1179275 1179280) (-803 "PATTERN2.spad" 1177621 1177633 1177873 1177878) (-802 "PATTERN1.spad" 1175965 1175981 1177611 1177616) (-801 "PATTERN.spad" 1170540 1170550 1175955 1175960) (-800 "PATRES2.spad" 1170212 1170226 1170530 1170535) (-799 "PATRES.spad" 1167795 1167807 1170202 1170207) (-798 "PATMATCH.spad" 1166036 1166067 1167547 1167552) (-797 "PATMAB.spad" 1165465 1165475 1166026 1166031) (-796 "PATLRES.spad" 1164551 1164565 1165455 1165460) (-795 "PATAB.spad" 1164315 1164325 1164541 1164546) (-794 "PARTPERM.spad" 1162371 1162379 1164305 1164310) (-793 "PARSURF.spad" 1161805 1161833 1162361 1162366) (-792 "PARSU2.spad" 1161602 1161618 1161795 1161800) (-791 "script-parser.spad" 1161122 1161130 1161592 1161597) (-790 "PARSCURV.spad" 1160556 1160584 1161112 1161117) (-789 "PARSC2.spad" 1160347 1160363 1160546 1160551) (-788 "PARPCURV.spad" 1159809 1159837 1160337 1160342) (-787 "PARPC2.spad" 1159600 1159616 1159799 1159804) (-786 "PARAMAST.spad" 1158728 1158736 1159590 1159595) (-785 "PAN2EXPR.spad" 1158140 1158148 1158718 1158723) (-784 "PALETTE.spad" 1157254 1157262 1158130 1158135) (-783 "PAIR.spad" 1156328 1156341 1156897 1156902) (-782 "PADICRC.spad" 1153733 1153751 1154896 1154989) (-781 "PADICRAT.spad" 1151793 1151805 1152006 1152099) (-780 "PADICCT.spad" 1150342 1150354 1151719 1151788) (-779 "PADIC.spad" 1150045 1150057 1150268 1150337) (-778 "PADEPAC.spad" 1148734 1148753 1150035 1150040) (-777 "PADE.spad" 1147486 1147502 1148724 1148729) (-776 "OWP.spad" 1146734 1146764 1147344 1147411) (-775 "OVERSET.spad" 1146307 1146315 1146724 1146729) (-774 "OVAR.spad" 1146088 1146111 1146297 1146302) (-773 "OUTFORM.spad" 1135496 1135504 1146078 1146083) (-772 "OUTBFILE.spad" 1134930 1134938 1135486 1135491) (-771 "OUTBCON.spad" 1134000 1134008 1134920 1134925) (-770 "OUTBCON.spad" 1133068 1133078 1133990 1133995) (-769 "OUT.spad" 1132186 1132194 1133058 1133063) (-768 "OSI.spad" 1131661 1131669 1132176 1132181) (-767 "OSGROUP.spad" 1131579 1131587 1131651 1131656) (-766 "ORTHPOL.spad" 1130090 1130100 1131522 1131527) (-765 "OREUP.spad" 1129584 1129612 1129811 1129850) (-764 "ORESUP.spad" 1128926 1128950 1129305 1129344) (-763 "OREPCTO.spad" 1126815 1126827 1128846 1128851) (-762 "OREPCAT.spad" 1121002 1121012 1126771 1126810) (-761 "OREPCAT.spad" 1115079 1115091 1120850 1120855) (-760 "ORDTYPE.spad" 1114316 1114324 1115069 1115074) (-759 "ORDTYPE.spad" 1113551 1113561 1114306 1114311) (-758 "ORDSTRCT.spad" 1113337 1113352 1113500 1113505) (-757 "ORDSET.spad" 1113037 1113045 1113327 1113332) (-756 "ORDRING.spad" 1112854 1112862 1113017 1113032) (-755 "ORDMON.spad" 1112709 1112717 1112844 1112849) (-754 "ORDFUNS.spad" 1111841 1111857 1112699 1112704) (-753 "ORDFIN.spad" 1111661 1111669 1111831 1111836) (-752 "ORDCOMP2.spad" 1110954 1110966 1111651 1111656) (-751 "ORDCOMP.spad" 1109480 1109490 1110562 1110591) (-750 "OPSIG.spad" 1109142 1109150 1109470 1109475) (-749 "OPQUERY.spad" 1108723 1108731 1109132 1109137) (-748 "OPERCAT.spad" 1108189 1108199 1108713 1108718) (-747 "OPERCAT.spad" 1107653 1107665 1108179 1108184) (-746 "OP.spad" 1107395 1107405 1107475 1107542) (-745 "ONECOMP2.spad" 1106819 1106831 1107385 1107390) (-744 "ONECOMP.spad" 1105625 1105635 1106427 1106456) (-743 "OMSAGG.spad" 1105425 1105435 1105593 1105620) (-742 "OMLO.spad" 1104858 1104870 1105311 1105350) (-741 "OINTDOM.spad" 1104621 1104629 1104784 1104853) (-740 "OFMONOID.spad" 1102760 1102770 1104577 1104582) (-739 "ODVAR.spad" 1102021 1102031 1102750 1102755) (-738 "ODR.spad" 1101665 1101691 1101833 1101982) (-737 "ODPOL.spad" 1099313 1099323 1099653 1099780) (-736 "ODP.spad" 1088861 1088881 1089234 1089319) (-735 "ODETOOLS.spad" 1087510 1087529 1088851 1088856) (-734 "ODESYS.spad" 1085204 1085221 1087500 1087505) (-733 "ODERTRIC.spad" 1081237 1081254 1085161 1085166) (-732 "ODERED.spad" 1080636 1080660 1081227 1081232) (-731 "ODERAT.spad" 1078269 1078286 1080626 1080631) (-730 "ODEPRRIC.spad" 1075362 1075384 1078259 1078264) (-729 "ODEPRIM.spad" 1072760 1072782 1075352 1075357) (-728 "ODEPAL.spad" 1072146 1072170 1072750 1072755) (-727 "ODEINT.spad" 1071581 1071597 1072136 1072141) (-726 "ODEEF.spad" 1067076 1067092 1071571 1071576) (-725 "ODECONST.spad" 1066621 1066639 1067066 1067071) (-724 "OCTCT2.spad" 1066262 1066280 1066611 1066616) (-723 "OCT.spad" 1064577 1064587 1065291 1065330) (-722 "OCAMON.spad" 1064425 1064433 1064567 1064572) (-721 "OC.spad" 1062221 1062231 1064381 1064420) (-720 "OC.spad" 1059756 1059768 1061918 1061923) (-719 "OASGP.spad" 1059571 1059579 1059746 1059751) (-718 "OAMONS.spad" 1059093 1059101 1059561 1059566) (-717 "OAMON.spad" 1058851 1058859 1059083 1059088) (-716 "OAMON.spad" 1058607 1058617 1058841 1058846) (-715 "OAGROUP.spad" 1058145 1058153 1058597 1058602) (-714 "OAGROUP.spad" 1057681 1057691 1058135 1058140) (-713 "NUMTUBE.spad" 1057272 1057288 1057671 1057676) (-712 "NUMQUAD.spad" 1045248 1045256 1057262 1057267) (-711 "NUMODE.spad" 1036600 1036608 1045238 1045243) (-710 "NUMFMT.spad" 1035440 1035448 1036590 1036595) (-709 "NUMERIC.spad" 1027555 1027565 1035246 1035251) (-708 "NTSCAT.spad" 1026075 1026091 1027535 1027550) (-707 "NTPOLFN.spad" 1025652 1025662 1026018 1026023) (-706 "NSUP2.spad" 1025044 1025056 1025642 1025647) (-705 "NSUP.spad" 1018481 1018491 1022901 1023054) (-704 "NSMP.spad" 1015393 1015412 1015685 1015812) (-703 "NREP.spad" 1013795 1013809 1015383 1015388) (-702 "NPCOEF.spad" 1013041 1013061 1013785 1013790) (-701 "NORMRETR.spad" 1012639 1012678 1013031 1013036) (-700 "NORMPK.spad" 1010581 1010600 1012629 1012634) (-699 "NORMMA.spad" 1010269 1010295 1010571 1010576) (-698 "NONE1.spad" 1009945 1009955 1010259 1010264) (-697 "NONE.spad" 1009686 1009694 1009935 1009940) (-696 "NODE1.spad" 1009173 1009189 1009676 1009681) (-695 "NNI.spad" 1008068 1008076 1009147 1009168) (-694 "NLINSOL.spad" 1006694 1006704 1008058 1008063) (-693 "NFINTBAS.spad" 1004254 1004271 1006684 1006689) (-692 "NETCLT.spad" 1004228 1004239 1004244 1004249) (-691 "NCODIV.spad" 1002452 1002468 1004218 1004223) (-690 "NCNTFRAC.spad" 1002094 1002108 1002442 1002447) (-689 "NCEP.spad" 1000260 1000274 1002084 1002089) (-688 "NASRING.spad" 999864 999872 1000250 1000255) (-687 "NASRING.spad" 999466 999476 999854 999859) (-686 "NARNG.spad" 998866 998874 999456 999461) (-685 "NARNG.spad" 998264 998274 998856 998861) (-684 "NAALG.spad" 997829 997839 998232 998259) (-683 "NAALG.spad" 997414 997426 997819 997824) (-682 "MULTSQFR.spad" 994372 994389 997404 997409) (-681 "MULTFACT.spad" 993755 993772 994362 994367) (-680 "MTSCAT.spad" 991849 991870 993653 993750) (-679 "MTHING.spad" 991508 991518 991839 991844) (-678 "MSYSCMD.spad" 990942 990950 991498 991503) (-677 "MSETAGG.spad" 990787 990797 990910 990937) (-676 "MSET.spad" 988585 988595 990332 990359) (-675 "MRING.spad" 985562 985574 988293 988360) (-674 "MRF2.spad" 985124 985138 985552 985557) (-673 "MRATFAC.spad" 984670 984687 985114 985119) (-672 "MPRFF.spad" 982710 982729 984660 984665) (-671 "MPOLY.spad" 980514 980529 980873 981000) (-670 "MPCPF.spad" 979778 979797 980504 980509) (-669 "MPC3.spad" 979595 979635 979768 979773) (-668 "MPC2.spad" 979249 979282 979585 979590) (-667 "MONOTOOL.spad" 977600 977617 979239 979244) (-666 "catdef.spad" 977033 977044 977254 977595) (-665 "catdef.spad" 976431 976442 976687 977028) (-664 "MONOID.spad" 975752 975760 976421 976426) (-663 "MONOID.spad" 975071 975081 975742 975747) (-662 "MONOGEN.spad" 973819 973832 974931 975066) (-661 "MONOGEN.spad" 972589 972604 973703 973708) (-660 "MONADWU.spad" 970669 970677 972579 972584) (-659 "MONADWU.spad" 968747 968757 970659 970664) (-658 "MONAD.spad" 967907 967915 968737 968742) (-657 "MONAD.spad" 967065 967075 967897 967902) (-656 "MOEBIUS.spad" 965801 965815 967045 967060) (-655 "MODULE.spad" 965671 965681 965769 965796) (-654 "MODULE.spad" 965561 965573 965661 965666) (-653 "MODRING.spad" 964896 964935 965541 965556) (-652 "MODOP.spad" 963553 963565 964718 964785) (-651 "MODMONOM.spad" 963284 963302 963543 963548) (-650 "MODMON.spad" 960354 960366 961069 961222) (-649 "MODFIELD.spad" 959716 959755 960256 960349) (-648 "MMLFORM.spad" 958576 958584 959706 959711) (-647 "MMAP.spad" 958318 958352 958566 958571) (-646 "MLO.spad" 956777 956787 958274 958313) (-645 "MLIFT.spad" 955389 955406 956767 956772) (-644 "MKUCFUNC.spad" 954924 954942 955379 955384) (-643 "MKRECORD.spad" 954512 954525 954914 954919) (-642 "MKFUNC.spad" 953919 953929 954502 954507) (-641 "MKFLCFN.spad" 952887 952897 953909 953914) (-640 "MKBCFUNC.spad" 952382 952400 952877 952882) (-639 "MHROWRED.spad" 950893 950903 952372 952377) (-638 "MFINFACT.spad" 950293 950315 950883 950888) (-637 "MESH.spad" 948088 948096 950283 950288) (-636 "MDDFACT.spad" 946307 946317 948078 948083) (-635 "MDAGG.spad" 945598 945608 946287 946302) (-634 "MCDEN.spad" 944808 944820 945588 945593) (-633 "MAYBE.spad" 944108 944119 944798 944803) (-632 "MATSTOR.spad" 941424 941434 944098 944103) (-631 "MATRIX.spad" 940215 940225 940699 940714) (-630 "MATLIN.spad" 937583 937607 940099 940104) (-629 "MATCAT2.spad" 936865 936913 937573 937578) (-628 "MATCAT.spad" 928573 928595 936845 936860) (-627 "MATCAT.spad" 920141 920165 928415 928420) (-626 "MAPPKG3.spad" 919056 919070 920131 920136) (-625 "MAPPKG2.spad" 918394 918406 919046 919051) (-624 "MAPPKG1.spad" 917222 917232 918384 918389) (-623 "MAPPAST.spad" 916561 916569 917212 917217) (-622 "MAPHACK3.spad" 916373 916387 916551 916556) (-621 "MAPHACK2.spad" 916142 916154 916363 916368) (-620 "MAPHACK1.spad" 915786 915796 916132 916137) (-619 "MAGMA.spad" 913592 913609 915776 915781) (-618 "MACROAST.spad" 913187 913195 913582 913587) (-617 "LZSTAGG.spad" 910441 910451 913177 913182) (-616 "LZSTAGG.spad" 907693 907705 910431 910436) (-615 "LWORD.spad" 904438 904455 907683 907688) (-614 "LSTAST.spad" 904222 904230 904428 904433) (-613 "LSQM.spad" 902512 902526 902906 902945) (-612 "LSPP.spad" 902047 902064 902502 902507) (-611 "LSMP1.spad" 899890 899904 902037 902042) (-610 "LSMP.spad" 898747 898775 899880 899885) (-609 "LSAGG.spad" 898428 898438 898727 898742) (-608 "LSAGG.spad" 898117 898129 898418 898423) (-607 "LPOLY.spad" 897079 897098 897973 898042) (-606 "LPEFRAC.spad" 896350 896360 897069 897074) (-605 "LOGIC.spad" 895952 895960 896340 896345) (-604 "LOGIC.spad" 895552 895562 895942 895947) (-603 "LODOOPS.spad" 894482 894494 895542 895547) (-602 "LODOF.spad" 893528 893545 894439 894444) (-601 "LODOCAT.spad" 892194 892204 893484 893523) (-600 "LODOCAT.spad" 890858 890870 892150 892155) (-599 "LODO2.spad" 890172 890184 890579 890618) (-598 "LODO1.spad" 889613 889623 889893 889932) (-597 "LODO.spad" 889038 889054 889334 889373) (-596 "LODEEF.spad" 887840 887858 889028 889033) (-595 "LO.spad" 887241 887255 887774 887801) (-594 "LNAGG.spad" 883428 883438 887231 887236) (-593 "LNAGG.spad" 879579 879591 883384 883389) (-592 "LMOPS.spad" 876347 876364 879569 879574) (-591 "LMODULE.spad" 876131 876141 876337 876342) (-590 "LMDICT.spad" 875363 875373 875611 875626) (-589 "LLINSET.spad" 875070 875080 875353 875358) (-588 "LITERAL.spad" 874976 874987 875060 875065) (-587 "LIST3.spad" 874287 874301 874966 874971) (-586 "LIST2MAP.spad" 871214 871226 874277 874282) (-585 "LIST2.spad" 869916 869928 871204 871209) (-584 "LIST.spad" 867649 867659 868992 869007) (-583 "LINSET.spad" 867428 867438 867639 867644) (-582 "LINFORM.spad" 866891 866903 867396 867423) (-581 "LINEXP.spad" 865634 865644 866881 866886) (-580 "LINELT.spad" 865005 865017 865517 865544) (-579 "LINDEP.spad" 863854 863866 864917 864922) (-578 "LINBASIS.spad" 863490 863505 863844 863849) (-577 "LIMITRF.spad" 861437 861447 863480 863485) (-576 "LIMITPS.spad" 860347 860360 861427 861432) (-575 "LIECAT.spad" 859831 859841 860273 860342) (-574 "LIECAT.spad" 859343 859355 859787 859792) (-573 "LIE.spad" 857347 857359 858621 858763) (-572 "LIB.spad" 855200 855208 855646 855661) (-571 "LGROBP.spad" 852553 852572 855190 855195) (-570 "LFCAT.spad" 851612 851620 852543 852548) (-569 "LF.spad" 850567 850583 851602 851607) (-568 "LEXTRIPK.spad" 846190 846205 850557 850562) (-567 "LEXP.spad" 844209 844236 846170 846185) (-566 "LETAST.spad" 843908 843916 844199 844204) (-565 "LEADCDET.spad" 842314 842331 843898 843903) (-564 "LAZM3PK.spad" 841058 841080 842304 842309) (-563 "LAUPOL.spad" 839725 839738 840625 840694) (-562 "LAPLACE.spad" 839308 839324 839715 839720) (-561 "LALG.spad" 839084 839094 839288 839303) (-560 "LALG.spad" 838868 838880 839074 839079) (-559 "LA.spad" 838308 838322 838790 838829) (-558 "KVTFROM.spad" 838051 838061 838298 838303) (-557 "KTVLOGIC.spad" 837595 837603 838041 838046) (-556 "KRCFROM.spad" 837341 837351 837585 837590) (-555 "KOVACIC.spad" 836072 836089 837331 837336) (-554 "KONVERT.spad" 835794 835804 836062 836067) (-553 "KOERCE.spad" 835531 835541 835784 835789) (-552 "KERNEL2.spad" 835234 835246 835521 835526) (-551 "KERNEL.spad" 833954 833964 835083 835088) (-550 "KDAGG.spad" 833063 833085 833934 833949) (-549 "KDAGG.spad" 832180 832204 833053 833058) (-548 "KAFILE.spad" 830607 830623 830842 830857) (-547 "JVMOP.spad" 830520 830528 830597 830602) (-546 "JVMMDACC.spad" 829574 829582 830510 830515) (-545 "JVMFDACC.spad" 828890 828898 829564 829569) (-544 "JVMCSTTG.spad" 827619 827627 828880 828885) (-543 "JVMCFACC.spad" 827065 827073 827609 827614) (-542 "JVMBCODE.spad" 826976 826984 827055 827060) (-541 "JORDAN.spad" 824793 824805 826254 826396) (-540 "JOINAST.spad" 824495 824503 824783 824788) (-539 "IXAGG.spad" 822628 822652 824485 824490) (-538 "IXAGG.spad" 820591 820617 822450 822455) (-537 "ITUPLE.spad" 819767 819777 820581 820586) (-536 "ITRIGMNP.spad" 818614 818633 819757 819762) (-535 "ITFUN3.spad" 818120 818134 818604 818609) (-534 "ITFUN2.spad" 817864 817876 818110 818115) (-533 "ITFORM.spad" 817219 817227 817854 817859) (-532 "ITAYLOR.spad" 815213 815228 817083 817180) (-531 "ISUPS.spad" 807662 807677 814199 814296) (-530 "ISUMP.spad" 807163 807179 807652 807657) (-529 "ISAST.spad" 806882 806890 807153 807158) (-528 "IRURPK.spad" 805599 805618 806872 806877) (-527 "IRSN.spad" 803603 803611 805589 805594) (-526 "IRRF2F.spad" 802096 802106 803559 803564) (-525 "IRREDFFX.spad" 801697 801708 802086 802091) (-524 "IROOT.spad" 800036 800046 801687 801692) (-523 "IRFORM.spad" 799360 799368 800026 800031) (-522 "IR2F.spad" 798574 798590 799350 799355) (-521 "IR2.spad" 797602 797618 798564 798569) (-520 "IR.spad" 795438 795452 797484 797511) (-519 "IPRNTPK.spad" 795198 795206 795428 795433) (-518 "IPF.spad" 794763 794775 795003 795096) (-517 "IPADIC.spad" 794532 794558 794689 794758) (-516 "IP4ADDR.spad" 794089 794097 794522 794527) (-515 "IOMODE.spad" 793611 793619 794079 794084) (-514 "IOBFILE.spad" 792996 793004 793601 793606) (-513 "IOBCON.spad" 792861 792869 792986 792991) (-512 "INVLAPLA.spad" 792510 792526 792851 792856) (-511 "INTTR.spad" 785904 785921 792500 792505) (-510 "INTTOOLS.spad" 783712 783728 785531 785536) (-509 "INTSLPE.spad" 783040 783048 783702 783707) (-508 "INTRVL.spad" 782606 782616 782954 783035) (-507 "INTRF.spad" 781038 781052 782596 782601) (-506 "INTRET.spad" 780470 780480 781028 781033) (-505 "INTRAT.spad" 779205 779222 780460 780465) (-504 "INTPM.spad" 777668 777684 778926 778931) (-503 "INTPAF.spad" 775544 775562 777597 777602) (-502 "INTHERTR.spad" 774818 774835 775534 775539) (-501 "INTHERAL.spad" 774488 774512 774808 774813) (-500 "INTHEORY.spad" 770927 770935 774478 774483) (-499 "INTG0.spad" 764691 764709 770856 770861) (-498 "INTFACT.spad" 763758 763768 764681 764686) (-497 "INTEF.spad" 762169 762185 763748 763753) (-496 "INTDOM.spad" 760792 760800 762095 762164) (-495 "INTDOM.spad" 759477 759487 760782 760787) (-494 "INTCAT.spad" 757744 757754 759391 759472) (-493 "INTBIT.spad" 757251 757259 757734 757739) (-492 "INTALG.spad" 756439 756466 757241 757246) (-491 "INTAF.spad" 755939 755955 756429 756434) (-490 "INTABL.spad" 753807 753838 753970 753985) (-489 "INT8.spad" 753687 753695 753797 753802) (-488 "INT64.spad" 753566 753574 753677 753682) (-487 "INT32.spad" 753445 753453 753556 753561) (-486 "INT16.spad" 753324 753332 753435 753440) (-485 "INT.spad" 752850 752858 753190 753319) (-484 "INS.spad" 750353 750361 752752 752845) (-483 "INS.spad" 747942 747952 750343 750348) (-482 "INPSIGN.spad" 747412 747425 747932 747937) (-481 "INPRODPF.spad" 746508 746527 747402 747407) (-480 "INPRODFF.spad" 745596 745620 746498 746503) (-479 "INNMFACT.spad" 744571 744588 745586 745591) (-478 "INMODGCD.spad" 744075 744105 744561 744566) (-477 "INFSP.spad" 742372 742394 744065 744070) (-476 "INFPROD0.spad" 741452 741471 742362 742367) (-475 "INFORM1.spad" 741077 741087 741442 741447) (-474 "INFORM.spad" 738288 738296 741067 741072) (-473 "INFINITY.spad" 737840 737848 738278 738283) (-472 "INETCLTS.spad" 737817 737825 737830 737835) (-471 "INEP.spad" 736363 736385 737807 737812) (-470 "INDE.spad" 736012 736029 736273 736278) (-469 "INCRMAPS.spad" 735449 735459 736002 736007) (-468 "INBFILE.spad" 734545 734553 735439 735444) (-467 "INBFF.spad" 730395 730406 734535 734540) (-466 "INBCON.spad" 728661 728669 730385 730390) (-465 "INBCON.spad" 726925 726935 728651 728656) (-464 "INAST.spad" 726586 726594 726915 726920) (-463 "IMPTAST.spad" 726294 726302 726576 726581) (-462 "IMATQF.spad" 725388 725432 726250 726255) (-461 "IMATLIN.spad" 724009 724033 725344 725349) (-460 "IFF.spad" 723422 723438 723693 723786) (-459 "IFAST.spad" 723036 723044 723412 723417) (-458 "IFARRAY.spad" 720414 720429 722112 722127) (-457 "IFAMON.spad" 720276 720293 720370 720375) (-456 "IEVALAB.spad" 719689 719701 720266 720271) (-455 "IEVALAB.spad" 719100 719114 719679 719684) (-454 "indexedp.spad" 718656 718668 719090 719095) (-453 "IDPOAMS.spad" 718334 718346 718568 718573) (-452 "IDPOAM.spad" 717976 717988 718246 718251) (-451 "IDPO.spad" 717390 717402 717888 717893) (-450 "IDPC.spad" 716105 716117 717380 717385) (-449 "IDPAM.spad" 715772 715784 716017 716022) (-448 "IDPAG.spad" 715441 715453 715684 715689) (-447 "IDENT.spad" 715093 715101 715431 715436) (-446 "catdef.spad" 714864 714875 714976 715088) (-445 "IDECOMP.spad" 712103 712121 714854 714859) (-444 "IDEAL.spad" 707065 707104 712051 712056) (-443 "ICDEN.spad" 706278 706294 707055 707060) (-442 "ICARD.spad" 705671 705679 706268 706273) (-441 "IBPTOOLS.spad" 704278 704295 705661 705666) (-440 "boolean.spad" 703683 703696 703816 703831) (-439 "IBATOOL.spad" 700668 700687 703673 703678) (-438 "IBACHIN.spad" 699175 699190 700658 700663) (-437 "array2.spad" 698672 698694 698859 698874) (-436 "IARRAY1.spad" 697602 697617 697748 697763) (-435 "IAN.spad" 695984 695992 697433 697526) (-434 "IALGFACT.spad" 695595 695628 695974 695979) (-433 "HYPCAT.spad" 695019 695027 695585 695590) (-432 "HYPCAT.spad" 694441 694451 695009 695014) (-431 "HOSTNAME.spad" 694257 694265 694431 694436) (-430 "HOMOTOP.spad" 694000 694010 694247 694252) (-429 "HOAGG.spad" 693236 693246 693990 693995) (-428 "HOAGG.spad" 692258 692270 693014 693019) (-427 "HEXADEC.spad" 690483 690491 690848 690941) (-426 "HEUGCD.spad" 689574 689585 690473 690478) (-425 "HELLFDIV.spad" 689180 689204 689564 689569) (-424 "HEAP.spad" 688649 688659 688864 688879) (-423 "HEADAST.spad" 688190 688198 688639 688644) (-422 "HDP.spad" 677734 677750 678111 678196) (-421 "HDMP.spad" 675281 675296 675897 676024) (-420 "HB.spad" 673556 673564 675271 675276) (-419 "HASHTBL.spad" 671376 671407 671587 671602) (-418 "HASAST.spad" 671092 671100 671366 671371) (-417 "HACKPI.spad" 670583 670591 670994 671087) (-416 "GTSET.spad" 669361 669377 670068 670083) (-415 "GSTBL.spad" 667218 667253 667392 667407) (-414 "GSERIES.spad" 664590 664617 665409 665558) (-413 "GROUP.spad" 663863 663871 664570 664585) (-412 "GROUP.spad" 663144 663154 663853 663858) (-411 "GROEBSOL.spad" 661638 661659 663134 663139) (-410 "GRMOD.spad" 660219 660231 661628 661633) (-409 "GRMOD.spad" 658798 658812 660209 660214) (-408 "GRIMAGE.spad" 651711 651719 658788 658793) (-407 "GRDEF.spad" 650090 650098 651701 651706) (-406 "GRAY.spad" 648561 648569 650080 650085) (-405 "GRALG.spad" 647656 647668 648551 648556) (-404 "GRALG.spad" 646749 646763 647646 647651) (-403 "GPOLSET.spad" 646058 646081 646270 646285) (-402 "GOSPER.spad" 645335 645353 646048 646053) (-401 "GMODPOL.spad" 644483 644510 645303 645330) (-400 "GHENSEL.spad" 643566 643580 644473 644478) (-399 "GENUPS.spad" 639859 639872 643556 643561) (-398 "GENUFACT.spad" 639436 639446 639849 639854) (-397 "GENPGCD.spad" 639038 639055 639426 639431) (-396 "GENMFACT.spad" 638490 638509 639028 639033) (-395 "GENEEZ.spad" 636449 636462 638480 638485) (-394 "GDMP.spad" 633838 633855 634612 634739) (-393 "GCNAALG.spad" 627761 627788 633632 633699) (-392 "GCDDOM.spad" 626953 626961 627687 627756) (-391 "GCDDOM.spad" 626207 626217 626943 626948) (-390 "GBINTERN.spad" 622227 622265 626197 626202) (-389 "GBF.spad" 618010 618048 622217 622222) (-388 "GBEUCLID.spad" 615892 615930 618000 618005) (-387 "GB.spad" 613418 613456 615848 615853) (-386 "GAUSSFAC.spad" 612731 612739 613408 613413) (-385 "GALUTIL.spad" 611057 611067 612687 612692) (-384 "GALPOLYU.spad" 609511 609524 611047 611052) (-383 "GALFACTU.spad" 607724 607743 609501 609506) (-382 "GALFACT.spad" 597937 597948 607714 607719) (-381 "FUNDESC.spad" 597615 597623 597927 597932) (-380 "FUNCTION.spad" 597464 597476 597605 597610) (-379 "FT.spad" 595764 595772 597454 597459) (-378 "FSUPFACT.spad" 594678 594697 595714 595719) (-377 "FST.spad" 592764 592772 594668 594673) (-376 "FSRED.spad" 592244 592260 592754 592759) (-375 "FSPRMELT.spad" 591110 591126 592201 592206) (-374 "FSPECF.spad" 589201 589217 591100 591105) (-373 "FSINT.spad" 588861 588877 589191 589196) (-372 "FSERIES.spad" 588052 588064 588681 588780) (-371 "FSCINT.spad" 587369 587385 588042 588047) (-370 "FSAGG2.spad" 586104 586120 587359 587364) (-369 "FSAGG.spad" 585233 585243 586072 586099) (-368 "FSAGG.spad" 584312 584324 585153 585158) (-367 "FS2UPS.spad" 578827 578861 584302 584307) (-366 "FS2EXPXP.spad" 577968 577991 578817 578822) (-365 "FS2.spad" 577623 577639 577958 577963) (-364 "FS.spad" 571895 571905 577402 577618) (-363 "FS.spad" 565969 565981 571478 571483) (-362 "FRUTIL.spad" 564923 564933 565959 565964) (-361 "FRNAALG.spad" 560200 560210 564865 564918) (-360 "FRNAALG.spad" 555489 555501 560156 560161) (-359 "FRNAAF2.spad" 554937 554955 555479 555484) (-358 "FRMOD.spad" 554345 554375 554866 554871) (-357 "FRIDEAL2.spad" 553949 553981 554335 554340) (-356 "FRIDEAL.spad" 553174 553195 553929 553944) (-355 "FRETRCT.spad" 552693 552703 553164 553169) (-354 "FRETRCT.spad" 552119 552131 552592 552597) (-353 "FRAMALG.spad" 550499 550512 552075 552114) (-352 "FRAMALG.spad" 548911 548926 550489 550494) (-351 "FRAC2.spad" 548516 548528 548901 548906) (-350 "FRAC.spad" 546503 546513 546890 547063) (-349 "FR2.spad" 545839 545851 546493 546498) (-348 "FR.spad" 539627 539637 544900 544969) (-347 "FPS.spad" 536466 536474 539517 539622) (-346 "FPS.spad" 533333 533343 536386 536391) (-345 "FPC.spad" 532379 532387 533235 533328) (-344 "FPC.spad" 531511 531521 532369 532374) (-343 "FPATMAB.spad" 531273 531283 531501 531506) (-342 "FPARFRAC.spad" 530115 530132 531263 531268) (-341 "FORDER.spad" 529806 529830 530105 530110) (-340 "FNLA.spad" 529230 529252 529774 529801) (-339 "FNCAT.spad" 527825 527833 529220 529225) (-338 "FNAME.spad" 527717 527725 527815 527820) (-337 "FMONOID.spad" 527398 527408 527673 527678) (-336 "FMONCAT.spad" 524567 524577 527388 527393) (-335 "FMCAT.spad" 522243 522261 524535 524562) (-334 "FM1.spad" 521608 521620 522177 522204) (-333 "FM.spad" 521223 521235 521462 521489) (-332 "FLOATRP.spad" 518966 518980 521213 521218) (-331 "FLOATCP.spad" 516405 516419 518956 518961) (-330 "FLOAT.spad" 513496 513504 516271 516400) (-329 "FLINEXP.spad" 513218 513228 513486 513491) (-328 "FLINEXP.spad" 512897 512909 513167 513172) (-327 "FLASORT.spad" 512223 512235 512887 512892) (-326 "FLALG.spad" 509893 509912 512149 512218) (-325 "FLAGG2.spad" 508610 508626 509883 509888) (-324 "FLAGG.spad" 505686 505696 508600 508605) (-323 "FLAGG.spad" 502655 502667 505571 505576) (-322 "FINRALG.spad" 500740 500753 502611 502650) (-321 "FINRALG.spad" 498751 498766 500624 500629) (-320 "FINITE.spad" 497903 497911 498741 498746) (-319 "FINITE.spad" 497053 497063 497893 497898) (-318 "aggcat.spad" 493983 493993 497043 497048) (-317 "FINAGG.spad" 490878 490890 493940 493945) (-316 "FINAALG.spad" 480063 480073 490820 490873) (-315 "FINAALG.spad" 469260 469272 480019 480024) (-314 "FILECAT.spad" 467794 467811 469250 469255) (-313 "FILE.spad" 467377 467387 467784 467789) (-312 "FIELD.spad" 466783 466791 467279 467372) (-311 "FIELD.spad" 466275 466285 466773 466778) (-310 "FGROUP.spad" 464938 464948 466255 466270) (-309 "FGLMICPK.spad" 463733 463748 464928 464933) (-308 "FFX.spad" 463119 463134 463452 463545) (-307 "FFSLPE.spad" 462630 462651 463109 463114) (-306 "FFPOLY2.spad" 461690 461707 462620 462625) (-305 "FFPOLY.spad" 453032 453043 461680 461685) (-304 "FFP.spad" 452440 452460 452751 452844) (-303 "FFNBX.spad" 450963 450983 452159 452252) (-302 "FFNBP.spad" 449487 449504 450682 450775) (-301 "FFNB.spad" 447955 447976 449171 449264) (-300 "FFINTBAS.spad" 445469 445488 447945 447950) (-299 "FFIELDC.spad" 443054 443062 445371 445464) (-298 "FFIELDC.spad" 440725 440735 443044 443049) (-297 "FFHOM.spad" 439497 439514 440715 440720) (-296 "FFF.spad" 436940 436951 439487 439492) (-295 "FFCGX.spad" 435798 435818 436659 436752) (-294 "FFCGP.spad" 434698 434718 435517 435610) (-293 "FFCG.spad" 433493 433514 434382 434475) (-292 "FFCAT2.spad" 433240 433280 433483 433488) (-291 "FFCAT.spad" 426405 426427 433079 433235) (-290 "FFCAT.spad" 419649 419673 426325 426330) (-289 "FF.spad" 419100 419116 419333 419426) (-288 "FEVALAB.spad" 418808 418818 419090 419095) (-287 "FEVALAB.spad" 418292 418304 418576 418581) (-286 "FDIVCAT.spad" 416388 416412 418282 418287) (-285 "FDIVCAT.spad" 414482 414508 416378 416383) (-284 "FDIV2.spad" 414138 414178 414472 414477) (-283 "FDIV.spad" 413596 413620 414128 414133) (-282 "FCTRDATA.spad" 412604 412612 413586 413591) (-281 "FCOMP.spad" 411983 411993 412594 412599) (-280 "FAXF.spad" 405018 405032 411885 411978) (-279 "FAXF.spad" 398105 398121 404974 404979) (-278 "FARRAY.spad" 396148 396158 397181 397196) (-277 "FAMR.spad" 394292 394304 396046 396143) (-276 "FAMR.spad" 392420 392434 394176 394181) (-275 "FAMONOID.spad" 392104 392114 392374 392379) (-274 "FAMONC.spad" 390424 390436 392094 392099) (-273 "FAGROUP.spad" 390064 390074 390320 390347) (-272 "FACUTIL.spad" 388276 388293 390054 390059) (-271 "FACTFUNC.spad" 387478 387488 388266 388271) (-270 "EXPUPXS.spad" 384370 384393 385669 385818) (-269 "EXPRTUBE.spad" 381658 381666 384360 384365) (-268 "EXPRODE.spad" 378826 378842 381648 381653) (-267 "EXPR2UPS.spad" 374948 374961 378816 378821) (-266 "EXPR2.spad" 374653 374665 374938 374943) (-265 "EXPR.spad" 370298 370308 371012 371299) (-264 "EXPEXPAN.spad" 367243 367268 367875 367968) (-263 "EXITAST.spad" 366979 366987 367233 367238) (-262 "EXIT.spad" 366650 366658 366969 366974) (-261 "EVALCYC.spad" 366110 366124 366640 366645) (-260 "EVALAB.spad" 365690 365700 366100 366105) (-259 "EVALAB.spad" 365268 365280 365680 365685) (-258 "EUCDOM.spad" 362858 362866 365194 365263) (-257 "EUCDOM.spad" 360510 360520 362848 362853) (-256 "ES2.spad" 360023 360039 360500 360505) (-255 "ES1.spad" 359593 359609 360013 360018) (-254 "ES.spad" 352464 352472 359583 359588) (-253 "ES.spad" 345256 345266 352377 352382) (-252 "ERROR.spad" 342583 342591 345246 345251) (-251 "EQTBL.spad" 340405 340427 340614 340629) (-250 "EQ2.spad" 340123 340135 340395 340400) (-249 "EQ.spad" 335029 335039 337824 337930) (-248 "EP.spad" 331355 331365 335019 335024) (-247 "ENV.spad" 330033 330041 331345 331350) (-246 "ENTIRER.spad" 329701 329709 329977 330028) (-245 "ENTIRER.spad" 329413 329423 329691 329696) (-244 "EMR.spad" 328701 328742 329339 329408) (-243 "ELTAGG.spad" 326955 326974 328691 328696) (-242 "ELTAGG.spad" 325173 325194 326911 326916) (-241 "ELTAB.spad" 324648 324661 325163 325168) (-240 "ELFUTS.spad" 324083 324102 324638 324643) (-239 "ELEMFUN.spad" 323772 323780 324073 324078) (-238 "ELEMFUN.spad" 323459 323469 323762 323767) (-237 "ELAGG.spad" 321430 321440 323439 323454) (-236 "ELAGG.spad" 319340 319352 321351 321356) (-235 "ELABOR.spad" 318686 318694 319330 319335) (-234 "ELABEXPR.spad" 317618 317626 318676 318681) (-233 "EFUPXS.spad" 314394 314424 317574 317579) (-232 "EFULS.spad" 311230 311253 314350 314355) (-231 "EFSTRUC.spad" 309245 309261 311220 311225) (-230 "EF.spad" 304021 304037 309235 309240) (-229 "EAB.spad" 302321 302329 304011 304016) (-228 "DVARCAT.spad" 299327 299337 302311 302316) (-227 "DVARCAT.spad" 296331 296343 299317 299322) (-226 "DSMP.spad" 294064 294078 294369 294496) (-225 "DSEXT.spad" 293366 293376 294054 294059) (-224 "DSEXT.spad" 292588 292600 293278 293283) (-223 "DROPT1.spad" 292253 292263 292578 292583) (-222 "DROPT0.spad" 287118 287126 292243 292248) (-221 "DROPT.spad" 281077 281085 287108 287113) (-220 "DRAWPT.spad" 279250 279258 281067 281072) (-219 "DRAWHACK.spad" 278558 278568 279240 279245) (-218 "DRAWCX.spad" 276036 276044 278548 278553) (-217 "DRAWCURV.spad" 275583 275598 276026 276031) (-216 "DRAWCFUN.spad" 265115 265123 275573 275578) (-215 "DRAW.spad" 257991 258004 265105 265110) (-214 "DQAGG.spad" 256181 256191 257971 257986) (-213 "DPOLCAT.spad" 251538 251554 256049 256176) (-212 "DPOLCAT.spad" 246981 246999 251494 251499) (-211 "DPMO.spad" 239595 239611 239733 239927) (-210 "DPMM.spad" 232222 232240 232347 232541) (-209 "DOMTMPLT.spad" 231993 232001 232212 232217) (-208 "DOMCTOR.spad" 231748 231756 231983 231988) (-207 "DOMAIN.spad" 230859 230867 231738 231743) (-206 "DMP.spad" 228452 228467 229022 229149) (-205 "DMEXT.spad" 228319 228329 228420 228447) (-204 "DLP.spad" 227679 227689 228309 228314) (-203 "DLIST.spad" 226151 226161 226755 226770) (-202 "DLAGG.spad" 224568 224578 226141 226146) (-201 "DIVRING.spad" 224110 224118 224512 224563) (-200 "DIVRING.spad" 223696 223706 224100 224105) (-199 "DISPLAY.spad" 221886 221894 223686 223691) (-198 "DIRPROD2.spad" 220704 220722 221876 221881) (-197 "DIRPROD.spad" 209985 210001 210625 210710) (-196 "DIRPCAT.spad" 209280 209296 209895 209980) (-195 "DIRPCAT.spad" 208189 208207 208806 208811) (-194 "DIOSP.spad" 207014 207022 208179 208184) (-193 "DIOPS.spad" 206010 206020 206994 207009) (-192 "DIOPS.spad" 204953 204965 205939 205944) (-191 "catdef.spad" 204811 204819 204943 204948) (-190 "DIFRING.spad" 204649 204657 204791 204806) (-189 "DIFFSPC.spad" 204228 204236 204639 204644) (-188 "DIFFSPC.spad" 203805 203815 204218 204223) (-187 "DIFFMOD.spad" 203294 203304 203773 203800) (-186 "DIFFDOM.spad" 202459 202470 203284 203289) (-185 "DIFFDOM.spad" 201622 201635 202449 202454) (-184 "DIFEXT.spad" 201441 201451 201602 201617) (-183 "DIAGG.spad" 201071 201081 201421 201436) (-182 "DIAGG.spad" 200709 200721 201061 201066) (-181 "DHMATRIX.spad" 199098 199108 200243 200258) (-180 "DFSFUN.spad" 192738 192746 199088 199093) (-179 "DFLOAT.spad" 189345 189353 192628 192733) (-178 "DFINTTLS.spad" 187576 187592 189335 189340) (-177 "DERHAM.spad" 185490 185522 187556 187571) (-176 "DEQUEUE.spad" 184891 184901 185174 185189) (-175 "DEGRED.spad" 184508 184522 184881 184886) (-174 "DEFINTRF.spad" 182090 182100 184498 184503) (-173 "DEFINTEF.spad" 180628 180644 182080 182085) (-172 "DEFAST.spad" 180012 180020 180618 180623) (-171 "DECIMAL.spad" 178241 178249 178602 178695) (-170 "DDFACT.spad" 176062 176079 178231 178236) (-169 "DBLRESP.spad" 175662 175686 176052 176057) (-168 "DBASIS.spad" 175288 175303 175652 175657) (-167 "DBASE.spad" 173952 173962 175278 175283) (-166 "DATAARY.spad" 173438 173451 173942 173947) (-165 "CYCLOTOM.spad" 172944 172952 173428 173433) (-164 "CYCLES.spad" 169730 169738 172934 172939) (-163 "CVMP.spad" 169147 169157 169720 169725) (-162 "CTRIGMNP.spad" 167647 167663 169137 169142) (-161 "CTORKIND.spad" 167250 167258 167637 167642) (-160 "CTORCAT.spad" 166491 166499 167240 167245) (-159 "CTORCAT.spad" 165730 165740 166481 166486) (-158 "CTORCALL.spad" 165319 165329 165720 165725) (-157 "CTOR.spad" 165010 165018 165309 165314) (-156 "CSTTOOLS.spad" 164255 164268 165000 165005) (-155 "CRFP.spad" 158027 158040 164245 164250) (-154 "CRCEAST.spad" 157747 157755 158017 158022) (-153 "CRAPACK.spad" 156814 156824 157737 157742) (-152 "CPMATCH.spad" 156315 156330 156736 156741) (-151 "CPIMA.spad" 156020 156039 156305 156310) (-150 "COORDSYS.spad" 151029 151039 156010 156015) (-149 "CONTOUR.spad" 150456 150464 151019 151024) (-148 "CONTFRAC.spad" 146206 146216 150358 150451) (-147 "CONDUIT.spad" 145964 145972 146196 146201) (-146 "COMRING.spad" 145638 145646 145902 145959) (-145 "COMPPROP.spad" 145156 145164 145628 145633) (-144 "COMPLPAT.spad" 144923 144938 145146 145151) (-143 "COMPLEX2.spad" 144638 144650 144913 144918) (-142 "COMPLEX.spad" 140344 140354 140588 140846) (-141 "COMPILER.spad" 139893 139901 140334 140339) (-140 "COMPFACT.spad" 139495 139509 139883 139888) (-139 "COMPCAT.spad" 137570 137580 139232 139490) (-138 "COMPCAT.spad" 135386 135398 137050 137055) (-137 "COMMUPC.spad" 135134 135152 135376 135381) (-136 "COMMONOP.spad" 134667 134675 135124 135129) (-135 "COMMAAST.spad" 134430 134438 134657 134662) (-134 "COMM.spad" 134241 134249 134420 134425) (-133 "COMBOPC.spad" 133164 133172 134231 134236) (-132 "COMBINAT.spad" 131931 131941 133154 133159) (-131 "COMBF.spad" 129353 129369 131921 131926) (-130 "COLOR.spad" 128190 128198 129343 129348) (-129 "COLONAST.spad" 127856 127864 128180 128185) (-128 "CMPLXRT.spad" 127567 127584 127846 127851) (-127 "CLLCTAST.spad" 127229 127237 127557 127562) (-126 "CLIP.spad" 123337 123345 127219 127224) (-125 "CLIF.spad" 121992 122008 123293 123332) (-124 "CLAGG.spad" 119984 119994 121982 121987) (-123 "CLAGG.spad" 117835 117847 119835 119840) (-122 "CINTSLPE.spad" 117190 117203 117825 117830) (-121 "CHVAR.spad" 115328 115350 117180 117185) (-120 "CHARZ.spad" 115243 115251 115308 115323) (-119 "CHARPOL.spad" 114769 114779 115233 115238) (-118 "CHARNZ.spad" 114531 114539 114749 114764) (-117 "CHAR.spad" 111899 111907 114521 114526) (-116 "CFCAT.spad" 111227 111235 111889 111894) (-115 "CDEN.spad" 110447 110461 111217 111222) (-114 "CCLASS.spad" 108516 108524 109778 109805) (-113 "CATEGORY.spad" 107590 107598 108506 108511) (-112 "CATCTOR.spad" 107481 107489 107580 107585) (-111 "CATAST.spad" 107107 107115 107471 107476) (-110 "CASEAST.spad" 106821 106829 107097 107102) (-109 "CARTEN2.spad" 106211 106238 106811 106816) (-108 "CARTEN.spad" 101963 101987 106201 106206) (-107 "CARD.spad" 99258 99266 101937 101958) (-106 "CAPSLAST.spad" 99040 99048 99248 99253) (-105 "CACHSET.spad" 98664 98672 99030 99035) (-104 "CABMON.spad" 98219 98227 98654 98659) (-103 "BYTEORD.spad" 97894 97902 98209 98214) (-102 "BYTEBUF.spad" 95830 95838 97036 97051) (-101 "BYTE.spad" 95305 95313 95820 95825) (-100 "BTREE.spad" 94455 94465 94989 95004) (-99 "BTOURN.spad" 93538 93547 94139 94154) (-98 "BTCAT.spad" 93108 93117 93518 93533) (-97 "BTCAT.spad" 92686 92697 93098 93103) (-96 "BTAGG.spad" 92165 92172 92666 92681) (-95 "BTAGG.spad" 91652 91661 92155 92160) (-94 "BSTREE.spad" 90471 90480 91336 91351) (-93 "BRILL.spad" 88677 88687 90461 90466) (-92 "BRAGG.spad" 87634 87643 88667 88672) (-91 "BRAGG.spad" 86555 86566 87590 87595) (-90 "BPADICRT.spad" 84615 84626 84861 84954) (-89 "BPADIC.spad" 84288 84299 84541 84610) (-88 "BOUNDZRO.spad" 83945 83961 84278 84283) (-87 "BOP1.spad" 81404 81413 83935 83940) (-86 "BOP.spad" 76547 76554 81394 81399) (-85 "BOOLEAN.spad" 76096 76103 76537 76542) (-84 "BOOLE.spad" 75747 75754 76086 76091) (-83 "BOOLE.spad" 75396 75405 75737 75742) (-82 "BMODULE.spad" 75109 75120 75364 75391) (-81 "BITS.spad" 74433 74440 74647 74662) (-80 "catdef.spad" 74316 74326 74423 74428) (-79 "catdef.spad" 74067 74077 74306 74311) (-78 "BINDING.spad" 73489 73496 74057 74062) (-77 "BINARY.spad" 71724 71731 72079 72172) (-76 "BGAGG.spad" 71044 71053 71704 71719) (-75 "BGAGG.spad" 70372 70383 71034 71039) (-74 "BEZOUT.spad" 69513 69539 70322 70327) (-73 "BBTREE.spad" 66468 66477 69197 69212) (-72 "BASTYPE.spad" 65968 65975 66458 66463) (-71 "BASTYPE.spad" 65466 65475 65958 65963) (-70 "BALFACT.spad" 64926 64938 65456 65461) (-69 "AUTOMOR.spad" 64377 64386 64906 64921) (-68 "ATTREG.spad" 61509 61516 64153 64372) (-67 "ATTRAST.spad" 61226 61233 61499 61504) (-66 "ATRIG.spad" 60696 60703 61216 61221) (-65 "ATRIG.spad" 60164 60173 60686 60691) (-64 "ASTCAT.spad" 60068 60075 60154 60159) (-63 "ASTCAT.spad" 59970 59979 60058 60063) (-62 "ASTACK.spad" 59386 59395 59654 59669) (-61 "ASSOCEQ.spad" 58220 58231 59342 59347) (-60 "ARRAY2.spad" 57755 57764 57904 57919) (-59 "ARRAY12.spad" 56468 56479 57745 57750) (-58 "ARRAY1.spad" 55198 55207 55544 55559) (-57 "ARR2CAT.spad" 51250 51271 55178 55193) (-56 "ARR2CAT.spad" 47310 47333 51240 51245) (-55 "ARITY.spad" 46682 46689 47300 47305) (-54 "APPRULE.spad" 45966 45988 46672 46677) (-53 "APPLYORE.spad" 45585 45598 45956 45961) (-52 "ANY1.spad" 44656 44665 45575 45580) (-51 "ANY.spad" 43507 43514 44646 44651) (-50 "ANTISYM.spad" 41952 41968 43487 43502) (-49 "ANON.spad" 41661 41668 41942 41947) (-48 "AN.spad" 40129 40136 41492 41585) (-47 "AMR.spad" 38314 38325 40027 40124) (-46 "AMR.spad" 36362 36375 38077 38082) (-45 "ALIST.spad" 33086 33107 33436 33451) (-44 "ALGSC.spad" 32221 32247 32958 33011) (-43 "ALGPKG.spad" 28004 28015 32177 32182) (-42 "ALGMFACT.spad" 27197 27211 27994 27999) (-41 "ALGMANIP.spad" 24698 24713 27041 27046) (-40 "ALGFF.spad" 22516 22543 22733 22889) (-39 "ALGFACT.spad" 21635 21645 22506 22511) (-38 "ALGEBRA.spad" 21468 21477 21591 21630) (-37 "ALGEBRA.spad" 21333 21344 21458 21463) (-36 "ALAGG.spad" 20861 20882 21313 21328) (-35 "AHYP.spad" 20242 20249 20851 20856) (-34 "AGG.spad" 19149 19156 20232 20237) (-33 "AGG.spad" 18054 18063 19139 19144) (-32 "AF.spad" 16499 16514 18003 18008) (-31 "ADDAST.spad" 16185 16192 16489 16494) (-30 "ACPLOT.spad" 15062 15069 16175 16180) (-29 "ACFS.spad" 12919 12928 14964 15057) (-28 "ACFS.spad" 10862 10873 12909 12914) (-27 "ACF.spad" 7616 7623 10764 10857) (-26 "ACF.spad" 4456 4465 7606 7611) (-25 "ABELSG.spad" 3997 4004 4446 4451) (-24 "ABELSG.spad" 3536 3545 3987 3992) (-23 "ABELMON.spad" 2964 2971 3526 3531) (-22 "ABELMON.spad" 2390 2399 2954 2959) (-21 "ABELGRP.spad" 2055 2062 2380 2385) (-20 "ABELGRP.spad" 1718 1727 2045 2050) (-19 "A1AGG.spad" 870 879 1698 1713) (-18 "A1AGG.spad" 30 41 860 865)) 
\ No newline at end of file
+((-3 NIL 1968699 1968704 1968709 1968714) (-2 NIL 1968679 1968684 1968689 1968694) (-1 NIL 1968659 1968664 1968669 1968674) (0 NIL 1968639 1968644 1968649 1968654) (-1210 "ZMOD.spad" 1968448 1968461 1968577 1968634) (-1209 "ZLINDEP.spad" 1967546 1967557 1968438 1968443) (-1208 "ZDSOLVE.spad" 1957507 1957529 1967536 1967541) (-1207 "YSTREAM.spad" 1957002 1957013 1957497 1957502) (-1206 "YDIAGRAM.spad" 1956636 1956645 1956992 1956997) (-1205 "XRPOLY.spad" 1955856 1955876 1956492 1956561) (-1204 "XPR.spad" 1953651 1953664 1955574 1955673) (-1203 "XPOLYC.spad" 1952970 1952986 1953577 1953646) (-1202 "XPOLY.spad" 1952525 1952536 1952826 1952895) (-1201 "XPBWPOLY.spad" 1950996 1951016 1952331 1952400) (-1200 "XFALG.spad" 1948044 1948060 1950922 1950991) (-1199 "XF.spad" 1946507 1946522 1947946 1948039) (-1198 "XF.spad" 1944950 1944967 1946391 1946396) (-1197 "XEXPPKG.spad" 1944209 1944235 1944940 1944945) (-1196 "XDPOLY.spad" 1943823 1943839 1944065 1944134) (-1195 "XALG.spad" 1943491 1943502 1943779 1943818) (-1194 "WUTSET.spad" 1939345 1939362 1942976 1942991) (-1193 "WP.spad" 1938552 1938596 1939203 1939270) (-1192 "WHILEAST.spad" 1938350 1938359 1938542 1938547) (-1191 "WHEREAST.spad" 1938021 1938030 1938340 1938345) (-1190 "WFFINTBS.spad" 1935684 1935706 1938011 1938016) (-1189 "WEIER.spad" 1933906 1933917 1935674 1935679) (-1188 "VSPACE.spad" 1933579 1933590 1933874 1933901) (-1187 "VSPACE.spad" 1933272 1933285 1933569 1933574) (-1186 "VOID.spad" 1932949 1932958 1933262 1933267) (-1185 "VIEWDEF.spad" 1928150 1928159 1932939 1932944) (-1184 "VIEW3D.spad" 1912111 1912120 1928140 1928145) (-1183 "VIEW2D.spad" 1900010 1900019 1912101 1912106) (-1182 "VIEW.spad" 1897730 1897739 1900000 1900005) (-1181 "VECTOR2.spad" 1896369 1896382 1897720 1897725) (-1180 "VECTOR.spad" 1894775 1894786 1895026 1895041) (-1179 "VECTCAT.spad" 1892699 1892710 1894755 1894770) (-1178 "VECTCAT.spad" 1890420 1890433 1892478 1892483) (-1177 "VARIABLE.spad" 1890200 1890215 1890410 1890415) (-1176 "UTYPE.spad" 1889844 1889853 1890190 1890195) (-1175 "UTSODETL.spad" 1889139 1889163 1889800 1889805) (-1174 "UTSODE.spad" 1887355 1887375 1889129 1889134) (-1173 "UTSCAT.spad" 1884834 1884850 1887253 1887350) (-1172 "UTSCAT.spad" 1881981 1881999 1884402 1884407) (-1171 "UTS2.spad" 1881576 1881611 1881971 1881976) (-1170 "UTS.spad" 1876588 1876616 1880108 1880205) (-1169 "URAGG.spad" 1871309 1871320 1876578 1876583) (-1168 "URAGG.spad" 1865966 1865979 1871237 1871242) (-1167 "UPXSSING.spad" 1863734 1863760 1865170 1865303) (-1166 "UPXSCONS.spad" 1861552 1861572 1861925 1862074) (-1165 "UPXSCCA.spad" 1860123 1860143 1861398 1861547) (-1164 "UPXSCCA.spad" 1858836 1858858 1860113 1860118) (-1163 "UPXSCAT.spad" 1857425 1857441 1858682 1858831) (-1162 "UPXS2.spad" 1856968 1857021 1857415 1857420) (-1161 "UPXS.spad" 1854323 1854351 1855159 1855308) (-1160 "UPSQFREE.spad" 1852738 1852752 1854313 1854318) (-1159 "UPSCAT.spad" 1850533 1850557 1852636 1852733) (-1158 "UPSCAT.spad" 1848029 1848055 1850134 1850139) (-1157 "UPOLYC2.spad" 1847500 1847519 1848019 1848024) (-1156 "UPOLYC.spad" 1842580 1842591 1847342 1847495) (-1155 "UPOLYC.spad" 1837578 1837591 1842342 1842347) (-1154 "UPMP.spad" 1836510 1836523 1837568 1837573) (-1153 "UPDIVP.spad" 1836075 1836089 1836500 1836505) (-1152 "UPDECOMP.spad" 1834336 1834350 1836065 1836070) (-1151 "UPCDEN.spad" 1833553 1833569 1834326 1834331) (-1150 "UP2.spad" 1832917 1832938 1833543 1833548) (-1149 "UP.spad" 1830387 1830402 1830774 1830927) (-1148 "UNISEG2.spad" 1829884 1829897 1830343 1830348) (-1147 "UNISEG.spad" 1829237 1829248 1829803 1829808) (-1146 "UNIFACT.spad" 1828340 1828352 1829227 1829232) (-1145 "ULSCONS.spad" 1822186 1822206 1822556 1822705) (-1144 "ULSCCAT.spad" 1819923 1819943 1822032 1822181) (-1143 "ULSCCAT.spad" 1817768 1817790 1819879 1819884) (-1142 "ULSCAT.spad" 1816008 1816024 1817614 1817763) (-1141 "ULS2.spad" 1815522 1815575 1815998 1816003) (-1140 "ULS.spad" 1807555 1807583 1808500 1808923) (-1139 "UINT8.spad" 1807432 1807441 1807545 1807550) (-1138 "UINT64.spad" 1807308 1807317 1807422 1807427) (-1137 "UINT32.spad" 1807184 1807193 1807298 1807303) (-1136 "UINT16.spad" 1807060 1807069 1807174 1807179) (-1135 "UFD.spad" 1806125 1806134 1806986 1807055) (-1134 "UFD.spad" 1805252 1805263 1806115 1806120) (-1133 "UDVO.spad" 1804133 1804142 1805242 1805247) (-1132 "UDPO.spad" 1801714 1801725 1804089 1804094) (-1131 "TYPEAST.spad" 1801633 1801642 1801704 1801709) (-1130 "TYPE.spad" 1801565 1801574 1801623 1801628) (-1129 "TWOFACT.spad" 1800217 1800232 1801555 1801560) (-1128 "TUPLE.spad" 1799724 1799735 1800129 1800134) (-1127 "TUBETOOL.spad" 1796591 1796600 1799714 1799719) (-1126 "TUBE.spad" 1795238 1795255 1796581 1796586) (-1125 "TSETCAT.spad" 1783321 1783338 1795218 1795233) (-1124 "TSETCAT.spad" 1771378 1771397 1783277 1783282) (-1123 "TS.spad" 1770006 1770022 1770972 1771069) (-1122 "TRMANIP.spad" 1764370 1764387 1769694 1769699) (-1121 "TRIMAT.spad" 1763333 1763358 1764360 1764365) (-1120 "TRIGMNIP.spad" 1761860 1761877 1763323 1763328) (-1119 "TRIGCAT.spad" 1761372 1761381 1761850 1761855) (-1118 "TRIGCAT.spad" 1760882 1760893 1761362 1761367) (-1117 "TREE.spad" 1759473 1759484 1760505 1760520) (-1116 "TRANFUN.spad" 1759312 1759321 1759463 1759468) (-1115 "TRANFUN.spad" 1759149 1759160 1759302 1759307) (-1114 "TOPSP.spad" 1758823 1758832 1759139 1759144) (-1113 "TOOLSIGN.spad" 1758486 1758497 1758813 1758818) (-1112 "TEXTFILE.spad" 1757047 1757056 1758476 1758481) (-1111 "TEX1.spad" 1756603 1756614 1757037 1757042) (-1110 "TEX.spad" 1753797 1753806 1756593 1756598) (-1109 "TBCMPPK.spad" 1751898 1751921 1753787 1753792) (-1108 "TBAGG.spad" 1751153 1751176 1751878 1751893) (-1107 "TBAGG.spad" 1750416 1750441 1751143 1751148) (-1106 "TANEXP.spad" 1749824 1749835 1750406 1750411) (-1105 "TALGOP.spad" 1749548 1749559 1749814 1749819) (-1104 "TABLEAU.spad" 1749029 1749040 1749538 1749543) (-1103 "TABLE.spad" 1746790 1746813 1747060 1747075) (-1102 "TABLBUMP.spad" 1743569 1743580 1746780 1746785) (-1101 "SYSTEM.spad" 1742797 1742806 1743559 1743564) (-1100 "SYSSOLP.spad" 1740280 1740291 1742787 1742792) (-1099 "SYSPTR.spad" 1740179 1740188 1740270 1740275) (-1098 "SYSNNI.spad" 1739402 1739413 1740169 1740174) (-1097 "SYSINT.spad" 1738806 1738817 1739392 1739397) (-1096 "SYNTAX.spad" 1735140 1735149 1738796 1738801) (-1095 "SYMTAB.spad" 1733208 1733217 1735130 1735135) (-1094 "SYMS.spad" 1729237 1729246 1733198 1733203) (-1093 "SYMPOLY.spad" 1728370 1728381 1728452 1728579) (-1092 "SYMFUNC.spad" 1727871 1727882 1728360 1728365) (-1091 "SYMBOL.spad" 1725366 1725375 1727861 1727866) (-1090 "SUTS.spad" 1722479 1722507 1723898 1723995) (-1089 "SUPXS.spad" 1719821 1719849 1720670 1720819) (-1088 "SUPFRACF.spad" 1718926 1718944 1719811 1719816) (-1087 "SUP2.spad" 1718318 1718331 1718916 1718921) (-1086 "SUP.spad" 1715402 1715413 1716175 1716328) (-1085 "SUMRF.spad" 1714376 1714387 1715392 1715397) (-1084 "SUMFS.spad" 1714005 1714022 1714366 1714371) (-1083 "SULS.spad" 1706025 1706053 1706983 1707406) (-1082 "syntax.spad" 1705794 1705803 1706015 1706020) (-1081 "SUCH.spad" 1705484 1705499 1705784 1705789) (-1080 "SUBSPACE.spad" 1697615 1697630 1705474 1705479) (-1079 "SUBRESP.spad" 1696785 1696799 1697571 1697576) (-1078 "STTFNC.spad" 1693253 1693269 1696775 1696780) (-1077 "STTF.spad" 1689352 1689368 1693243 1693248) (-1076 "STTAYLOR.spad" 1682029 1682040 1689259 1689264) (-1075 "STRTBL.spad" 1679953 1679970 1680102 1680117) (-1074 "STRING.spad" 1678584 1678593 1678969 1678984) (-1073 "STREAM3.spad" 1678157 1678172 1678574 1678579) (-1072 "STREAM2.spad" 1677285 1677298 1678147 1678152) (-1071 "STREAM1.spad" 1676991 1677002 1677275 1677280) (-1070 "STREAM.spad" 1673941 1673952 1676432 1676447) (-1069 "STINPROD.spad" 1672877 1672893 1673931 1673936) (-1068 "STEPAST.spad" 1672111 1672120 1672867 1672872) (-1067 "STEP.spad" 1671428 1671437 1672101 1672106) (-1066 "STBL.spad" 1669292 1669320 1669459 1669474) (-1065 "STAGG.spad" 1667991 1668002 1669282 1669287) (-1064 "STAGG.spad" 1666688 1666701 1667981 1667986) (-1063 "STACK.spad" 1666122 1666133 1666372 1666387) (-1062 "SRING.spad" 1665882 1665891 1666112 1666117) (-1061 "SREGSET.spad" 1663465 1663482 1665367 1665382) (-1060 "SRDCMPK.spad" 1662042 1662062 1663455 1663460) (-1059 "SRAGG.spad" 1657237 1657246 1662022 1662037) (-1058 "SRAGG.spad" 1652440 1652451 1657227 1657232) (-1057 "SQMATRIX.spad" 1650129 1650147 1651045 1651120) (-1056 "SPLTREE.spad" 1644779 1644792 1649575 1649590) (-1055 "SPLNODE.spad" 1641399 1641412 1644769 1644774) (-1054 "SPFCAT.spad" 1640208 1640217 1641389 1641394) (-1053 "SPECOUT.spad" 1638760 1638769 1640198 1640203) (-1052 "SPADXPT.spad" 1630851 1630860 1638750 1638755) (-1051 "spad-parser.spad" 1630316 1630325 1630841 1630846) (-1050 "SPADAST.spad" 1630017 1630026 1630306 1630311) (-1049 "SPACEC.spad" 1614232 1614243 1630007 1630012) (-1048 "SPACE3.spad" 1614008 1614019 1614222 1614227) (-1047 "SORTPAK.spad" 1613557 1613570 1613964 1613969) (-1046 "SOLVETRA.spad" 1611320 1611331 1613547 1613552) (-1045 "SOLVESER.spad" 1609776 1609787 1611310 1611315) (-1044 "SOLVERAD.spad" 1605802 1605813 1609766 1609771) (-1043 "SOLVEFOR.spad" 1604264 1604282 1605792 1605797) (-1042 "SNTSCAT.spad" 1603876 1603893 1604244 1604259) (-1041 "SMTS.spad" 1602193 1602219 1603470 1603567) (-1040 "SMP.spad" 1600001 1600021 1600391 1600518) (-1039 "SMITH.spad" 1598846 1598871 1599991 1599996) (-1038 "SMATCAT.spad" 1596976 1597006 1598802 1598841) (-1037 "SMATCAT.spad" 1595026 1595058 1596854 1596859) (-1036 "aggcat.spad" 1594702 1594713 1595006 1595021) (-1035 "SKAGG.spad" 1593683 1593694 1594682 1594697) (-1034 "SINT.spad" 1592982 1592991 1593549 1593678) (-1033 "SIMPAN.spad" 1592710 1592719 1592972 1592977) (-1032 "SIGNRF.spad" 1591835 1591846 1592700 1592705) (-1031 "SIGNEF.spad" 1591121 1591138 1591825 1591830) (-1030 "syntax.spad" 1590538 1590547 1591111 1591116) (-1029 "SIG.spad" 1589900 1589909 1590528 1590533) (-1028 "SHP.spad" 1587844 1587859 1589856 1589861) (-1027 "SHDP.spad" 1577248 1577275 1577765 1577850) (-1026 "SGROUP.spad" 1576856 1576865 1577238 1577243) (-1025 "SGROUP.spad" 1576462 1576473 1576846 1576851) (-1024 "catdef.spad" 1576172 1576184 1576283 1576457) (-1023 "catdef.spad" 1575728 1575740 1575993 1576167) (-1022 "SGCF.spad" 1568867 1568876 1575718 1575723) (-1021 "SFRTCAT.spad" 1567825 1567842 1568847 1568862) (-1020 "SFRGCD.spad" 1566888 1566908 1567815 1567820) (-1019 "SFQCMPK.spad" 1561701 1561721 1566878 1566883) (-1018 "SEXOF.spad" 1561544 1561584 1561691 1561696) (-1017 "SEXCAT.spad" 1559372 1559412 1561534 1561539) (-1016 "SEX.spad" 1559264 1559273 1559362 1559367) (-1015 "SETMN.spad" 1557724 1557741 1559254 1559259) (-1014 "SETCAT.spad" 1557209 1557218 1557714 1557719) (-1013 "SETCAT.spad" 1556692 1556703 1557199 1557204) (-1012 "SETAGG.spad" 1553241 1553252 1556672 1556687) (-1011 "SETAGG.spad" 1549798 1549811 1553231 1553236) (-1010 "SET.spad" 1547956 1547967 1549055 1549082) (-1009 "syntax.spad" 1547659 1547668 1547946 1547951) (-1008 "SEGXCAT.spad" 1546815 1546828 1547649 1547654) (-1007 "SEGCAT.spad" 1545740 1545751 1546805 1546810) (-1006 "SEGBIND2.spad" 1545438 1545451 1545730 1545735) (-1005 "SEGBIND.spad" 1545196 1545207 1545385 1545390) (-1004 "SEGAST.spad" 1544926 1544935 1545186 1545191) (-1003 "SEG2.spad" 1544361 1544374 1544882 1544887) (-1002 "SEG.spad" 1544174 1544185 1544280 1544285) (-1001 "SDVAR.spad" 1543450 1543461 1544164 1544169) (-1000 "SDPOL.spad" 1541142 1541153 1541433 1541560) (-999 "SCPKG.spad" 1539232 1539242 1541132 1541137) (-998 "SCOPE.spad" 1538410 1538418 1539222 1539227) (-997 "SCACHE.spad" 1537107 1537117 1538400 1538405) (-996 "SASTCAT.spad" 1537017 1537025 1537097 1537102) (-995 "SAOS.spad" 1536890 1536898 1537007 1537012) (-994 "SAERFFC.spad" 1536604 1536623 1536880 1536885) (-993 "SAEFACT.spad" 1536306 1536325 1536594 1536599) (-992 "SAE.spad" 1533957 1533972 1534567 1534702) (-991 "RURPK.spad" 1531617 1531632 1533947 1533952) (-990 "RULESET.spad" 1531071 1531094 1531607 1531612) (-989 "RULECOLD.spad" 1530924 1530936 1531061 1531066) (-988 "RULE.spad" 1529173 1529196 1530914 1530919) (-987 "RTVALUE.spad" 1528909 1528917 1529163 1529168) (-986 "syntax.spad" 1528627 1528635 1528899 1528904) (-985 "RSETGCD.spad" 1525070 1525089 1528617 1528622) (-984 "RSETCAT.spad" 1515051 1515067 1525050 1525065) (-983 "RSETCAT.spad" 1505040 1505058 1515041 1515046) (-982 "RSDCMPK.spad" 1503541 1503560 1505030 1505035) (-981 "RRCC.spad" 1501926 1501955 1503531 1503536) (-980 "RRCC.spad" 1500309 1500340 1501916 1501921) (-979 "RPTAST.spad" 1500012 1500020 1500299 1500304) (-978 "RPOLCAT.spad" 1479517 1479531 1499880 1500007) (-977 "RPOLCAT.spad" 1458815 1458831 1479180 1479185) (-976 "ROMAN.spad" 1458144 1458152 1458681 1458810) (-975 "ROIRC.spad" 1457225 1457256 1458134 1458139) (-974 "RNS.spad" 1456202 1456210 1457127 1457220) (-973 "RNS.spad" 1455265 1455275 1456192 1456197) (-972 "RNGBIND.spad" 1454426 1454439 1455220 1455225) (-971 "RNG.spad" 1454035 1454043 1454416 1454421) (-970 "RNG.spad" 1453642 1453652 1454025 1454030) (-969 "RMODULE.spad" 1453424 1453434 1453632 1453637) (-968 "RMCAT2.spad" 1452845 1452901 1453414 1453419) (-967 "RMATRIX.spad" 1451667 1451685 1452009 1452036) (-966 "RMATCAT.spad" 1447317 1447347 1451635 1451662) (-965 "RMATCAT.spad" 1442845 1442877 1447165 1447170) (-964 "RLINSET.spad" 1442550 1442560 1442835 1442840) (-963 "RINTERP.spad" 1442439 1442458 1442540 1442545) (-962 "RING.spad" 1441910 1441918 1442419 1442434) (-961 "RING.spad" 1441389 1441399 1441900 1441905) (-960 "RIDIST.spad" 1440782 1440790 1441379 1441384) (-959 "RGCHAIN.spad" 1439039 1439054 1439932 1439947) (-958 "RGBCSPC.spad" 1438829 1438840 1439029 1439034) (-957 "RGBCMDL.spad" 1438392 1438403 1438819 1438824) (-956 "RFFACTOR.spad" 1437855 1437865 1438382 1438387) (-955 "RFFACT.spad" 1437591 1437602 1437845 1437850) (-954 "RFDIST.spad" 1436588 1436596 1437581 1437586) (-953 "RF.spad" 1434263 1434273 1436578 1436583) (-952 "RETSOL.spad" 1433683 1433695 1434253 1434258) (-951 "RETRACT.spad" 1433112 1433122 1433673 1433678) (-950 "RETRACT.spad" 1432539 1432551 1433102 1433107) (-949 "RETAST.spad" 1432352 1432360 1432529 1432534) (-948 "RESRING.spad" 1431700 1431746 1432290 1432347) (-947 "RESLATC.spad" 1431025 1431035 1431690 1431695) (-946 "REPSQ.spad" 1430757 1430767 1431015 1431020) (-945 "REPDB.spad" 1430465 1430475 1430747 1430752) (-944 "REP2.spad" 1420180 1420190 1430307 1430312) (-943 "REP1.spad" 1414401 1414411 1420130 1420135) (-942 "REP.spad" 1411956 1411964 1414391 1414396) (-941 "REGSET.spad" 1409633 1409649 1411441 1411456) (-940 "REF.spad" 1409152 1409162 1409623 1409628) (-939 "REDORDER.spad" 1408359 1408375 1409142 1409147) (-938 "RECLOS.spad" 1407256 1407275 1407959 1408052) (-937 "REALSOLV.spad" 1406397 1406405 1407246 1407251) (-936 "REAL0Q.spad" 1403696 1403710 1406387 1406392) (-935 "REAL0.spad" 1400541 1400555 1403686 1403691) (-934 "REAL.spad" 1400414 1400422 1400531 1400536) (-933 "RDUCEAST.spad" 1400136 1400144 1400404 1400409) (-932 "RDIV.spad" 1399792 1399816 1400126 1400131) (-931 "RDIST.spad" 1399360 1399370 1399782 1399787) (-930 "RDETRS.spad" 1398225 1398242 1399350 1399355) (-929 "RDETR.spad" 1396365 1396382 1398215 1398220) (-928 "RDEEFS.spad" 1395465 1395481 1396355 1396360) (-927 "RDEEF.spad" 1394476 1394492 1395455 1395460) (-926 "RCFIELD.spad" 1391695 1391703 1394378 1394471) (-925 "RCFIELD.spad" 1389000 1389010 1391685 1391690) (-924 "RCAGG.spad" 1386937 1386947 1388990 1388995) (-923 "RCAGG.spad" 1384775 1384787 1386830 1386835) (-922 "RATRET.spad" 1384136 1384146 1384765 1384770) (-921 "RATFACT.spad" 1383829 1383840 1384126 1384131) (-920 "RANDSRC.spad" 1383149 1383157 1383819 1383824) (-919 "RADUTIL.spad" 1382906 1382914 1383139 1383144) (-918 "RADIX.spad" 1379951 1379964 1381496 1381589) (-917 "RADFF.spad" 1377868 1377904 1377986 1378142) (-916 "RADCAT.spad" 1377464 1377472 1377858 1377863) (-915 "RADCAT.spad" 1377058 1377068 1377454 1377459) (-914 "QUEUE.spad" 1376484 1376494 1376742 1376757) (-913 "QUATCT2.spad" 1376105 1376123 1376474 1376479) (-912 "QUATCAT.spad" 1374276 1374286 1376035 1376100) (-911 "QUATCAT.spad" 1372212 1372224 1373973 1373978) (-910 "QUAT.spad" 1370819 1370829 1371161 1371226) (-909 "QUAGG.spad" 1369665 1369675 1370799 1370814) (-908 "QQUTAST.spad" 1369434 1369442 1369655 1369660) (-907 "QFORM.spad" 1369053 1369067 1369424 1369429) (-906 "QFCAT2.spad" 1368746 1368762 1369043 1369048) (-905 "QFCAT.spad" 1367449 1367459 1368648 1368741) (-904 "QFCAT.spad" 1365785 1365797 1366986 1366991) (-903 "QEQUAT.spad" 1365344 1365352 1365775 1365780) (-902 "QCMPACK.spad" 1360259 1360278 1365334 1365339) (-901 "QALGSET2.spad" 1358255 1358273 1360249 1360254) (-900 "QALGSET.spad" 1354360 1354392 1358169 1358174) (-899 "PWFFINTB.spad" 1351776 1351797 1354350 1354355) (-898 "PUSHVAR.spad" 1351115 1351134 1351766 1351771) (-897 "PTRANFN.spad" 1347251 1347261 1351105 1351110) (-896 "PTPACK.spad" 1344339 1344349 1347241 1347246) (-895 "PTFUNC2.spad" 1344162 1344176 1344329 1344334) (-894 "PTCAT.spad" 1343429 1343439 1344142 1344157) (-893 "PSQFR.spad" 1342744 1342768 1343419 1343424) (-892 "PSEUDLIN.spad" 1341630 1341640 1342734 1342739) (-891 "PSETPK.spad" 1328335 1328351 1341508 1341513) (-890 "PSETCAT.spad" 1322745 1322768 1328325 1328330) (-889 "PSETCAT.spad" 1317119 1317144 1322701 1322706) (-888 "PSCURVE.spad" 1316118 1316126 1317109 1317114) (-887 "PSCAT.spad" 1314901 1314930 1316016 1316113) (-886 "PSCAT.spad" 1313774 1313805 1314891 1314896) (-885 "PRTITION.spad" 1312472 1312480 1313764 1313769) (-884 "PRTDAST.spad" 1312191 1312199 1312462 1312467) (-883 "PRS.spad" 1301809 1301826 1312147 1312152) (-882 "PRQAGG.spad" 1301256 1301266 1301789 1301804) (-881 "PROPLOG.spad" 1300860 1300868 1301246 1301251) (-880 "PROPFUN2.spad" 1300483 1300496 1300850 1300855) (-879 "PROPFUN1.spad" 1299889 1299900 1300473 1300478) (-878 "PROPFRML.spad" 1298457 1298468 1299879 1299884) (-877 "PROPERTY.spad" 1297953 1297961 1298447 1298452) (-876 "PRODUCT.spad" 1295650 1295662 1295934 1295989) (-875 "PRINT.spad" 1295402 1295410 1295640 1295645) (-874 "PRIMES.spad" 1293663 1293673 1295392 1295397) (-873 "PRIMELT.spad" 1291784 1291798 1293653 1293658) (-872 "PRIMCAT.spad" 1291427 1291435 1291774 1291779) (-871 "PRIMARR2.spad" 1290194 1290206 1291417 1291422) (-870 "PRIMARR.spad" 1288936 1288946 1289106 1289121) (-869 "PREASSOC.spad" 1288318 1288330 1288926 1288931) (-868 "PR.spad" 1286836 1286848 1287535 1287662) (-867 "PPCURVE.spad" 1285973 1285981 1286826 1286831) (-866 "PORTNUM.spad" 1285764 1285772 1285963 1285968) (-865 "POLYROOT.spad" 1284613 1284635 1285720 1285725) (-864 "POLYLIFT.spad" 1283878 1283901 1284603 1284608) (-863 "POLYCATQ.spad" 1282004 1282026 1283868 1283873) (-862 "POLYCAT.spad" 1275506 1275527 1281872 1281999) (-861 "POLYCAT.spad" 1268528 1268551 1274896 1274901) (-860 "POLY2UP.spad" 1267980 1267994 1268518 1268523) (-859 "POLY2.spad" 1267577 1267589 1267970 1267975) (-858 "POLY.spad" 1265245 1265255 1265760 1265887) (-857 "POLUTIL.spad" 1264210 1264239 1265201 1265206) (-856 "POLTOPOL.spad" 1262958 1262973 1264200 1264205) (-855 "POINT.spad" 1261528 1261538 1261615 1261630) (-854 "PNTHEORY.spad" 1258230 1258238 1261518 1261523) (-853 "PMTOOLS.spad" 1257005 1257019 1258220 1258225) (-852 "PMSYM.spad" 1256554 1256564 1256995 1257000) (-851 "PMQFCAT.spad" 1256145 1256159 1256544 1256549) (-850 "PMPREDFS.spad" 1255607 1255629 1256135 1256140) (-849 "PMPRED.spad" 1255094 1255108 1255597 1255602) (-848 "PMPLCAT.spad" 1254171 1254189 1255023 1255028) (-847 "PMLSAGG.spad" 1253756 1253770 1254161 1254166) (-846 "PMKERNEL.spad" 1253335 1253347 1253746 1253751) (-845 "PMINS.spad" 1252915 1252925 1253325 1253330) (-844 "PMFS.spad" 1252492 1252510 1252905 1252910) (-843 "PMDOWN.spad" 1251782 1251796 1252482 1252487) (-842 "PMASSFS.spad" 1250757 1250773 1251772 1251777) (-841 "PMASS.spad" 1249775 1249783 1250747 1250752) (-840 "PLOTTOOL.spad" 1249555 1249563 1249765 1249770) (-839 "PLOT3D.spad" 1246019 1246027 1249545 1249550) (-838 "PLOT1.spad" 1245192 1245202 1246009 1246014) (-837 "PLOT.spad" 1240115 1240123 1245182 1245187) (-836 "PLEQN.spad" 1227517 1227544 1240105 1240110) (-835 "PINTERPA.spad" 1227301 1227317 1227507 1227512) (-834 "PINTERP.spad" 1226923 1226942 1227291 1227296) (-833 "PID.spad" 1225897 1225905 1226849 1226918) (-832 "PICOERCE.spad" 1225554 1225564 1225887 1225892) (-831 "PI.spad" 1225171 1225179 1225528 1225549) (-830 "PGROEB.spad" 1223780 1223794 1225161 1225166) (-829 "PGE.spad" 1215453 1215461 1223770 1223775) (-828 "PGCD.spad" 1214407 1214424 1215443 1215448) (-827 "PFRPAC.spad" 1213556 1213566 1214397 1214402) (-826 "PFR.spad" 1210259 1210269 1213458 1213551) (-825 "PFOTOOLS.spad" 1209517 1209533 1210249 1210254) (-824 "PFOQ.spad" 1208887 1208905 1209507 1209512) (-823 "PFO.spad" 1208306 1208333 1208877 1208882) (-822 "PFECAT.spad" 1206016 1206024 1208232 1208301) (-821 "PFECAT.spad" 1203754 1203764 1205972 1205977) (-820 "PFBRU.spad" 1201642 1201654 1203744 1203749) (-819 "PFBR.spad" 1199202 1199225 1201632 1201637) (-818 "PF.spad" 1198776 1198788 1199007 1199100) (-817 "PERMGRP.spad" 1193546 1193556 1198766 1198771) (-816 "PERMCAT.spad" 1192207 1192217 1193526 1193541) (-815 "PERMAN.spad" 1190763 1190777 1192197 1192202) (-814 "PERM.spad" 1186573 1186583 1190596 1190611) (-813 "PENDTREE.spad" 1185926 1185936 1186206 1186211) (-812 "PDSPC.spad" 1184739 1184749 1185916 1185921) (-811 "PDSPC.spad" 1183550 1183562 1184729 1184734) (-810 "PDRING.spad" 1183392 1183402 1183530 1183545) (-809 "PDMOD.spad" 1183208 1183220 1183360 1183387) (-808 "PDECOMP.spad" 1182678 1182695 1183198 1183203) (-807 "PDDOM.spad" 1182116 1182129 1182668 1182673) (-806 "PDDOM.spad" 1181552 1181567 1182106 1182111) (-805 "PCOMP.spad" 1181405 1181418 1181542 1181547) (-804 "PBWLB.spad" 1180003 1180020 1181395 1181400) (-803 "PATTERN2.spad" 1179741 1179753 1179993 1179998) (-802 "PATTERN1.spad" 1178085 1178101 1179731 1179736) (-801 "PATTERN.spad" 1172660 1172670 1178075 1178080) (-800 "PATRES2.spad" 1172332 1172346 1172650 1172655) (-799 "PATRES.spad" 1169915 1169927 1172322 1172327) (-798 "PATMATCH.spad" 1168156 1168187 1169667 1169672) (-797 "PATMAB.spad" 1167585 1167595 1168146 1168151) (-796 "PATLRES.spad" 1166671 1166685 1167575 1167580) (-795 "PATAB.spad" 1166435 1166445 1166661 1166666) (-794 "PARTPERM.spad" 1164491 1164499 1166425 1166430) (-793 "PARSURF.spad" 1163925 1163953 1164481 1164486) (-792 "PARSU2.spad" 1163722 1163738 1163915 1163920) (-791 "script-parser.spad" 1163242 1163250 1163712 1163717) (-790 "PARSCURV.spad" 1162676 1162704 1163232 1163237) (-789 "PARSC2.spad" 1162467 1162483 1162666 1162671) (-788 "PARPCURV.spad" 1161929 1161957 1162457 1162462) (-787 "PARPC2.spad" 1161720 1161736 1161919 1161924) (-786 "PARAMAST.spad" 1160848 1160856 1161710 1161715) (-785 "PAN2EXPR.spad" 1160260 1160268 1160838 1160843) (-784 "PALETTE.spad" 1159374 1159382 1160250 1160255) (-783 "PAIR.spad" 1158448 1158461 1159017 1159022) (-782 "PADICRC.spad" 1155853 1155871 1157016 1157109) (-781 "PADICRAT.spad" 1153913 1153925 1154126 1154219) (-780 "PADICCT.spad" 1152462 1152474 1153839 1153908) (-779 "PADIC.spad" 1152165 1152177 1152388 1152457) (-778 "PADEPAC.spad" 1150854 1150873 1152155 1152160) (-777 "PADE.spad" 1149606 1149622 1150844 1150849) (-776 "OWP.spad" 1148854 1148884 1149464 1149531) (-775 "OVERSET.spad" 1148427 1148435 1148844 1148849) (-774 "OVAR.spad" 1148208 1148231 1148417 1148422) (-773 "OUTFORM.spad" 1137616 1137624 1148198 1148203) (-772 "OUTBFILE.spad" 1137050 1137058 1137606 1137611) (-771 "OUTBCON.spad" 1136120 1136128 1137040 1137045) (-770 "OUTBCON.spad" 1135188 1135198 1136110 1136115) (-769 "OUT.spad" 1134306 1134314 1135178 1135183) (-768 "OSI.spad" 1133781 1133789 1134296 1134301) (-767 "OSGROUP.spad" 1133699 1133707 1133771 1133776) (-766 "ORTHPOL.spad" 1132210 1132220 1133642 1133647) (-765 "OREUP.spad" 1131704 1131732 1131931 1131970) (-764 "ORESUP.spad" 1131046 1131070 1131425 1131464) (-763 "OREPCTO.spad" 1128935 1128947 1130966 1130971) (-762 "OREPCAT.spad" 1123122 1123132 1128891 1128930) (-761 "OREPCAT.spad" 1117199 1117211 1122970 1122975) (-760 "ORDTYPE.spad" 1116436 1116444 1117189 1117194) (-759 "ORDTYPE.spad" 1115671 1115681 1116426 1116431) (-758 "ORDSTRCT.spad" 1115457 1115472 1115620 1115625) (-757 "ORDSET.spad" 1115157 1115165 1115447 1115452) (-756 "ORDRING.spad" 1114974 1114982 1115137 1115152) (-755 "ORDMON.spad" 1114829 1114837 1114964 1114969) (-754 "ORDFUNS.spad" 1113961 1113977 1114819 1114824) (-753 "ORDFIN.spad" 1113781 1113789 1113951 1113956) (-752 "ORDCOMP2.spad" 1113074 1113086 1113771 1113776) (-751 "ORDCOMP.spad" 1111600 1111610 1112682 1112711) (-750 "OPSIG.spad" 1111262 1111270 1111590 1111595) (-749 "OPQUERY.spad" 1110843 1110851 1111252 1111257) (-748 "OPERCAT.spad" 1110309 1110319 1110833 1110838) (-747 "OPERCAT.spad" 1109773 1109785 1110299 1110304) (-746 "OP.spad" 1109515 1109525 1109595 1109662) (-745 "ONECOMP2.spad" 1108939 1108951 1109505 1109510) (-744 "ONECOMP.spad" 1107745 1107755 1108547 1108576) (-743 "OMSAGG.spad" 1107545 1107555 1107713 1107740) (-742 "OMLO.spad" 1106978 1106990 1107431 1107470) (-741 "OINTDOM.spad" 1106741 1106749 1106904 1106973) (-740 "OFMONOID.spad" 1104880 1104890 1106697 1106702) (-739 "ODVAR.spad" 1104141 1104151 1104870 1104875) (-738 "ODR.spad" 1103785 1103811 1103953 1104102) (-737 "ODPOL.spad" 1101433 1101443 1101773 1101900) (-736 "ODP.spad" 1090981 1091001 1091354 1091439) (-735 "ODETOOLS.spad" 1089630 1089649 1090971 1090976) (-734 "ODESYS.spad" 1087324 1087341 1089620 1089625) (-733 "ODERTRIC.spad" 1083357 1083374 1087281 1087286) (-732 "ODERED.spad" 1082756 1082780 1083347 1083352) (-731 "ODERAT.spad" 1080389 1080406 1082746 1082751) (-730 "ODEPRRIC.spad" 1077482 1077504 1080379 1080384) (-729 "ODEPRIM.spad" 1074880 1074902 1077472 1077477) (-728 "ODEPAL.spad" 1074266 1074290 1074870 1074875) (-727 "ODEINT.spad" 1073701 1073717 1074256 1074261) (-726 "ODEEF.spad" 1069196 1069212 1073691 1073696) (-725 "ODECONST.spad" 1068741 1068759 1069186 1069191) (-724 "OCTCT2.spad" 1068382 1068400 1068731 1068736) (-723 "OCT.spad" 1066697 1066707 1067411 1067450) (-722 "OCAMON.spad" 1066545 1066553 1066687 1066692) (-721 "OC.spad" 1064341 1064351 1066501 1066540) (-720 "OC.spad" 1061876 1061888 1064038 1064043) (-719 "OASGP.spad" 1061691 1061699 1061866 1061871) (-718 "OAMONS.spad" 1061213 1061221 1061681 1061686) (-717 "OAMON.spad" 1060971 1060979 1061203 1061208) (-716 "OAMON.spad" 1060727 1060737 1060961 1060966) (-715 "OAGROUP.spad" 1060265 1060273 1060717 1060722) (-714 "OAGROUP.spad" 1059801 1059811 1060255 1060260) (-713 "NUMTUBE.spad" 1059392 1059408 1059791 1059796) (-712 "NUMQUAD.spad" 1047368 1047376 1059382 1059387) (-711 "NUMODE.spad" 1038720 1038728 1047358 1047363) (-710 "NUMFMT.spad" 1037560 1037568 1038710 1038715) (-709 "NUMERIC.spad" 1029675 1029685 1037366 1037371) (-708 "NTSCAT.spad" 1028195 1028211 1029655 1029670) (-707 "NTPOLFN.spad" 1027772 1027782 1028138 1028143) (-706 "NSUP2.spad" 1027164 1027176 1027762 1027767) (-705 "NSUP.spad" 1020601 1020611 1025021 1025174) (-704 "NSMP.spad" 1017513 1017532 1017805 1017932) (-703 "NREP.spad" 1015915 1015929 1017503 1017508) (-702 "NPCOEF.spad" 1015161 1015181 1015905 1015910) (-701 "NORMRETR.spad" 1014759 1014798 1015151 1015156) (-700 "NORMPK.spad" 1012701 1012720 1014749 1014754) (-699 "NORMMA.spad" 1012389 1012415 1012691 1012696) (-698 "NONE1.spad" 1012065 1012075 1012379 1012384) (-697 "NONE.spad" 1011806 1011814 1012055 1012060) (-696 "NODE1.spad" 1011293 1011309 1011796 1011801) (-695 "NNI.spad" 1010188 1010196 1011267 1011288) (-694 "NLINSOL.spad" 1008814 1008824 1010178 1010183) (-693 "NFINTBAS.spad" 1006374 1006391 1008804 1008809) (-692 "NETCLT.spad" 1006348 1006359 1006364 1006369) (-691 "NCODIV.spad" 1004572 1004588 1006338 1006343) (-690 "NCNTFRAC.spad" 1004214 1004228 1004562 1004567) (-689 "NCEP.spad" 1002380 1002394 1004204 1004209) (-688 "NASRING.spad" 1001984 1001992 1002370 1002375) (-687 "NASRING.spad" 1001586 1001596 1001974 1001979) (-686 "NARNG.spad" 1000986 1000994 1001576 1001581) (-685 "NARNG.spad" 1000384 1000394 1000976 1000981) (-684 "NAALG.spad" 999949 999959 1000352 1000379) (-683 "NAALG.spad" 999534 999546 999939 999944) (-682 "MULTSQFR.spad" 996492 996509 999524 999529) (-681 "MULTFACT.spad" 995875 995892 996482 996487) (-680 "MTSCAT.spad" 993969 993990 995773 995870) (-679 "MTHING.spad" 993628 993638 993959 993964) (-678 "MSYSCMD.spad" 993062 993070 993618 993623) (-677 "MSETAGG.spad" 992907 992917 993030 993057) (-676 "MSET.spad" 990705 990715 992452 992479) (-675 "MRING.spad" 987682 987694 990413 990480) (-674 "MRF2.spad" 987244 987258 987672 987677) (-673 "MRATFAC.spad" 986790 986807 987234 987239) (-672 "MPRFF.spad" 984830 984849 986780 986785) (-671 "MPOLY.spad" 982634 982649 982993 983120) (-670 "MPCPF.spad" 981898 981917 982624 982629) (-669 "MPC3.spad" 981715 981755 981888 981893) (-668 "MPC2.spad" 981369 981402 981705 981710) (-667 "MONOTOOL.spad" 979720 979737 981359 981364) (-666 "catdef.spad" 979153 979164 979374 979715) (-665 "catdef.spad" 978551 978562 978807 979148) (-664 "MONOID.spad" 977872 977880 978541 978546) (-663 "MONOID.spad" 977191 977201 977862 977867) (-662 "MONOGEN.spad" 975939 975952 977051 977186) (-661 "MONOGEN.spad" 974709 974724 975823 975828) (-660 "MONADWU.spad" 972789 972797 974699 974704) (-659 "MONADWU.spad" 970867 970877 972779 972784) (-658 "MONAD.spad" 970027 970035 970857 970862) (-657 "MONAD.spad" 969185 969195 970017 970022) (-656 "MOEBIUS.spad" 967921 967935 969165 969180) (-655 "MODULE.spad" 967791 967801 967889 967916) (-654 "MODULE.spad" 967681 967693 967781 967786) (-653 "MODRING.spad" 967016 967055 967661 967676) (-652 "MODOP.spad" 965673 965685 966838 966905) (-651 "MODMONOM.spad" 965404 965422 965663 965668) (-650 "MODMON.spad" 962474 962486 963189 963342) (-649 "MODFIELD.spad" 961836 961875 962376 962469) (-648 "MMLFORM.spad" 960696 960704 961826 961831) (-647 "MMAP.spad" 960438 960472 960686 960691) (-646 "MLO.spad" 958897 958907 960394 960433) (-645 "MLIFT.spad" 957509 957526 958887 958892) (-644 "MKUCFUNC.spad" 957044 957062 957499 957504) (-643 "MKRECORD.spad" 956632 956645 957034 957039) (-642 "MKFUNC.spad" 956039 956049 956622 956627) (-641 "MKFLCFN.spad" 955007 955017 956029 956034) (-640 "MKBCFUNC.spad" 954502 954520 954997 955002) (-639 "MHROWRED.spad" 953013 953023 954492 954497) (-638 "MFINFACT.spad" 952413 952435 953003 953008) (-637 "MESH.spad" 950208 950216 952403 952408) (-636 "MDDFACT.spad" 948427 948437 950198 950203) (-635 "MDAGG.spad" 947718 947728 948407 948422) (-634 "MCDEN.spad" 946928 946940 947708 947713) (-633 "MAYBE.spad" 946228 946239 946918 946923) (-632 "MATSTOR.spad" 943544 943554 946218 946223) (-631 "MATRIX.spad" 942335 942345 942819 942834) (-630 "MATLIN.spad" 939703 939727 942219 942224) (-629 "MATCAT2.spad" 938985 939033 939693 939698) (-628 "MATCAT.spad" 930693 930715 938965 938980) (-627 "MATCAT.spad" 922261 922285 930535 930540) (-626 "MAPPKG3.spad" 921176 921190 922251 922256) (-625 "MAPPKG2.spad" 920514 920526 921166 921171) (-624 "MAPPKG1.spad" 919342 919352 920504 920509) (-623 "MAPPAST.spad" 918681 918689 919332 919337) (-622 "MAPHACK3.spad" 918493 918507 918671 918676) (-621 "MAPHACK2.spad" 918262 918274 918483 918488) (-620 "MAPHACK1.spad" 917906 917916 918252 918257) (-619 "MAGMA.spad" 915712 915729 917896 917901) (-618 "MACROAST.spad" 915307 915315 915702 915707) (-617 "LZSTAGG.spad" 912561 912571 915297 915302) (-616 "LZSTAGG.spad" 909813 909825 912551 912556) (-615 "LWORD.spad" 906558 906575 909803 909808) (-614 "LSTAST.spad" 906342 906350 906548 906553) (-613 "LSQM.spad" 904632 904646 905026 905065) (-612 "LSPP.spad" 904167 904184 904622 904627) (-611 "LSMP1.spad" 902010 902024 904157 904162) (-610 "LSMP.spad" 900867 900895 902000 902005) (-609 "LSAGG.spad" 900548 900558 900847 900862) (-608 "LSAGG.spad" 900237 900249 900538 900543) (-607 "LPOLY.spad" 899199 899218 900093 900162) (-606 "LPEFRAC.spad" 898470 898480 899189 899194) (-605 "LOGIC.spad" 898072 898080 898460 898465) (-604 "LOGIC.spad" 897672 897682 898062 898067) (-603 "LODOOPS.spad" 896602 896614 897662 897667) (-602 "LODOF.spad" 895648 895665 896559 896564) (-601 "LODOCAT.spad" 894314 894324 895604 895643) (-600 "LODOCAT.spad" 892978 892990 894270 894275) (-599 "LODO2.spad" 892292 892304 892699 892738) (-598 "LODO1.spad" 891733 891743 892013 892052) (-597 "LODO.spad" 891158 891174 891454 891493) (-596 "LODEEF.spad" 889960 889978 891148 891153) (-595 "LO.spad" 889361 889375 889894 889921) (-594 "LNAGG.spad" 885548 885558 889351 889356) (-593 "LNAGG.spad" 881699 881711 885504 885509) (-592 "LMOPS.spad" 878467 878484 881689 881694) (-591 "LMODULE.spad" 878251 878261 878457 878462) (-590 "LMDICT.spad" 877483 877493 877731 877746) (-589 "LLINSET.spad" 877190 877200 877473 877478) (-588 "LITERAL.spad" 877096 877107 877180 877185) (-587 "LIST3.spad" 876407 876421 877086 877091) (-586 "LIST2MAP.spad" 873334 873346 876397 876402) (-585 "LIST2.spad" 872036 872048 873324 873329) (-584 "LIST.spad" 869605 869615 870948 870963) (-583 "LINSET.spad" 869384 869394 869595 869600) (-582 "LINFORM.spad" 868847 868859 869352 869379) (-581 "LINEXP.spad" 867590 867600 868837 868842) (-580 "LINELT.spad" 866961 866973 867473 867500) (-579 "LINDEP.spad" 865810 865822 866873 866878) (-578 "LINBASIS.spad" 865446 865461 865800 865805) (-577 "LIMITRF.spad" 863393 863403 865436 865441) (-576 "LIMITPS.spad" 862303 862316 863383 863388) (-575 "LIECAT.spad" 861787 861797 862229 862298) (-574 "LIECAT.spad" 861299 861311 861743 861748) (-573 "LIE.spad" 859303 859315 860577 860719) (-572 "LIB.spad" 857156 857164 857602 857617) (-571 "LGROBP.spad" 854509 854528 857146 857151) (-570 "LFCAT.spad" 853568 853576 854499 854504) (-569 "LF.spad" 852523 852539 853558 853563) (-568 "LEXTRIPK.spad" 848146 848161 852513 852518) (-567 "LEXP.spad" 846165 846192 848126 848141) (-566 "LETAST.spad" 845864 845872 846155 846160) (-565 "LEADCDET.spad" 844270 844287 845854 845859) (-564 "LAZM3PK.spad" 843014 843036 844260 844265) (-563 "LAUPOL.spad" 841681 841694 842581 842650) (-562 "LAPLACE.spad" 841264 841280 841671 841676) (-561 "LALG.spad" 841040 841050 841244 841259) (-560 "LALG.spad" 840824 840836 841030 841035) (-559 "LA.spad" 840264 840278 840746 840785) (-558 "KVTFROM.spad" 840007 840017 840254 840259) (-557 "KTVLOGIC.spad" 839551 839559 839997 840002) (-556 "KRCFROM.spad" 839297 839307 839541 839546) (-555 "KOVACIC.spad" 838028 838045 839287 839292) (-554 "KONVERT.spad" 837750 837760 838018 838023) (-553 "KOERCE.spad" 837487 837497 837740 837745) (-552 "KERNEL2.spad" 837190 837202 837477 837482) (-551 "KERNEL.spad" 835910 835920 837039 837044) (-550 "KDAGG.spad" 835019 835041 835890 835905) (-549 "KDAGG.spad" 834136 834160 835009 835014) (-548 "KAFILE.spad" 832563 832579 832798 832813) (-547 "JVMOP.spad" 832476 832484 832553 832558) (-546 "JVMMDACC.spad" 831530 831538 832466 832471) (-545 "JVMFDACC.spad" 830846 830854 831520 831525) (-544 "JVMCSTTG.spad" 829575 829583 830836 830841) (-543 "JVMCFACC.spad" 829021 829029 829565 829570) (-542 "JVMBCODE.spad" 828932 828940 829011 829016) (-541 "JORDAN.spad" 826749 826761 828210 828352) (-540 "JOINAST.spad" 826451 826459 826739 826744) (-539 "IXAGG.spad" 824584 824608 826441 826446) (-538 "IXAGG.spad" 822547 822573 824406 824411) (-537 "ITUPLE.spad" 821723 821733 822537 822542) (-536 "ITRIGMNP.spad" 820570 820589 821713 821718) (-535 "ITFUN3.spad" 820076 820090 820560 820565) (-534 "ITFUN2.spad" 819820 819832 820066 820071) (-533 "ITFORM.spad" 819175 819183 819810 819815) (-532 "ITAYLOR.spad" 817169 817184 819039 819136) (-531 "ISUPS.spad" 809618 809633 816155 816252) (-530 "ISUMP.spad" 809119 809135 809608 809613) (-529 "ISAST.spad" 808838 808846 809109 809114) (-528 "IRURPK.spad" 807555 807574 808828 808833) (-527 "IRSN.spad" 805559 805567 807545 807550) (-526 "IRRF2F.spad" 804052 804062 805515 805520) (-525 "IRREDFFX.spad" 803653 803664 804042 804047) (-524 "IROOT.spad" 801992 802002 803643 803648) (-523 "IRFORM.spad" 801316 801324 801982 801987) (-522 "IR2F.spad" 800530 800546 801306 801311) (-521 "IR2.spad" 799558 799574 800520 800525) (-520 "IR.spad" 797394 797408 799440 799467) (-519 "IPRNTPK.spad" 797154 797162 797384 797389) (-518 "IPF.spad" 796719 796731 796959 797052) (-517 "IPADIC.spad" 796488 796514 796645 796714) (-516 "IP4ADDR.spad" 796045 796053 796478 796483) (-515 "IOMODE.spad" 795567 795575 796035 796040) (-514 "IOBFILE.spad" 794952 794960 795557 795562) (-513 "IOBCON.spad" 794817 794825 794942 794947) (-512 "INVLAPLA.spad" 794466 794482 794807 794812) (-511 "INTTR.spad" 787860 787877 794456 794461) (-510 "INTTOOLS.spad" 785668 785684 787487 787492) (-509 "INTSLPE.spad" 784996 785004 785658 785663) (-508 "INTRVL.spad" 784562 784572 784910 784991) (-507 "INTRF.spad" 782994 783008 784552 784557) (-506 "INTRET.spad" 782426 782436 782984 782989) (-505 "INTRAT.spad" 781161 781178 782416 782421) (-504 "INTPM.spad" 779624 779640 780882 780887) (-503 "INTPAF.spad" 777500 777518 779553 779558) (-502 "INTHERTR.spad" 776774 776791 777490 777495) (-501 "INTHERAL.spad" 776444 776468 776764 776769) (-500 "INTHEORY.spad" 772883 772891 776434 776439) (-499 "INTG0.spad" 766647 766665 772812 772817) (-498 "INTFACT.spad" 765714 765724 766637 766642) (-497 "INTEF.spad" 764125 764141 765704 765709) (-496 "INTDOM.spad" 762748 762756 764051 764120) (-495 "INTDOM.spad" 761433 761443 762738 762743) (-494 "INTCAT.spad" 759700 759710 761347 761428) (-493 "INTBIT.spad" 759207 759215 759690 759695) (-492 "INTALG.spad" 758395 758422 759197 759202) (-491 "INTAF.spad" 757895 757911 758385 758390) (-490 "INTABL.spad" 755763 755794 755926 755941) (-489 "INT8.spad" 755643 755651 755753 755758) (-488 "INT64.spad" 755522 755530 755633 755638) (-487 "INT32.spad" 755401 755409 755512 755517) (-486 "INT16.spad" 755280 755288 755391 755396) (-485 "INT.spad" 754806 754814 755146 755275) (-484 "INS.spad" 752309 752317 754708 754801) (-483 "INS.spad" 749898 749908 752299 752304) (-482 "INPSIGN.spad" 749368 749381 749888 749893) (-481 "INPRODPF.spad" 748464 748483 749358 749363) (-480 "INPRODFF.spad" 747552 747576 748454 748459) (-479 "INNMFACT.spad" 746527 746544 747542 747547) (-478 "INMODGCD.spad" 746031 746061 746517 746522) (-477 "INFSP.spad" 744328 744350 746021 746026) (-476 "INFPROD0.spad" 743408 743427 744318 744323) (-475 "INFORM1.spad" 743033 743043 743398 743403) (-474 "INFORM.spad" 740244 740252 743023 743028) (-473 "INFINITY.spad" 739796 739804 740234 740239) (-472 "INETCLTS.spad" 739773 739781 739786 739791) (-471 "INEP.spad" 738319 738341 739763 739768) (-470 "INDE.spad" 737968 737985 738229 738234) (-469 "INCRMAPS.spad" 737405 737415 737958 737963) (-468 "INBFILE.spad" 736501 736509 737395 737400) (-467 "INBFF.spad" 732351 732362 736491 736496) (-466 "INBCON.spad" 730617 730625 732341 732346) (-465 "INBCON.spad" 728881 728891 730607 730612) (-464 "INAST.spad" 728542 728550 728871 728876) (-463 "IMPTAST.spad" 728250 728258 728532 728537) (-462 "IMATQF.spad" 727316 727360 728178 728183) (-461 "IMATLIN.spad" 725909 725933 727244 727249) (-460 "IFF.spad" 725322 725338 725593 725686) (-459 "IFAST.spad" 724936 724944 725312 725317) (-458 "IFARRAY.spad" 722150 722165 723848 723863) (-457 "IFAMON.spad" 722012 722029 722106 722111) (-456 "IEVALAB.spad" 721425 721437 722002 722007) (-455 "IEVALAB.spad" 720836 720850 721415 721420) (-454 "indexedp.spad" 720392 720404 720826 720831) (-453 "IDPOAMS.spad" 720070 720082 720304 720309) (-452 "IDPOAM.spad" 719712 719724 719982 719987) (-451 "IDPO.spad" 719126 719138 719624 719629) (-450 "IDPC.spad" 717841 717853 719116 719121) (-449 "IDPAM.spad" 717508 717520 717753 717758) (-448 "IDPAG.spad" 717177 717189 717420 717425) (-447 "IDENT.spad" 716829 716837 717167 717172) (-446 "catdef.spad" 716600 716611 716712 716824) (-445 "IDECOMP.spad" 713839 713857 716590 716595) (-444 "IDEAL.spad" 708801 708840 713787 713792) (-443 "ICDEN.spad" 708014 708030 708791 708796) (-442 "ICARD.spad" 707407 707415 708004 708009) (-441 "IBPTOOLS.spad" 706014 706031 707397 707402) (-440 "boolean.spad" 705296 705309 705429 705444) (-439 "IBATOOL.spad" 702281 702300 705286 705291) (-438 "IBACHIN.spad" 700788 700803 702271 702276) (-437 "array2.spad" 700285 700307 700472 700487) (-436 "IARRAY1.spad" 699051 699066 699197 699212) (-435 "IAN.spad" 697433 697441 698882 698975) (-434 "IALGFACT.spad" 697044 697077 697423 697428) (-433 "HYPCAT.spad" 696468 696476 697034 697039) (-432 "HYPCAT.spad" 695890 695900 696458 696463) (-431 "HOSTNAME.spad" 695706 695714 695880 695885) (-430 "HOMOTOP.spad" 695449 695459 695696 695701) (-429 "HOAGG.spad" 694685 694695 695439 695444) (-428 "HOAGG.spad" 693707 693719 694463 694468) (-427 "HEXADEC.spad" 691932 691940 692297 692390) (-426 "HEUGCD.spad" 691023 691034 691922 691927) (-425 "HELLFDIV.spad" 690629 690653 691013 691018) (-424 "HEAP.spad" 690098 690108 690313 690328) (-423 "HEADAST.spad" 689639 689647 690088 690093) (-422 "HDP.spad" 679183 679199 679560 679645) (-421 "HDMP.spad" 676730 676745 677346 677473) (-420 "HB.spad" 675005 675013 676720 676725) (-419 "HASHTBL.spad" 672825 672856 673036 673051) (-418 "HASAST.spad" 672541 672549 672815 672820) (-417 "HACKPI.spad" 672032 672040 672443 672536) (-416 "GTSET.spad" 670810 670826 671517 671532) (-415 "GSTBL.spad" 668667 668702 668841 668856) (-414 "GSERIES.spad" 666039 666066 666858 667007) (-413 "GROUP.spad" 665312 665320 666019 666034) (-412 "GROUP.spad" 664593 664603 665302 665307) (-411 "GROEBSOL.spad" 663087 663108 664583 664588) (-410 "GRMOD.spad" 661668 661680 663077 663082) (-409 "GRMOD.spad" 660247 660261 661658 661663) (-408 "GRIMAGE.spad" 653160 653168 660237 660242) (-407 "GRDEF.spad" 651539 651547 653150 653155) (-406 "GRAY.spad" 650010 650018 651529 651534) (-405 "GRALG.spad" 649105 649117 650000 650005) (-404 "GRALG.spad" 648198 648212 649095 649100) (-403 "GPOLSET.spad" 647507 647530 647719 647734) (-402 "GOSPER.spad" 646784 646802 647497 647502) (-401 "GMODPOL.spad" 645932 645959 646752 646779) (-400 "GHENSEL.spad" 645015 645029 645922 645927) (-399 "GENUPS.spad" 641308 641321 645005 645010) (-398 "GENUFACT.spad" 640885 640895 641298 641303) (-397 "GENPGCD.spad" 640487 640504 640875 640880) (-396 "GENMFACT.spad" 639939 639958 640477 640482) (-395 "GENEEZ.spad" 637898 637911 639929 639934) (-394 "GDMP.spad" 635287 635304 636061 636188) (-393 "GCNAALG.spad" 629210 629237 635081 635148) (-392 "GCDDOM.spad" 628402 628410 629136 629205) (-391 "GCDDOM.spad" 627656 627666 628392 628397) (-390 "GBINTERN.spad" 623676 623714 627646 627651) (-389 "GBF.spad" 619459 619497 623666 623671) (-388 "GBEUCLID.spad" 617341 617379 619449 619454) (-387 "GB.spad" 614867 614905 617297 617302) (-386 "GAUSSFAC.spad" 614180 614188 614857 614862) (-385 "GALUTIL.spad" 612506 612516 614136 614141) (-384 "GALPOLYU.spad" 610960 610973 612496 612501) (-383 "GALFACTU.spad" 609173 609192 610950 610955) (-382 "GALFACT.spad" 599386 599397 609163 609168) (-381 "FUNDESC.spad" 599064 599072 599376 599381) (-380 "FUNCTION.spad" 598913 598925 599054 599059) (-379 "FT.spad" 597213 597221 598903 598908) (-378 "FSUPFACT.spad" 596127 596146 597163 597168) (-377 "FST.spad" 594213 594221 596117 596122) (-376 "FSRED.spad" 593693 593709 594203 594208) (-375 "FSPRMELT.spad" 592559 592575 593650 593655) (-374 "FSPECF.spad" 590650 590666 592549 592554) (-373 "FSINT.spad" 590310 590326 590640 590645) (-372 "FSERIES.spad" 589501 589513 590130 590229) (-371 "FSCINT.spad" 588818 588834 589491 589496) (-370 "FSAGG2.spad" 587553 587569 588808 588813) (-369 "FSAGG.spad" 586682 586692 587521 587548) (-368 "FSAGG.spad" 585761 585773 586602 586607) (-367 "FS2UPS.spad" 580276 580310 585751 585756) (-366 "FS2EXPXP.spad" 579417 579440 580266 580271) (-365 "FS2.spad" 579072 579088 579407 579412) (-364 "FS.spad" 573344 573354 578851 579067) (-363 "FS.spad" 567418 567430 572927 572932) (-362 "FRUTIL.spad" 566372 566382 567408 567413) (-361 "FRNAALG.spad" 561649 561659 566314 566367) (-360 "FRNAALG.spad" 556938 556950 561605 561610) (-359 "FRNAAF2.spad" 556386 556404 556928 556933) (-358 "FRMOD.spad" 555794 555824 556315 556320) (-357 "FRIDEAL2.spad" 555398 555430 555784 555789) (-356 "FRIDEAL.spad" 554623 554644 555378 555393) (-355 "FRETRCT.spad" 554142 554152 554613 554618) (-354 "FRETRCT.spad" 553568 553580 554041 554046) (-353 "FRAMALG.spad" 551948 551961 553524 553563) (-352 "FRAMALG.spad" 550360 550375 551938 551943) (-351 "FRAC2.spad" 549965 549977 550350 550355) (-350 "FRAC.spad" 547952 547962 548339 548512) (-349 "FR2.spad" 547288 547300 547942 547947) (-348 "FR.spad" 541076 541086 546349 546418) (-347 "FPS.spad" 537915 537923 540966 541071) (-346 "FPS.spad" 534782 534792 537835 537840) (-345 "FPC.spad" 533828 533836 534684 534777) (-344 "FPC.spad" 532960 532970 533818 533823) (-343 "FPATMAB.spad" 532722 532732 532950 532955) (-342 "FPARFRAC.spad" 531564 531581 532712 532717) (-341 "FORDER.spad" 531255 531279 531554 531559) (-340 "FNLA.spad" 530679 530701 531223 531250) (-339 "FNCAT.spad" 529274 529282 530669 530674) (-338 "FNAME.spad" 529166 529174 529264 529269) (-337 "FMONOID.spad" 528847 528857 529122 529127) (-336 "FMONCAT.spad" 526016 526026 528837 528842) (-335 "FMCAT.spad" 523692 523710 525984 526011) (-334 "FM1.spad" 523057 523069 523626 523653) (-333 "FM.spad" 522672 522684 522911 522938) (-332 "FLOATRP.spad" 520415 520429 522662 522667) (-331 "FLOATCP.spad" 517854 517868 520405 520410) (-330 "FLOAT.spad" 514945 514953 517720 517849) (-329 "FLINEXP.spad" 514667 514677 514935 514940) (-328 "FLINEXP.spad" 514346 514358 514616 514621) (-327 "FLASORT.spad" 513672 513684 514336 514341) (-326 "FLALG.spad" 511342 511361 513598 513667) (-325 "FLAGG2.spad" 510059 510075 511332 511337) (-324 "FLAGG.spad" 507135 507145 510049 510054) (-323 "FLAGG.spad" 504076 504088 506992 506997) (-322 "FINRALG.spad" 502161 502174 504032 504071) (-321 "FINRALG.spad" 500172 500187 502045 502050) (-320 "FINITE.spad" 499324 499332 500162 500167) (-319 "FINITE.spad" 498474 498484 499314 499319) (-318 "aggcat.spad" 495404 495414 498464 498469) (-317 "FINAGG.spad" 492299 492311 495361 495366) (-316 "FINAALG.spad" 481484 481494 492241 492294) (-315 "FINAALG.spad" 470681 470693 481440 481445) (-314 "FILECAT.spad" 469215 469232 470671 470676) (-313 "FILE.spad" 468798 468808 469205 469210) (-312 "FIELD.spad" 468204 468212 468700 468793) (-311 "FIELD.spad" 467696 467706 468194 468199) (-310 "FGROUP.spad" 466359 466369 467676 467691) (-309 "FGLMICPK.spad" 465154 465169 466349 466354) (-308 "FFX.spad" 464540 464555 464873 464966) (-307 "FFSLPE.spad" 464051 464072 464530 464535) (-306 "FFPOLY2.spad" 463111 463128 464041 464046) (-305 "FFPOLY.spad" 454453 454464 463101 463106) (-304 "FFP.spad" 453861 453881 454172 454265) (-303 "FFNBX.spad" 452384 452404 453580 453673) (-302 "FFNBP.spad" 450908 450925 452103 452196) (-301 "FFNB.spad" 449376 449397 450592 450685) (-300 "FFINTBAS.spad" 446890 446909 449366 449371) (-299 "FFIELDC.spad" 444475 444483 446792 446885) (-298 "FFIELDC.spad" 442146 442156 444465 444470) (-297 "FFHOM.spad" 440918 440935 442136 442141) (-296 "FFF.spad" 438361 438372 440908 440913) (-295 "FFCGX.spad" 437219 437239 438080 438173) (-294 "FFCGP.spad" 436119 436139 436938 437031) (-293 "FFCG.spad" 434914 434935 435803 435896) (-292 "FFCAT2.spad" 434661 434701 434904 434909) (-291 "FFCAT.spad" 427826 427848 434500 434656) (-290 "FFCAT.spad" 421070 421094 427746 427751) (-289 "FF.spad" 420521 420537 420754 420847) (-288 "FEVALAB.spad" 420229 420239 420511 420516) (-287 "FEVALAB.spad" 419713 419725 419997 420002) (-286 "FDIVCAT.spad" 417809 417833 419703 419708) (-285 "FDIVCAT.spad" 415903 415929 417799 417804) (-284 "FDIV2.spad" 415559 415599 415893 415898) (-283 "FDIV.spad" 415017 415041 415549 415554) (-282 "FCTRDATA.spad" 414025 414033 415007 415012) (-281 "FCOMP.spad" 413404 413414 414015 414020) (-280 "FAXF.spad" 406439 406453 413306 413399) (-279 "FAXF.spad" 399526 399542 406395 406400) (-278 "FARRAY.spad" 397405 397415 398438 398453) (-277 "FAMR.spad" 395549 395561 397303 397400) (-276 "FAMR.spad" 393677 393691 395433 395438) (-275 "FAMONOID.spad" 393361 393371 393631 393636) (-274 "FAMONC.spad" 391681 391693 393351 393356) (-273 "FAGROUP.spad" 391321 391331 391577 391604) (-272 "FACUTIL.spad" 389533 389550 391311 391316) (-271 "FACTFUNC.spad" 388735 388745 389523 389528) (-270 "EXPUPXS.spad" 385627 385650 386926 387075) (-269 "EXPRTUBE.spad" 382915 382923 385617 385622) (-268 "EXPRODE.spad" 380083 380099 382905 382910) (-267 "EXPR2UPS.spad" 376205 376218 380073 380078) (-266 "EXPR2.spad" 375910 375922 376195 376200) (-265 "EXPR.spad" 371555 371565 372269 372556) (-264 "EXPEXPAN.spad" 368500 368525 369132 369225) (-263 "EXITAST.spad" 368236 368244 368490 368495) (-262 "EXIT.spad" 367907 367915 368226 368231) (-261 "EVALCYC.spad" 367367 367381 367897 367902) (-260 "EVALAB.spad" 366947 366957 367357 367362) (-259 "EVALAB.spad" 366525 366537 366937 366942) (-258 "EUCDOM.spad" 364115 364123 366451 366520) (-257 "EUCDOM.spad" 361767 361777 364105 364110) (-256 "ES2.spad" 361280 361296 361757 361762) (-255 "ES1.spad" 360850 360866 361270 361275) (-254 "ES.spad" 353721 353729 360840 360845) (-253 "ES.spad" 346513 346523 353634 353639) (-252 "ERROR.spad" 343840 343848 346503 346508) (-251 "EQTBL.spad" 341662 341684 341871 341886) (-250 "EQ2.spad" 341380 341392 341652 341657) (-249 "EQ.spad" 336286 336296 339081 339187) (-248 "EP.spad" 332612 332622 336276 336281) (-247 "ENV.spad" 331290 331298 332602 332607) (-246 "ENTIRER.spad" 330958 330966 331234 331285) (-245 "ENTIRER.spad" 330670 330680 330948 330953) (-244 "EMR.spad" 329958 329999 330596 330665) (-243 "ELTAGG.spad" 328212 328231 329948 329953) (-242 "ELTAGG.spad" 326430 326451 328168 328173) (-241 "ELTAB.spad" 325905 325918 326420 326425) (-240 "ELFUTS.spad" 325340 325359 325895 325900) (-239 "ELEMFUN.spad" 325029 325037 325330 325335) (-238 "ELEMFUN.spad" 324716 324726 325019 325024) (-237 "ELAGG.spad" 322687 322697 324696 324711) (-236 "ELAGG.spad" 320597 320609 322608 322613) (-235 "ELABOR.spad" 319943 319951 320587 320592) (-234 "ELABEXPR.spad" 318875 318883 319933 319938) (-233 "EFUPXS.spad" 315651 315681 318831 318836) (-232 "EFULS.spad" 312487 312510 315607 315612) (-231 "EFSTRUC.spad" 310502 310518 312477 312482) (-230 "EF.spad" 305278 305294 310492 310497) (-229 "EAB.spad" 303578 303586 305268 305273) (-228 "DVARCAT.spad" 300584 300594 303568 303573) (-227 "DVARCAT.spad" 297588 297600 300574 300579) (-226 "DSMP.spad" 295321 295335 295626 295753) (-225 "DSEXT.spad" 294623 294633 295311 295316) (-224 "DSEXT.spad" 293845 293857 294535 294540) (-223 "DROPT1.spad" 293510 293520 293835 293840) (-222 "DROPT0.spad" 288375 288383 293500 293505) (-221 "DROPT.spad" 282334 282342 288365 288370) (-220 "DRAWPT.spad" 280507 280515 282324 282329) (-219 "DRAWHACK.spad" 279815 279825 280497 280502) (-218 "DRAWCX.spad" 277293 277301 279805 279810) (-217 "DRAWCURV.spad" 276840 276855 277283 277288) (-216 "DRAWCFUN.spad" 266372 266380 276830 276835) (-215 "DRAW.spad" 259248 259261 266362 266367) (-214 "DQAGG.spad" 257438 257448 259228 259243) (-213 "DPOLCAT.spad" 252795 252811 257306 257433) (-212 "DPOLCAT.spad" 248238 248256 252751 252756) (-211 "DPMO.spad" 240852 240868 240990 241184) (-210 "DPMM.spad" 233479 233497 233604 233798) (-209 "DOMTMPLT.spad" 233250 233258 233469 233474) (-208 "DOMCTOR.spad" 233005 233013 233240 233245) (-207 "DOMAIN.spad" 232116 232124 232995 233000) (-206 "DMP.spad" 229709 229724 230279 230406) (-205 "DMEXT.spad" 229576 229586 229677 229704) (-204 "DLP.spad" 228936 228946 229566 229571) (-203 "DLIST.spad" 227244 227254 227848 227863) (-202 "DLAGG.spad" 225661 225671 227234 227239) (-201 "DIVRING.spad" 225203 225211 225605 225656) (-200 "DIVRING.spad" 224789 224799 225193 225198) (-199 "DISPLAY.spad" 222979 222987 224779 224784) (-198 "DIRPROD2.spad" 221797 221815 222969 222974) (-197 "DIRPROD.spad" 211078 211094 211718 211803) (-196 "DIRPCAT.spad" 210373 210389 210988 211073) (-195 "DIRPCAT.spad" 209282 209300 209899 209904) (-194 "DIOSP.spad" 208107 208115 209272 209277) (-193 "DIOPS.spad" 207103 207113 208087 208102) (-192 "DIOPS.spad" 206046 206058 207032 207037) (-191 "catdef.spad" 205904 205912 206036 206041) (-190 "DIFRING.spad" 205742 205750 205884 205899) (-189 "DIFFSPC.spad" 205321 205329 205732 205737) (-188 "DIFFSPC.spad" 204898 204908 205311 205316) (-187 "DIFFMOD.spad" 204387 204397 204866 204893) (-186 "DIFFDOM.spad" 203552 203563 204377 204382) (-185 "DIFFDOM.spad" 202715 202728 203542 203547) (-184 "DIFEXT.spad" 202534 202544 202695 202710) (-183 "DIAGG.spad" 202164 202174 202514 202529) (-182 "DIAGG.spad" 201802 201814 202154 202159) (-181 "DHMATRIX.spad" 200191 200201 201336 201351) (-180 "DFSFUN.spad" 193831 193839 200181 200186) (-179 "DFLOAT.spad" 190438 190446 193721 193826) (-178 "DFINTTLS.spad" 188669 188685 190428 190433) (-177 "DERHAM.spad" 186583 186615 188649 188664) (-176 "DEQUEUE.spad" 185984 185994 186267 186282) (-175 "DEGRED.spad" 185601 185615 185974 185979) (-174 "DEFINTRF.spad" 183183 183193 185591 185596) (-173 "DEFINTEF.spad" 181721 181737 183173 183178) (-172 "DEFAST.spad" 181105 181113 181711 181716) (-171 "DECIMAL.spad" 179334 179342 179695 179788) (-170 "DDFACT.spad" 177155 177172 179324 179329) (-169 "DBLRESP.spad" 176755 176779 177145 177150) (-168 "DBASIS.spad" 176381 176396 176745 176750) (-167 "DBASE.spad" 175045 175055 176371 176376) (-166 "DATAARY.spad" 174531 174544 175035 175040) (-165 "CYCLOTOM.spad" 174037 174045 174521 174526) (-164 "CYCLES.spad" 170823 170831 174027 174032) (-163 "CVMP.spad" 170240 170250 170813 170818) (-162 "CTRIGMNP.spad" 168740 168756 170230 170235) (-161 "CTORKIND.spad" 168343 168351 168730 168735) (-160 "CTORCAT.spad" 167584 167592 168333 168338) (-159 "CTORCAT.spad" 166823 166833 167574 167579) (-158 "CTORCALL.spad" 166412 166422 166813 166818) (-157 "CTOR.spad" 166103 166111 166402 166407) (-156 "CSTTOOLS.spad" 165348 165361 166093 166098) (-155 "CRFP.spad" 159120 159133 165338 165343) (-154 "CRCEAST.spad" 158840 158848 159110 159115) (-153 "CRAPACK.spad" 157907 157917 158830 158835) (-152 "CPMATCH.spad" 157408 157423 157829 157834) (-151 "CPIMA.spad" 157113 157132 157398 157403) (-150 "COORDSYS.spad" 152122 152132 157103 157108) (-149 "CONTOUR.spad" 151549 151557 152112 152117) (-148 "CONTFRAC.spad" 147299 147309 151451 151544) (-147 "CONDUIT.spad" 147057 147065 147289 147294) (-146 "COMRING.spad" 146731 146739 146995 147052) (-145 "COMPPROP.spad" 146249 146257 146721 146726) (-144 "COMPLPAT.spad" 146016 146031 146239 146244) (-143 "COMPLEX2.spad" 145731 145743 146006 146011) (-142 "COMPLEX.spad" 141437 141447 141681 141939) (-141 "COMPILER.spad" 140986 140994 141427 141432) (-140 "COMPFACT.spad" 140588 140602 140976 140981) (-139 "COMPCAT.spad" 138663 138673 140325 140583) (-138 "COMPCAT.spad" 136479 136491 138143 138148) (-137 "COMMUPC.spad" 136227 136245 136469 136474) (-136 "COMMONOP.spad" 135760 135768 136217 136222) (-135 "COMMAAST.spad" 135523 135531 135750 135755) (-134 "COMM.spad" 135334 135342 135513 135518) (-133 "COMBOPC.spad" 134257 134265 135324 135329) (-132 "COMBINAT.spad" 133024 133034 134247 134252) (-131 "COMBF.spad" 130446 130462 133014 133019) (-130 "COLOR.spad" 129283 129291 130436 130441) (-129 "COLONAST.spad" 128949 128957 129273 129278) (-128 "CMPLXRT.spad" 128660 128677 128939 128944) (-127 "CLLCTAST.spad" 128322 128330 128650 128655) (-126 "CLIP.spad" 124430 124438 128312 128317) (-125 "CLIF.spad" 123085 123101 124386 124425) (-124 "CLAGG.spad" 121077 121087 123075 123080) (-123 "CLAGG.spad" 118928 118940 120928 120933) (-122 "CINTSLPE.spad" 118283 118296 118918 118923) (-121 "CHVAR.spad" 116421 116443 118273 118278) (-120 "CHARZ.spad" 116336 116344 116401 116416) (-119 "CHARPOL.spad" 115862 115872 116326 116331) (-118 "CHARNZ.spad" 115624 115632 115842 115857) (-117 "CHAR.spad" 112992 113000 115614 115619) (-116 "CFCAT.spad" 112320 112328 112982 112987) (-115 "CDEN.spad" 111540 111554 112310 112315) (-114 "CCLASS.spad" 109609 109617 110871 110898) (-113 "CATEGORY.spad" 108683 108691 109599 109604) (-112 "CATCTOR.spad" 108574 108582 108673 108678) (-111 "CATAST.spad" 108200 108208 108564 108569) (-110 "CASEAST.spad" 107914 107922 108190 108195) (-109 "CARTEN2.spad" 107304 107331 107904 107909) (-108 "CARTEN.spad" 103056 103080 107294 107299) (-107 "CARD.spad" 100351 100359 103030 103051) (-106 "CAPSLAST.spad" 100133 100141 100341 100346) (-105 "CACHSET.spad" 99757 99765 100123 100128) (-104 "CABMON.spad" 99312 99320 99747 99752) (-103 "BYTEORD.spad" 98987 98995 99302 99307) (-102 "BYTEBUF.spad" 96797 96805 98003 98018) (-101 "BYTE.spad" 96272 96280 96787 96792) (-100 "BTREE.spad" 95361 95371 95895 95910) (-99 "BTOURN.spad" 94383 94392 94984 94999) (-98 "BTCAT.spad" 93953 93962 94363 94378) (-97 "BTCAT.spad" 93531 93542 93943 93948) (-96 "BTAGG.spad" 93010 93017 93511 93526) (-95 "BTAGG.spad" 92497 92506 93000 93005) (-94 "BSTREE.spad" 91255 91264 92120 92135) (-93 "BRILL.spad" 89461 89471 91245 91250) (-92 "BRAGG.spad" 88418 88427 89451 89456) (-91 "BRAGG.spad" 87311 87322 88346 88351) (-90 "BPADICRT.spad" 85371 85382 85617 85710) (-89 "BPADIC.spad" 85044 85055 85297 85366) (-88 "BOUNDZRO.spad" 84701 84717 85034 85039) (-87 "BOP1.spad" 82160 82169 84691 84696) (-86 "BOP.spad" 77303 77310 82150 82155) (-85 "BOOLEAN.spad" 76852 76859 77293 77298) (-84 "BOOLE.spad" 76503 76510 76842 76847) (-83 "BOOLE.spad" 76152 76161 76493 76498) (-82 "BMODULE.spad" 75865 75876 76120 76147) (-81 "BITS.spad" 75066 75073 75280 75295) (-80 "catdef.spad" 74949 74959 75056 75061) (-79 "catdef.spad" 74700 74710 74939 74944) (-78 "BINDING.spad" 74122 74129 74690 74695) (-77 "BINARY.spad" 72357 72364 72712 72805) (-76 "BGAGG.spad" 71677 71686 72337 72352) (-75 "BGAGG.spad" 71005 71016 71667 71672) (-74 "BEZOUT.spad" 70146 70172 70955 70960) (-73 "BBTREE.spad" 67040 67049 69769 69784) (-72 "BASTYPE.spad" 66540 66547 67030 67035) (-71 "BASTYPE.spad" 66038 66047 66530 66535) (-70 "BALFACT.spad" 65498 65510 66028 66033) (-69 "AUTOMOR.spad" 64949 64958 65478 65493) (-68 "ATTREG.spad" 62081 62088 64725 64944) (-67 "ATTRAST.spad" 61798 61805 62071 62076) (-66 "ATRIG.spad" 61268 61275 61788 61793) (-65 "ATRIG.spad" 60736 60745 61258 61263) (-64 "ASTCAT.spad" 60640 60647 60726 60731) (-63 "ASTCAT.spad" 60542 60551 60630 60635) (-62 "ASTACK.spad" 59958 59967 60226 60241) (-61 "ASSOCEQ.spad" 58792 58803 59914 59919) (-60 "ARRAY2.spad" 58327 58336 58476 58491) (-59 "ARRAY12.spad" 57040 57051 58317 58322) (-58 "ARRAY1.spad" 55606 55615 55952 55967) (-57 "ARR2CAT.spad" 51658 51679 55586 55601) (-56 "ARR2CAT.spad" 47718 47741 51648 51653) (-55 "ARITY.spad" 47090 47097 47708 47713) (-54 "APPRULE.spad" 46374 46396 47080 47085) (-53 "APPLYORE.spad" 45993 46006 46364 46369) (-52 "ANY1.spad" 45064 45073 45983 45988) (-51 "ANY.spad" 43915 43922 45054 45059) (-50 "ANTISYM.spad" 42360 42376 43895 43910) (-49 "ANON.spad" 42069 42076 42350 42355) (-48 "AN.spad" 40537 40544 41900 41993) (-47 "AMR.spad" 38722 38733 40435 40532) (-46 "AMR.spad" 36770 36783 38485 38490) (-45 "ALIST.spad" 33066 33087 33416 33431) (-44 "ALGSC.spad" 32201 32227 32938 32991) (-43 "ALGPKG.spad" 27984 27995 32157 32162) (-42 "ALGMFACT.spad" 27177 27191 27974 27979) (-41 "ALGMANIP.spad" 24678 24693 27021 27026) (-40 "ALGFF.spad" 22496 22523 22713 22869) (-39 "ALGFACT.spad" 21615 21625 22486 22491) (-38 "ALGEBRA.spad" 21448 21457 21571 21610) (-37 "ALGEBRA.spad" 21313 21324 21438 21443) (-36 "ALAGG.spad" 20841 20862 21293 21308) (-35 "AHYP.spad" 20222 20229 20831 20836) (-34 "AGG.spad" 19129 19136 20212 20217) (-33 "AGG.spad" 18034 18043 19119 19124) (-32 "AF.spad" 16479 16494 17983 17988) (-31 "ADDAST.spad" 16165 16172 16469 16474) (-30 "ACPLOT.spad" 15042 15049 16155 16160) (-29 "ACFS.spad" 12899 12908 14944 15037) (-28 "ACFS.spad" 10842 10853 12889 12894) (-27 "ACF.spad" 7596 7603 10744 10837) (-26 "ACF.spad" 4436 4445 7586 7591) (-25 "ABELSG.spad" 3977 3984 4426 4431) (-24 "ABELSG.spad" 3516 3525 3967 3972) (-23 "ABELMON.spad" 2944 2951 3506 3511) (-22 "ABELMON.spad" 2370 2379 2934 2939) (-21 "ABELGRP.spad" 2035 2042 2360 2365) (-20 "ABELGRP.spad" 1698 1707 2025 2030) (-19 "A1AGG.spad" 860 869 1678 1693) (-18 "A1AGG.spad" 30 41 850 855)) 
\ No newline at end of file