Index: factory/facFqFactorize.h
===================================================================
--- factory/facFqFactorize.h	(revision 33c80401859cb1e4a4821ef802c31f324cbd0e08)
+++ factory/facFqFactorize.h	(revision 806c18d2f2e69cf5e6fa6718d85031aa2119a70f)
@@ -1,11 +1,11 @@
 /*****************************************************************************\
- * Computer Algebra System SINGULAR    
+ * Computer Algebra System SINGULAR
 \*****************************************************************************/
 /** @file facFqFactorize.h
- * 
+ *
  * This file provides functions for factorizing a multivariate polynomial over
- * \f$ F_{p} \f$ , \f$ F_{p}(\alpha ) \f$ or GF.   
+ * \f$ F_{p} \f$ , \f$ F_{p}(\alpha ) \f$ or GF.
  *
- * ABSTRACT: So far factor recombination is done naive!        
+ * ABSTRACT: So far factor recombination is done naive!
  *
  * @author Martin Lee
@@ -29,8 +29,8 @@
 
 /// Factorization over a finite field
-///  
+///
 /// @return @a multiFactorize returns a factorization of F
 /// @sa biFactorize(), extFactorize()
-CFList 
+CFList
 multiFactorize (const CanonicalForm& F,    ///< [in] poly to be factored
                 const ExtensionInfo& info  ///< [in] info about extension
@@ -39,10 +39,10 @@
 /// factorize a squarefree multivariate polynomial over \f$ F_{p} \f$
 ///
-/// @return @a FpSqrfFactorize returns a list of monic factors, the first 
-///         element is the leading coefficient.     
+/// @return @a FpSqrfFactorize returns a list of monic factors, the first
+///         element is the leading coefficient.
 /// @sa FqSqrfFactorize(), GFSqrfFactorize()
 inline
 CFList FpSqrfFactorize (const CanonicalForm & F ///< [in] a multivariate poly
-                       ) 
+                       )
 {
   ExtensionInfo info= ExtensionInfo (false);
@@ -54,11 +54,11 @@
 /// factorize a squarefree multivariate polynomial over \f$ F_{p} (\alpha ) \f$
 ///
-/// @return @a FqSqrfFactorize returns a list of monic factors, the first 
-///         element is the leading coefficient.     
-/// @sa FpSqrfFactorize(), GFSqrfFactorize() 
+/// @return @a FqSqrfFactorize returns a list of monic factors, the first
+///         element is the leading coefficient.
+/// @sa FpSqrfFactorize(), GFSqrfFactorize()
 inline
 CFList FqSqrfFactorize (const CanonicalForm & F, ///< [in] a multivariate poly
                         const Variable& alpha    ///< [in] algebraic variable
-                       ) 
+                       )
 {
   ExtensionInfo info= ExtensionInfo (alpha, false);
@@ -68,14 +68,14 @@
 }
 
-/// factorize a squarefree multivariate polynomial over GF 
-///
-/// @return @a GFSqrfFactorize returns a list of monic factors, the first 
-///         element is the leading coefficient.     
+/// factorize a squarefree multivariate polynomial over GF
+///
+/// @return @a GFSqrfFactorize returns a list of monic factors, the first
+///         element is the leading coefficient.
 /// @sa FpSqrfFactorize(), FqSqrfFactorize()
 inline
 CFList GFSqrfFactorize (const CanonicalForm & F ///< [in] a multivariate poly
-                       ) 
+                       )
 {
-  ASSERT (CFFactory::gettype() == GaloisFieldDomain, 
+  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
           "GF as base field expected");
   ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
@@ -85,16 +85,16 @@
 }
 
-/// factorize a multivariate polynomial over \f$ F_{p} \f$ 
-///
-/// @return @a FpFactorize returns a list of monic factors with 
-///         multiplicity, the first element is the leading coefficient.      
+/// factorize a multivariate polynomial over \f$ F_{p} \f$
+///
+/// @return @a FpFactorize returns a list of monic factors with
+///         multiplicity, the first element is the leading coefficient.
 /// @sa FqFactorize(), GFFactorize()
 inline
 CFFList FpFactorize (const CanonicalForm& F ///< [in] a multivariate poly
-                    ) 
+                    )
 {
   ExtensionInfo info= ExtensionInfo (false);
   Variable a= Variable (1);
-  CanonicalForm LcF= Lc (F); 
+  CanonicalForm LcF= Lc (F);
   CanonicalForm pthRoot, A;
   CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, a);
@@ -114,5 +114,5 @@
   }
   else
-  {  
+  {
     buf= multiFactorize (sqrfP, info);
     A= F/LcF;
@@ -131,14 +131,14 @@
 /// factorize a multivariate polynomial over \f$ F_{p} (\alpha ) \f$
 ///
-/// @return @a FqFactorize returns a list of monic factors with 
-///         multiplicity, the first element is the leading coefficient.      
+/// @return @a FqFactorize returns a list of monic factors with
+///         multiplicity, the first element is the leading coefficient.
 /// @sa FpFactorize(), GFFactorize()
 inline
 CFFList FqFactorize (const CanonicalForm& F, ///< [in] a multivariate poly
                      const Variable& alpha   ///< [in] algebraic variable
-                    ) 
+                    )
 {
-  ExtensionInfo info= ExtensionInfo (alpha, false); 
-  CanonicalForm LcF= Lc (F); 
+  ExtensionInfo info= ExtensionInfo (alpha, false);
+  CanonicalForm LcF= Lc (F);
   CanonicalForm pthRoot, A;
   CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, alpha);
@@ -159,5 +159,5 @@
   }
   else
-  {  
+  {
     buf= multiFactorize (sqrfP, info);
     A= F/LcF;
@@ -176,15 +176,15 @@
 /// factorize a multivariate polynomial over GF
 ///
-/// @return @a GFFactorize returns a list of monic factors with 
-///         multiplicity, the first element is the leading coefficient.      
+/// @return @a GFFactorize returns a list of monic factors with
+///         multiplicity, the first element is the leading coefficient.
 /// @sa FpFactorize(), FqFactorize()
 inline
 CFFList GFFactorize (const CanonicalForm& F ///< [in] a multivariate poly
-                    ) 
+                    )
 {
-  ASSERT (CFFactory::gettype() == GaloisFieldDomain, 
+  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
           "GF as base field expected");
   Variable a= Variable (1);
-  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false); 
+  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
   CanonicalForm LcF= Lc (F);
   CanonicalForm pthRoot, A;
@@ -221,14 +221,14 @@
 }
 
-/// compute the content of @a F wrt Variable (1) using routines from 
+/// compute the content of @a F wrt Variable (1) using routines from
 /// @a cf_gcd_smallp.h
 ///
 /// @return @a myContent returns the content of F wrt Variable (1)
 static inline
-CanonicalForm 
+CanonicalForm
 myContent (const CanonicalForm& F ///< [in] a poly
           );
 
-/// compute the content of @a F wrt @a x using routines from 
+/// compute the content of @a F wrt @a x using routines from
 /// @a cf_gcd_smallp.h
 ///
@@ -236,18 +236,18 @@
 static inline
 CanonicalForm
-myContent (const CanonicalForm& F, ///< [in] a poly 
+myContent (const CanonicalForm& F, ///< [in] a poly
            const Variable& x       ///< [in] a variable
           );
 
-/// compute the GCD of all element in @a L using routines from 
+/// compute the GCD of all element in @a L using routines from
 /// @a cf_gcd_smallp.h
 ///
 /// @return @a listGCD returns the GCD of all elements in @a L
 static inline
-CanonicalForm 
+CanonicalForm
 listGCD (const CFList& L ///< [in] a list of polys
         );
 
-/// compute the LCM of @a F and @a G using routines from 
+/// compute the LCM of @a F and @a G using routines from
 /// @a cf_gcd_smallp.h
 ///
@@ -262,16 +262,16 @@
 /// A.
 ///
-/// @return @a lcmContent returns the LCM of the contents of @a A wrt to each 
+/// @return @a lcmContent returns the LCM of the contents of @a A wrt to each
 ///         variable occuring in @a A.
-static inline 
-CanonicalForm 
-lcmContent (const CanonicalForm& A, ///< [in] a compressed multivariate poly 
+static inline
+CanonicalForm
+lcmContent (const CanonicalForm& A, ///< [in] a compressed multivariate poly
             CFList& contentAi       ///< [in,out] an empty list, returns a list
-                                    ///< of the contents of @a A wrt to each 
+                                    ///< of the contents of @a A wrt to each
                                     ///< variable occuring in @a A starting from
                                     ///< @a A.mvar().
            );
 
-/// compress a polynomial s.t. \f$ deg_{x_{i}} (F) >= deg_{x_{i+1}} (F) \f$ and 
+/// compress a polynomial s.t. \f$ deg_{x_{i}} (F) >= deg_{x_{i+1}} (F) \f$ and
 /// no gaps between the variables occur
 ///
@@ -279,5 +279,5 @@
 static inline
 CanonicalForm myCompress (const CanonicalForm& F, ///< [in] a poly
-                          CFMap& N                ///< [in,out] a map to 
+                          CFMap& N                ///< [in,out] a map to
                                                   ///< decompress
                          );
@@ -286,12 +286,12 @@
 /// Uses precomputed data to exclude combinations that are not possible.
 ///
-/// @return @a monicFactorRecombi returns a list of factors of F, that are 
+/// @return @a monicFactorRecombi returns a list of factors of F, that are
 ///         monic wrt Variable (1).
 /// @sa extFactorRecombination(), factorRecombination(), biFactorizer()
-CFList 
+CFList
 monicFactorRecombi (
                   const CFList& factors,    ///< [in] list of lifted factors
                                             ///< that are monic wrt Variable (1)
-                  const CanonicalForm& F,   ///< [in] bivariate poly 
+                  const CanonicalForm& F,   ///< [in] bivariate poly
                   const CanonicalForm& M,   ///< [in] Variable (2)^liftBound
                   const DegreePattern& degs ///< [in] degree pattern
@@ -300,16 +300,16 @@
 /// detects factors of @a F at stage @a deg of Hensel lifting.
 /// No combinations of more than one factor are tested. Lift bound and possible
-/// degree pattern are updated. 
-/// 
-/// @return @a earlyMonicFactorDetect returns a list of factors of F (possibly 
+/// degree pattern are updated.
+///
+/// @return @a earlyMonicFactorDetect returns a list of factors of F (possibly
 ///         incomplete) that are monic wrt Variable (1)
 /// @sa monicFactorRecombi(), earlyFactorDetection(), monicFactorDetect(),
 ///     biFactorizer()
-CFList 
+CFList
 earlyMonicFactorDetect (
            CanonicalForm& F,       ///< [in,out] poly to be factored, returns
                                    ///< poly divided by detected factors in case
                                    ///< of success
-           CFList& factors,        ///< [in,out] list of factors lifted up to 
+           CFList& factors,        ///< [in,out] list of factors lifted up to
                                    ///< @a deg, returns a list of factors
                                    ///< without detected factors
@@ -319,40 +319,40 @@
            bool& success,          ///< [in,out] indicating success
            int deg,                ///< [in] stage of Hensel lifting
-           const int bound         ///< [in] degree (A, 2) + 1 + 
+           const int bound         ///< [in] degree (A, 2) + 1 +
                                    ///< degree (LC (A, 1), 2), where A is the
                                    ///< multivariate polynomial corresponding to
-                                   ///< F. 
+                                   ///< F.
                        );
 
-/// Bivariate factorization. In contrast to biFactorize() the factors returned 
+/// Bivariate factorization. In contrast to biFactorize() the factors returned
 /// are monic wrt Variable (1), if @a F is not irreducible. And no factorization
-/// wrt Variable (2) are performed. However, 
-///
-/// @return @a biFactorizer returns a list of factors that are monic wrt 
+/// wrt Variable (2) are performed. However,
+///
+/// @return @a biFactorizer returns a list of factors that are monic wrt
 ///         Variable (1), if @a F is irreducible @a F is returned
-/// @sa multiFactorize(), biFactorize() 
-CFList biFactorizer (const CanonicalForm& F,   ///< [in] a bivariate poly 
+/// @sa multiFactorize(), biFactorize()
+CFList biFactorizer (const CanonicalForm& F,   ///< [in] a bivariate poly
                      const Variable& alpha,    ///< [in] algebraic variable
-                     CanonicalForm& bivarEval, ///< [in,out] a valid evaluation 
-                                               ///< point  
+                     CanonicalForm& bivarEval, ///< [in,out] a valid evaluation
+                                               ///< point
                      int& liftBound            ///< [in,out] lift bound, may be
-                                               ///< adapted during Hensel 
-                                               ///< lifting 
+                                               ///< adapted during Hensel
+                                               ///< lifting
                     );
 
-/// Naive factor recombination for multivariate factorization over an extension 
-/// of the initial field. No precomputed is used to exclude combinations. 
+/// Naive factor recombination for multivariate factorization over an extension
+/// of the initial field. No precomputed is used to exclude combinations.
 ///
 /// @return @a extFactorRecombination returns a list of factors of @a F, whose
 ///         shift to zero is reversed.
-/// @sa factorRecombination()   
-CFList 
+/// @sa factorRecombination()
+CFList
 extFactorRecombination (
                  const CFList& factors,     ///< [in] list of lifted factors
-                                            ///< that are monic wrt Variable (1) 
+                                            ///< that are monic wrt Variable (1)
                  const CanonicalForm& F,    ///< [in] poly to be factored
                  const CFList& M,           ///< [in] a list of powers of
-                                            ///< Variables 
-                 const ExtensionInfo& info, ///< [in] info about extension 
+                                            ///< Variables
+                 const ExtensionInfo& info, ///< [in] info about extension
                  const CFList& evaluation   ///< [in] evaluation point
                        );
@@ -361,7 +361,7 @@
 /// No precomputed is used to exclude combinations.
 ///
-/// @return @a factorRecombination returns a list of factors of @a F 
-/// @sa extFactorRecombination() 
-CFList 
+/// @return @a factorRecombination returns a list of factors of @a F
+/// @sa extFactorRecombination()
+CFList
 factorRecombination (const CanonicalForm& F,///< [in] poly to be factored
                      const CFList& factors, ///< [in] list of lifted factors
@@ -375,9 +375,9 @@
 ///
 /// @return @a liftBoundAdaption returns an adapted lift bound.
-/// @sa earlyFactorDetect(), earlyFactorDetection()    
+/// @sa earlyFactorDetect(), earlyFactorDetection()
 int
 liftBoundAdaption (const CanonicalForm& F, ///< [in] a poly
-                   const CFList& factors,  ///< [in] list of list of lifted 
-                                           ///< factors that are monic wrt 
+                   const CFList& factors,  ///< [in] list of list of lifted
+                                           ///< factors that are monic wrt
                                            ///< Variable (1)
                    bool& success,          ///< [in,out] indicates that no
@@ -393,77 +393,77 @@
 ///
 /// @return @a liftBoundAdaption returns an adapted lift bound.
-/// @sa earlyFactorDetect(), earlyFactorDetection() 
-int 
+/// @sa earlyFactorDetect(), earlyFactorDetection()
+int
 extLiftBoundAdaption (
-	    const CanonicalForm& F,    ///< [in] a poly
-	    const CFList& factors,     ///< [in] list of list of lifted 
-                                       ///< factors that are monic wrt 
-	    bool& success,             ///< [in,out] indicates that no further 
+            const CanonicalForm& F,    ///< [in] a poly
+            const CFList& factors,     ///< [in] list of list of lifted
+                                       ///< factors that are monic wrt
+            bool& success,             ///< [in,out] indicates that no further
                                        ///< lifting is necessary
-	    const ExtensionInfo& info, ///< [in] info about extension
-	    const CFList& eval,        ///< [in] evaluation point
-	    const int deg,             ///< [in] stage of Hensel lifting
-	    const CFList& MOD,         ///< [in] a list of powers of
-                                       ///< Variables 
-	    const int bound            ///< [in] initial lift bound
+            const ExtensionInfo& info, ///< [in] info about extension
+            const CFList& eval,        ///< [in] evaluation point
+            const int deg,             ///< [in] stage of Hensel lifting
+            const CFList& MOD,         ///< [in] a list of powers of
+                                       ///< Variables
+            const int bound            ///< [in] initial lift bound
                      );
 
 /// detects factors of @a F at stage @a deg of Hensel lifting.
-/// No combinations of more than one factor are tested. Lift bound is adapted. 
-/// 
-/// @return @a earlyFactorDetect returns a list of factors of F (possibly 
+/// No combinations of more than one factor are tested. Lift bound is adapted.
+///
+/// @return @a earlyFactorDetect returns a list of factors of F (possibly
 ///         incomplete), in case of success. Otherwise an empty list.
 /// @sa factorRecombination(), extEarlyFactorDetect()
-CFList 
+CFList
 earlyFactorDetect (
-		CanonicalForm& F,      ///< [in,out] poly to be factored, 
+                CanonicalForm& F,      ///< [in,out] poly to be factored,
                                        ///< returns poly divided by detected
                                        ///< factors in case of success
-		CFList& factors,       ///< [in,out] list of factors lifted up
+                CFList& factors,       ///< [in,out] list of factors lifted up
                                        ///< to @a deg, returns a list of factors
                                        ///< without detected factors
-		int& adaptedLiftBound, ///< [in,out] adapted lift bound
-		bool& success,         ///< [in,out] indicating success
-		const int deg,         ///< [in] stage of Hensel lifting
-		const CFList& MOD,     ///< [in] a list of powers of
+                int& adaptedLiftBound, ///< [in,out] adapted lift bound
+                bool& success,         ///< [in,out] indicating success
+                const int deg,         ///< [in] stage of Hensel lifting
+                const CFList& MOD,     ///< [in] a list of powers of
                                        ///< Variables
-		const int bound        ///< [in] initial lift bound
+                const int bound        ///< [in] initial lift bound
                   );
 
 /// detects factors of @a F at stage @a deg of Hensel lifting.
-/// No combinations of more than one factor are tested. Lift bound is adapted. 
-/// 
-/// @return @a extEarlyFactorDetect returns a list of factors of F (possibly 
+/// No combinations of more than one factor are tested. Lift bound is adapted.
+///
+/// @return @a extEarlyFactorDetect returns a list of factors of F (possibly
 ///         incomplete), whose shift to zero is reversed, in case of success.
-///         Otherwise an empty list. 
+///         Otherwise an empty list.
 /// @sa factorRecombination(), earlyFactorDetection()
-CFList 
+CFList
 extEarlyFactorDetect (
-	    CanonicalForm& F,          ///< [in,out] poly to be factored, 
+            CanonicalForm& F,          ///< [in,out] poly to be factored,
                                        ///< returns poly divided by detected
                                        ///< factors in case of success
-	    CFList& factors,           ///< [in,out] list of factors lifted up
+            CFList& factors,           ///< [in,out] list of factors lifted up
                                        ///< to @a deg, returns a list of factors
                                        ///< without detected factors
-	    int& adaptedLiftBound,     ///< [in,out] adapted lift bound
-	    bool& success,             ///< [in,out] indicating succes
-	    const ExtensionInfo& info, ///< [in] info about extension
-	    const CFList& eval,        ///< [in] evaluation point
-	    const int deg,             ///< [in] stage of Hensel lifting
-	    const CFList& MOD,         ///< [in] a list of powers of Variables
-	    const int bound            ///< [in] initial lift bound
+            int& adaptedLiftBound,     ///< [in,out] adapted lift bound
+            bool& success,             ///< [in,out] indicating succes
+            const ExtensionInfo& info, ///< [in] info about extension
+            const CFList& eval,        ///< [in] evaluation point
+            const int deg,             ///< [in] stage of Hensel lifting
+            const CFList& MOD,         ///< [in] a list of powers of Variables
+            const int bound            ///< [in] initial lift bound
                      );
 
-/// evaluation point search for multivariate factorization, 
+/// evaluation point search for multivariate factorization,
 /// looks for a (F.level() - 1)-tuple such that the resulting univariate
 /// polynomial has main variable F.mvar(), is squarefree and its degree
-/// coincides with degree(F) and the bivariate one is primitive wrt. 
-/// Variable(1), fails if there are no valid evaluation points, eval contains 
-/// the intermediate evaluated polynomials.  
+/// coincides with degree(F) and the bivariate one is primitive wrt.
+/// Variable(1), fails if there are no valid evaluation points, eval contains
+/// the intermediate evaluated polynomials.
 ///
 /// @return @a evalPoints returns an evaluation point, which is valid if and
-///         only if fail == false. 
-CFList 
-evalPoints (const CanonicalForm& F,  ///< [in] a compressed poly 
+///         only if fail == false.
+CFList
+evalPoints (const CanonicalForm& F,  ///< [in] a compressed poly
             CFList & eval,           ///< [in,out] an empty list, returns @a F
                                      ///< successive evaluated
@@ -472,5 +472,5 @@
                                      ///< considered, a point is encoded as a
                                      ///< poly of degree F.level()-1 in
-                                     ///< Variable(1) 
+                                     ///< Variable(1)
             const bool& GF,          ///< [in] GF?
             bool& fail               ///< [in,out] indicates failure
@@ -482,20 +482,20 @@
 ///
 /// @return @a newMainVariableSearch returns the level of the new main variable,
-///         if there no variable which omitts a valid evaluation 0 is returned 
+///         if there no variable which omitts a valid evaluation 0 is returned
 static inline
 int newMainVariableSearch (
               CanonicalForm& A,     ///< [in,out] a compressed poly, returns
-                                    ///< the swapped initial poly or the 
-                                    ///< initial poly if 0 is returned 
-	      CFList& Aeval,        ///< [in,out] @a A successively evaluated,
+                                    ///< the swapped initial poly or the
+                                    ///< initial poly if 0 is returned
+              CFList& Aeval,        ///< [in,out] @a A successively evaluated,
                                     ///< empty list if 0 is returned
-	      CFList& evaluation,   ///< [in,out] evaluation point, empty list
-                                    ///< if 0 is returned 
-	      const Variable& alpha,///< [in] algebraic variable
-	      const int lev         ///< [in] some int <= A.level()
+              CFList& evaluation,   ///< [in,out] evaluation point, empty list
+                                    ///< if 0 is returned
+              const Variable& alpha,///< [in] algebraic variable
+              const int lev         ///< [in] some int <= A.level()
                           );
-/// hensel Lifting and early factor detection 
-///
-/// @return @a henselLiftAndEarly returns monic (wrt Variable (1)) lifted 
+/// hensel Lifting and early factor detection
+///
+/// @return @a henselLiftAndEarly returns monic (wrt Variable (1)) lifted
 ///         factors without factors which have been detected at an early stage
 ///         of Hensel lifting
@@ -503,18 +503,18 @@
 CFList
 henselLiftAndEarly (
-	    CanonicalForm& A,         ///< [in,out] poly to be factored,  
+            CanonicalForm& A,         ///< [in,out] poly to be factored,
                                       ///< returns poly divided by detected
-                                      ///< factors, in case of success 
-	    CFList& MOD,              ///< [in,out] a list of powers of
+                                      ///< factors, in case of success
+            CFList& MOD,              ///< [in,out] a list of powers of
                                       ///< Variables
-	    int*& liftBounds,         ///< [in,out] initial lift bounds, returns
+            int*& liftBounds,         ///< [in,out] initial lift bounds, returns
                                       ///< adapted lift bounds
-	    bool& earlySuccess,       ///< [in,out] indicating success
-	    CFList& earlyFactors,     ///< [in,out] early factors
-	    const CFList& Aeval,      ///< [in] @a A successively evaluated at
+            bool& earlySuccess,       ///< [in,out] indicating success
+            CFList& earlyFactors,     ///< [in,out] early factors
+            const CFList& Aeval,      ///< [in] @a A successively evaluated at
                                       ///< elements of @a evaluation
-	    const CFList& biFactors,  ///< [in] bivariate factors
-	    const CFList& evaluation, ///< [in] evaluation point
-	    const ExtensionInfo& info ///< [in] info about extension
+            const CFList& biFactors,  ///< [in] bivariate factors
+            const CFList& evaluation, ///< [in] evaluation point
+            const ExtensionInfo& info ///< [in] info about extension
                    );
 
@@ -523,8 +523,8 @@
 /// @return @a extFactorize returns factorization of F over initial field
 /// @sa extBiFactorize(), multiFactorize()
-CFList 
-extFactorize (const CanonicalForm& F,   ///< [in] poly to be factored 
-              const ExtensionInfo& info ///< [in] info about extension 
-             ); 
+CFList
+extFactorize (const CanonicalForm& F,   ///< [in] poly to be factored
+              const ExtensionInfo& info ///< [in] info about extension
+             );
 
 #endif
