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

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

Origin: (upstream|backport|vendor|other), (<patch-url>|commit:<commit-id>)
Bug: <upstream-bugtracker-url>
Bug-Debian: https://bugs.debian.org/<bugnumber>
Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
Forwarded: (no|not-needed|<patch-forwarded-url>)
Applied-Upstream: <version>, (<commit-url>|commit:<commid-id>)
Reviewed-By: <name and email of someone who approved/reviewed the patch>
Last-Update: 2025-02-13

--- axiom-20170501.orig/books/Makefile.pamphlet
+++ axiom-20170501/books/Makefile.pamphlet
@@ -86,12 +86,15 @@ all: announce tanglecopy ${PDF}/axiom.bi
      ${BOOKPDF} ${PDF}/toc.pdf ${OUT1}/SPADEDIT axbook 
 	@(cd ${PDF} ; ${RM} *.out *.sty *.def *.png *.bbl *.blg)
 
-tanglecopy:
+${BOOKS}/tanglec: ${BOOKS}/tanglec.c
+	@ gcc -o $@ $<
+
+tanglecopy: ${BOOKS}/tanglec
 	@ echo ==================================
 	@ echo COPY TANGLEC TO BIN
 	@ echo ==================================
-	@ gcc -o tanglec tanglec.c
-	@ cp tanglec ${OUTBIN}
+#	@ gcc -o tanglec tanglec.c
+	@ cp $< ${OUTBIN}
 
 axbook: axbook.tgz
 	@ echo ==================================
@@ -109,7 +112,7 @@ finish:
 	@ echo FINISHED BUILDING PDF FILES books/Makefile
 	@ echo ==========================================
 
-${PROOFS}/acl2.lisp:
+${PROOFS}/acl2.lisp: ${BOOKS}/tanglec
 	@ echo ===========================================
 	@ echo making ${PROOFS}/acl2.lisp
 	@ echo ===========================================
@@ -119,7 +122,7 @@ ${PROOFS}/acl2.lisp:
 	    ( cd ${PROOFS} ; echo '(ld "acl2.lisp")' | acl2 >acl2.output ) ; \
 	   fi ; 
 
-${PROOFS}/coq.v:
+${PROOFS}/coq.v: ${BOOKS}/tanglec
 	@ echo ===========================================
 	@ echo making ${PROOFS}/coq.v
 	@ echo ===========================================
@@ -131,7 +134,7 @@ ${PROOFS}/coq.v:
 	    ( cd ${PROOFS} ; cat coq.v | coqtop >coq.console 2>&1 ) ; \
 	   fi ; 
 
-${PDF}/axiom.bib:
+${PDF}/axiom.bib: ${BOOKS}/tanglec
 	@ echo ===========================================
 	@ echo making ${PDF}/axiom.bib from ${IN}/bookvolbib.pamphlet
 	@ echo ===========================================
@@ -430,11 +433,11 @@ ${PDF}/toc.pdf: ${BOOKPDF} $(patsubst %.
 
 \end{chunk}
 \begin{chunk}{*}
-${OUT1}/SPADEDIT: ${BOOKS}/bookvol5.pamphlet
+${OUT1}/SPADEDIT: ${BOOKS}/bookvol5.pamphlet ${BOOKS}/tanglec
 	@echo b4 making $@ from $^
 	@${BOOKS}/tanglec $< spadedit >$@
 	@chmod +x $@
-		  
+
 #spadedit:
 #	@echo b4 making spadedit from ${BOOKS}/bookvol5 to ${OUT1}
 #	@${BOOKS}/tanglec ${BOOKS}/bookvol5.pamphlet spadedit \
--- axiom-20170501.orig/books/bookvol10.pamphlet
+++ axiom-20170501/books/bookvol10.pamphlet
@@ -10337,7 +10337,7 @@ Used by next layer: TBAGG
 
 LAYER14=\
   ${OUT}/BSD.o \
-  ${OUT}/CCLASS.o   ${OUT}/CPIMA.o   ${OUT}/FSAGG2.o   ${OUT}/GALFACT.o  \
+  ${OUT}/CCLASS.o   ${OUT}/CPIMA.o   ${OUT}/FSAGG2.o     \
   ${OUT}/IALGFACT.o ${OUT}/IBACHIN.o  ${OUT}/MMLFORM.o ${OUT}/NORMMA.o   \
   ${OUT}/ODERED.o   ${OUT}/OMSAGG.o   ${OUT}/PERM.o    ${OUT}/PERMGRP.o  \
   ${OUT}/PRIMES.o   ${OUT}/PRJALGPK.o \
@@ -10784,7 +10784,7 @@ Used by next layer: ALIST
 \begin{chunk}{layer15}
 
 LAYER15=\
-  ${OUT}/ALIST.o   ${OUT}/EQTBL.o   ${OUT}/GSTBL.o   ${OUT}/HASHTBL.o \
+  ${OUT}/ALIST.o   ${OUT}/EQTBL.o   ${OUT}/GALFACT.o  ${OUT}/GSTBL.o   ${OUT}/HASHTBL.o \
   ${OUT}/INTABL.o  ${OUT}/INTFTBL.o ${OUT}/IPF.o     \
   ${OUT}/KAFILE.o  ${OUT}/PATRES.o  ${OUT}/STBL.o    \
   ${OUT}/STRTBL.o  ${OUT}/TABLE.o   ${OUT}/TBCMPPK.o  
--- axiom-20170501.orig/src/algebra/libdb.text
+++ axiom-20170501/src/algebra/libdb.text
@@ -9,7 +9,7 @@ cArcHyperbolicFunctionCategory`0`x`()->C
 cIntegerNumberSystem`0`x`()->Category``INS`An \spad{IntegerNumberSystem} is a model for the integers.
 dPlaneAlgebraicCurvePlot`0`x`()->Join(PlottablePlaneCurveCategory,etc)``ACPLOT`\indented{1}{Plot a NON-SINGULAR plane algebraic curve \spad{p}(\spad{x},{}\spad{y}) = 0.} Author: Clifton \spad{J}. Williamson Date Created: Fall 1988 Date Last Updated: 27 April 1990 Keywords: algebraic curve,{} non-singular,{} plot Examples: References:
 dSingleInteger`0`x`()->Join(IntegerNumberSystem,etc)``SINT`SingleInteger is intended to support machine integer arithmetic.
-dSparseUnivariateLaurentSeries`3`x`(:(Coef,Ring),:(var,Symbol),:(cen,Coef))->Join(UnivariateLaurentSeriesConstructorCategory(Coef,SparseUnivariateTaylorSeries(Coef,var,cen)),etc)`(Coef,var,cen)`SULS`Sparse Laurent series in one variable \spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent series in one variable with coefficients in an arbitrary ring. The parameters of the type specify the coefficient ring, the power series variable, and the center of the power series expansi----on. For example, \spad{SparseUnivariateLaurentSeries(Integer,x,3)} represents Laurent series in \spad{(x - 3)} with integer coefficients.
+dSparseUnivariateLaurentSeries`3`x`(:(Coef,Ring),:(var,Symbol),:(cen,Coef))->Join(UnivariateLaurentSeriesConstructorCategory(Coef,SparseUnivariateTaylorSeries(Coef,var,cen)),etc)`(Coef,var,cen)`SULS`Sparse Laurent series in one variable \spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent series in one variable with coefficients in an arbitrary ring. The parameters of the type specify the coefficient ring, the power series variable, and the center of the power series expansi------on. For example, \spad{SparseUnivariateLaurentSeries(Integer,x,3)} represents Laurent series in \spad{(x - 3)} with integer coefficients.
 o/\`2`x`(_$,_$)->_$`dSingleInteger``\spad{n} \spad{/\} \spad{m} returns the bit-by-bit logical {\em and} of the single integers \spad{n} and \spad{m}.
 oAnd`2`x`(_$,_$)->_$`dSingleInteger``\spad{And(n,{}m)} returns the bit-by-bit logical {\em and} of the single integers \spad{n} and \spad{m}.
 oNot`1`x`(_$)->_$`dSingleInteger``\spad{Not(n)} returns the bit-by-bit logical {\em not} of the single integer \spad{n}.
@@ -26,6 +26,7 @@ obase`0`x`()->_$`cIntegerNumberSystem``\
 obinomial`2`x`(S,S)->S`xIntegerNumberSystem&(S)``
 obit?`2`x`(S,S)->Boolean`xIntegerNumberSystem&(S)``
 obit?`2`x`(_$,_$)->Boolean`cIntegerNumberSystem``\spad{bit?(n,{}i)} returns \spad{true} if and only if \spad{i}-th bit of \spad{n} is a 1.
+obtwFact`4`x`(UP,Boolean,Set(NonNegativeInteger),NonNegativeInteger)->Record(contp:Integer,factors:List(Record(irr:UP,pow:Integer)))`pGaloisGroupFactorizer(UP)``\spad{btwFact(p,sqf,pd,r)} returns the factorization of \spad{p,} the result is a Record such that \spad{contp=}content \spad{p,} \spad{factors=}List of irreducible factors of \spad{p} with exponent. If \spad{sqf=true} the polynomial is assumed to be square free (without repeated factors). \spad{pd} is the \spadtype{Set} of possible degr----ees. \spad{r} is a lower bound for the number of factors of \spad{p.} Please do not use this function in your code because its design may change.
 ocharacteristic`0`x`()->NonNegativeInteger`xIntegerNumberSystem&(S)``
 ocoerce`1`x`(Variable(var))->_$`dSparseUnivariateLaurentSeries(Coef,var,cen)``\spad{coerce(var)} converts the series variable \spad{var} into a Laurent series.
 oconvert`1`x`(S)->DoubleFloat`xIntegerNumberSystem&(S)``
@@ -36,28 +37,51 @@ oconvert`1`x`(S)->Pattern(Integer)`xInte
 ocopy`1`x`(S)->S`xIntegerNumberSystem&(S)``
 ocopy`1`x`(_$)->_$`cIntegerNumberSystem``\spad{copy(n)} gives a copy of \spad{n}.
 odec`1`x`(_$)->_$`cIntegerNumberSystem``\spad{dec(x)} returns \spad{x - 1}.
+odegreePartition`1`x`(List(Record(factor:UP,degree:Integer)))->Multiset(NonNegativeInteger)`pGaloisGroupFactorizer(UP)``\spad{degreePartition(ddfactorization)} returns the degree partition of the polynomial \spad{f} modulo \spad{p} where \spad{ddfactorization} is the distinct degree factorization of \spad{f} computed by ddFact for some prime \spad{p.}
 odifferentiate`1`x`(S)->S`xIntegerNumberSystem&(S)``
 odifferentiate`2`x`(S,NonNegativeInteger)->S`xIntegerNumberSystem&(S)``
 odifferentiate`2`x`(_$,Variable(var))->_$`dSparseUnivariateLaurentSeries(Coef,var,cen)``\spad{differentiate(f(x),x)} returns the derivative of \spad{f(x)} with respect to \spad{x}.
+oeisensteinIrreducible?`1`x`(UP)->Boolean`pGaloisGroupFactorizer(UP)``\spad{eisensteinIrreducible?(p)} returns \spad{true} if \spad{p} can be shown to be irreducible by Eisenstein's criterion, \spad{false} is inconclusive.
 oeuclideanSize`1`x`(S)->NonNegativeInteger`xIntegerNumberSystem&(S)``
 oeven?`1`x`(S)->Boolean`xIntegerNumberSystem&(S)``
 oeven?`1`x`(_$)->Boolean`cIntegerNumberSystem``\spad{even?(n)} returns \spad{true} if and only if \spad{n} is even.
+ofactorOfDegree`2`x`(PositiveInteger,UP)->Union(UP,"failed")`pGaloisGroupFactorizer(UP)``\spad{factorOfDegree(d,p)} returns a factor of \spad{p} of degree \spad{d.}
+ofactorOfDegree`3`x`(PositiveInteger,UP,List(NonNegativeInteger))->Union(UP,"failed")`pGaloisGroupFactorizer(UP)``\spad{factorOfDegree(d,p,listOfDegrees)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree listOfDegrees.
+ofactorOfDegree`3`x`(PositiveInteger,UP,NonNegativeInteger)->Union(UP,"failed")`pGaloisGroupFactorizer(UP)``\spad{factorOfDegree(d,p,r)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has at least \spad{r} factors.
+ofactorOfDegree`4`x`(PositiveInteger,UP,List(NonNegativeInteger),NonNegativeInteger)->Union(UP,"failed")`pGaloisGroupFactorizer(UP)``\spad{factorOfDegree(d,p,listOfDegrees,r)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree listOfDegrees, and that \spad{p} has at least \spad{r} factors.
+ofactorOfDegree`5`x`(PositiveInteger,UP,List(NonNegativeInteger),NonNegativeInteger,Boolean)->Union(UP,"failed")`pGaloisGroupFactorizer(UP)``\spad{factorOfDegree(d,p,listOfDegrees,r,sqf)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree listOfDegrees, and that \spad{p} has at least \spad{r} factors. If \spad{sqf=true} the polynomial is assumed to be square free (without repeated factors).
+ofactorSquareFree`1`x`(UP)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factorSquareFree(p)} returns the factorization of \spad{p} which is supposed not having any repeated factor (this is not checked).
+ofactorSquareFree`2`x`(UP,List(NonNegativeInteger))->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factorSquareFree(p,listOfDegrees)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has for possible splitting of its degree listOfDegrees. \spad{f} is supposed not having any repeated factor (this is not checked).
+ofactorSquareFree`2`x`(UP,NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factorSquareFree(p,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has at least \spad{r} factors. \spad{f} is supposed not having any repeated factor (this is not checked).
+ofactorSquareFree`3`x`(UP,List(NonNegativeInteger),NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factorSquareFree(p,listOfDegrees,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm, knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees} and that \spad{p} has at least \spad{r} factors. \spad{f} is supposed not having any repeated factor (this is not checked).
+ofactorSquareFree`3`x`(UP,NonNegativeInteger,NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factorSquareFree(p,d,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm, knowing that \spad{d} divides the degree of all factors of \spad{p} and that \spad{p} has at least \spad{r} factors. \spad{f} is supposed not having any repeated factor (this is not checked).
 ofactor`1`x`(S)->Factored(S)`xIntegerNumberSystem&(S)``
+ofactor`1`x`(UP)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factor(p)} returns the factorization of \spad{p} over the integers.
+ofactor`2`x`(UP,List(NonNegativeInteger))->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factor(p,listOfDegrees)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has for possible splitting of its degree listOfDegrees.
+ofactor`2`x`(UP,NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factor(p,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has at least \spad{r} factors.
+ofactor`3`x`(UP,List(NonNegativeInteger),NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factor(p,listOfDegrees,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm, knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees} and that \spad{p} has at least \spad{r} factors.
+ofactor`3`x`(UP,NonNegativeInteger,NonNegativeInteger)->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{factor(p,d,r)} factorizes the polynomial \spad{p} using the single factor bound algorithm, knowing that \spad{d} divides the degree of all factors of \spad{p} and that \spad{p} has at least \spad{r} factors.
 ofactorial`1`x`(S)->S`xIntegerNumberSystem&(S)``
 ohash`1`x`(_$)->_$`cIntegerNumberSystem``\spad{hash(n)} returns the hash code of \spad{n}.
+ohenselFact`2`x`(UP,Boolean)->Record(contp:Integer,factors:List(Record(irr:UP,pow:Integer)))`pGaloisGroupFactorizer(UP)``\spad{henselFact(p,sqf)} returns the factorization of \spad{p,} the result is a Record such that \spad{contp=}content \spad{p,} \spad{factors=}List of irreducible factors of \spad{p} with exponent. If \spad{sqf=true} the polynomial is assumed to be square free (without repeated factors).
 oinc`1`x`(_$)->_$`cIntegerNumberSystem``\spad{inc(x)} returns \spad{x + 1}.
 oinit`0`x`()->S`xIntegerNumberSystem&(S)``
 ointegrate`2`x`(_$,Variable(var))->_$`dSparseUnivariateLaurentSeries(Coef,var,cen)`has(Coef,Algebra(Fraction(Integer)))`\spad{integrate(f(x))} returns an anti-derivative of the power series \spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.
 oinvmod`2`x`(S,S)->S`xIntegerNumberSystem&(S)``
 oinvmod`2`x`(_$,_$)->_$`cIntegerNumberSystem``\spad{invmod(a,{}b)},{} \spad{0<=a<b>1},{} \spad{(a,{}b)=1} means \spad{1/a mod b}.
 olength`1`x`(_$)->_$`cIntegerNumberSystem``\spad{length(a)} length of \spad{a} in digits.
-omakeSketch`5`x`(Polynomial(Integer),Symbol,Symbol,Segment(Fraction(Integer)),Segment(Fraction(Integer)))->_$`dPlaneAlgebraicCurvePlot``\spad{makeSketch(p,{}x,{}y,{}a..b,{}c..d)} creates an ACPLOT of the curve \spad{p = 0} in the region {\em a <= x <= b,{} c <= y <= d}. More specifically,{} 'makeSketch' plots a non-singular algebraic curve \spad{p = 0} in an rectangular region {\em xMin <= x <= xMax},{} {\em yMin <= y <= yMax}. The user inputs \spad{makeSketch(p,{}x,{}y,{}xMin..xMax,{}yMin..yMax------------)}. Here \spad{p} is a polynomial in the variables \spad{x} and \spad{y} with integer coefficients (\spad{p} belongs to the domain \spad{Polynomial Integer}). The case where \spad{p} is a polynomial in only one of the variables is allowed. The variables \spad{x} and \spad{y} are input to specify the the coordinate axes. The horizontal axis is the \spad{x}-axis and the vertical axis is the \spad{y}-axis. The rational numbers xMin,{}...,{}yMax specify the boundaries of the region in wh--ic--h --th--e --cu--rve is to be plotted.
+omakeFR`1`x`(Record(contp:Integer,factors:List(Record(irr:UP,pow:Integer))))->Factored(UP)`pGaloisGroupFactorizer(UP)``\spad{makeFR(flist)} turns the final factorization of henselFact into a \spadtype{Factored} object.
+omakeSketch`5`x`(Polynomial(Integer),Symbol,Symbol,Segment(Fraction(Integer)),Segment(Fraction(Integer)))->_$`dPlaneAlgebraicCurvePlot``\spad{makeSketch(p,{}x,{}y,{}a..b,{}c..d)} creates an ACPLOT of the curve \spad{p = 0} in the region {\em a <= x <= b,{} c <= y <= d}. More specifically,{} 'makeSketch' plots a non-singular algebraic curve \spad{p = 0} in an rectangular region {\em xMin <= x <= xMax},{} {\em yMin <= y <= yMax}. The user inputs \spad{makeSketch(p,{}x,{}y,{}xMin..xMax,{}yMin..yMax--------------)}. Here \spad{p} is a polynomial in the variables \spad{x} and \spad{y} with integer coefficients (\spad{p} belongs to the domain \spad{Polynomial Integer}). The case where \spad{p} is a polynomial in only one of the variables is allowed. The variables \spad{x} and \spad{y} are input to specify the the coordinate axes. The horizontal axis is the \spad{x}-axis and the vertical axis is the \spad{y}-axis. The rational numbers xMin,{}...,{}yMax specify the boundaries of the region in --wh--ic--h --th--e --cu--rve is to be plotted.
 omask`1`x`(S)->S`xIntegerNumberSystem&(S)``
 omask`1`x`(_$)->_$`cIntegerNumberSystem``\spad{mask(n)} returns \spad{2**n-1} (an \spad{n} bit mask).
 omax`0`x`()->_$`dSingleInteger``\spad{max()} returns the largest single integer.
 omin`0`x`()->_$`dSingleInteger``\spad{min()} returns the smallest single integer.
+omodularFactor`1`x`(UP)->Record(prime:Integer,factors:List(UP))`pGaloisGroupFactorizer(UP)``\spad{modularFactor(f)} chooses a "good" prime and returns the factorization of \spad{f} modulo this prime in a form that may be used by completeHensel. If prime is zero it means that \spad{f} has been proved to be irreducible over the integers or that \spad{f} is a unit \spad{(1} or -1). \spad{f} shall be primitive (content(p)=1) and square free (without repeated factors).
 omulmod`3`x`(_$,_$,_$)->_$`cIntegerNumberSystem``\spad{mulmod(a,{}b,{}p)},{} \spad{0<=a,{}b<p>1},{} means \spad{a*b mod p}.
+omusserTrials`0`x`()->PositiveInteger`pGaloisGroupFactorizer(UP)``\spad{musserTrials()} returns the number of primes that are tried in \spadfun{modularFactor}.
+omusserTrials`1`x`(PositiveInteger)->PositiveInteger`pGaloisGroupFactorizer(UP)``\spad{musserTrials(n)} sets to \spad{n} the number of primes to be tried in \spadfun{modularFactor} and returns the previous value.
 onextItem`1`x`(S)->Union(S,"failed")`xIntegerNumberSystem&(S)``
+onumberOfFactors`1`x`(List(Record(factor:UP,degree:Integer)))->NonNegativeInteger`pGaloisGroupFactorizer(UP)``\spad{numberOfFactors(ddfactorization)} returns the number of factors of the polynomial \spad{f} modulo \spad{p} where \spad{ddfactorization} is the distinct degree factorization of \spad{f} computed by ddFact for some prime \spad{p.}
 oodd?`1`x`(_$)->Boolean`cIntegerNumberSystem``\spad{odd?(n)} returns \spad{true} if and only if \spad{n} is odd.
 opatternMatch`3`x`(S,Pattern(Integer),PatternMatchResult(Integer,S))->PatternMatchResult(Integer,S)`xIntegerNumberSystem&(S)``
 opermutation`2`x`(S,S)->S`xIntegerNumberSystem&(S)``
@@ -82,10 +106,19 @@ oshift`2`x`(_$,_$)->_$`cIntegerNumberSys
 osolve`2`x`(Polynomial(Fraction(Integer)),Float)->List(Float)`pRealSolvePackage``\spad{solve(p,{}eps)} finds the real zeroes of a univariate rational polynomial \spad{p} with precision \spad{eps}.
 osolve`2`x`(Polynomial(Integer),Float)->List(Float)`pRealSolvePackage``\spad{solve(p,{}eps)} finds the real zeroes of a univariate integer polynomial \spad{p} with precision \spad{eps}.
 osquareFree`1`x`(S)->Factored(S)`xIntegerNumberSystem&(S)``
+ostopMusserTrials`0`x`()->PositiveInteger`pGaloisGroupFactorizer(UP)``\spad{stopMusserTrials()} returns the bound on the number of factors for which \spadfun{modularFactor} stops to look for an other prime. You will have to remember that the step of recombining the extraneous factors may take up to \spad{2**stopMusserTrials()} trials.
+ostopMusserTrials`1`x`(PositiveInteger)->PositiveInteger`pGaloisGroupFactorizer(UP)``\spad{stopMusserTrials(n)} sets to \spad{n} the bound on the number of factors for which \spadfun{modularFactor} stops to look for an other prime. You will have to remember that the step of recombining the extraneous factors may take up to \spad{2**n} trials. Returns the previous value.
 osubmod`3`x`(_$,_$,_$)->_$`cIntegerNumberSystem``\spad{submod(a,{}b,{}p)},{} \spad{0<=a,{}b<p>1},{} means \spad{a-b mod p}.
 osymmetricRemainder`2`x`(S,S)->S`xIntegerNumberSystem&(S)``
 osymmetricRemainder`2`x`(_$,_$)->_$`cIntegerNumberSystem``\spad{symmetricRemainder(a,{}b)} (where \spad{b > 1}) yields \spad{r} where \spad{ -b/2 <= r < b/2 }.
+otryFunctionalDecomposition?`0`x`()->Boolean`pGaloisGroupFactorizer(UP)``\spad{tryFunctionalDecomposition?()} returns \spad{true} if factorizers try functional decomposition of polynomials before factoring them.
+otryFunctionalDecomposition`1`x`(Boolean)->Boolean`pGaloisGroupFactorizer(UP)``\spad{tryFunctionalDecomposition(b)} chooses whether factorizers have to look for functional decomposition of polynomials (\spad{true}) or not (\spad{false}). Returns the previous value.
+ouseEisensteinCriterion?`0`x`()->Boolean`pGaloisGroupFactorizer(UP)``\spad{useEisensteinCriterion?()} returns \spad{true} if factorizers check Eisenstein's criterion before factoring.
+ouseEisensteinCriterion`1`x`(Boolean)->Boolean`pGaloisGroupFactorizer(UP)``\spad{useEisensteinCriterion(b)} chooses whether factorizers check Eisenstein's criterion before factoring: \spad{true} for using it, \spad{false} else. Returns the previous value.
+ouseSingleFactorBound?`0`x`()->Boolean`pGaloisGroupFactorizer(UP)``\spad{useSingleFactorBound?()} returns \spad{true} if algorithm with single factor bound is used for factorization, \spad{false} for algorithm with overall bound.
+ouseSingleFactorBound`1`x`(Boolean)->Boolean`pGaloisGroupFactorizer(UP)``\spad{useSingleFactorBound(b)} chooses the algorithm to be used by the factorizers: \spad{true} for algorithm with single factor bound, \spad{false} for algorithm with overall bound. Returns the previous value.
 oxor`2`x`(_$,_$)->_$`dSingleInteger``\spad{xor(n,{}m)} returns the bit-by-bit logical {\em xor} of the single integers \spad{n} and \spad{m}.
 o~`1`x`(_$)->_$`dSingleInteger``\spad{~ n} returns the bit-by-bit logical {\em not } of the single integer \spad{n}.
+pGaloisGroupFactorizer`1`x`(UnivariatePolynomialCategory(Integer))->etc`(UP)`GALFACT`\spadtype{GaloisGroupFactorizer} provides functions to factor resolvents.
 pRealSolvePackage`0`x`()->etc``REALSOLV`\indented{1}{This package provides numerical solutions of systems of polynomial} equations for use in ACPLOT.
 xIntegerNumberSystem&`1`x`(IntegerNumberSystem)->etc`(S)`INS-`An \spad{IntegerNumberSystem} is a model for the integers.
--- axiom-20170501.orig/src/interp/util.lisp.pamphlet
+++ axiom-20170501/src/interp/util.lisp.pamphlet
@@ -1457,16 +1457,16 @@ function assumes that \\ can only appear
   (values longnames names)))
 
 
-#+(and :AKCL (not :dos))
-(in-package "COMPILER")
-#+(and :AKCL (not :dos))
-(defun gazonk-name ( &aux tem)
- "return the name of the intermediate compiler file"
- (dotimes (i 1000)
-  (setq tem (merge-pathnames (format nil "/tmp/gazonk~d.lsp" i)))
-  (unless (probe-file tem)
-    (return-from gazonk-name (pathname tem))))
- (error "1000 gazonk names used already!"))
+;#+(and :AKCL (not :dos))
+;(in-package "COMPILER")
+;#+(and :AKCL (not :dos))
+;(defun gazonk-name ( &aux tem)
+; "return the name of the intermediate compiler file"
+; (dotimes (i 1000)
+;  (setq tem (merge-pathnames (format nil "/tmp/gazonk~d.lsp" i)))
+;  (unless (probe-file tem)
+;    (return-from gazonk-name (pathname tem))))
+; (error "1000 gazonk names used already!"))
 
 (in-package "BOOT")
 
