Changeset 81fb58d in git

Timestamp:

Apr 14, 1999, 2:11:57 PM (24 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

a1417ca18268fbc29752b22baabf8c7d5409ef6f

Parents:

a3600c96f2d4c4189dbfe8f553885cf86db78ffa

Message:

* hannes/lamm: new hnoether.lib/primtiv.lib


git-svn-id: file:///usr/local/Singular/svn/trunk@2979 2c84dea3-7e68-4137-9b89-c4e89433aadc

Files:

• Singular/LIB/hnoether.lib (modified) (109 diffs)
• Singular/LIB/primitiv.lib (modified) (9 diffs)
• Tst/Long/hnoether_l.res.gz.uu (modified) (1 diff)
• Tst/Long/hnoether_l.stat (modified) (1 diff)
• Tst/Long/hnoether_l.tst (modified) (3 diffs)
• Tst/Short/hnoether_s.res.gz.uu (modified) (1 diff)
• Tst/Short/hnoether_s.stat (modified) (1 diff)
• Tst/Short/hnoether_s.tst (modified) (2 diffs)

Singular/LIB/hnoether.lib

@@ -1 @@
-// $Id: hnoether.lib,v 1.9 1998-10-21 10:28:24 krueger Exp $
+// $Id: hnoether.lib,v 1.10 1999-04-14 12:11:49 Singular Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
-// last change:           26.03.98
-///////////////////////////////////////////////////////////////////////////////
-
-version="$Id: hnoether.lib,v 1.9 1998-10-21 10:28:24 krueger Exp $";
+// last change:           09.03.99
+///////////////////////////////////////////////////////////////////////////////
+// This library is for Singular 1.2 or newer
+
+version="$Id: hnoether.lib,v 1.10 1999-04-14 12:11:49 Singular Exp $";
 info="
-LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER-DEVELOPMENT
+LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER DEVELOPMENT
 
            Important procedures:
- develop(f [,n]);    Hamburger-Noether development from the irred. polynomial f
- reddevelop(f);      Hamburger-Noether development from the (red.) polynomial f
- extdevelop(hne,n);  extension of Hamburger-Noether development hne from f
+ develop(f [,n]);    Hamburger-Noether development of the irred. polynomial f
+ reddevelop(f);      Hamburger-Noether development of the (red.) polynomial f
+ extdevelop(hne,n);  extension of the Hamburger-Noether development hne of f
  param(hne);         returns a parametrization of f (input=output(develop))
  displayHNE(hne);    display Hamburger-Noether development as an ideal
  invariants(hne);    invariants of f, e.g. the characteristic exponents
  displayInvariants(hne);  display invariants of f
- generators(hne);    computes the generators of the semigroup of values
  intersection(hne1,hne2); intersection multiplicity of two curves
+ multsequence(hne);  sequence of multiplicities
+ displayMultsequence(hne);  display sequence of multiplicities
  stripHNE(hne);      reduce amount of memory consumed by hne
+
+           perhaps useful procedures:
+ puiseux2generators(m,n); convert Puiseux pairs to generators of semigroup
+ multiplicities(hne);     multiplicities of blowed up curves
+ separateHNE(hne1,hne2);  number of quadratic transf. needed for separation
+ squarefree(f);      returns a squarefree divisor of the poly f
+ allsquarefree(f,l); returns the maximal squarefree divisor of the poly f
 ";
-////////////////////////////////////////////////////////////////////////////
-//           perhaps useful procedures:
-// puiseux2generators(m,n); convert puiseux pairs to generators of semigroup
-// multiplicities(hne);     multiplicities of blowed up curves
-// newtonpoly(f);      newtonpolygon of polynom f
-// newtonhoehne(f);    same as newtonpoly, but uses internal procedure
-// getnm(f);           intersection points of the Newton-polygon with the axes
+///////////////////////////////////////////////////////////////////////////////
+// newtonpoly(f);      Newton polygon of polynom f
+// getnm(f);           intersection points of the Newton polygon with the axes
 // T_Transform(f,Q,N); returns f(y,xy^Q)/y^NQ (type f(x,y): poly, Q,N: int)
 // T1_Transform(f,d,M); returns f(x,y+d*x^M)  (type f(x,y): poly,d:number,M:int)
-// T2_Transform(f,d,M,N);   a composition of T1 & T
+// T2_Transform(f,d,M,N,ref);   a composition of T1 & T
 // koeff(f,I,J);       gets coefficient of indicated monomial of poly f (I,J:int)
 // redleit(f,S,E);     restriction of monomials of f to line (S-E)
-// squarefree(f);      returns a squarefree divisor of the poly f
-// allsquarefree(f,l); returns the maximal squarefree divisor of the poly f
+// leit(f,n,m);        special case of redleit (for irred. polynomials)
 // set_list(L,v,l);    managing interconnected lists
 //
 //           procedures (more or less) for internal use:
-// leit(f,n,m);        special case of redleit (for irred. polynomials)
 // testreducible(f,n,m); tests whether f is reducible
 // polytest(f);        tests coefficients and exponents of poly f
@@ -44 +47 @@
 // get_last_divisor(M,N); last divisor in Euclid's algorithm
 // factorfirst(f,M,N); try to factor f in a trivial way before using 'factorize'
+// factorlist(L);      factorize a list L of polynomials
 // extrafactor(f,M,N); try to factor charPoly(f,M,N) where 'factorize' cannot
+// referencepoly(D);   a polynomial f s.t. D is the Newton diagram of f
 // extractHNEs(H,t);   extracts output H of HN to output of reddevelop
 // HN(f,grenze);       recursive subroutine for reddevelop
@@ -75 +80 @@
 
 proc leit (poly f, int n, int m)
-"// leit(poly f, int n, int m) returns all monomials on the line
-// from (0,n) to (m,0) in the Newton diagram
+"USAGE:   leit(f,n,m);  poly f, int n,m
+RETURN:  all monomials on the line from (0,n) to (m,0) in the Newton diagram
+EXAMPLE: example leit;  shows an example
 "
 {
  return(jet(f,m*n,intvec(n,m))-jet(f,m*n-1,intvec(n,m)))
 }
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r = 0,(x,y),ds;
+   poly f = x5+x4y3-y2+y4;
+   leit(f,2,5);
+}
 ///////////////////////////////////////////////////////////////////////////////
 proc testreducible (poly f, int n, int m)
-"// testreducible(poly f,int n,int m) returns true if there are points in the
-// Newton diagram below the line (0,n)-(m,0)
-"
+" testreducible(poly f,int n,int m) returns true if there are points in the
+ Newton diagram below the line (0,n)-(m,0)"
 {
  return(size(jet(f,m*n-1,intvec(n,m))) != 0)
@@ -91 +102 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc T_Transform (poly f, int Q, int N)
-"// returns f(y,xy^Q)/y^NQ
-"
+" returns f(y,xy^Q)/y^NQ  (only useful if f is irreducible) "
 {
  map T = basering,y,x*y^Q;
@@ -98 +108 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc T1_Transform (poly f, number d, int M)
-"// returns f(x,y+d*x^M)
-"
-{
- map T1 = basering,x,y+d*x^M;
+proc T1_Transform (poly f, number d, int Q)
+" returns f(x,y+d*x^Q) "
+{
+ map T1 = basering,x,y+d*x^Q;
  return(T1(f));
 }
 ///////////////////////////////////////////////////////////////////////////////
 
-proc T2_Transform (poly f, number d, int M, int N)
-"USAGE: T2_Transform(f,d,M,N); f poly, d number; M,N int
-RETURN: list: poly T2(f,d',M,N), number d' in \{ d, 1/d \}
+proc T2_Transform (poly f, number d, int M, int N, poly refpoly)
+"USAGE:   T2_Transform(f,d,M,N,ref); f poly, d number; M,N int; ref poly
+ASSUME:  ref has the same Newton polygon as f (but can be simpler)
+         for this you can e.g. use the proc `referencepoly' or simply f again
+RETURN:  list: poly T2(f,d',M,N), number d' in \{ d, 1/d \}
+EXAMPLE: example T2_Transform;  shows an example
 "
 {
@@ -117 +129 @@
   list ts=extgcd(M,N);
   int tau,sigma=ts[2],-ts[3];
+  int s,t;
+  poly hilf;
   if (sigma<0) { tau=-tau; sigma=-sigma;}
  // es gilt: 0<=tau<=N, 0<=sigma<=M, |N*sigma-M*tau| = 1 = ggT(M,N)
@@ -127 +141 @@
   map T1 = basering,x,y+d*x^Q;
   map Tstar=basering,x^(N-Q*tau)*y^tau,x^(M-sigma*Q)*y^sigma;
-  if (defined(Protokoll)) {
+  if (defined(HNDebugOn)) {
    "Trafo. T2: x->x^"+string(N-Q*tau)+"*y^"+string(tau)+", y->x^"
     +string(M-sigma*Q)+"*y^"+string(sigma);
@@ -133 +147 @@
   }
  //------------------- Durchfuehrung der Transformation T2 --------------------
- // man koennte an T2_Transform noch eine Liste mit allen Eckpunkten des
- // Newtonpolys uebergeben und nur die Transformierten der Eckpunkte betrachten
- // um max. Exponenten e,f von x,y zu finden--noch einfacher: ein Referenzpo-
- // lynom, das das gleiche Newtonpolygon hat (z.B. Einschraenkung auf die Mono-
- // me in den Eckpunkten, oder alle Monome haben Koeff. 1, das ist einfacher)
- //----------------------------------------------------------------------------
-
-  f=Tstar(f); // hier dann refpoly=Tstar(refpoly)
-  poly hilf;
- // dividiere f so lange durch x, wie die Div. aufgeht:
-  for (hilf=f/x; hilf*x==f; hilf=f/x) {f=hilf;}
-  for (hilf=f/y; hilf*y==f; hilf=f/y) {f=hilf;} // gleiches fuer y
+  f=Tstar(f);
+  refpoly=Tstar(refpoly);
+ //--- dividiere f so lange durch x & y, wie die Div. aufgeht, benutze ein  ---
+ //--- Referenzpolynom mit gleichem Newtonpolynom wie f zur Beschleunigung: ---
+  for (hilf=refpoly/x; hilf*x==refpoly; hilf=refpoly/x) {refpoly=hilf; s++;}
+  for (hilf=refpoly/y; hilf*y==refpoly; hilf=refpoly/y) {refpoly=hilf; t++;}
+  f=f/(x^s*y^t);
   return(list(T1(f),d));
 }
+example
+{ "EXAMPLE:"; echo = 2;
+  ring exrg=0,(x,y),ds;
+  export exrg;
+  poly f=y2-2x2y+x6-x5y+x4y2;
+  T2_Transform(f,1/2,4,1,f);
+  T2_Transform(f,1/2,4,1,referencepoly(newtonpoly(f)));
+  // if  size(referencepoly) << size(f)  the 2nd example would be faster
+  referencepoly(newtonpoly(f));
+  kill exrg;
+}
 ///////////////////////////////////////////////////////////////////////////////
 
 proc koeff (poly f, int I, int J)
-"USAGE:  koeff(f,I,J); f polynomial in x and y, I,J integers
-RETURN: if f = sum(a(i,j)*x^i*y^j), then koeff(f,I,J)= a(I,J) (of type number)
+"USAGE:   koeff(f,I,J); f polynomial in x and y, I,J integers
+RETURN:  if f = sum(a(i,j)*x^i*y^j), then koeff(f,I,J)= a(I,J) (of type number)
 EXAMPLE: example koeff;  shows an example
-"{
+NOTE:    J must be in the range of the exponents of y
+"
+{
   matrix mat = coeffs(coeffs(f,y)[J+1,1],x);
   if (size(mat) <= I) { return(0);}
@@ -166 +188 @@
 
 proc squarefree (poly f)
-"USAGE:  squarefree(f); f poly in x and y
+"USAGE:  squarefree(f);  f a bivariate polynomial
 RETURN: a squarefree divisor of f
         Normally the return value is a greatest squarefree divisor, but there
@@ -172 +194 @@
         are lost.
 EXAMPLE: example squarefree; shows some examples.
-"{
- // es gibt noch ein Problem: syz gibt manchmal in Koerpererweiterung (p,a)
- // nicht f/g zurueck, obwohl die Division aufgeht ... In dem Fall ist die
- // Rueckgabe evtl. nicht quadratfrei! Bsp.: squarefree((1/a*x3+y7)^3);
- // in char 7
- // In Singular 1.1.3 funktioniert syz, dafuer geht das gleiche Bsp. schief,
- // weil gcd auf einmal falsch wird! (ring (7,a),(x,y),dp; minpoly=a2+1; )
-
+"
+{
  //----------------- Wechsel in geeigneten Ring & Variablendefinition ---------
   def altring = basering;
@@ -185 +201 @@
   int gcd_ok=1;
   string mipl="0";
-  if (size(parstr(altring))==1) {mipl=string(minpoly);}
+  if (size(parstr(altring))==1) { mipl=string(minpoly); }
  //---- test: char = (p^k,a) (-> gcd not implemented) or (p,a) (gcd works) ----
   if ((char(basering)!=0) and (charstr(basering)!=string(char(basering)))) {
@@ -196 +212 @@
   poly f=fetch(altring,f);
   poly dif,g,l;
+  if ((char(basering)==0) and (charstr(basering)!=string(char(basering)))
+      and (mipl!="0")) {
+    gcd_ok=0;                   // since Singular 1.2 gcd no longer implemented
+  }
   if (gcd_ok!=0) {
- //-------------------- Berechne f/ggT(f,df/dx,df/dy) ------------------------
+ //--------------------- Berechne f/ggT(f,df/dx,df/dy) ------------------------
     dif=diff(f,x);
     if (dif==0) { g=f; }        // zur Beschleunigung
@@ -216 +236 @@
        else { l=m[1,1]; }
      }
- //----------------------------------------------------------------------------
- // Polynomdivision geht, wenn factory eingebunden ist
- // dann also l=f/g; aber: ist ebenfalls fehlerhaft! (s.o. als Bsp.)
- // wenn / zur Polynomdivision einsetzbar ist, kann der Ringwechsel gespart
- // werden, sollte dann also zum Einsatz gebracht werden (Zeitersparnis)
- //----------------------------------------------------------------------------
     }
     else { e=1; }
@@ -236 +250 @@
      if (dif==0) { e=2; l=1; } // f is of power divisible by char of basefield
      else { l=syz(ideal(dif,f))[1,1];  // x^p+y^(p-1) abgedeckt
-            if (deg(l)==deg(f)) { e=1;}
+            if (subst(f,x,0)==0) { l=l*x; }
+            if (deg(l)==deg(f))  { e=1;}
             else {e=0;}
      }
     }
     else { l=syz(ideal(dif,f))[1,1];
-           if (deg(l)==deg(f)) { e=1;}
+           if (subst(f,y,0)==0) { l=l*y; }
+           if (deg(l)==deg(f))  { e=1;}
            else {e=0;}
     }
@@ -269 +285 @@
         l is the squarefree divisor of f you get by l=squarefree(f);
 RETURN: the squarefree divisor of f consisting of all irreducible factors of f
-NOTE  : * this proc uses factorize to get the missing factors of f not in l and
-          therefore may be slow. Furthermore factorize can still return
-          a factor more than once (what should not occur)
-        * this proc uses polynomial division of factory (which still has a bug
-         at the moment: it can return nonsense, if the basering has parameters)
+NOTE  : This proc uses factorize to get the missing factors of f not in l and
+        therefore may be slow. Furthermore factorize still seems to contain
+        errors...
 EXAMPLE: example allsquarefree;  shows an example
-"{
+"
+{
+ //------------------------ Wechsel in geeigneten Ring ------------------------
+ def altring = basering;
+ string mipl="0";
+ if (size(parstr(altring))==1) { mipl=string(minpoly); }
+ if ((char(basering)!=0) and (charstr(basering)!=string(char(basering)))) {
+   string tststr=charstr(basering);
+   tststr=tststr[1..find(tststr,",")-1];           //-> "p^k" bzw. "p"
+   if (tststr!=string(char(basering))) {
+     " Sorry -- not implemented for this ring (gcd doesn't work)";
+     return(l);
+   }
+ }
+ execute("ring rsqrf = ("+charstr(altring)+"),(x,y),dp;");
+ if (mipl!="0") { execute "minpoly="+mipl+";"; }
+ poly f=fetch(altring,f);
+ poly l=fetch(altring,l);
  //---------- eliminiere bereits mit squarefree gefundene Faktoren ------------
- poly g=l;                            // g = gcd(f,l);
+ poly g=l;
  while (deg(g)!=0) {
-  f=f/g;
-  g=gcd(f,l);
- }                                    // jetzt f=h^p
+   f=syz(ideal(g,f))[1,1];                         // f=f/g;
+   g=gcd(f,l);
+ }                                                 // jetzt f=h^p
  //--------------- Berechne uebrige Faktoren mit factorize --------------------
  if (deg(f)>0) {
@@ -291 +322 @@
     "!! factorize has not worked correctly !!";
     if (testp==1) {" We cannot proceed ..."; g=1;}
-    else {" But we could recover the correct result..."; g=testp;}
+    else {" But we could recover some factors..."; g=testp;}
   }
   l=l*g;
  }
+ //--------------- Wechsel in alten Ring und Rueckgabe des Ergebnisses --------
+ setring altring;
+ l=fetch(rsqrf,l);
  return(l);
 }
@@ -315 +349 @@
 NOTE:   this procedure is only useful in characteristic zero, because otherwise
         there is no appropriate ordering of the leading coefficients
-"{
+"
+{
  poly verbrecher=0;
  intvec leitexp;
@@ -337 +372 @@
          [1]: Hamburger-Noether matrix
             each row contains the coefficients of the corresponding line of the
-            Hamburger-Noether extension (HNE). The end of the line is marked in
+            Hamburger-Noether expansion (HNE). The end of the line is marked in
             the matrix as the first ring variable (usually x)
          [2]: intvec indicating the length of lines of the HNE
          [3]: int:
-           0  if the 1st ring variable was transverse (with respect to f),
+           0  if the 1st ring variable was transversal (with respect to f),
            1  if the variables were changed at the beginning of the computation
            -1 if an error has occurred
@@ -352 +387 @@
          n columns. Otherwise the number of columns will be chosen minimal s.t.
          the matrix contains all necessary information (i.e. all lines of the
-         HNE but the last (which is in general infinite) appear).
+         HNE but the last (which is in general infinite) have place).
          If n is negative, the algorithm is stopped as soon as possible, i.e.
          the information computed is enough for 'invariants', but the HN-matrix
@@ -369 +404 @@
 EXAMPLES: example develop; shows an example
           example param;   shows an example for using the 2nd parameter
-"{
+"
+{
  //--------- Abfangen unzulaessiger Ringe: 1) nur eine Unbestimmte ------------
  poly f=#[1];
@@ -390 +426 @@
 
  if (charstr(basering)=="real") {
-  "The algorithm doesn't work with 'real' as coefficient field.";
+  " The algorithm doesn't work with 'real' as coefficient field.";
                      // denn : map from characteristic -1 to -1 not implemented
   return(return_error);
@@ -400 +436 @@
     int primit=(tststr==string(char(basering)));
     if (primit!=0) {
-      "such extensions of Z/p are not implemented.",
-      "Please try (p^k,a) as ground field.";
+      " Such extensions of Z/p are not implemented.";
+      " Please try (p^k,a) as ground field or use `reddevelop'.";
       return(return_error);
     }
@@ -422 +458 @@
  map m=altring,x,y;
  if (ringwechsel) { poly f=m(f); }
- if (defined(Protokoll))
+ if (defined(HNDebugOn))
  {"received polynomial: ",f,", where x =",namex,", y =",namey;}
 
@@ -515 +551 @@
         if (str<>"c") {
           setring altring;kill guenstig;kill zweitring;
-          if(system("with","Namespaces")) { kill Top::guenstig; }
           return(return_error);}
         else { "if the algorithm doesn't terminate, you were wrong...";}
@@ -522 +557 @@
     nm = getnm(f);             // N,M haben sich evtl. veraendert
     N = nm[1]; M = nm[2];      // Berechne Schnittpunkte Newtonpoly mit Achsen
-    if (defined(Protokoll)) {"I continue with the polynomial",f; }
+    if (defined(HNDebugOn)) {"I continue with the polynomial",f; }
    }
    else {
@@ -537 +572 @@
     setring altring;
     kill guenstig;
-    if(system("with","Namespaces")) { kill Top::guenstig; }
     return(return_error);}
    if (test_sqr != f) {
@@ -548 +582 @@
     nm = getnm(f);              // N,M haben sich veraendert
     N = nm[1]; M = nm[2];       // Berechne Schnittpunkte Newtonpoly mit Achsen
-    if (defined(Protokoll)) {"I continue with the polynomial",f; }
+    if (defined(HNDebugOn)) {"I continue with the polynomial",f; }
    }
 
@@ -555 +589 @@
   if (N==0) {
     " Sorry. The remaining polynomial is a unit in the power series ring...";
-    if(system("with","Namespaces")) { kill Top::guenstig; }
     setring altring;kill guenstig;return(return_error);
   }
@@ -564 +597 @@
     M = M+N; N = M-N; M = M-N;  // M, N auch vertauschen
   }
-  if (defined(Protokoll)) {
+  if (defined(HNDebugOn)) {
    if (getauscht) {"x<->y were exchanged; poly is now ",f;}
    else           {"x , y were not exchanged";}
@@ -580 +613 @@
     " The given polynomial is not irreducible";
     kill guenstig;
-    if(system("with","Namespaces")) { kill Top::guenstig; }
     setring altring;
     return(return_error);       // Abbruch der Prozedur!
@@ -595 +627 @@
     if (p==0) {
       delta = koeff(f,M/ e,N - N/ e) / (-1*e*c);
-      if (defined(Protokoll)) {"quasihomogeneous leading form:",
+      if (defined(HNDebugOn)) {"quasihomogeneous leading form:",
          leit(f,N,M)," = ",c,"* (y -",delta,"* x^"+string(M/ e)+")^",e," ?";}
       if (leit(f,N,M) != c*(y^(N/ e) - delta*x^(M/ e))^e)
-        { " The given Polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
+        { " The given polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
     }
     else {                     // p!=0
       if (e%p != 0) {
         delta = koeff(f,M/ e,N - N/ e) / (-1*e*c);
-        if (defined(Protokoll)) {"quasihomogeneous leading form:",
+        if (defined(HNDebugOn)) {"quasihomogeneous leading form:",
            leit(f,N,M)," = ",c,"* (y -",delta,"* x^"+string(M/ e)+")^",e," ?";}
         if (leit(f,N,M) != c*(y^(N/ e) - delta*x^(M/ e))^e)
-         { " The given Polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
+         { " The given polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
       }
 
@@ -612 +644 @@
         eps = e;
         for (l = 0; eps%p == 0; l=l+1) { eps=eps/ p;}
-        if (defined(Protokoll)) {e," -> ",eps,"*",p,"^",l;}
+        if (defined(HNDebugOn)) {e," -> ",eps,"*",p,"^",l;}
         delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps-1)) / (-1*eps*c);
 
@@ -632 +664 @@
         }
 
-        if (defined(Protokoll)) {"quasihomogeneous leading form:",
+        if (defined(HNDebugOn)) {"quasihomogeneous leading form:",
           leit(f,N,M)," = ",c,"* (y^"+string(N/ e),"-",delta,"* x^"
           +string(M/ e)+")^",e,"  ?";}
         if (leit(f,N,M) != c*(y^(N/ e) - delta*x^(M/ e))^e)
-          { " The given Polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
+          { " The given polynomial is reducible !"; Abbruch=1; Ausgabe=1;}
       }
     }
@@ -643 +675 @@
       "a("+string(zeile)+","+string(Q)+") =",delta;
       a(zeile)[Q]=delta;
-      if (defined(Protokoll)) {"transformed polynomial: ",f;}}
+      if (defined(HNDebugOn)) {"transformed polynomial: ",f;}}
 
       nm=getnm(f); N=nm[1]; M=nm[2];        // Neuberechnung des Newtonpolygons
@@ -655 +687 @@
                                      // Anpassung der Sp.zahl der HNE-Matrix
     f = T_Transform(f,Q,N);
-    if (defined(Protokoll)) {"transformed polynomial: ",f;}
+    if (defined(HNDebugOn)) {"transformed polynomial: ",f;}
     zeile=zeile+1;
  //------------ Bereitstellung von Speicherplatz fuer eine neue Zeile: --------
@@ -672 +704 @@
   }
   else {if (M<N) {"Something has gone wrong: M<N";}}
-  if(defined(Protokoll)) {"new M,N:",M,N;}
+  if(defined(HNDebugOn)) {"new M,N:",M,N;}
 
  //----------------- Abbruchbedingungen fuer die Schleife: --------------------
@@ -709 +741 @@
  }
 
- if(system("with","Namespaces")) { kill Top::guenstig; }
  kill guenstig;
  if (Ausgabe == 0) { return(list(amat,hqs,getauscht,f));}
@@ -731 +762 @@
   hne[2]; pause;
   param(hne);
-  // returns the parametrisation x(t)= -t14+O(t21), y(t)= -3t98+O(t105)
+  // returns the parametrization x(t)= -t14+O(t21), y(t)= -3t98+O(t105)
   // (the term -t109 in y may have a wrong coefficient)
   displayHNE(hne);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//               procedures to extract information out of HNE                //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -741 +774 @@
 "USAGE:  param(l) takes the output of develop(f)
         (list l (matrix m, intvec v, int s[,poly g]))
-        and gives a parametrisation for f; the first variable of the active
+        and gives a parametrization for f; the first variable of the active
         ring is chosen as indefinite. If the ring contains more than
         two variables, the 3rd variable is chosen (remember that develop takes
         the first two variables and therefore the other vars should be unused)
 RETURN: ideal of two polynomials: if the HNE was finite, f(param[1],param[2])
-        will be  zero. If not, the real parametrisation will be
+        will be  zero. If not, the real parametrization will be
         two power series; then param will return a truncation of these series.
-EXAMPLE: example param;      shows an example
+EXAMPLE: example param;     shows an example
          example develop;   shows another example
-
-"{
+"
+{
  //-------------------------- Initialisierungen -------------------------------
  matrix m=#[1];
@@ -850 +883 @@
 "USAGE:  invariants(l) takes the output of develop(f)
         (list l (matrix m, intvec v, int s[,poly g]))
-        and computes some invariants:
+        and computes the following irreducible curve invariants:
 RETURN:  a list, if l contains a valid HNE:
     - invariants(l)[1]: intvec         (characteristic exponents)
-    - invariants(1)[2],[3]: 2 x intvec (puiseux pairs, 1st and 2nd components)
-    - invariants(l)[4]: int            (degree of the conductor)
-    - invariants(l)[5]: intvec         (sequence of multiplicities)
+    - invariants(l)[2]: intvec         (generators of the semigroup)
+    - invariants(l)[3],[4]: 2 x intvec (Puiseux pairs, 1st and 2nd components)
+    - invariants(l)[5]: int            (degree of the conductor)
+    - invariants(l)[6]: intvec         (sequence of multiplicities)
          an empty list, if an error occurred in the procedure develop
 EXAMPLE: example invariants; shows an example
-"{
+"
+{
  //-------------------------- Initialisierungen -------------------------------
  matrix m=#[1];
@@ -868 +903 @@
    return(ergebnis);
  }
- intvec beta,s,svorl,ordnung,multips,multseq,mpuiseux,npuiseux;
+ intvec beta,s,svorl,ordnung,multseq,mpuiseux,npuiseux,halbgr;
  int genus,zeile,i,j,k,summe,conductor,ggT;
  string Ausgabe;
@@ -912 +947 @@
  }
  conductor=summe;
+ //------------------- Erzeuger der Halbgruppe: -------------------------------
+ halbgr=puiseux2generators(mpuiseux,npuiseux);
+
  //------------------- Multiplizitaetensequenz: -------------------------------
  k=1;
- multips=multiplicities(#);
  for (i=1; i<size(v); i++) {
    for (j=1; j<=v[i]; j++) {
-     multseq[k]=multips[i];
+     multseq[k]=ordnung[i];
      k++;
  }}
  multseq[k]=1;
  //------------------------- Rueckgabe ----------------------------------------
- ergebnis=beta,mpuiseux,npuiseux,conductor,multseq;
+ ergebnis=beta,halbgr,mpuiseux,npuiseux,conductor,multseq;
  return(ergebnis);
 }
@@ -931 +968 @@
  list erg=invariants(hne);
  erg[1];                   // the characteristic exponents
- erg[2],erg[3];            // the puiseux pairs in packed form
- erg[4] / 2;               // the delta-invariant
- erg[5];                   // the sequence of multiplicities
+ erg[2];                   // the generators of the semigroup of values
+ erg[3],erg[4];            // the Puiseux pairs in packed form
+ erg[5] / 2;               // the delta-invariant
+ erg[6];                   // the sequence of multiplicities
                            // To display the invariants more 'nicely':
  displayInvariants(hne);
@@ -948 +986 @@
 RETURN:  nothing
 EXAMPLE: example displayInvariants;  shows an example
-"{
+"
+{
  int i,j,k,mul;
  string Ausgabe;
@@ -959 +998 @@
    if (size(ergebnis)!=0) {
     " characteristic exponents  :",ergebnis[1];
+    " generators of semigroup   :",ergebnis[2];
     if (size(ergebnis[1])>1) {
-     for (i=1; i<=size(ergebnis[2]); i++) {
-       Ausgabe=Ausgabe+"("+string(ergebnis[2][i])+","
-       +string(ergebnis[3][i])+")";
+     for (i=1; i<=size(ergebnis[3]); i++) {
+       Ausgabe=Ausgabe+"("+string(ergebnis[3][i])+","
+       +string(ergebnis[4][i])+")";
     }}
-    " puiseux pairs             :",Ausgabe;
-    " degree of the conductor   :",ergebnis[4];
-    " delta invariant           :",ergebnis[4]/2;
-    " generators of semigroup   :",puiseux2generators(ergebnis[2],ergebnis[3]);
-    " sequence of multiplicities:",ergebnis[5];
+    " Puiseux pairs             :",Ausgabe;
+    " degree of the conductor   :",ergebnis[5];
+    " delta invariant           :",ergebnis[5]/2;
+    " sequence of multiplicities:",ergebnis[6];
  }}
  //-------------------- Ausgabe aller Zweige ----------------------------------
@@ -976 +1015 @@
     " --- invariants of branch number",j,": ---";
     " characteristic exponents  :",ergebnis[1];
+    " generators of semigroup   :",ergebnis[2];
     Ausgabe="";
     if (size(ergebnis[1])>1) {
-     for (i=1; i<=size(ergebnis[2]); i++) {
-       Ausgabe=Ausgabe+"("+string(ergebnis[2][i])+","
-       +string(ergebnis[3][i])+")";
+     for (i=1; i<=size(ergebnis[3]); i++) {
+       Ausgabe=Ausgabe+"("+string(ergebnis[3][i])+","
+       +string(ergebnis[4][i])+")";
     }}
-    " puiseux pairs             :",Ausgabe;
-    " degree of the conductor   :",ergebnis[4];
-    " delta invariant           :",ergebnis[4]/2;
-    " generators of semigroup   :",puiseux2generators(ergebnis[2],ergebnis[3]);
-    " sequence of multiplicities:",ergebnis[5];
+    " Puiseux pairs             :",Ausgabe;
+    " degree of the conductor   :",ergebnis[5];
+    " delta invariant           :",ergebnis[5]/2;
+    " sequence of multiplicities:",ergebnis[6];
     "";
   }
@@ -1030 +1069 @@
          sive blowing up of the curve corresponding to f
 EXAMPLE: example multiplicities;  shows an example
-"{
+"
+{
  matrix m=#[1];
  intvec v=#[2];
@@ -1065 +1105 @@
 proc puiseux2generators (intvec m, intvec n)
 "USAGE:   puiseux2generators (m,n);
-         m,n intvecs with 1st resp. 2nd components of puiseux pairs
+         m,n intvecs with 1st resp. 2nd components of Puiseux pairs
 RETURN:  intvec of the generators of the semigroup of values
 EXAMPLE: example puiseux2generators;  shows an example
-"{
+"
+{
  intvec beta;
  int q=1;
@@ -1085 +1126 @@
 example
 { "EXAMPLE:"; echo = 2;
-  // take (3,2),(7,2),(15,2),(31,2),(63,2),(127,2) as puiseux pairs:
+  // take (3,2),(7,2),(15,2),(31,2),(63,2),(127,2) as Puiseux pairs:
   puiseux2generators(intvec(3,7,15,31,63,127),intvec(2,2,2,2,2,2));
-}
-///////////////////////////////////////////////////////////////////////////////
-
-proc generators
-"USAGE:   generators(l); takes the output of develop(f)
-         (list l (matrix m, intvec v, int s[,poly g]))
-RETURN:  intvec of the generators of the semigroup of values
-EXAMPLE: example generators;  shows an example
-"
-{
- list inv=invariants(#);
- return(puiseux2generators(inv[2..3]));
-}
-example
-{ "EXAMPLE:"; echo = 2;
-  ring r=0,(x,y),dp;
-  poly f=x15-21x14+8x13y-6x13-16x12y+20x11y2-1x12+8x11y-36x10y2+24x9y3+4x9y2
-         -16x8y3+26x7y4-6x6y4+8x5y5+4x3y6-1y8;
-  list hne=develop(f);
-  generators(hne);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -1135 +1156 @@
  //--------- die jeweils erste Zeile gehoert zum gleichen Parameter -----------
    unterschied=0;
- //h1[1],h2[1];size(h1),size(h2);
    for (s=1; (h1[s]==h2[s]) && (s<size(h1)) && (s<size(h2))
               && (unterschied==0); s++) {
@@ -1175 +1195 @@
          matrix ma2[1][j]=a2[s,1..j];          // Teil (der evtl. y's enth.)
        }
- // print(ma1);print(ma2);
        for (i=1; (ma1[1,i]==ma2[1,i]) && (i<j) && (ma1[1,i]!=var(2)); i++) {;}
        if (ma1[1,i]==ma2[1,i]) {
@@ -1227 +1246 @@
 ///////////////////////////////////////////////////////////////////////////////
 
+proc multsequence
+"USAGE:   multsequence(l);
+         l is the output of either develop(f) or reddevelop(f)
+RETURN:  - if l=develop(f) or l=reddevelop(f)[i] :
+           intvec of the sequence of multiplicities of the curve
+           resp. of the i-th branch (the same as invariants(l)[6]; )
+
+         - if l=reddevelop(f) : list of two integer matrices:
+           multsequence(l)[1][i,*] contains the multiplicities of the branches
+           at their infinitely near point of 0 in its (i-1) order neighbour-
+           hood (i.e. i=1: multiplicity of the branches themselves,
+                      i=2: multipl. of their 1st quadratic transformed etc.,
+                 or to say it in another way: multsequence(l)[1][*,j] is the
+                 sequence of multiplicities of the j-th branch).
+           multsequence(l)[2][i,*] contains the information which of these
+           infinitely near points coincide.
+NOTE:    The order of elements of the list obtained from reddevelop must not
+         be changed (because then the coincident infinitely near points
+         couldn't be grouped together, cf. meaning of 2nd intmat in example).
+         Hence it is not wise to compute the HNE of several polynomials
+         separately, put them into a list l and call multsequence(l).
+
+         Use displayMultsequence to produce a better readable output for
+         reducible curves on the screen
+EXAMPLE: example multsequence;  shows an example
+"
+{
+ //-- entferne ueberfluessige Daten zur Erhoehung der Rechengeschwindigkeit: --
+ #=stripHNE(#);
+ int k,i,j;
+ //----------------- Multiplizitaetensequenz eines Zweiges --------------------
+ if (typeof(#[1])=="matrix") {
+  intvec v=#[2];
+  list ergebnis;
+  if (#[3]==-1) {
+    "An error has occurred in develop, so there is no HNE.";
+   return(intvec(0));
+  }
+  intvec multips,multseq;
+  multips=multiplicities(#);
+  k=1;
+  for (i=1; i<size(v); i++) {
+    for (j=1; j<=v[i]; j++) {
+      multseq[k]=multips[i];
+      k++;
+  }}
+  multseq[k]=1;
+  return(multseq);
+ }
+ //---------------------------- mehrere Zweige --------------------------------
+ else {
+   list HNEs=#;
+   int anzahl=size(HNEs);
+   int maxlength=0;
+   int bisher;
+   intvec schnitt,ones;
+   ones[anzahl]=0;
+   ones=ones+1;                  // = 1,1,...,1
+   for (i=1; i<anzahl; i++) {
+     schnitt[i]=separateHNE(HNEs[i],HNEs[i+1]);
+     j=size(multsequence(HNEs[i]));
+     maxlength=maxlength*(j < maxlength) + j*(j >= maxlength);
+     maxlength=maxlength*(schnitt[i]+1 < maxlength)
+               + (schnitt[i]+1)*(schnitt[i]+1 >= maxlength);
+   }
+   j=size(multsequence(HNEs[anzahl]));
+   maxlength=maxlength*(j < maxlength) + j*(j >= maxlength);
+
+//-------------- Konstruktion der ersten zu berechnenden Matrix ---------------
+   intmat allmults[maxlength][anzahl];
+   for (i=1; i<=maxlength; i++)  { allmults[i,1..anzahl]=ones[1..anzahl]; }
+   for (i=1; i<=anzahl; i++) {
+     ones=multsequence(HNEs[i]);
+     allmults[1..size(ones),i]=ones[1..size(ones)];
+   }
+//---------------------- Konstruktion der zweiten Matrix ----------------------
+   intmat separate[maxlength][anzahl];
+   for (i=1; i<=maxlength; i++) {
+     k=1;
+     bisher=0;
+     if (anzahl==1) { separate[i,1]=1; }
+     for (j=1; j<anzahl; j++)   {
+       if (schnitt[j]<i) {
+         separate[i,k]=j-bisher;
+         bisher=j;
+         k++;
+       }
+       separate[i,k]=anzahl-bisher;
+     }
+   }
+  return(list(allmults,separate));
+ }
+}
+example
+{
+  if (nameof(basering)=="HNEring") {
+   def rettering=HNEring;
+   kill HNEring;
+  }
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),dp;
+  list hne=reddevelop((x6-y10)*(x+y2-y3)*(x+y2+y3));
+
+  multsequence(hne[1]),"  |  ",multsequence(hne[2]),"  |  ",
+  multsequence(hne[3]),"  |  ",multsequence(hne[4]);
+  multsequence(hne);
+  // The meaning of the entries of the 2nd matrix is as follows:
+  displayMultsequence(hne);
+  kill HNEring,r;
+  echo = 0;
+  if (defined(rettering)) { // wenn aktueller Ring vor Aufruf von example
+   setring rettering;       // HNEring war, muss dieser erst wieder restauriert
+   def HNEring=rettering;   // werden
+   export HNEring;
+  }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+proc displayMultsequence
+"USAGE:   displayMultsequence(l);
+         l is the output of either develop(f) or reddevelop(f)
+RETURN:  nothing
+DISPLAY: the sequence of multiplicities:
+         if l=develop(f) or l=reddevelop(f)[i] : just the sequence a,b,c,...,1
+         if l=reddevelop(f) : a sequence of the following form:
+
+         [(a_1,....,b_1,....,c_1)],
+         [(a_2,...),...,(...,c_2)],
+            ...................
+         [(a_n),(b_n),.....,(c_n)]
+
+         with a_1,...,a_n the sequence of multiplicities of the 1st branch
+         [...] the multiplicities of the j-th transformed of all branches
+         (...) the multiplicities of those branches meeting in the same
+               infinitely near point
+NOTE:    The same restrictions for l as in `multsequence' apply.
+EXAMPLE: example displayMultsequence;  shows an example
+"
+{
+ //-- entferne ueberfluessige Daten zur Erhoehung der Rechengeschwindigkeit: --
+ #=stripHNE(#);
+ //----------------- Multiplizitaetensequenz eines Zweiges --------------------
+ if (typeof(#[1])=="matrix") {
+   if (#[3]==-1) {
+     "An error has occurred in develop, so there is no HNE.";
+   }
+   else {
+     "The sequence of multiplicities is  ",multiplicities(#);
+ }}
+ //---------------------------- mehrere Zweige --------------------------------
+ else {
+   list multips=multsequence(#);
+   int i,j,k,l;
+   string output;
+   for (i=1; i<=nrows(multips[1]); i++) {
+     output="[";
+     k=1;
+     for (l=1; k<=ncols(multips[1]); l++) {
+       output=output+"(";
+       for (j=1; j<=multips[2][i,l]; j++) {
+         output=output+string(multips[1][i,k]);
+         k++;
+         if (j<multips[2][i,l]) { output=output+","; }
+       }
+       output=output+")";
+       if ((k-1) < ncols(multips[1])) { output=output+","; }
+      }
+     output=output+"]";
+     if (i<nrows(multips[1])) { output=output+","; }
+     output;
+   }
+ }
+}
+example
+{ // example multsequence; geht wegen echo nicht (muesste auf 3 gesetzt werden)
+  if (nameof(basering)=="HNEring") {
+   def rettering=HNEring;
+   kill HNEring;
+  }
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),dp;
+  list hne=reddevelop((x6-y10)*(x+y2-y3)*(x+y2+y3));
+
+  displayMultsequence(hne[1]);
+  displayMultsequence(hne);
+  kill HNEring,r;
+  echo = 0;
+  if (defined(rettering)) { // wenn aktueller Ring vor Aufruf von example
+   setring rettering;       // HNEring war, muss dieser erst wieder restauriert
+   def HNEring=rettering;   // werden
+   export HNEring;
+  }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+proc separateHNE (list hn1,list hn2)
+"USAGE:    separateHNE(hne1,hne2);  list hne1,hne2: output of develop
+RETURN:   number of quadratic transformations needed to separate both curves
+EXAMPLE:  example separateHNE;  shows an example
+"
+{
+ int i,j,s,unterschied,separated;
+ matrix a1=hn1[1];
+ matrix a2=hn2[1];
+ intvec h1=hn1[2];
+ intvec h2=hn2[2];
+ if (hn1[3]!=hn2[3]) {
+ //-- die jeweils erste Zeile von hn1,hn2 gehoert zu verschiedenen Parametern -
+ //---------------- d.h. beide Kurven schneiden sich transversal --------------
+   separated=1;
+ }
+ else {
+ //--------- die jeweils erste Zeile gehoert zum gleichen Parameter -----------
+   unterschied=0;
+   for (s=1; (h1[s]==h2[s]) && (s<size(h1)) && (s<size(h2))
+              && (unterschied==0); s++) {
+     for (i=1; (a1[s,i]==a2[s,i]) && (i<=h1[s]); i++) {;}
+     if (i<=h1[s]) {
+       unterschied=1;
+       s--;                    // um s++ am Schleifenende wieder auszugleichen
+     }
+   }
+   if (unterschied==0) {
+     if ((s<size(h1)) && (s<size(h2))) {
+       for (i=1; (a1[s,i]==a2[s,i]) && (i<=h1[s]) && (i<=h2[s]); i++) {;}
+     }
+     else {
+ //-------------- Sonderfall: Unterschied in letzter Zeile suchen -------------
+ // Beachte: Es koennen undefinierte Stellen auftreten, bei abbrechender HNE
+ // muss die Ende-Markierung weg, h_[r] ist unendlich, die Matrix muss mit
+ // Nullen fortgesetzt gedacht werden
+ //----------------------------------------------------------------------------
+       if (ncols(a1)>ncols(a2)) { j=ncols(a1); }
+       else                     { j=ncols(a2); }
+       unterschied=0;
+       if ((h1[s]>0) && (s==size(h1))) {
+         a1[s,h1[s]+1]=0;
+         if (ncols(a1)<=ncols(a2)) { unterschied=1; }
+       }
+       if ((h2[s]>0) && (s==size(h2))) {
+         a2[s,h2[s]+1]=0;
+         if (ncols(a2)<=ncols(a1)) { unterschied=1; }
+       }
+       if (unterschied==1) {                   // mind. eine HNE war endlich
+         matrix ma1[1][j]=a1[s,1..ncols(a1)];  // und bedarf der Fortsetzung
+         matrix ma2[1][j]=a2[s,1..ncols(a2)];  // mit Nullen
+       }
+       else {
+         if (ncols(a1)>ncols(a2)) { j=ncols(a2); }
+         else                     { j=ncols(a1); }
+         matrix ma1[1][j]=a1[s,1..j];          // Beschr. auf vergleichbaren
+         matrix ma2[1][j]=a2[s,1..j];          // Teil (der evtl. y's enth.)
+       }
+       for (i=1; (ma1[1,i]==ma2[1,i]) && (i<j) && (ma1[1,i]!=var(2)); i++) {;}
+       if (ma1[1,i]==ma2[1,i]) {
+         "//** The two HNE's are identical!";
+         "//** You have either tried to compare a branch with itself,";
+         "//** or the two branches have been developed separately.";
+         "//   In the latter case use `extdevelop' to extend the HNE's until",
+         "they differ.";
+         return(-1);
+       }
+       if ((ma1[1,i]==var(2)) || (ma2[1,i]==var(2))) {
+         "//** The two HNE's are (so far) identical. This is because they",
+         "have been";
+         "//** computed separately. I need more data; use `extdevelop' to",
+         "extend them,";
+         if (ma1[1,i]==var(2)) {"//** at least the first one.";}
+         else                  {"//** at least the second one.";}
+         return(-1);
+       }
+     }
+   }
+   separated=i;
+   for (j=1; j<s; j++) { separated=separated+h1[j]; }
+ }
+ return(separated);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),dp;
+  list hne1=develop(x);
+  list hne2=develop(x+y);
+  list hne3=develop(x+y2);
+  separateHNE(hne1,hne2);  // two transversal lines
+  separateHNE(hne1,hne3);  // one quadratic transformation gives 1st example
+}
+///////////////////////////////////////////////////////////////////////////////
+
 proc displayHNE(list ldev,list #)
 "USAGE:   displayHNE(ldev,[,n]); ldev=list
@@ -1241 +1549 @@
      represented in the HN-matrix as 'x'
          the 1st line (HNE[1]) means that y==[]*z(0)^1+... ,
-         the 2nd line (HNE[2]) means that x==[]*z(1)^1+...
+         the 2nd line (HNE[2]) means that x==[]*z(1)^2+...
      so you can see which indeterminate corresponds to which line
      (it's also possible that x corresponds to the 1st line and y to the 2nd)
@@ -1268 +1576 @@
    return(ideal(0));
  }
+ def altring=basering;
  if (parstr(basering)!="") {
    if (charstr(basering)!=string(char(basering))+","+parstr(basering)) {
-     "Sorry -- not implemented for rings of type (p^k,a),...";
-     return(ideal(0));
-   }
- }
- def altring=basering;
- ring dazu=char(altring),z(0..size(v)-1),ls;
+     execute
+       "ring dazu=("+charstr(basering)+"),z(0.."+string(size(v)-1)+"),ls;";
+   }
+   else { ring dazu=char(altring),z(0..size(v)-1),ls; }
+ }
+ else   { ring dazu=char(altring),z(0..size(v)-1),ls; }
  def displayring=dazu+altring;
  setring displayring;
@@ -1324 +1633 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-
-proc newtonhoehne (poly f)
-"USAGE:   newtonhoehne(f);   f poly
-ASSUME:  basering = ...,(x,y),ds  or ls
-RETURN:  list of intvec(x,y) of coordinates of the newtonpolygon of f
-NOTE:    This proc is only available in versions of Singular that know the
-         command  system(\"newton\",f);  f poly
-"
-{
- intvec nm = getnm(f);
- if ((nm[1]>0) && (nm[2]>0)) { f=jet(f,nm[1]*nm[2],nm); }
- list erg=system("newton",f);
- int i; list Ausgabe;
- for (i=1; i<=size(erg); i++) { Ausgabe[i]=leadexp(erg[i]); }
- return(Ausgabe);
-}
+// proc newtonhoehne (poly f)
+// USAGE:   newtonhoehne(f);   f poly
+// ASSUME:  basering = ...,(x,y),ds  or ls
+// RETURN:  list of intvec(x,y) of coordinates of the newtonpolygon of f
+// NOTE:    This proc is only available in versions of Singular that know the
+//         command  system("newton",f);  f poly
+// {
+// intvec nm = getnm(f);
+//  if ((nm[1]>0) && (nm[2]>0)) { f=jet(f,nm[1]*nm[2],nm); }
+//  list erg=system("newton",f);
+//  int i; list Ausgabe;
+//  for (i=1; i<=size(erg); i++) { Ausgabe[i]=leadexp(erg[i]); }
+// return(Ausgabe);
+// }
 ///////////////////////////////////////////////////////////////////////////////
 
 proc newtonpoly (poly f)
 "USAGE:   newtonpoly(f);   f poly
-RETURN:  list of intvec(x,y) of coordinates of the newtonpolygon of f
+RETURN:  list of intvec(x,y) of coordinates of the Newton polygon of f
 NOTE: There are many assumptions: (to improve speed)
       - The basering must be ...,(x,y),ls
@@ -1353 +1660 @@
  intvec A=(0,ord(subst(f,x,0)));
  intvec B=(ord(subst(f,y,0)),0);
- intvec C,D,H; list L;
+ intvec C,H; list L;
  int abbruch,i;
  poly hilf;
@@ -1379 +1686 @@
 
    H=leadexp(xytausch(hilf));
-   D=H[2],H[1];
+   A=H[2],H[1];
 
  // die Alternative waere ein Ringwechsel nach ..,(y,x),ds gewesen
- // D ist der naechste Eckpunkt (unterster Punkt auf Geraden durch A,C)
-
-   L[i]=D;
-   A=D;
- //----------------- alle Monome auf oder unterhalb DB raus -------------------
-   f=jet(f,D[2]*B[1]-1,intvec(D[2],B[1]-D[1]));
+ // A_neu ist der naechste Eckpunkt (unterster Punkt auf Geraden durch A,C)
+
+   L[i]=A;
+ //----------------- alle Monome auf oder unterhalb AB raus -------------------
+   f=jet(f,A[2]*B[1]-1,intvec(A[2],B[1]-A[1]));
  }
  L[i]=B;
@@ -1407 +1713 @@
 proc charPoly(poly f, int M, int N)
 "USAGE:  charPoly(f,M,N);  f poly in x,y,  M,N int: length and height
-                          of newtonpolygon of f, which has to be only one line
+                          of Newton polygon of f, which has to be only one line
 RETURN:  the characteristic polynomial of f
 EXAMPLE: example charPoly;  shows an example
@@ -1485 +1791 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc redleit (poly f,intvec S, intvec E)
-"USAGE:   redleit(f,S,E); f poly,
-         S,E intvec(x,y): two different points on a line in the newtonpolygon
-         of f (e.g. the starting and the ending point)
-RETURN:  poly g: all monomials of f which lay on that line
-NOTE:    It is not checked whether S and E really belong to the newtonpolygon!
+"USAGE:   redleit(f,S,E);  f poly, S,E intvec(x,y)
+         S,E are two different points on a line in the Newton diagram of f
+RETURN:  poly g: all monomials of f which lie on or below that line
+NOTE:    The main purpose is that if the line defined by S and E is part of the
+         Newton polygon, the result is the quasihomogeneous leading form of f
+         wrt. that line.
 EXAMPLE: example redleit;  shows an example
 "
@@ -1506 +1813 @@
 proc extdevelop (list l, int Exaktheit)
 "USAGE:   extdevelop(l,n);  list l (matrix m, intvec v, int s, poly g), int n
-         takes the output l of develop(f) ( or extdevelop(L,n),
+         takes the output l of develop(f) ( or extdevelop(L,N),
          or one entry of the output of reddevelop(f))  and
 RETURN:  an extension of the Hamburger-Noether development of f in the form
@@ -1514 +1821 @@
          Thus if f is irreducible, extdevelop(develop(f),n);
          (in most cases) will produce the same result as develop(f,n).
-         Type  help develop;  for more details
+         Type  help develop;  for more details.
+NOTE:    If the matrix m of l has N columns, the exactness of
+         param(extdevelop(l,n))  will be increased by at least (n-N) more
+         significant monomials compared to param(l).
 EXAMPLE: example extdevelop;  shows an example
 "
@@ -1544 +1854 @@
  }
  int zeile=nrows(m);
- int spalten,i,lastside;
+ int spalten,i,M;
  ideal lastrow=m[zeile,1..Q];
  int ringwechsel=(varstr(basering)!="x,y") or (ordstr(basering)!="ls(2),C");
@@ -1551 +1861 @@
  if (ringwechsel) {
   def altring = basering;
-  int p = char(basering); // Ringcharakteristik
+  int p = char(basering);
   if (charstr(basering)!=string(p)) {
      string tststr=charstr(basering);
@@ -1581 +1891 @@
  }
  else { ideal a=lastrow; }
- list Newton;
+ list Newton=newtonpoly(f);
+ int M1=Newton[size(Newton)-1][1];     // konstant
  number delta;
+ if (Newton[size(Newton)-1][2]!=1) {
+    " *** The transformed polynomial was not valid!!";}
+ else {
  //--------------------- Fortsetzung der HNE ----------------------------------
- while (Q<Exaktheit) {
-  Newton=newtonpoly(f);
-  lastside=size(Newton)-1;
-  if (Newton[lastside][2]!=1) {
-    " *** The transformed polynomial was not valid!!";}
-  Q=Newton[lastside+1][1]-Newton[lastside][1];      // Laenge der letzten Seite
-
- //--- quasihomogenes Leitpolynom ist c*x^a*y+d*x^(a+Q) => delta=-d/c: --------
-  delta=-koeff(f,Newton[lastside+1][1],0)/koeff(f,Newton[lastside][1],1);
-  a[Q]=delta;
-  "a("+string(zeile-1)+","+string(Q)+") =",delta;
-  if (Q<Exaktheit) {
-   f=T1_Transform(f,delta,Q);
-   if (defined(Protokoll)) { "transformed polynomial:",f; }
-   if (subst(f,y,0)==0) {
-     "The HNE is finite!";
-     a[Q+1]=x; Exaktheit=Q;
-     f=0;                          // Speicherersparnis: f nicht mehr gebraucht
-   }
+  while (Q<Exaktheit) {
+    M=ord(subst(f,y,0));
+    Q=M-M1;
+ //------ quasihomogene Leitform ist c*x^M1*y+d*x^(M1+Q) => delta=-d/c: -------
+    delta=-koeff(f,M,0)/koeff(f,M1,1);
+    a[Q]=delta;
+    "a("+string(zeile-1)+","+string(Q)+") =",delta;
+    if (Q<Exaktheit) {
+     f=T1_Transform(f,delta,Q);
+     if (defined(HNDebugOn)) { "transformed polynomial:",f; }
+     if (subst(f,y,0)==0) {
+       "The HNE is finite!";
+       a[Q+1]=x; Exaktheit=Q;
+       f=0;                        // Speicherersparnis: f nicht mehr gebraucht
+     }
+    }
   }
  }
@@ -1628 +1939 @@
  }}}
  else { v[zeile]=Q; }               // HNE war exakt
- if (ringwechsel) { 
+ if (ringwechsel)
+ {
    if(system("with","Namespaces")) { kill Top::extdguenstig; }
    kill extdguenstig;
@@ -1698 +2010 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-
+static
 proc extractHNEs(list HNEs, int transvers)
 "USAGE:  extractHNEs(HNEs,transvers);  list HNEs (output from HN),
@@ -1711 +2023 @@
   maxspalte=0;
   HNEaktu=HNEs[hnezaehler];
-  if (defined(Protokoll)) {"To process:";HNEaktu;}
+  if (defined(HNDebugOn)) {"To process:";HNEaktu;}
   if (size(HNEs[hnezaehler])!=size(HNEs[hnezaehler][1])+2) {
      "The ideals and the hqs in HNEs[",hnezaehler,"] don't match!!";
@@ -1757 +2069 @@
      eps = e;
      for (l = 0; eps%p == 0; l=l+1) { eps=eps/ p;}
-     if (defined(Protokoll)) {e," -> ",eps,"*",p,"^",l;}
+     if (defined(HNDebugOn)) {e," -> ",eps,"*",p,"^",l;}
      delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps-1)) / (-1*eps*c);
 
@@ -1763 +2075 @@
  //------ coefficient field is not Z/pZ => (p^l)th root is not identity -------
        delta=0;
-       if (defined(Protokoll)) {
+       if (defined(HNDebugOn)) {
          "trivial factorization not implemented for",
          "parameters---I've to use 'factorize'";
@@ -1770 +2082 @@
    }
  }
- if (defined(Protokoll)) {"quasihomogeneous leading form:",f," = ",c,
+ if (defined(HNDebugOn)) {"quasihomogeneous leading form:",f," = ",c,
         "* (y^"+string(N/ e),"-",delta,"* x^"+string(M/ e)+")^",e," ?";}
  if (f != c*(y^(N/ e) - delta*x^(M/ e))^e) {return(0);}
@@ -1791 +2103 @@
          data for one of the branches of f.
          For more details type 'help develop;'
-NOTE:    as the Hamburger-Noether development of a reducible curve normally
-         exists only in a ring extension, reddevelop automatically changes
-         the basering to  ring HNEring=...,(x,y),ls; !
+CREATE:  a ring with name `HNEring', variables `x,y' and ordering `ls' over
+         a field extension of the current basering's ground field.
+         As the Hamburger-Noether development of a reducible curve normally
+         does not exist in the given basering, reddevelop always defines
+         HNEring and changes to it. The field extension is chosen minimal.
 EXAMPLE: example reddevelop;  shows an example
 "
@@ -1857 +2171 @@
  export HNEring;
 
- if (defined(Protokoll))
+ if (defined(HNDebugOn))
  {"received polynomial: ",f,", with x =",namex,", y =",namey;}
 
@@ -1923 +2237 @@
      else {
        if (str<>"c") {
+         setring altring;
          if(system("with","Namespaces")) { kill Top::HNEring; }
-         setring altring;kill HNEring;kill zweitring;
+         kill HNEring;kill zweitring;
          return(list());}
        else { "if the algorithm doesn't terminate, you were wrong...";}
    }}
    kill zweitring;
-   if (defined(Protokoll)) {"I continue with the polynomial",f; }
+   if (defined(HNDebugOn)) {"I continue with the polynomial",f; }
   }
   else {
@@ -1975 +2290 @@
    if (str=="f") { f=allsquarefree(f,test_sqr); }
   }
-  if (defined(Protokoll)) {"I continue with the polynomial",f; }
+  if (defined(HNDebugOn)) {"I continue with the polynomial",f; }
 
  }
@@ -2017 +2332 @@
  list HNEs=ideal(0);
  list aneu=ideal(0);
+ list faktoren=ideal(0);
  ideal deltais;
  poly delta;                   // nicht number, weil delta von a abhaengen kann
- export f,azeilen,HNEs,aneu,deltais,delta;
+ export f,azeilen,HNEs,aneu,faktoren,deltais,delta;
  //----- hier steht die Anzahl bisher benoetigter Ringerweiterungen drin: -----
  int EXTHNEnumber=0; export EXTHNEnumber;
@@ -2025 +2341 @@
 
  // -------- Berechne HNE von allen Zweigen, fuer die x transvers ist: --------
- if (defined(Protokoll))
-   {"1st step: Treat newton polygon until height",grenze1;}
+ if (defined(HNDebugOn))
+   {"1st step: Treat Newton polygon until height",grenze1;}
  if (grenze1>0) {
   hilflist=HN(f,grenze1,1);
@@ -2033 +2349 @@
   Ergebnis=extractHNEs(hilflist[1],0);
   if (hilflist[2]!=-1) {
-    if (defined(Protokoll)) {" ring change in HN(",1,") detected";}
+    if (defined(HNDebugOn)) {" ring change in HN(",1,") detected";}
     poly transfproc=hilflist[2];
     map hole=HNE_noparam,transfproc,x,y;
@@ -2046 +2362 @@
  }
  // --------------- Berechne HNE von allen verbliebenen Zweigen: --------------
- if (defined(Protokoll))
-    {"2nd step: Treat newton polygon until height",grenze2;}
+ if (defined(HNDebugOn))
+    {"2nd step: Treat Newton polygon until height",grenze2;}
  if (grenze2>0) {
   map xytausch=basering,y,x;
@@ -2058 +2374 @@
   if (not(defined(Ergebnis))) {
  //-- HN wurde schon mal ausgefuehrt; Ringwechsel beim zweiten Aufruf von HN --
-    if (defined(Protokoll)) {" ring change in HN(",1,") detected";}
+    if (defined(HNDebugOn)) {" ring change in HN(",1,") detected";}
     poly transfproc=hilflist[2];
     map hole=HNE_noparam,transfproc,x,y;
@@ -2078 +2394 @@
   setring HNEring;
   export HNEring;
-  if(system("with","Namespaces")) { kill Primitiv::EXTHNEring(1..EXTHNEnumber);}
   kill EXTHNEring(1..EXTHNEnumber);
  }
- if(system("with","Namespaces")){kill Top::HNE_noparam;}
  kill HNE_noparam;
  kill EXTHNEnumber;
@@ -2127 +2441 @@
 static
 proc HN (poly f,int grenze, int Aufruf_Ebene)
-"NOTE: This procedure is only for internal use, it is called via reddevelop
-"
+"NOTE: This procedure is only for internal use, it is called via reddevelop"
 {
  //---------- Variablendefinitionen fuer den unverzweigten Teil: --------------
- if (defined(Protokoll)) {"procedure HN",Aufruf_Ebene;}
+ if (defined(HNDebugOn)) {"procedure HN",Aufruf_Ebene;}
  int Abbruch,ende,i,j,e,M,N,Q,R,zeiger,zeile,zeilevorher;
  intvec hqs;
@@ -2155 +2468 @@
   zeiger=find_in_list(Newton,grenze);
   if (Newton[zeiger][2] != grenze)
-    {"Didn't find an edge in the newton polygon!";}
+    {"Didn't find an edge in the Newton polygon!";}
   if (zeiger==size(Newton)-1) {
-    if (defined(Protokoll)) {"only one relevant side in newton polygon";}
+    if (defined(HNDebugOn)) {"only one relevant side in Newton polygon";}
     M=Newton[zeiger+1][1]-Newton[zeiger][1];
     N=Newton[zeiger][2]-Newton[zeiger+1][2];
@@ -2170 +2483 @@
                       /x^Newton[zeiger][1],M,N);
     if (delta==0) {
-      if (defined(Protokoll)) {" The given polynomial is reducible !";}
+      if (defined(HNDebugOn)) {" The given polynomial is reducible !";}
       Abbruch=1;
     }
@@ -2180 +2493 @@
         if (N>1) { f = T1_Transform(f,delta,M/ e); }
         else     { ende=1; }
-        if (defined(Protokoll)) {"a("+string(zeile)+","+string(Q)+") =",delta;}
+        if (defined(HNDebugOn)) {"a("+string(zeile)+","+string(Q)+") =",delta;}
         azeilen=set_list(azeilen,intvec(zeile+1,Q),delta);
       }
       else {
  //------------- R > 0 : transformiere f mit T2 -------------------------------
-        erg=T2_Transform(f,delta,M,N);
+        erg=T2_Transform(f,delta,M,N,referencepoly(Newton));
         f=erg[1];delta=erg[2];
  //------- vollziehe Euklid.Alg. nach, um die HN-Matrix zu berechnen: ---------
         while (R!=0) {
-         if (defined(Protokoll)) { "h("+string(zeile)+") =",Q; }
+         if (defined(HNDebugOn)) { "h("+string(zeile)+") =",Q; }
          hqs[zeile+1]=Q;  //denn zeile beginnt mit dem Wert 0
  //------------------ markiere das Zeilenende der HNE: ------------------------
@@ -2198 +2511 @@
          M=N; N=R; R=M%N; Q=M / N;
         }
-        if (defined(Protokoll)) {"a("+string(zeile)+","+string(Q)+") =",delta;}
+        if (defined(HNDebugOn)) {"a("+string(zeile)+","+string(Q)+") =",delta;}
         azeilen=set_list(azeilen,intvec(zeile+1,Q),delta);
       }
-      if (defined(Protokoll)) {"transformed polynomial: ",f;}
+      if (defined(HNDebugOn)) {"transformed polynomial: ",f;}
       grenze=e;
  //----------------------- teste Abbruchbedingungen: --------------------------
@@ -2239 +2552 @@
  //---------- Variablendefinitionen fuer den verzweigten Teil: ----------------
   poly leitf,teiler,transformiert;
-  list faktoren=ideal(0); list aneu=ideal(0);
+  list aneu=ideal(0);
+  list faktoren;
+  list HNEakut=ideal(0);
   ideal deltais;
   intvec eis;
@@ -2247 +2562 @@
 
   zeiger=find_in_list(Newton,grenze);
-  if (defined(Protokoll)) {
-    "Branching part reached---newton polygon :",Newton;
+  if (defined(HNDebugOn)) {
+    "Branching part reached---Newton polygon :",Newton;
     "relevant part until height",grenze,", from",Newton[zeiger],"on";
   }
@@ -2255 +2570 @@
  //======= Schleife fuer jede zu betrachtende Seite des Newtonpolygons: =======
   for(i=zeiger; i<size(Newton); i++) {
-   if (defined(Protokoll)) { "we consider side",Newton[i],Newton[i+1]; }
+   if (defined(HNDebugOn)) { "we consider side",Newton[i],Newton[i+1]; }
    M=Newton[i+1][1]-Newton[i][1];
    N=Newton[i][2]-Newton[i+1][2];
@@ -2264 +2579 @@
    letztringname=nameof(basering);
    lastRingnumber=EXTHNEnumber;
+   faktoren=list(ideal(charPoly(redleit(f,Newton[i],Newton[i+1])
+                       /(x^Newton[i][1]*y^Newton[i+1][2]),M,N)  ),
+                 intvec(1));                  // = (zu faktoriserendes Poly, 1)
 
  //-- wechsle so lange in Ringerw., bis Leitform vollst. in Linearfakt. zerf.:-
@@ -2278 +2596 @@
          { " ** I cannot proceed, will produce some error messages...";}
      }
-     else
-      {
+     else {
  //------------------ faktorisiere das charakt. Polynom: ----------------------
-      faktoren=factorize(charPoly(leitf,M,N));
+ // faktoren=factorize(charPoly(leitf,M,N));       wird ersetzt durch:
+       faktoren=factorlist(faktoren);
      }
 
@@ -2288 +2606 @@
       teiler=faktoren[1][j];
       if (teiler/y != 0) {         // sonst war's eine Einheit --> wegwerfen!
-        if (defined(Protokoll)) {"factor of leading form found:",teiler;}
+        if (defined(HNDebugOn)) {"factor of leading form found:",teiler;}
         if (teiler/y2 == 0) {      // --> Faktor hat die Form cy+d
           deltais[zaehler]=-subst(teiler,y,0)/koeff(teiler,0,1); //=-d/c
@@ -2296 +2614 @@
         else {
           " Change of basering necessary!!";
-          if (defined(Protokoll)) { teiler,"is not properly factored!"; }
+          if (defined(HNDebugOn)) { teiler,"is not properly factored!"; }
           if (needext==0) { poly zerlege=teiler; }
           needext=1;
@@ -2304 +2622 @@
     }
     else { deltais=ideal(delta); eis=e;}
-    if (defined(Protokoll)) {"roots of char. poly:";deltais;
+    if (defined(HNDebugOn)) {"roots of char. poly:";deltais;
                              "with multiplicities:",eis;}
     if (needext==1) {
@@ -2324 +2642 @@
         if (defined(translist)) { kill translist; } // Vermeidung einer Warnung
         if (numberofRingchanges>1) {  // ein Ringwechsel hat nicht gereicht
-         list translist=splitring(zerlege,"",list(transf,transfproc));
-         poly transf=translist[1]; poly transfproc=translist[2];
+         list translist=splitring(zerlege,"",list(transf,transfproc,faktoren));
+         poly transf=translist[1];
+         poly transfproc=translist[2];
+         list faktoren=translist[3];
         }
         else {
@@ -2354 +2674 @@
  //------ Neudef. von Variablen, Uebertragung bisher errechneter Daten: -------
       poly leitf,teiler,transformiert;
-      list faktoren; list aneu=ideal(0);
+      list aneu=ideal(0);
       ideal deltais;
       number delta;
@@ -2362 +2682 @@
       else                  { def letztring=HNEring; }
       f=imap(letztring,f);
+      faktoren=imap(letztring,faktoren);
       setring EXTHNEring(EXTHNEnumber);
       map hole=HNE_noparam,transf,x,y;
       poly f=hole(f);
+      if (not defined(faktoren)) {
+        list faktoren=hole(faktoren);
+      }
     }
    }    // end (while needext==1) bzw. for (numberofRingchanges)
@@ -2370 +2694 @@
    if (eis==0) { i++; continue; }
    if (ringischanged==1) {
-    list erg,hilflist;              // dienen nur zum Sp. von Zwi.erg.
+    list erg,hilflist,HNEakut;            // dienen nur zum Sp. von Zwi.erg.
     ideal hilfid;
-    erg=ideal(0); hilflist=erg;
+    erg=ideal(0); hilflist=erg; HNEakut=erg;
 
     hole=HNE_noparam,transf,x,y;
@@ -2393 +2717 @@
     if (R==0) {
       transformiert = T1_Transform(f,number(deltais[j]),M/ e);
-      if (defined(Protokoll)) {
+      if (defined(HNDebugOn)) {
         "a("+string(zeile)+","+string(Q)+") =",deltais[j];
         "transformed polynomial: ",transformiert;
@@ -2401 +2725 @@
        hnezaehler++;
  //------------ trage deltais[j],x ein in letzte Zeile, fertig: ---------------
-       HNEs[hnezaehler]=azeilen+list(poly(0));
-       hilfid=HNEs[hnezaehler][zeile+2]; hilfid[Q]=deltais[j]; hilfid[Q+1]=x;
-       HNEs=set_list(HNEs,intvec(hnezaehler,zeile+2),hilfid);
-       HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+1),Q);
-                                  // aktualisiere Vektor mit den hqs
+       HNEakut=azeilen+list(poly(0));        // =HNEs[hnezaehler];
+       hilfid=HNEakut[zeile+2]; hilfid[Q]=deltais[j]; hilfid[Q+1]=x;
+       HNEakut[zeile+2]=hilfid;
+       HNEakut=set_list(HNEakut,intvec(1,zeile+1),Q);
+                                             // aktualisiere Vektor mit den hqs
+       HNEs[hnezaehler]=HNEakut;
        if (eis[j]>1) {
         transformiert=transformiert/y;
@@ -2419 +2744 @@
     else {
  //------------------------ Fall R <> 0: --------------------------------------
-      erg=T2_Transform(f,number(deltais[j]),M,N);
+      erg=T2_Transform(f,number(deltais[j]),M,N,referencepoly(Newton));
       transformiert=erg[1];delta=erg[2];
-      if (defined(Protokoll)) {"transformed polynomial: ",transformiert;}
+      if (defined(HNDebugOn)) {"transformed polynomial: ",transformiert;}
       if (subst(transformiert,y,0)==0) {
        "finite HNE found";
@@ -2427 +2752 @@
  //---------------- trage endliche HNE in HNEs ein: ---------------------------
        HNEs[hnezaehler]=azeilen;  // dupliziere den gemeins. Anfang der HNE's
+       HNEakut=HNEs[hnezaehler];
        zl=2;
  //----------------------------------------------------------------------------
@@ -2438 +2764 @@
        M1=M;N1=N;R1=R;Q1=M1/ N1;
        while (R1!=0) {
-        if (defined(Protokoll)) { "h("+string(zeile+zl-2)+") =",Q1; }
-        HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+zl-1),Q1);
-        HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1+1),x);
+        if (defined(HNDebugOn)) { "h("+string(zeile+zl-2)+") =",Q1; }
+        HNEakut=set_list(HNEakut,intvec(1,zeile+zl-1),Q1);
+        HNEakut=set_list(HNEakut,intvec(zeile+zl,Q1+1),x);
                                   // markiere das Zeilenende der HNE
         zl=zl+1;
  //-------- Bereitstellung von Speicherplatz fuer eine neue Zeile: ------------
-        HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),ideal(0));
+        HNEakut[zeile+zl]=ideal(0);
 
         M1=N1; N1=R1; R1=M1%N1; Q1=M1 / N1;
        }
-       if (defined(Protokoll)) {
+       if (defined(HNDebugOn)) {
          "a("+string(zeile+zl-2)+","+string(Q1)+") =",delta;
        }
        hilfid=ideal(0);           // = HNEs[hnezaehler][zeile+zl];
        hilfid[Q1]=delta;hilfid[Q1+1]=x;
-       HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),hilfid);
-       HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+zl-1),Q1);
+       HNEakut[zeile+zl]=hilfid;
+       HNEakut=set_list(HNEakut,intvec(1,zeile+zl-1),Q1);
                                   // aktualisiere Vektor mit hqs
-       HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl+1),poly(0));
+       HNEakut[zeile+zl+1]=poly(0);
+       HNEs[hnezaehler]=HNEakut;
  //-------------------- Ende der Eintragungen in HNEs -------------------------
 
@@ -2478 +2805 @@
        aneu=HNerg[1];  }
      else {
-       if (defined(Protokoll))
+       if (defined(HNDebugOn))
           {" ring change in HN(",Aufruf_Ebene+1,") detected";}
        list aneu=HNerg[1];
@@ -2484 +2811 @@
 
  //- stelle lokale Var. im neuen Ring wieder her und rette ggf. ihren Inhalt: -
-       list erg,hilflist,faktoren;
+       list erg,hilflist,faktoren,HNEakut;
        ideal hilfid;
-       erg=ideal(0); hilflist=erg; faktoren=erg;
+       erg=ideal(0); hilflist=erg; faktoren=erg; HNEakut=erg;
        poly leitf,teiler,transformiert;
 
@@ -2520 +2847 @@
        hnezaehler++;
        HNEs[hnezaehler]=azeilen; // dupliziere den gemeinsamen Anfang der HNE's
+       HNEakut=HNEs[hnezaehler];
        zl=2;
  //---------------- Trage Beitrag dieser Transformation T2 ein: ---------------
@@ -2527 +2855 @@
        M1=M;N1=N;R1=R;Q1=M1/ N1;
        while (R1!=0) {
-        if (defined(Protokoll)) { "h("+string(zeile+zl-2)+") =",Q1; }
-        HNEs=set_list(HNEs,intvec(hnezaehler,1,zeile+zl-1),Q1);
-        HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1+1),x);
+        if (defined(HNDebugOn)) { "h("+string(zeile+zl-2)+") =",Q1; }
+        HNEakut=set_list(HNEakut,intvec(1,zeile+zl-1),Q1);
+        HNEakut=set_list(HNEakut,intvec(zeile+zl,Q1+1),x);
                                  // Markierung des Zeilenendes der HNE
         zl=zl+1;
  //-------- Bereitstellung von Speicherplatz fuer eine neue Zeile: ------------
-        HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),ideal(0));
+        HNEakut[zeile+zl]=ideal(0);
         M1=N1; N1=R1; R1=M1%N1; Q1=M1 / N1;
        }
-       if (defined(Protokoll)) {
+       if (defined(HNDebugOn)) {
          "a("+string(zeile+zl-2)+","+string(Q1)+") =",delta;
        }
-       HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl,Q1),delta);
+       HNEakut=set_list(HNEakut,intvec(zeile+zl,Q1),delta);
 
  //--- Daten aus T2_Transform sind eingetragen; haenge Daten von HN an: -------
-       hilfid=HNEs[hnezaehler][zeile+zl];
+       hilfid=HNEakut[zeile+zl];
        for (zl1=Q1+1; zl1<=ncols(aneu[zaehler][2]); zl1++) {
         hilfid[zl1]=aneu[zaehler][2][zl1];
        }
-       HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),hilfid);
+       HNEakut[zeile+zl]=hilfid;
  //--- vorher HNEs[.][zeile+zl]<-aneu[.][2], jetzt [zeile+zl+1] <- [3] usw.: --
        for (zl1=3; zl1<=size(aneu[zaehler]); zl1++) {
-        HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl+zl1-2),
-             aneu[zaehler][zl1]);
+         HNEakut[zeile+zl+zl1-2]=aneu[zaehler][zl1];
        }
  //--- setze die hqs zusammen: HNEs[hnezaehler][1]=HNEs[..][1],aneu[..][1] ----
-       hilfvec=HNEs[hnezaehler][1],aneu[zaehler][1];
-       HNEs=set_list(HNEs,intvec(hnezaehler,1),hilfvec);
+       hilfvec=HNEakut[1],aneu[zaehler][1];
+       HNEakut[1]=hilfvec;
  //----------- weil nicht geht: liste[1]=liste[1],aneu[zaehler][1] ------------
+       HNEs[hnezaehler]=HNEakut;
       }                     // end(for zaehler)
      }                      // endelse (R<>0)
@@ -2579 +2907 @@
 static
 proc constructHNEs (list HNEs,int hnezaehler,list aneu,list azeilen,int zeile,ideal deltais,int Q,int j)
-"NOTE: This procedure is only for internal use, it is called via HN
-"
+"NOTE: This procedure is only for internal use, it is called via HN"
 {
   int zaehler,zl;
@@ -2609 +2936 @@
 ///////////////////////////////////////////////////////////////////////////////
 
+proc referencepoly (list newton)
+"USAGE:   referencepoly(newton);
+         newton is list of intvec(x,y) which represents points in the Newton
+         diagram (e.g. output of the proc newtonpoly)
+RETURN:  a polynomial which has newton as Newton diagram
+EXAMPLE: example referencepoly;  shows an example
+"
+{
+ poly f;
+ for (int i=1; i<=size(newton); i++) {
+   f=f+var(1)^newton[i][1]*var(2)^newton[i][2];
+ }
+ return(f);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring exring=0,(x,y),ds;
+ referencepoly(list(intvec(0,4),intvec(2,3),intvec(5,1),intvec(7,0)));
+}
+///////////////////////////////////////////////////////////////////////////////
+
+proc factorlist (list L)
+"USAGE:   factorlist(L);   L a list in the format of `factorize'
+RETURN:  the nonconstant irreducible factors of
+         L[1][1]^L[2][1] * L[1][2]^L[2][2] *...* L[1][size(L[1])]^...
+         with multiplicities (same format as factorize)
+EXAMPLE: example factorlist;  shows an example
+"
+{
+ // eine Sortierung der Faktoren eruebrigt sich, weil keine zwei versch.
+ // red.Fakt. einen gleichen irred. Fakt. haben koennen (I.3.27 Diplarb.)
+ int i,gross;
+ list faktoren,hilf;
+ ideal hil1,hil2;
+ intvec v,w;
+ for (i=1; (L[1][i] == jet(L[1][i],0)) && (i<size(L[1])); i++) {;}
+ if (L[1][i] != jet(L[1][i],0)) {
+   hilf=factorize(L[1][i]);
+ // Achtung!!! factorize(..,2) wirft entgegen der Beschreibung nicht nur
+ // konstante Faktoren raus, sondern alle Einheiten in der LOKALISIERUNG nach
+ // der Monomordnung!!! Im Beispiel unten verschwindet der Faktor x+y+1, wenn
+ // man ds statt dp als Ordnung nimmt!
+   hilf[2]=hilf[2]*L[2][i];
+   hil1=hilf[1];
+   gross=size(hil1);
+   if (gross>1) {
+       // faktoren=list(hilf[1][2..gross],hilf[2][2..gross]);
+       // -->  `? indexed object must have a name'
+     v=hilf[2];
+     faktoren=list(ideal(hil1[2..gross]),intvec(v[2..gross]));
+   }
+   else         { faktoren=hilf; }
+ }
+ else {
+   faktoren=L;
+ }
+
+ for (i++; i<=size(L[2]); i++) {
+ //------------------------- linearer Term -- irreduzibel ---------------------
+   if (L[1][i] == jet(L[1][i],1)) {
+     if (L[1][i] != jet(L[1][i],0)) {           // konst. Faktoren eliminieren
+       hil1=faktoren[1];
+       hil1[size(hil1)+1]=L[1][i];
+       faktoren[1]=hil1;
+       v=faktoren[2],L[2][i];
+       faktoren[2]=v;
+     }
+   }
+ //----------------------- nichtlinearer Term -- faktorisiere -----------------
+   else {
+     hilf=factorize(L[1][i]);
+     hilf[2]=hilf[2]*L[2][i];
+     hil1=faktoren[1];
+     hil2=hilf[1];
+     gross=size(hil2);
+       // hil2[1] ist konstant, wird weggelassen:
+     hil1[(size(hil1)+1)..(size(hil1)+gross-1)]=hil2[2..gross];
+       // ideal+ideal does not work due to simplification;
+       // ideal,ideal not allowed
+     faktoren[1]=hil1;
+     w=hilf[2];
+     v=faktoren[2],w[2..gross];
+     faktoren[2]=v;
+   }
+ }
+ return(faktoren);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring exring=0,(x,y),ds;
+ list L=ideal(x,(x-y)^2*(x+y+1),x+y),intvec(2,2,1);
+ L;
+ factorlist(L);
+}
+///////////////////////////////////////////////////////////////////////////////
+
 proc extrafactor (poly leitf, int M, int N)
 "USAGE:   factors,flag=extrafactor(f,M,N);
          list factors, int flag,M,N, poly f in x,y
 ASSUME:  basering is (0,a),(x,y),ds or ls
-         Newtonpolygon of f is one side with height N, length M
+         Newton polygon of f is one side with height N, length M
 RETURN:  for some special f, factors is a list of the factors of
          charPoly(f,M,N), same format as factorize
@@ -2621 +3044 @@
 NOTE:    This procedure is designed to make reddevelop able to compute some
          special cases that need a ring extension in char 0.
-         It becomes obsolete as soon as factorize works also in such rings.
+         It becomes obsolete as soon as `factorize' works also in such rings.
 EXAMPLE: example extrafactor;  shows an example
 "

Singular/LIB/primitiv.lib

@@ -1 @@
-// $Id: primitiv.lib,v 1.7 1998-10-21 10:28:26 krueger Exp $
+// $Id: primitiv.lib,v 1.8 1999-04-14 12:11:53 Singular Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
-// last change:           11.3.98
-///////////////////////////////////////////////////////////////////////////////
-version="$Id: primitiv.lib,v 1.7 1998-10-21 10:28:26 krueger Exp $";
+// last change:            19.03.99
+///////////////////////////////////////////////////////////////////////////////
+// This library is for Singular 1.2 or newer
+
+version="$Id: primitiv.lib,v 1.8 1999-04-14 12:11:53 Singular Exp $";
 info="
 LIBRARY:    primitiv.lib    PROCEDURES FOR FINDING A PRIMITIVE ELEMENT
 
- primitive(ideal i);   finds minimal polynomial for a primitive element
+ primitive(ideal i);   find minimal polynomial for a primitive element
+ primitive_extra(i);   find primitive element for two generators
  splitring(f,R[,L]);   define ring extension with name R and switch to it
  randomLast(b);        random transformation of the last variable
@@ -17 +20 @@
 
 proc randomLast(int b)
-"USAGE:   randomLast
-RETURN:  ideal = maxideal(1) but the last variable exchanged by
+"USAGE:   randomLast(b);  b int
+RETURN:  ideal = maxideal(1), but the last variable is exchanged by
          a sum of it with a linear random combination of the other
-         variables
+         variables. The coefficients are in the interval [-b,b].
 EXAMPLE: example randomLast; shows an example
 "
@@ -41 +44 @@
 
 proc primitive(ideal i)
-"USAGE:  primitive(i); i ideal of the following form:
+"USAGE:   primitive(i); i ideal of the following form:
  Let k be the ground field of your basering, a_1,...,a_n algebraic over k,
- m_1(x1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials in k such that
+ m_1(x_1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials in k such that
  m_j(a_1,...,a_(j-1),x_j) is minimal polynomial for a_j over k(a_1,...,a_(j-1))
                                                         for all j=1,...,n.
@@ -53 +56 @@
  j[2],...,j[n+1] polynomials in k[x_n] : j[i+1](b)=a_i for i=1,...,n
 NOTE:    the number of variables in the basering has to be exactly the number n
-         of given algebraic elements (and minimal polynomials)
+         of given algebraic elements (and minimal polynomials).
+
+         If k has few elements it can be that no one of the linear combinations
+         of a_1,...,a_n is a primitive element. In this case `primitive'
+         returns the zero ideal. If this occurs use primitive_extra instead.
 EXAMPLE: example primitive;  shows an example
 "
@@ -63 +70 @@
  ideal i=fetch(altring,i);
 
- int k,schlecht;
+ int k,schlecht,Fehlversuche,maxtry;
  int nva = nvars(basering);
+ int p=char(basering);
+ if (p==0) {
+   p=100000;
+   if (nva<3) { maxtry= 100000000; }
+   else       { maxtry=2147483647; }
+ }
+ else {
+   if ((nva<4) || (p<60)) {
+     maxtry=p^(nva-1); }
+   else {
+     maxtry=2147483647;          // int overflow(^)  vermeiden
+   }
+ }
  ideal jmap,j;
  map phi;
  option(redSB);
- int Fehlversuche;
+
  //-------- Mache so lange Random-Koord.wechsel, bis letztes Poly -------------
  //--------------- das Minpoly eines primitiven Elements ist : ----------------
- for (Fehlversuche=0; 1; Fehlversuche++) {
+ for (Fehlversuche=0; Fehlversuche<maxtry; Fehlversuche++) {
    schlecht=0;
-   if (Fehlversuche==0) { jmap=maxideal(1);}
+   if ((p<60) && (nva==2)) {  // systematische Suche statt random
+      jmap=ideal(var(1),var(2)+Fehlversuche*var(1));
+   }
    else {
-     if (Fehlversuche<3) { jmap=randomLast(10);}
-     else                { jmap=randomLast(100);}
+    if (Fehlversuche==0) { jmap=maxideal(1);}
+    else {
+      if (Fehlversuche<5) { jmap=randomLast(10);}
+      else {
+       if (Fehlversuche<20) { jmap=randomLast(100);}
+       else                 { jmap=randomLast(100000000);}
+    }}                        // groessere Werte machen keinen Sinn
    }
    phi=lexring,jmap;
@@ -100 +127 @@
        ideal extra=maxideal(1);extra=phi(extra);
                                // sonst: "argument of a map must have a name"
-       erg=j[1]+chi(extra);    // j[1] = Minimalpolynom
+       erg=j[1],chi(extra);    // j[1] = Minimalpolynom
        setring altring;
        return(fetch(lexring,erg));
      }
    }
-   "The random coordinate change was bad!";
- }
+   dbprint("The random coordinate change was bad!");
+ }
+ if (voice==2) {
+   "// ** Warning: No primitive element could be found.";
+   "//    If the given ideal really describes the minimal polynomials of";
+   "//    a series of algebraic elements (cf. `help primitive;') then";
+   "//    try `primitive_extra'.";
+ }
+ setring altring;
+ return(ideal(0));
 }
 example
@@ -126 +161 @@
 ///////////////////////////////////////////////////////////////////////////////
 
+proc primitive_extra(ideal i)
+"USAGE:   primitive_extra(i);  ideal i=f,g;  with the following properties:
+ Let k=Q or k=Z/pZ be the ground field of the basering, a,b algebraic over k,
+ x the name of the first ring variable, y the name of the second, then:
+ f is the minimal polynomial of a in k[x], g is a polynomial in k[x,y] s.t.
+ g(a,y) is the minimal polynomial of b in k(a)[y]
+
+RETURN:  ideal j in k[y] such that
+ j[1] is minimal polynomial over k for a primitive element c of k(a,b)=k(c)
+ j[2] is a polynomial s.t. j[2](c)=a
+
+NOTE: - While `primitive' may fail for finite fields, this proc tries all
+        elements of k(a,b) and hence finds by assurance a primitive element.
+        In order to do this (try all elements) field extensions like Z/pZ(a)
+        are not allowed for the ground field k.
+      - primitive_extra assumes that g is monic as polynomial in (k[x])[y]
+EXAMPLE: example primitive_extra;  shows an example
+"
+{
+ def altring=basering;
+ int grad1,grad2=deg(i[1]),deg(jet(i[2],0,intvec(1,0)));
+ int countx,countz;
+ ring deglexring=char(altring),(x,y,z),dp;
+ map transfer=altring,x,z;
+ ideal i=transfer(i);
+ if (size(i)!=2) {
+   "//** Error -- either wrong number of given minimal polynomials";
+   "//**          or wrong choice of ring variables (must use the first two)";
+   setring altring;
+   return(ideal(0));
+ }
+ matrix mat;
+ ring lexring=char(altring),(x,y),lp;
+ ideal j;
+ ring deglex2ring=char(altring),(x,y),dp;
+ ideal j;
+ setring deglexring;
+ ideal j;
+ option(redSB);
+ poly g=z;
+ int found=0;
+
+ //---------------- Schleife zum Finden des primitiven Elements ---------------
+ //--- Schleife ist so angordnet, dass g in Charakteristik 0 linear bleibt ----
+ while (found==0) {
+   j=eliminate(i+ideal(g-y),z);
+   setring deglex2ring;
+   j=std(imap(deglexring,j));
+   setring lexring;
+   j=fglm(deglex2ring,j);
+   if (size(j)==2) {
+     if (deg(j[1])==grad1*grad2) {
+       j[2]=j[2]/leadcoef(j[2]);    // Normierung
+       if (lead(j[2])==x) {         // Alles ok
+          found=1;
+       }
+     }
+   }
+   setring deglexring;
+   if (found==0) {
+ //------------------ waehle ein neues Polynom g ------------------------------
+     dbprint("Still searching for primitive element...");
+     countx=0;
+     countz=0;
+     while (found==0) {
+      countx++;
+      if (countx>=grad1) {
+        countx=0;
+        countz++;
+        if (countz>=grad2) {
+         "//** Error: No primitive element found!! This should NEVER happen!";
+         setring altring;
+         return(ideal(0));
+        }
+      }
+      g = g +x^countx *z^countz;
+      mat=coeffs(g,z);
+      if (size(mat)>countz) {
+        mat=coeffs(mat[countz+1,1],x);
+        if (size(mat)>countx) {
+          if (mat[countx+1,1] != 0) {
+            found=1;         // d.h. hier: neues g gefunden
+      }}}
+     }
+     found=0;
+   }
+ }
+ //------------------- primitives Element gefunden; Rueckgabe -----------------
+ setring lexring;
+ j[2]=x-j[2];
+ setring altring;
+ map transfer=lexring,var(1),var(2);
+ return(transfer(j));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring exring=3,(x,y),dp;
+ ideal i=x2+1,y3+y2-1;
+ primitive_extra(i);
+ ring extension=(3,y),x,dp;
+ minpoly=y6-y5+y4-y3-y-1;
+ number a=y5+y4+y2+y+1;
+ a^2;
+ factorize(x2+1);
+ factorize(x3+x2-1);
+}
+///////////////////////////////////////////////////////////////////////////////
+
 proc splitring
 "USAGE:  splitring(f,R[,L]);  f poly, univariate, irreducible(!), R string,
                      L list of polys and/or ideals (optional)
-ACTION: defines a ring with name R, in which f is reducible, and changes to it
+CREATE: defines a ring with name R, in which f is reducible, and changes to it
         If the old ring has no parameter, the name 'a' is chosen for the
         parameter of R (if a is no variable; if it is, the proc takes 'b',
@@ -221 +364 @@
   ideal maxid=nach_splt1_2(mipol),nach_splt1_3(f);
   ideal primit=primitive(maxid);
-  "new minimal polynomial:",primit[1];
+  if (size(primit)==0) {             // Suche mit 1. Proc erfolglos
+    primit=primitive_extra(maxid);
+  }
  //-- erzeuge einen String, der das Minimalpolynom des neuen Rings enthaelt: --
   setring splt2;
   map nach_splt2=splt1,0,var(1);     // x->0, y->a
   minp=string(nach_splt2(primit)[1]);
+  "// new minimal polynomial:",minp;
  //--------------------- definiere den neuen Ring: ----------------------------
   execute("ring "+@R+" = ("+charakt+","+algname+"),("+varnames+"),("
@@ -252 +398 @@
  }
  if (defined(altrname)) {
-   if(system("with","Namespaces")) { kill Top::`altrname`; }
+   if(system("with","Namespaces"))
+   { kill Top::`altrname`; kill Top::splt_temp; }
    execute("kill "+altrname+";");
    execute("def "+altrname+" = splt_temp;");
    @R=altrname;
    execute("export "+altrname+";");
-   if(system("with","Namespaces")) { kill Top::splt_temp; }
    kill splt_temp;
  }

Tst/Long/hnoether_l.res.gz.uu

@@ -1 @@
-begin 644 hnoether_l.res.gz
-M'XL("(>9-#8``VAN;V5T:&5R7VPN<F5S`.P]:V\C-Y+?_2LX^1+);'J:;[:#
-M&2"WN;T=X#!8)`L<[H),T);;4L.RI--CIGMPR&^_*O:[U;+EL3QQ-NLD+3;)
-M)NO%8K%89'[ZQP_OWA-"^%OR^C7Y:SI/+LELL4RVLV3]Z_QBN]F>_516$1=8
-MY=UBFRPVZ<>$;)/-=D-NENOZ`S)/K^KJ\H+\Y[M_(]]`$Q>0_\UW=8EZ2R#S
-MUW21;D?C[\[PE[PM\C;;>+O;7"QW3;?Z;=%.U4FO,>,!9ZT_#QA9WI#KY&,R
-M7ZXN.Z7E7_V]O2#K=#$EGW>W\R1=O`F#++A>->V[MU4[HTQ0D4F`F/RT7*_S
-M"_*.+)+DFFP_+<G'>)W&5_-D0](%`3!]HQ=G/_-?+L^@E5]_Y@'_Y4UV]K,H
-M,L*SGV618OSL9U5E5KU&;PNHU@#/*`OR<7"]J6'B80\F*FF.8/T#^IT":Q9D
-MM9SGB^5=&L])NB$QV2&-XPWD?P(V;9)UFFQ>O>J#EQ\)'N<-`"%T_-_+'9G%
-M'ZO.[Q)/@<_)>LE:@'QY=Z*#;RZZN/Z]@^LZN=Y-4N#$$_J3W?Z*'N-1&(@Q
-M>>,_Z38<5FGQRQLL%4W;LNZP[`5;8R(3.<U4W:%J.H0B*K.<JBR7#*I!SXCJ
-MW][_.V*70?_A?=TW$M9T/H0BC"ID#5G]RJ')7-!,-O)EZD(!A5#E@R"49#IO
-MJMBZBO151%'E`P_).7S05'1U1>4KRK*B\!5%4S&J*VI?4945E:_80"=`^E?Q
-M.KX;522#9L9`IAG((GS)@5.\YM1LQ#$E(%/4F9B6/BW.0'F<GY/_BM<+&&^7
-M(#Z;W7R+I$ZR>+(ENQ79+LER?0W#1N/8SDB\N"86DSF(&)`=>)XI)C,-/+.0
-M@5PP5&>6FLPQE47,9;RFO("QDRZVY/.;;7J7K!NTQ#Y:ZG%HS4:BRI2M3%EE
-MJA8!5$D`\Q@"<-M00.@>";AA2F7<,B?@QS&G%.`=,1U*8S,1,FZLDU$F.!,F
-MM,9E0C!N5035A&0\-%J$4!%(R:7D.LR$ICQ22F-50Z6,+%>0:YE0$;<VU)EP
-ME(?*"2,@'5'AI`NU<)D,F17"1LZH3'(JI(DD-Y')I&#:**,5P"@E,]"[YM!O
-M)A7E-C)&1`+@D9I)A%9'(=0S3(M(N[+(4F6U,59H#K.!HS**`!MK.+0>,:-E
-M*)4-0Y>ID`H.)4Y(:3+%2]$0BAI3X&:$1TQICQ:T!%11B)3D7$G+$2=NX"_2
-MT%5(=:0`!ALB3EQJ``D``9R@'\F5,4`1*0$\SH7C``$B!7AHQ96%!J!+8:TU
-M0F%SA@D!!4)'1B)6TDGH$U`)$2L>`0A`YC#T:,G0*N<`:64!+Z:@T"GH57-`
-MC$)-H0%+%_(P4\A59ZU4D=2(N`1^1\`,$X8`;Z84M=)!2PXP`<25!LD(.9`Q
-M@B:Q@J%0$&F`1$I@IK+4<F>YT"$7420RY1B@I9V2`*25P`85,2C6D9,`AW)A
-MID.J%!?*TS9",#0'28R@`P`=.`ZRH`53UD4VXDX#*B"\6@*%N`.&149KW[)6
-M3#@4*RX`:`1':^9`GD`:0`042IM&@#605@'_C`JA>PLX1<(8X)A2%KMW]4"7
-MI?DS72S7R<AK`?8Y^`83W\!XA_'8%%]B+KF\!$-CM;S;36XO[F*86^&1WE[`
-MI,YNYQ?7R:6)ZM9A*ME3+:#LYRG81+-%\J:E70+&GTF_5!V;TZ,J&E1Q#@(K
-M:3M*LFV%%J`8J#%H)#]C-UH.TZI0^=$9VG@D]/]"FO'R]?XT,P%K=>Y.CYJS
-M=>O1/A=E6*';9F&%ZW//$J>FG^2GIQ\,T;IY45H34"MYD^6.PK^9R@W,T1*>
-M,+!S#?.SR17DN%Q2F*+!"H+9.D>+FG.PSWACG4@8M.W1@\T^D>K<)SU]3=V-
-MJG@,G16,+6E=T;/URP-B2/VE+E<,/[Z1(@QEM6IH5C*RL>KTF_0N7HW6`23'
-M304[('1N7^@TZHWGD[K92%69NLX\3(6!W[RA2G1Z*4.57[6O8$S>IO,Y:2BF
-M>+UT:S-BWBS?E&@QXB;93F:C'[N<4'*?$TK]H3FA]#-P0CI=MV\J3@0_-C2S
-M-2^$YT.P[2RD5;4XN7F#*R`+8SZBF6O*H[Y-?H,6>64LOR+UPO<ZN4D7Z`I8
-M+LE=O,@;?\"K,_(]@-7X!Y)LDJRV?H5\DZYA5D;WP2<$_2HA!?[7K_QJ4Q4<
-M+5FK&M;R+URU<-ZQV;>B,$FWCFYKQ:SW15HW(FWW]8H6-1'%^2B'A9`=?^"J
-M*6^MIF]0J>9<E<MIB\C("D%;R2M_UM6]5AUX;`'.(=?)\J;@U')]1Z8?;(!O
-MZP1>DP:6B[._SY-XDY#M.B?Q-$X7>XZ?HX'3^]0W-?6!9.DX&,7!59<#ML$H
-M%C2]D@<4PNM1.FY[$V[0]9;L4;+M3XBKM*SS1:N.*%P>ON$R0^)'M1,B$/>Y
-M(73+NQ9KFHKS6%&1GL?BBEYUG"XC!CV4.(F.DGL</KZ=!J7X($J#Z(@6.N$`
-M.M$>]TS8<,]Z[O7'CVDYTS+OQ]OL)C,8R-[/NEQX&?R?URL2@\PMEC#*[U9S
-M,#\6V^3Z@K0D;[3Z<!O$8W3S3=?+'8SWFS297W^Q+!JQCXU\$!L877?I`@?1
-MFU30QA%D=`O-%X2DV4>RF35&*@IN`<MI,!L'/[2P;,GM5-*9Z@\X^47".=T?
-M;#Q0AP=>V!+21F(5-M0,0'G?`#11@\AH"I;O;/S!TEG4'GJWKAEXM88NK8B6
-M$7O+S7VX02L-<M,#"$U;")7YLE5'MNK(5AW5JJ-:A%%8Q\-5CU^`*QCTRT*U
-M\ZF,Z*V#'S-C4ZGIK0KA1<X$O(D9+:J$,TFGDA>%(IH)>BL%I-R,3KF;V:*`
-MZYGS;7$ULVS*Q:QHFG/(GT8S'A:?\1"+'99BZ[;ZBE/(+/.*FAI[PG<U\U4$
-MP.$+`+Q9Q4^[/WO;9O9>)_%\?\C:MGN=50[G>#Y=KM/M[(Y<+Y/-XMLM^;1<
-MWX*ALIV1;[&A;W$,3I;)S4TZ26&@/G$@6KD/N6H&(N<!3'O!!`;C=9`$-QV+
-MVK9T2WPM*$P?,I%47$U4HKZ2P?;,^BPYEHS[^LR"/JO3[N+@=AF@<<R.F8TN
-MR";9MC?-ZJX<SG9U,U[/D^]Q\\E3<YNTC2O?P%U\"Q1>+*'%Q0:-NN1NM<V]
-MMZINLV-]]FT?)SH]QH9>>8[_918OI@FB=17C=A=\OT@FR683K_-7K\X*9>Q5
-M\PU2?3^#D-]^^ZTTK"^)(.1J'2]@J99LQ@1XC4W=[.9@]DZ6=ZL=L!7KUURK
-M?GNZL+U/T[S*=JGH5O9J<12/6QFR_+H2B-+,PAQ9Y_@6*NDHI$8\"VCL%+!5
-MS*QT`+`!618T0NS4_HYH2PIT5^X,RU$*_EA<+F;PE\CD$P!6,0K44Z4\6LRU
-M7;XW!:[#UY*QL,HT+/.;8P]S^+$RH'Y7&7BQ(G`2X90O@F1\'S#U,DBV#UDU
-M#J+VL!D<*E%WZAWE+,--?1PLD&*0>@D*D7<)V'Y5^Q22IQ/V7L?LR3U79.=#
-M"BT2!Q1:)'L*S3*1*70^YHKQ7`.[($OY+%7E`>.006#++!=)R9"278?R6WS]
-M@N)3:T3>Y043/6JSA\B=PW))9WD$-!&Y8[C#GUL6.;^C8^!I&=?*[^G($'X,
-MPT@!W-R!7)-K9DUF<XF%%H@JX*F9D)G+!8,\W/_!%XSBB'*FBUT@*>!'8CD/
-M<ZJ=WR%B)H.UF?([1#X-%3G/N&!<H&\3\W`S2=TCFJI'#OY:?0E!I*>(5IXF
-M5$4%5:C`;?J&,``=YV%!&ZX-$J>H4M"'6_@,*(1!#5P65.*A-BU"4:6=U0*)
-M1:7#[6V@%Q,6"89!#"9T0"CJ1*0\X1CGGG(T<A(Z!JHQ(&6QO19QC:2C&/[1
-MIJ!P(=(0(T:`AE%#Q&>9,L2`8B9=9P.I_0V\]3JLQ8^9^IYEAAF:8)X7CTJ-
-MJ4&MIP]I/=.;F_Q\=%[\[EMR#VBL^S7?2[+H7X0UUW@0CX6S7:JJN;(#-],/
-MZ2?JM]$[48Z1'10:=TAHH@&A06%!N0'+AA9R\]B9\?>2CR/8T#<83\`'AL&F
-MH*U!4WMN&'@(/XM*AM.#?R"G,##"@*7H_J@2UV#JHVN9QY3U,84RPRI,"T'C
-M83@@ESSDPW+)PZ['"6PXP?+Q!Q!)M-XP?K=^?91:^QV$M6<49X^2SKXV.VH:
-M/%:VQ->&K&*N')0%=4@6>GXGL&1H+N_93BXC\<LS`NUH?._=&O!_\G#(9<+#
-M`RX3'G9=)N$]P&"`_F"/T2$W'.=A9V]L8`>0X^&`O@_8?X);Z?DJJ5W>/;?X
-M`"!\;P>2\X=V(#D&T]?1CFU`),T-`H.!$]__^/[=^_^X).^7N-&1P+!*)XWW
-MOMCU3[LN>:38:KG9X([_JZ*5PH6_75:;#\5'#9$#<K4#'(L0`G]4!$_+Q(NF
-M)]_.<C+9K3?D>N<1P[J3>#[9S>,MU`C()WQ?(+56Z^4$6_&;,%#/?SU9KD%!
-MK):+:_RZ4!`@3A<7%T]WALDC-4Y%>NVCY+X[7@.Q(174'KJ]@3O@NSE6I<@G
-M]W3L6H0-::]'=571$X;^=;I9S>,<.(0Q@46DU-_BNZO=>IJLV?ORX%4I@#B2
-M_)Y',8DLUA?\$BVA(D*??09U\$'X#`0SIYAQ]L@61:M%*L]/TJ9L0RD.M5E1
-M9<B.Y/R`'<EYSX[$$SUH1&;X\^?2!P_MBA5(?/LQ(;/X&JI<D_EN<ON*5%$,
-M9;<X].?)-@$M<-7`AIN@#Z@3?FH#)NP.M)X)VE$N>G\<JF/'H1BT$,4A"U&(
-MOE7@=Z/^)6BG$[2N7(5'RM6^A2'JJ(-@CXNMZ(,P2"I+8]Y8&J)O_;'B:.*?
-MA\]??S^AYTK><ZD\80G"GMQV)1?FD&(8G+F$ZXM1\F>3HS^.OH@.Z@O96AH5
-MD?]#JQ,\]S(4'\GE\*3QN^_8M6-/GMM$[P23/,UTQ@,[-8?`&"5D,HO7\60+
-MPK79PAB"Q0TRJ2CC19@_B,X:6[F$=7I14+**E'^7!`.L^;@H7.SNKN`#$-J/
-M,0P+('Z1[_^NYLO)K6_ZL@C$1]&8;UHUFK]+LH#.-YC,2$X&6A'M5OY2(ZD.
-M2Z,^2AI-1QK3MCS:%RJ/C(<JBF+*0ZO%5Y3-HEMVFFXK(H/JKQ3>R<4T?D&"
-M>EAMJD9M#H:G<C7@3_H)/@#5OJX4_PU0;+E./\,,\A$0;>)3V_/B@#I7^PXF
-MU7(P]8-.@VD7L@.>IEA<70MZ-4DDC<5$=D)0@6<8.+KKQY,VX:88,5I'E?Z)
-M;(#C?.#'+B$K%CW:(_6470V8O\3X]6C2BXCL[6Y`+0.UKL9]^W)_DZ.O.$97
-MD_%Y3D<H5I`0=,1$K"9B?(Z;.Z/80'&]X<;5GONH."O8N&_0KW+^>01ZHO&U
-M`'@?"BQ\R0?A<PJ(BYRF`_NP^N*\*)#[NNN*3`[IK_"%*"[E#BNNZ)"B&`<_
-MU+'I7'?CL@9UP[\&^3/[B?Z)!K7F!R423V*V);(P^(+/X^#3"@_,!7+<U)6-
-MY0>V@FH*#FV?@$'AM[:^<"9[U$[G([6\/IV6'Y0`^?@8]X,FG_XRI2S/XTH?
-MURT]0OL^SG)4+\5NU(?5KXZ.%W83]M<R3Q+E/Y&^?I91^US')UY_P3F9@^/4
-M\(.;X'@P]O7KWO$H/'F/WJ=-0=M)X=`"SGJ6-.RJVI#EO8-_%>7=!)VE!1ZC
-M;4EL^W:">V*>?M?=EJ'-EO+5/"T<J/VJNZ^F_+:]JQ,P^X"G-J=XX0O^)WPH
-M&3X4D%?#?P8H77/AH4M5N#GDZC6VM^MH*`;B@_&,\6LT&XS&/_6IM6.W[P]+
-MP--]XH<=+$--'SO83W,B[N"&_I-`.^&).(X'S:L=@Q\;X8H.2!T>_RWOXL"K
-M]_`>/BHS;JG+N,D9QTOZ>)AQG6,91OX9_*&8)S%RVV#\M:#"8+RV9#J+,"@^
-M]*'>13"X,#Z@GILRQ%Q@['WN&A"Z[IJ;(PYC/C:$\VDAGR<_X+7OM1Z!Q1'R
-MF+DP#/L+`M;?==X/9'1TY&)JO/UO836@1$PY+@>0XB,5HA,23$0?MB_./5=&
-M+H0Z"G.15>@DC9F&MZAX4RIF`E2/9RL="2@56)ES?-4F9LKA*S(?2ZEO"F6"
-M<G..,L+4>2$Q`$\88R%H2X33?V=\FGDH.<+L?!5'00P?X6/=(R1[,B59FY1=
-M2K)A4K(>+3ND[%.2]4C)>K1D#Q"S14O6)B9K4[-#S&.CD!X5W-D[$;%W0D<$
-M#U(;L!?GQ80*&@62VC^MCRD^]OC#0:`?'U/<?E7MIHXX',%DZ[WJN$,.>01!
-MJ#S/_$/XIT1+`Q,*+(U:78HA!6_E(04/=B'H=A%A?+,#*<5[0SE>(PK:':])
-M!?G+A/;ASRA?7/J;1D&_PRO%RT51S6N\914O"(4W)AQ\CK'2^"7*L%;X3F7D
-MWP4DX&L4=NB-XWP@\/Y2/`OE5(@YDDF<0'"PV,@GH"Z7>!DLGA"2?O*!*4-;
-MC2GL&OH&F=?^<!6.12&$3VFJG<.A@E?T<9Q;A##^4)!A@OO30H"OB?QY(DL5
-M3E".15S#4,6[=FT>4:GQ:%/$`!2%YZ202#GG,$LU%_IQJX?='%]SOGJ64W@5
-M?B<-'?1>8:K&960>OA4JN<B0M:<B>VI((3J\FFY\+^I$O<AV+V4/Q4_7VY)1
-M47I:6)F0C^U*'=U5Z6(O?J!0%(6@@S#M2T11(HL2A242W4`UJVW-ZG<+[[)8
-M;#<EQ_$B#Y+6N6TH"]\.>F_P<H^^ZRC)5B"0^`EZD<[(:I=NDEU&5G&ZWI#V
-MWR4Y`T),UTE2798V62ZN=[@A1PI7/A3/MW$#1N=C*)XFBV0=0WT/WR:Y2]%K
-MLB)EUYOD?W?)8N*;OX.QD*[FZ23=ILD&BQ]&4?SSHRB/01$6S_<CZ6]YO!]3
-M=3^FXGY,/03WX0KS>'`,ONH8?%T@PD!`D_((M-&'"$\A'R0!6(;W$\$^P&\/
-MEQ*!>X`8+G"!@G]:1&G[F](%H+U))NCBZWU+^A?XD+.SDH#_AS`J#ZDL3!E\
-MG)7UZ/ZM/UC,B?^.F\!_[9^%Q2BZ)6=ENYBGZD6L'5S$VD.+V/XE0F`+@.&D
-M&)YAEA2/*..YK@@OZ.4O;G6IG[RZ["Z"ONRX/"QN#*X9T.I2:'_Z1:#/DG@P
-M^]R?A5/X@ZM!S/<K$%XF\40V+HJHP2<N4S`?5B)%!0OVY3G^OPUPA83K*,R,
-M\`KE>]9ZO67R%R/&]C`[B!BK,3N(&*LP8X.HM3%[EH77OK>HVFUZY.I+($KE
-MYN'_MW>LO7$CM^_^%<JA0-:6Y&B>DG)U@/O0^W0%"C0?6A1)L'$VR<:/3;V;
-M9/>*_O>2G*=>J[6M)$YQ-FR-I-$\2`[)F>&09N>0*3,=<UV#R0<O3FBU<P:*
-M]YRFP90+809?*S^W5P0@A2M"\%K[_!H72/$49=&"&6:K7-T5P;#."6KWGOD=
-MM/P'#;P?U#I`Z\)L`&0#$.L%6!M>77"IVVR-[%F('=S7J%C,C`<X<-,6%291
-M.;I-K\AANB;F*U.SP`$3N@?'@Q^>"Z=D:-VA,?S%P/#'W<P?EP%\,X]DPT#N
-MP+B'6]P2R`^%7QPJE'H6J7D'!N/]9X596Z;.UR@E!:Z[4`>A?<**V=+(5XT]
-ML/U"1S2TPDK$I$U'5,I9@0F-19FU:LZ-T`4)7Q>TS$I/%14-=\H)?%QPS7E5
-M4,KQ(U<APW/_5#A#'8%+NP`[L\4S$10$W`&AJF1<@-$@;%6`+FH^4V;PF*>`
-M+>PZTT;GH(5O`P)F]`A6>7"QRJSZ`M[X+<1BSY+X7?$VC+:\B[>\%W%[\-:+
-MM@;6\GUHR\?PEC<0UX.WO(&X7KP-HZV#M3ZD.>DH#I"@S?W[41%Z8ET;'F9A
-M_Z"DK?[#:>97<_[SS1PF)E]?0>$GM!]A=11IY:?03D?A=A:7*N5TE));":H*
-M(T%Q*!,G84Z(\M)(42R'V%;AY&A%,[P<2T.^K,Q$;Y?2^@$66'F6!*,<RZF=
-M0*AW>85<"T0L>PBNNZ938!I(Z."@BX(A#`PB8`C^O>!O0[\'^(?.AZ;1;_(=
-MHSU>`Q@F4I*4C*<UP^XSHMS*])RQ'#4WHQ()+4VW&48WE-A3?*X*T\$:Z9)A
-M"I]656$Z6J><*Q*/J-L5A1.6=<IJ*R"K5)$HI(6/PHG(,A5%(2A)XIOIRLK&
-MTJOJN)L&U2HC($GKDL+)S9+$FD+C#EUK2NJ\U"04$0)<%U94XAX=5674.6WE
-M)(A87RONFJ.H1.6ID%9NDAO!XL1L"X;.D>Y`(A4)T?32ZGT$]`((A]&5AQZ;
-MW4>"("^BM2S.:*?<@).;_7=AD,>!J!"VG%N%S3T6V',N#)9H-Q2I7SI<<;G+
-M$=G<[,Y3!SF0.1:E/6F@!G&"6Z];7AW]2W]37<[0:+Z72/MH=(!$\WX:S?N)
-M-!^ETB$B;=+H`(D>3J'Y((GF,8WF?42:#U%I/DZF/50Z1*01C39(M)="#R#0
-MO(]"\PZ)YGTTZM32EH?&$"N+57J/4:NQ:;W"J$<;T#U))22UTYBY^C)<,.U?
-MQ5F/L21Z\^[;<Y^A7S_HS`Y]0IH`SW"5.4HBM-*T?EK&SH@_\/?7BR]H;;^\
-MFE]&!MY/$R`5=%N7LM$2\+0[:-IO5E>@6:]NWBRO,:2"M33^,E_CP?@]]3`.
-MK(.E.+PQ'F*9VIHY53Z%)_6O\J`YVZAO9P:!CK.OYA^3YS]3T.6EI\4Z6$H>
-M0'[A,_:,+/!GRS,&1?[Y;+W\?6'VVI-EFAXG__$Y^6F2/#]SB,Q,'#D\[K%\
-M$94G,1=9G;@G^C3Y[U'1^76ORXGM.N8O@2;F+VOXJ^"OA#^%)P#I^#`97DQK
-MW&&J:U0U236B74V!O8+BJ]Q4I7-3G82T2*?LH>ST,,?Z7=VYK1OJE+FK>YJ:
-M5<M$ASHL0!6>HG#=+IQ`2IC#+J51EQ"+^3R?IE-EIUX6@5(Y]$U25]6M*XT[
-MFMJ..KHQ(V.BCM:]':U;G=T'6,<4JLZ9,O$B8X8S>%&RQ$`[7Y+'-B<^>XRV
-M#9OY\IK>OUF`R'@,)3RV,=UO/Y!>Q<USK7,;_5'%CMWQHNBW`N!%M$_UJPB/
-M6]Y7B7=+].SX@%6'<='_C43I)`K&%&H(J"`U.B6^N_)Q-[5@C]E%/@?"!IJ&
-M,6Z&7,_JSD0G7V9S$+<BG:22P25"J"3NDG$'<M_:!M?"J$O`*D$<X,GV*7HV
-MN/3C>T:8NG]%@_-WH(DF#"?H57GP8D'=I,C[N[JI[EIUL]]WJ[R^:^7Y_2MW
-MLD/TBY0![\Z\Y=VY(VNTES42A`V#)TP?(FZ^&^<>Y,D:!&6.XA+ZD!_"CN\K
-M$:>2(2DV'>>P![;[V\N5[CIU/<V`NH53M7H*[G$+2X-ZDE%[\,9+ZUSR;!_S
-M.B#64T]+#MV%:+<DDHAM:7^WAARZU+S_J/9>87TG1[D'B[71ACG)3LB;H&&'
-M"KV1AN61SM%&Y=T:=JA`'&]8`Y<M>K^'VV->#!QNYQA\H!5%-L^3U\MW,.UM
-M^4'8+(&!OUO[+ZO3X3">'`,/T*+<QU<L.4OH;+Y_R0K_DL-+R/*2)VFR5;N0
-MA?DL@K)PDP7FL,D)?!`R<I]14D9A,W+*R$-&X3,JRBAM1DD9H]:!$O'[&?1V
-M<1.>#9PQ@Y9@)?@]_+6\*MXK^-&WL9MTW0/RV*PWKXQ?E!GU/?\]^PD3/YFU
-MA_#Z*3Y-GCX%+>#CZNK3^<7IU7SS?@'_EA>GGZZ7^<7EZ9O%4\&Y+[YL%']Q
-MM;A:W>QFQ]E/)F6K,#?)IS4T[O4NF9]OEI\7D>>6&5#PZO5NLSA^VFJ1_7*T
-M34SKTC>J`GH``M[811;CNZ?(MEE29$4&J9S!33?%T2N%*Z2."Y'-0I+PK4_F
-M\+5P7Z,S\J][W(MG8R=FQD_)\/UG9-C802$Q=E!HNI-?.N,RXU4FBDR,'`.C
-MCL]*.B]$IX8$&X6$J$;."[%Z[(`8M5!!GPM(L1'00.Z>DT/W/SY690Q*DQD;
-M.T76@M%^Z%0C)\KDR)$R:A77F1J!RNT`<M#Y,IGIK#P4%B-GRO1^*%3[@8`M
-M&2.+AW2.3.!I,4YGQE1\C@SI.TF(PA-_CDP%SM<7:Y7S@5BK''W[MT4R'_!N
-M!^)]<K]*KDHUO9A4.H**?B!R4DCA54?T=!]$'&N*."??]E]9**SZVA)/\$Q6
-MF=*9+C+-,WV(_.N(@9D^X/"H9B.2L2KT_L%NVLH*&-#`^B0,HVJ,^<$G(!6Z
-M@L'!MQZ`K\':'Y#K0,X"3@QM7J&7_]8$*=DLUK3_M]AN+-=I<U?#*%T1_+2'
-MV:%;>\^_8M_L@E;P%`P<P-C[67$,LQ5V-$=/B)C,0YN!`X8F()8S##;AIJ'Q
-M'#1>Y(ZM6(/IM9M5@HK*_`I1,)G=ZER08S69"@K'2)$9[3JC;Y#J-`BG1-AT
-M:9L^WK@P-8Y=Q?0W.O%6M_Z%G*XWNM,;5K2Z@VE-:4'IRCPOZ(85YDUUCUXS
-M[R8/TSI*EU&ZBM)UE&;%W<!G;U3T0CM7.GA31B\J_,+?U7&%!7Y3C2&#%07Z
-MM$EKO/!4E>BC)E5%N645F@/2*0\A2O)X5A7&RYE";V=Y5:))8EJB6YF\I+#>
-M*?JH*5)R=,9SR?#L;TWFRXRC+;,@VV>%V-^#^K+M3)ZC?_^^<(F7ZY"E[AG1
-M.*27.W'\LDRW3/6.Z"47\)1ADD."F\0<&*R@U_[X/4</^RV2K(@BA:'"94WI
-MVI2JOQ/==4@-.QAH;1O16C%`:L4`I?70F8AJ$WZ5+0Z-'7M^PK2*TCI*EU&Z
-MBM*A+AG5):.Z)-:%>+)W,GJCHC34!BBR-V7THHK2-0),1Z,&!57OR%F6)SOR
-M1+6L3[:U)Q+6(5[)AX486;/URJ^&$)-BWW(?QD\P9G%>DF'\5$Y[:",15.?K
-M1O341X^.?KE.%C<WH"V\AW?D$!?T>XRT:@O/DO4*]0KTY(N6,"BT3XVA2V'L
-M5L*(49V&D7G@D&AU88B@7+-4]\@:T&R%LXCQRUKHE+]9-BUSWJ%L[LKV4P'T
-MQ]\&*%I84.GS6>$+!;2B]V'G_=C,;+"*Q184O03TI<W*N&.&F1F`<)NT:]WZ
-M.JM>6%G+F]XNW:)V86J?7[\Q#=DE^T!;MYLRVV),:(K&[&$@',NDELFX94\J
-MNE-&`C]AO+I-6^O05M5H:\6><%U)H22Y6$MY^42R&F9+Y)\3[D`EK50)P@F=
-MI#W12@GTPPGM42!^:KAR^%#;_E*[M@I;&[J.409:5)5NI\"\[\2V`V[T1-\"
-M]PX$HP%WV0]N<5O:+C%BMZ^1=V?TZ,A^J!4[U=^*LH%TP6\#E2I@F;5($HOR
-M+8<;P'A=BDJ@`SO$%].BDE%OY/0+`R5CE2]?=5@Z.I]W^@@OLP^@CUQDE]DF
-M#FO(T:]\5R.Y$/F'R^.7.KTL054(OM,?)?]<?0*>^WD!C!:P"#QWLUHE5_/K
-M75A=>'24_`(-":L-B^WYXF/;W?H7;.SKR-&ZQ]P'KGHHB`4%:#[C-B<S-]I]
-MAC>UNW$]]#S+VT\?BGZ#\PO#D22F+QW^/W!YLF%U:JY5^H$QN&I[5?8J[)7;
-M?(6YVL]*<[%C_0.K(0TE:+@(NJC27"1=)-8">41MK]I>"W.-B*$>%N;!='3O
-MC%07IUW3\[^O;FYV\%4[FC=9R2.IK=MQOS/T*V_%KBNYJWSH$,M"]!&I[IL(
-M`Y&FWXU&<W8@B;)`H#D+]!FFZ.C\O0-H9RE\::(X"^-/4#3]"5Z,^1,4.5VT
-MN7CM#QV=C\8A&X@)(49C0GP<BPEQ`8-H<W!4"*X[OBTGL'7NA>NK8:B^&H7I
-M`>$YAF"J[Q]G`[N18(,3;-8H<.^!)-&/I*IK]9U%XSN$[^B9&91%`\,A]AN@
-M.5(:MC!LBA`YI1TPW!7&>@O;M0K;-0K;M6WM76&\MS#V'>8LKD5BE+.'5=TF
-M@_=%R-.!@WE.E:=PZ9Q,[>A&I;NRUUG%_2P0#@U8X-JM[KYPK4;W[DJ8"(QL
-M<H]L7K*1S4MJP[[E9]5<;XZ<^K;ZRT?[^X-LZKN>?G6?MC\4_B<R=?A!:&`B
-M@X4'[](WYMCWV(4?V7^/=]Z3$O?<F8SVW-'LU`VZ:F`[J^Q.'N[[XXJN8%(1
-MBO:"*R`_BP"=-<"4)3T_<=&L4;3[66]NEA^AAYFC#AY7T`1]!M/M+YN5"9$6
-M%\U/_='XT%32\C#"5DR[;V]65R!<7X-L-><!3^'FZ"__^.6O?_OM+T^/7'@H
-MO#0TH>[LAD*P4*PBC:&*AE;7&A,.'LTRS"R%VY(7-^_.EAW6"D]!=O[<`UA<
-MC7B_&!QP1]8:!@O@+S*\B&8YMH#FD`15Y^/\_,+,%Z^.1%:B#VA3C'R1/$EX
-MNRVV&!J<N>_`466^4?O:/CPDC]S&;A])A4*>KYQ0HO(B+)-KA,?7R_/%Y>XQ
-M8'50=OT?&A2Y,2&>^3$1R@YC(JIO;$STS0R2$-A(Y9QMF4PI4$2NX;\-7)1B
-M$`F&NW9PAZ_9+A<4RHBG'%VNB13_\X!F_!"]@'!T*RUS=,Z&Y:J=2M%=FS:A
-MC9+N8'S;._SZ1A][(IO[<V9,5F&O#M>9DP@^EE8BTS8/8]EG`54-V!G/S`KP
-M2=B]^%K1VUU#0#^-.;15Q3.OH?JUSZH,Q.(8<B`5]^2.A#)H(#'$,I-F]-!I
-M;2`D;1:;G>(@?2R.OTJ51:`77.CL2+D9X.CSXAS(K\R8R@3+M`!:*X\S^X)G
-M_A>I1LNLUADOJDQRF55HB%H6.A.2>=4!_6QT"1.=;#391IC*NQFD1TBOW.K9
-M(5#QC`C]<3@Z"J(Z4%(DO@^CI98DQHWZP'D4">"<G*6)+?`(8!"[$G.$>H@S
-M.+066=B21;GF<`7@]MA2&6)W<?Y^A0L0`7:-W5>O&+U;;*ZOLN3YJ^<P+M<H
-M-.&&->YX?'>Q6KQ]FR4-G:L6O8H1<([+Q7*3)>M_?YK?+-Z"<,DP,&I\"SA^
-M1<,K_#2+EJ>1$("FQOP?;L>Q8(<TPL(-:L*!10(\!S2@>W<Z]"?I%15-@.>)
-M\L1?`UN,X&3V63-&YD[;R&ZC!JX5@Q#C-,991905V%8,7UMFSC+1L*+:>:R'
-M55UTTD#80';$,3#4%B05VI'PG:O+CR?TF>#@:/$2(&D?[(?E`$$;#FE+F&%H
-M!0SH%$)@ZLPS!^[Y@<QH?0LRN*P[Z<`LBB)BY9Y4(F;NG]U*%X[]1T5ES!`=
-M#BO-Y_"4-1\1^IJ/,/0F/(1+XSDN;^&J[VR;PQ6^PP%B'R+SN5RM-T?PKN<C
-MV?PH;![1:_/R""4Q#R!C/JXH;L-=''=60`7ZN>AVQ;T4C9<[TW7W4CYK-I(W
-MND8K>81-:I+[",:*3^LPAAO#/^"T\?AVG+7LT^D,)$O;QLJ_N3R+>D*AN9)+
-M@C+D,PI+\GIQ/O^T7B1E\F:U6-,VU)OEY^6;!>BXA+!F8V=OLTN#*`SY_'9^
-M3@IIA"JK![40YK9$?SO#RXP8/>;.:".!>G0<<&?BG1"CG/T6A"H[SA`99<0H
-ML(6.5="R[@[]M5EI#W>^R-KL%:\W\\VG-4C*G_]TQ))G\</3U:?-T?\`/JAH
-%2\_)````
+begin 640 hnoether_l.res.gz
+M'XL("#Q($S<``VAN;V5T:&5R7VPN<F5S`.P\:V\C-Y+?_2MZ\B62*7K(XK,=
+M>(#<9O=V@,-@D2QPN`LRN9;<E@3+DJ''3/=\R&^_*O93+<F67QEGL\:,NIMD
+M%^O%8K%8[)_^^</[#U$4R7?1V[?1WZ:S]#R:S!?I>I(N?YV=K5?KDY_*)G!&
+M3=[/U^E\-?V41NMTM5Y%5XME_4(TFP[KYNHL^J_W_Q%]@R#.L/R;[^H:_2["
+MPE^G\^FZU__NA*[1NZ)LM4[6F]798M-T:]X5<*I..L!L0)RW_@)BT>(JNDP_
+MI;/%[?E6;?E7O^_.HN5T/HZ^;*YGZ71^(0;9X/*V@>_?57!Z&3#(%&(<_;18
+M+O.SZ'TT3]/+:/UY$7U*EM-D.$M7T70>(9H!Z-G)S_*7\Q.$\NO/<B!_N<A.
+M?H:B0)S\K(H[+D]^UE5AU6O\KL!JB?CTLD'>'URN:IRDZ.#$%,L)K7]BOV,4
+MS3RZ7<SR^>)FFLRBZ2I*H@WQ.%EA^6<4TRI=3M/5FS==]/(CT9.R04!@Q_^S
+MV$23Y%/5^4T:./`E72YX"Y''=P=;].9P%ZW+]'(SFJ(DGM"?VNZOZ#'IB0'T
+MHXOPRC9@4=W#+Q=4"PUL57=8]D+0.&20LTS7'>JF0ZQB*LN9SG+%L1GV3*3^
+M_<-?B;H,^Q=W==]H6-/Y/A)Q5!'?HMM?)8+,@66JT2];5P)68I./$+$H,WG3
+MQ-5-5&@"19./4D2G^$+3T-<-=6BHRH80&D+3,*X;FM!0EPUU:-A@!ZC]M\DR
+MN>E5+$,P?633!'41WY0H*5E+:M*3=`=8"'4AW:MP#R=H/$Y/H_].EG,<;^>H
+M/JO-;$VL3K-DM(XVM]%Z$2V6ESAL#(WM+$KFEY&CVQQ5#-F.,L\T5YE!F3DL
+M("E89C+';.:YSF+N,UES'G#L3.?KZ,O%>GJ3+ANR8)<L_3"R)CVH"E6K4%6%
+MNL4`73+`/H0!TC4<`--A@;1<ZTPZ[@$OGGNMD>Z8&Z&LRT!P:9U7<0:2@Q7.
+M^@R`2Z=C;`:*2V$-"&R(K)1*22,R,$S&6AMJ:IE2L9,:2QT''4OGA,G`,RFT
+M!PMX'S/PR@L#/E.".P`7>ZLS)1DH&RMI8YLIX,9J:S3BJ!2WV+N1V&^F-),N
+MMA9B0'R4X8JP-;'`=I8;B(TOJQS3SECKP$B<#3Q3<8S4."L1>LRM44)I)X3/
+MM&`@L<:#4C;3LE0-T,S:@C8+@3!M`ED(";FBB2@EI59.$DW2XE]LL"O!3*P1
+M!R>()JD,HH2(($W8CY+:6N2(4HB>E.`E8D!$(1U&2^T0`'8)SCD+FL!9#H`5
+M8&*KB"KE%?:)I`BB2L:(`K)9B$"6$DY[CT1KAW1QC95>8Z]&(F$,6X)!*KV0
+M(M,D5>^<TK$R1+A"><<H#"L$XIMIS9SR",DC)4BX-J@90B(;8P1)#2S#BM@@
+M)DJA,+5C3GHGP0@)<0R9]AS),EXK1-(I%(...5:;V"O$0WN1&<&TEJ`#;V-"
+MPTC4Q!@[0-11XJ@+!KAV/G:Q]`9)0>4U"CDD/0HLML8$R$9S\*16$A!I0L<8
+M[E&?4!M0!31IFR&$#;)6H_RL%MB]0YIBL!8EIK6C[GT]T%7I_HSGBV7:"U:`
+M?QE\0S??X'C'\=A4GU-I='Z.CL;MXF8SNCZ[27!NQ9_I]1E.ZOQZ=G:9GCNH
+MH>-4LF-:T-C/IN@33>;I1<NZ#+A\(?M2=6R?GU2P-72:@]!+6O?2;%V1A20.
+M=!\M4IBQ&RM'][HP^?$)^7B1"/_PGLOR\>Y[;@?T;M6Y?P$I-J3%NU)4HB*W
+M+<**UI>>)9Z;?TH^/_]DHQL*2F\"6Z476>X9_LMT;G&.5OB+`SLW.#_;7&.)
+MSQ7#*1J]()RM<_*HI43_3#;>B<)!VQX]!/:)7)?A-O"W05M7,L;."L&6O*[X
+MV;K*062C^DU3KAA^O%`@A*I6#<U*1C5>G;F8WB2WO>4`;_M-`[='Z?RNTAFR
+M&R^G=9.>K@I-77B8"WNN><.5^/FU#">UVI9K')/7T]DL:CBF9;UT:PMBUBS?
+M-+0$<96N1Y/>C]N2T&I7$EK_H26AS0M(0LIZY&A;26+P8\,S5\L"@AP&ZZV%
+MM*X6)U<7M`)R..9CEOFF/N[ZY%?DD5?.\INH7OA>IE?3.84"%HOH)IGG33S@
+MS4GT/:+5Q`?2;)3>KL,*^6JZQ%F9P@>?"?5A&A7T7[X)JTU=2+04K6Y$*Q^Y
+M:I%RRV=?0^&2KCU;UX;9[*JT:53:[=H5`S43X;27XT+(]3]*W=2W5M-79%1S
+MJ<OEM"-B5$6@J_15ONCJWN@M?%R!SJ$.%U>%I!;+FVC\T0WH:9GB8]K@<G;R
+MCUF:K-)HO<RC9)Q,YSN!GZ.1,[O<MS7WD673_J"7#(;;$G`-10FPZ5`=,`AO
+M>]-^.YIP1:&W=(>3[7A"4MVKNAQ:;:`(>03`98&BE^H@Q`#N"D.85G0M,6P*
+MIXEF,#U-8,B&6T&7'L<>2II@R\@]C)X`IR$I.4C27G*@18[80TZ\(STK[I.>
+MQ=%U,YV3VEU,@36A$PM'B?5E9/I(@5KU+R50V[(5O83!L/^1!&%*0F0YK&`/
+M(3U<D7I$K8-Z:-U@+XY`O8+4X"]:^.\-,O8XKHV]T!97NU+H:?\TD8Z!L))6
+MS0*$QP(S9#TMP!HEO1:AC1H"]\;',:Z;8Q!8HG&M'^,KFA[D4+$>5\H8K<FY
+M">^@9'L<-"W7Z3D>:H9K<%PT"WI%#('AJO@T<4/#>M9)X6F)'-Z4U#^%!>C)
+M$VRZ,4/+0<2.PC($CJ(#>&,1;KL?AX![W+P%>M`('"Q(36AZ7,1[08`0HJ4R
+M:F(1S;*U&B)5U$(7,"2$%B;`"\P"?)4:J/"2M%06VLJWBD#4NQQVUU[;EKUV
+M8<1W9TS;LM=9$;G_:3.:X-P=ME86\S#M_._;VRC!:6:^P(G]YG:&*X[Y.KT\
+M.XE:LTWO]N/U(.E3:'^\7&QPCK^:IK-+G/JC#3;Y/YRCRIZ^??2<9/TNC?%]
+M-#IQP*JYUMY!]MI)=[!#NE,-Z3H>7"/MX\&D/_BA17O+:HP5F^BNW5:/LG3C
+M7;,M!_JP"1<MB]&8/TV`&FNN[K+FSK3,WQC7Q9/^1\<F<=N.7_O&^-7^6[G&
+M:"UQK]%5OX,VA-(0-SY`T'C+!(9[U6JC6FU4JXUNM=$MQFAJ$_"JC2GBM=^@
+M8K/3L8K9M<>+G?"Q,NP:C<U8J0G@$TQ8T41,%!LK651"/`%VK0#O_(2-I9^X
+MHD*:B0^PI)XX/I8P*4!+B>7C>")%\9H45.VIEJ"[ZBW)L+`L*UH:ZHF>]20T
+M`<0C5"!ZDUJ>=E>=FR72,DUF>P9R>P.4U]N,R6R\6$[7DYOH<I&NYM^NH\^+
+MY36N8]:3Z%N"]"T-S-$BO;J:CJ8X?(O1^?B1N.M:^99K)>4`_:K!"$?CY2`=
+M7&TMN'W+Y"27P,B\IPIG\Y%.]>^TGOLJ9BX]DKE^U\QY-'/UO3X[N,?>='_G
+M-KLW9]$J7;=WVINN:,*LP123PO>T8QUXO$[;*[(`X":Y1K[/%PAQOJ*58'IS
+MN\Y#B+N&Z=I+UJ[+[?U6CXEEPZ`'?YDD\W%*9`T3VB/']^?I*%VMDF7^YLU)
+M8:.#Q;XB2>P61-%OO_U6KL;/(XBBX3*9CR:]=-6/5IL1@;K:S'"M/%K<W&Y0
+MUM2^EEIU[9C(]N9N\ZC:M;#=N'`;DWZK0)5O5PI1NO)4HNJ2`*'2CD)KX$50
+MX\^!6R7,RC*@&$AD@T:)8[&;1M%H02RW]<[RG+3@CR7E8F)_C4)^!L0J0:%Y
+MJHQ'2[AJ6^Y-A=Z2:RG8TUYN>19VU.^7\$-U0']5'7BU*O`LRJE>!<OD+F+Z
+M=;!L%[-J')CVL-D_5+:GWE[.,\H$HL&"=QSO7H-!E-L,;#_J70ZIYU/V3L?\
+MR3U7;'=[#9H_9-#BCD%S'#)-.Q:YYC(W*"XLTJ%(5V4H.!(0^C*+>5H*I!37
+MH?*67!]1_=P646[+@D.'V_P^=N>XBC)9'B-/(/><TH)RQV,?MH$M_CHNC0X;
+MP4K@Q7)*+Z(=82RUN>'.9BY75.F0J8"_AH/*?`X<RVC3F!XH]2O.N2FVCA7@
+M15&]%#DS/FPK<YOADDV';>5PCPVES"1P";0A0F6T`ZWO4$W=88=\JQ_#$!4X
+M8G3@"=-QP14&E-O3,`:QH[AAX(TTEIA3-"GX(QV^AARB3"BI"BY)86R+44P;
+M[PP0LYCRE!.#_.+@B&&4^62%1T8Q#[$.C.-2!LZQV"OL&+G&D97%GGPL#;&.
+MXHA;'`0OB(>49H8\C!LFOLB4`7L,<[0=@XCJ,(1L/>ZWXL=,?2\RP^R;8%Z6
+MCL*,22'V6#TIY'ZK)P5TYJ8P'YT6UUU/[AZ+=;?E>TT>_:OPYIK`XK%XMFMU
+M-5=NX<W-??:)A=R;=FJT%&JOTNA#2F/V*`TI"^D->C:LT)N'SHQ?2S^.$$/7
+M87P&.7#*4$=KC98Z2,/B#X195'&:'L(/28JRJ2QZBOZ/JG$-I2$EGP=*>9=2
+MK+.\HK12-+M7+]TAO=R..*$/!SRGS<2,O#=*^J\?'V36OH*R=ISB[$':V;5F
+M1TV#Q^H6_-Z85<*-]^F"%`=T07;B3NC)L%S=D8-2'M\I#Q:UC_"$Z-:>^*>4
+M^T(F4AX(F4BY'3(1=R!#IWKV]F@.A>&DM%M;9GNV"R6=)^G&@,,KE'^3WZ9U
+M&+P3*]^'R,YVI93W;5=*.E12ITBW$5$LMX0,95M]_^.']Q_^\SSZL*#MCQ2'
+MU734A/2+5*%I)TP_I3-7JQ6E";TIH!1A_?6BVI(H7FJ8/(B&&Z2QR#L*Y\OH
+MB%TR;WH*<!:CT6:YBBXW@3!J.TIFH\TL66.+0?29GN?$K=OE8D10PM8,M@MO
+MCQ9+-!"WB_DEO5T8"%2GL[.SIP?#U)$6IV*]#*FUWQUO@?@^$]0>NIV!NR=V
+M<ZQ)44_NZ=BU"-]GO1[45<5/2AN:KFYG28X2HD3B(KWR[\G-<+,<ITO^H3RM
+M62H@C:2PYU%,(O/EF3PG3Z@XUL._H#GX"*&`T,P9%9P\$"*T(#)U^BPP51M+
+M.`2SXLI>/Q(.^9'0\2/I&"`YD1E=_ESVX+Y=L8*(;S^ET22YQ":7T6PSNGX3
+M5<D-9;<T]&?I.D4K,&QPHZW1>\R)?&X'1FP/M(X+NF5<S.XXU$>/P[T>(ASR
+M$,%WO8*P&_5O17L^1=O6*W&D7NUZ&%#G(@RZ4E1;Z9YIY6G,&D]#=;T_7IQG
+M_O/(^???3^B$DG="*D]8@O`GPZ[T`@X8!K5WYE*ZJT;IGTV/_C#V0IG#]J*U
+M-"J."^U;G=#)K'W)E%+MGS2^^HY=._?DI5WTK622I[G.=%RLEA`ZHU$TFB3+
+M9+1&Y5JM<0SAXH:$5-3)XFP0JLZ2H)SC.KVH*$45E7_G$:7ORWY1.=_<#/$%
+M5-I/"0X+9'Y1'OZ&L\7H.H`^+T[OD&K,5JT6S=]Y-,?.5W2;17FT!PJTH?RE
+M(K(YL[:CC:VS:W=H(YU?:VGCM*6/='#M5>HCET+'<<*D<`9^1]TLNN7/TVW%
+M9#3]E<%[=C5-7I&B'C:;NC&;>[-6I=X33_H)7T#3OJP,_Q5R;+&<?L$9Y!,2
+MVF2MMN?%/>9<[P:8="O`U$U%'8RW,#,'(DT)#"^!#4>I8@F,U%9B*LJ,TDDW
+MW2S3)@F5TDB;7-,_CP]P7`S\V"5D):('1Z2>LJN!\Q?TW_9&G8S(SNX&MK+8
+M:MCO^I>[FQQ=P]$;COJG.>N16N$-'6.!1(^@?TJ;.[W$8G6SX69VPD?%`>,F
+M?$-QE=,O/;033:P%T?M84!%J/D(H*3`N2IH.U/WF2\JB0NW:KF$T.F2_Q"LQ
+M7$8?-%S&'#(4_<$/JZ;9=E[67MOP[T'^PG&B?Z5![0YKI-_6R,+A&WSI#S[?
+MTEG&@>HW;>/&\T-?H3[C+>VA[1-T*,+6UB-GL@?M=#[0RMOGL_)[-4`]/,?]
+MH,MG'V>4U6E2V>,:T@.L[\,\1_U:_$9[V/Q:<[RR6]M=RSQ)E?]$]OI%1NU+
+M'9]X^XAS,H?'J3NX"4ZG:-^^[1R/HL]U4/1I5?!V5`2T4+)!)(VX*AAQ^;'2
+MOT'Y09.MI06=N6UI;/N3)G?D/'W5W99]FRWEHWU:.E#[T6P_VO+=]J[.@+M[
+M(K4YHZ]$T7\(J63THY&]!O];Y'0MA2J(<NA+3-(="O4ZU=EUM(P2\=%YIOPU
+MENW-QG_N4VO';M\?UH"GQ\0/!UCV@3YVL#_/B;B#&_I/0NT93\1).G]>[1C\
+MV"B7.:1UMOZ`#WVODS[>R50F'?.9M#F7]&5/*3)I<JJCS#]+%T9EBC*W+>5?
+M`P-+^=J*FRRFI'@14KV+9'"P(:%>VC+%'"CW/O<-"MOAFJLC#F,^-(7S:2F?
+MSW[`:S=JW:/O7,B$>R%$=T'`N[O.NXF,GO5\PFSP_QVN!C0D3-)R@#C>TX*"
+MD.@BAK1].`U2Z7F!;325DJ@H2)IP@T]Q\:1UP@%-3Q`KZP'6`C66DAZ-3;CV
+M]$C"IUH60)%.,&E/24>X/BTT!O$1"56BM20\PWLVW/.`I22<?6CB&:KA`V*L
+M.XSD3^8D;[-RFY-\/RMYAY=;K.QRDG=8R3N\Y/<PL\5+WF8F;W-SBYG'9B$]
+M*+FS<R)BYX0.#.[E-E(/I\6$BA8%;TWX=2&G^-CC#P>1?GA.<?M1MT$=<3B"
+MJ]9SU?$6.]01#&'J-`L_$'X5>1ITH]'3J,VEWVO@XP,&GCZ4@+8=8LIO]JBE
+M]+%A2=\>1NM.WU9&_<O`A/1GTB^IPN>)T;[C(Z,O$I.9-_1I9OJJ,#YQ\/@Z
+MY4K3FZ3#1M,S4W%X!KS!MTG9L3=)\P'01X_I+)37@DH45S2!T&!Q<;C!ME+1
+M%Z3IA)`*DP].&<89NJ.NL6_4>1,.5]%8!(!P9YCQGH8*?==3TMP"8,.A(,M!
+MAM-"2*^-PWDBQS1-4)['TN!0I0]TNSQFRM#1II@C*IK.21&3<BEQEFJ^`BKI
+M0Q+[PAR_YWSU(J?P*OJ>-74P1(69[I>9>?14F.2B0-61BNRI*844\&JZ";WH
+M9^I%M7LI>R@NV]&6C$$9:>'EC7IH5_KHKLH0>W'!2B@JT0;1?:B!HD85-9IJ
+M%(6!:E&K6M3OYR%D,5^O2HG3ASRB:5W:QK*([5#TAC[NT0T=I=DM*B2]0E&D
+MDVB<SM-ELEXL`XQ5>C.ER,9M5%;_8S-=I9LLNDW^O[TCVXW<.+[/5W"-`#L2
+M22W[8+.YC@SX(7ER@#SL0X+`6LQJ9]>S.B.-[!DG^?=459^\1YK16@XB06*3
+M;'9W'5U5?56M[NZ3^.=M,@,\?;Y;+IT#QO.;ZX\/N%Z7F)E^>'VY7H16-CZ&
+MU_?+?SXLK\_I^ROH"ZO;R]7Y:KU:WF/5TR#R_WT0Q2X@PN!Y'$C*,`8F^8X=
+MAU6.P\K'804]GNT"K]P%7IWQ(N-0I!@'F_))GNE=H,>Y1OC/Q20FP((<QT4U
+M07B=Z4S";X24>+YI=0U@WR_/<8JO]6W2=N"3S&86@?_&NB6U0!A3!O_-;+ZT
+MZ_4'7[.$OF,JHZ_IO[$8>?/-S):+SZ0?Q.K>0:P>&L2VG0B!+0"&D\SQ#+-(
+M\8@RGNNJT:LW>W&CRW+OT65S$/2TX_(PN%$X9D"K2Z+]28-`>B3P8/8QG863
+M>,'1(#ZG$0BS23R1C8.B5.%_'*;@<QB)F`P5V)?'&!`%1T@XCL*'-?I='QGK
+MM8;)3P8L[T`V"%CN(1L$+'>0Y;V@Q9`]R\"K.UOD5IL>.?KB"))=/#0KAZPT
+MPS$'&@P^>'%,LYUS,+P7-`RF7(@S^+KT8_N2$%3BC!"\5CZ_P@E2/$59M'"&
+MV;2K6Q,.ZYRPMO?(;Z?I/VC@?ECK(*V+LP&4#6"L%V%M?'7153YF:61D(G9P
+M74-7L3`>D,#-O:@PB,HQUH*F*`N*A*],S00'#.A>G`Q^>2Z<DJ%YAT;W%P/=
+M'U<S?[\"X*MY)!M&<@?'/=+BD4A^*?)B5Z74,TG-.SB8AI\59FZ9@*]12PJ<
+M=R$`H7W"JMG*Z%>%$%BXT!$-S;`2,RD#2)ER5F!"85%FKIISHW1!P]<%3;/2
+MTY**AKO2*7R<<,W1/32FG#QR%3(\]T^%,[01N+03L'-;/!/!0,`5$*I*Q@48
+M"\)6!>2BYK/2=![S%*B%H#-E;`Z:^#8H8,:.8-JCBVDSZPMTXX]0BSU3XD^E
+MVS#9\B[=\E["C="MEVP-JN5C9,NGZ)8W"-=#M[Q!N%ZZ#9.M0[4^HCGM6$]K
+MT+JY?C^I0H^M:\/==MB_*&VK_N\T\]F<_WPUAXG)\QLH_)C6(ZR-(JW^%,K9
+M*-R.XM*R=#9*Q:T&+0NC0;$KDR1A3HGRRFA1+(?$5N'TJ*817HZEH5PNS4!O
+MF]+\`1:HO4B"7H[EU$XAU-M<H]0"%<M>@NNNPQDP#2)T:-`EP1`%!@DPA/]>
+M]+>QWX/\7<=#A[%O\BVC-5Z#&"92TI2,IS5#\!EQKC:0,Y:CY69,(J&D`9MA
+M2%2)D.+SLC``ULB7#%/X5.O"`%JGG)>D'M&V*PJG+.N4U59!ZK0D54@3'X53
+MD54JBD)0DM0W4]KJQLJ;ZKB:!M661D&2U26%TYL5J;42-W>H6E%2Y94BI8@8
+MX*JPJA+7Z*@J8\XIJR=!Q?I:<=4<524:3X6T>I/<"!;'9EDP`$>V`ZE49$0#
+MI;7[".D%,`ZC*P\0F]5'PB`OHKDLSFBEW*"3F_5W88C'@:D0MYQ;@\T]%@@Y
+M%X9*M!J*W"\=K;C<YDAL;E;G"4`.;(Y%*<\::$$<X]+KANO9/]17M>4,C^:C
+M3-K'HP,LFO?S:-[/I/DDEPXQ:9-'!UAT=P[-!UDTCWDT[V/2?(A+\VDV[>'2
+M(2:->+3!HKT<N@.#YGT<FG=8-._C46>6MCPTA@![##US#VYJ-7M:KS!4VAIL
+M3S()R>PTVUQ]&<)M:A6G/9LET9MWWYK['/WZ`3!;]`EIHL+#5>:HB7"7IO73
+M,G5&_(6_?_,&;G_!#?>KJ\5EM,?[;;)0Z:),%S)=B'2!%NTS5@7B80$28`$*
+M=E&G"YV[RO.%R/%P\T%\JC_+@^:XHW[<A@ATH7VUN$W>?4LQVU>!*\.>R1T8
+M,7Q6?4=[\>>K4P9%_O'T?O7KTJRZ)ZLT/4K^Y7/JDR1Y=^HHE9DPE'CP8_6C
+M+P\D#^:B_2?N"3])_C,K.K_NM3CX#H\S9(PS$/^+,V"-,XWG_N`/^/),T*E`
+MVHAQV,T>4&>*=4+Y-?QIN`&&/`-V/(/.<*`Z1:=.!Z<.=1VD)ME!J<>FA<P<
+MS#Y$7>4`^?(!\AT(1-6MUE%0N^H.!F/5IARA,P_0\?PP4.E^MDQ;;)E:MLP/
+M!6#=JK=.QYC1]7W9.40F?LR8$0!>):PPLLXOR6N;$Y^]QDT*Z\7JFMY_7()V
+M>`TEO#919*<[Q_NX-:XQ;B$_JB<(,=6_RL^+:!WJSR(\;GE7)8DLT7/C"S8-
+MQO0M*G5DEJ^E(_<R#=`L2!?`\-!J_M16/TU-CVV(@#ZAC(6"S6*M;02'/),"
+MX@R@5[DE&_EZV;>RP4F\>5Q3OC@$8(-S5?,67(M#0#8X.4,D(UMV_TH&1]<>
+M),+>_A55.P_CZR;AFJA\FAL:_=3*]Z^Z?FK5^?YP.ZE?]RJ#(;_+O.5WN:,E
+ME-<2$M0$#'FV3.VB*+ZRP%5NS$?(/$!E!Y'^)&R-D-BI45]?(W3G?NO#],)'
+M."JK#]'U'K%Z7Q^DO^V\F-$ZZSL?DW@[Q$_J:<FN,_OMED2F0%O!/*TANT[?
+MCA]_GN<M,Z6%I"?YG]U9)TVT;<R">EK#=M57TTCS.KQ-S:<U;%=M-HDQUR[B
+M^/T;YC37P(%QC@[]6Y%9\SSYL/H,H\B6;X'U"@3XYWO_I3P9#HW)T9D_36_=
+MOF?):4+GW<-+Y5]R>`E9SGB2)IMR&[)4/HN@+-QD@1%B<@P?A(S:9Y244=B,
+MG#+RD+'V&4O**&U&21E#Z]"3_Z^G`.WR+CP;.+<%+<%*\'OX:WDJW"N@T-?9
+MB^C``_98WZ_?&U\C<X(]_S7[!A/?F.%]>/T6GR9OWX).O[VY>CB_.+E:K']:
+MPK_5Q<G#]2J_N#SYN'P+UI4O7C2*O[A:7MW<;>='V3<F9:LP-QB4^&/R89LL
+MSM>KGY>1-Y0Y</#-A^UZ>?2VU2+[Y62;2J%]FR2P`_#OVDYC&'<X1;;)DB(K
+M,DCE#&ZZ*8Z.'EPA95R(;!:2A&]],H>OA?]:/?<)*IY-'$*A#*.G3Z9/G/#Q
+M\R9LZNS-X0Y3J8S+C.M,%)F8.EE%>4NHO8`4VP4+\XH.XM!Q',$FT2+TQ$$<
+M5D\=P5)9SV&<_4]DZ8Q!:3)C$P>S*!]76?E([(SC14^<U9(3A[4>AY"=CFS)
+M3&75."XPR^Y<,G%$2XUC0(\CX"4=S1)X`(O3,:PR/IJ%O2I)J%\E_FA6&21?
+M7_A2S@?"EW)TE]_6R&+`81QH]X.[*G)5LL-K2<FU5Y."OQ`UR;0L?:-$K.)8
+M4\4Y_39^9=X,%?*Y-9[@F=19J3)59(IG:D+_F>RL@#X%LDX")^O'2CNC"^9J
+MAZ.9BDWH2EVH\;X/[06MT%4,#K_E`'X-U?Z/N0[F'.*&UHO0<7YK?)2LE_>T
+MFK;<K*W4:4M7(RA=$?JD1]BAIW@OOV)WY[BZE&]+Z#A`L9_FQ1$,5MAL@<X%
+M,9G[-J,;]M`$I'*&\1O<$#0>?\:ST_'&T+";V0TJP41E?H(H[$+=J%R0KS*9
+M"HIP2,$.L:W08M\@UFD0CHBPZ=(V?;IQ85@<>U_I;W3B-[+Z%_)PT/`.-*QH
+M@8-I16E!:6V>%W3#"O-&[P$U\Y[G,*VB=!6E=92NHS0KGH8^>U-&+Y3S3H,W
+M5?1"XQ?^KHXK+/`;/44,5A3H)B:M\<+3LD*W+VE95!NF<8<='9P0HB(G8KHP
+MCL-*=""6ZPIW^:45>FK)*XJ4G:+;ER(EWV$\EPR/T]:T(YAQW!XL:#MQB=0?
+M(;UH^V?GZ#*_+P+AY7W(4O;T:.S2JZTX.JO2#2M[>_2*"WC*,,DAP4UB`=)2
+MT&M_HIVCT_H62VKB2&&X<%53NC:EJM^([SJLA@`&7MM$O%8,L%HQP&D]?":B
+MVH2?88NC3<?.E#!=1FD5I:LHK:-TJ$M&=<FH+HEU(9WLG8S>E%$::@,2V9LJ
+M>J&C=(T(4U&O0475VW-6U?&6G#NMZN.-MR)EU65>/:S$:%M8K_YJ*#%9C\WV
+M84@"L[_,:S(,2<II\6LB*.GBOA&0]-6KV??7R?+N#E3_3_".?,R"?8_!2VWA
+M67)_@T8".L?%O2:HM$_,5I+";!7Q/08=\;<:1OOLAE2KB^P#Y9J9NE=VB\I&
+MN$THW)?-VV73+.<3RN:N;#]`0A?W;82"L#(M7\P+7RB0%1WZ.H?"9F2#52PW
+M8.@E8*RM;XR'8QB9`0HW2;O6C:]3]N+*;G;I!>D1M0M3^^+ZHVG(-AE#;=EN
+MRGR#898IP+''@7`BDUHFXY:]T717&@W\AG']F+;6H:UEHZV:O>%*2U%*\EJ6
+M\NJ-9+44!;F\A#NPAW59@7)"OV-O5%D*=&T)[2E!_=1PY?"ALO!2NS8EMC8"
+M776X*MT<@O(>B$T7W54'W5M0C`;=53^ZQ6-YN\(@V+Y&W1W1HV_XH59LR_Y6
+M5`VB"_X8K.A`9=9B22S*MQQN@.)U);1`GW!(+Z:$E@$:=%Y_Z(F!JJP]?13K
+MB'3TY^[L$5YE7\`>N<@NLW4<*9"CJ_:N17(A\B^71V<JO:S`5`CNR%\E?[]Y
+M`)G[\Q($+5`19.[ZYB:Y6EQOP^S"JUGR/30DS#8L-^?+V[8'\U^PL1\BW^6>
+M<E]XV<-!+!A`BSFW.9FY4>XSO*G=C8/0RRR_$7E7\AN:7QB))#%]Z>C_A<OC
+M-:M3<]7I%\;@JNRUM%=AK]SF*\S5?E:9B^WK7U@-:2A!P470I:S,1=)%8BV0
+M1]3VJNRU,%?F%R[0`_V0,@^;,T='I$J==/=PN^V@E^F7,UY:WW?&?9QHNH^[
+M&'$?]^6,F0?PK2V'(Z^%M#=45-=042&4A.AEZ+Y!,S!T^IOQ<\YV9&<6F#EG
+M@9?#<!Y]KP\3)7\B/0PI<D.%O$D`]#,^&09L("2#F`S)<#L5DN$".MQZYZ`,
+MO.JXECS`SN->O+X?QNK[29SN$!UC"*=J_S`7"$:"#4ZP69/(W8-(HI](LKLI
+M.X0PX%6(GM$SBJA4@\(A]!J0.3(P-M!MBA"XI!VOVQ56]1:V;16V;12V;>]\
+M=X7IWL+8;S"^<2VJ)[5`F`%N*@-7A"Y.!L[%.;.?HI7C36YNRG1;]?J*V&^S
+MPJ[Q`ER[V=,GN<NI=3[*,#J)7<&H8F)!?&*%DTVL<);-N>G(IVX+7CX)[^]D
+M`X"#]-E=ROZNZ'^@;1&_$QXXT.:&%^]1-Y;8>ZS83ZS5QZOT287K\TQ&Z_.X
+M0]5U.CFP]*6[`XU]?WS1,``)17O%%8B?-5`#"G%]M[J%!F;)K:$>#T0&X.*B
+MJT;1[J>)W`SWHZ]O&C'(!G[BHO6)/YD>FDI6'@:XBGGWT]W-%2C7#Z!;S4F\
+M$[B9_>EOW__EKS_\Z>W,16?"2\,2ZHYN*`(*A0I2&"EH:":N,>#@T2C#C%*X
+M+7EY]_ETU1&M\!1TY[<]T./,!7:#@0XWLSMGL``^5D"S2^*3T"W)`+Y\6)K2
+M<,L(%B=^S/`BFZ7:XII=&"RGV\7YA8E2=C43684>G4TQY8_)FX2W6V:+H<Z<
+M>WS,M/E&C4$RW,-G;DUYA)N@D'<W3L=1>1'3D*.#U]>K\^7E]C4PR:`J_!_<
+MR^2Z6-VW,:@>V.LS-Q.CQV%2_[GBA+N&@.D9"R9K=6;>&/-3@C6M'AM9X817
+MD!3NR:2<Z!LM)</[!H:D0]*,4WG8K0&2UE#-`FKB0;.\^BQ5%IY?:EPGZ6B$
+M.=#HY^4Y\'"5L3(3+%,B8[PZRNP+GOE?Y!HELUIEO-"9Y#+3N"NT*E0F)/-:
+MLI:]C(G>'1HL'4:M;K#D"=(KHGLFSLO8^*]5X*.@LP(G17IL-UYJ*1U<OTY\
+M\*Z2=$U.;KG$9@L@J'Q;88Y0#_F*<&0MLK!2B3+7T0K0[:E59DC=Y?E/-SC6
+M#KAK[*SQ-L#GY?KZ*DO>O7\'_?(>!3K<L,8=C^\N;I:?/F5)P[Q`UQ>Q#0`B
+MXW*Y6H,9\<^'Q=WR$TBS#&-OQK=`W/?8KS+(_0F&WB"PK'70++H.-@`U-9""
+M;J>I8+LTXL)U:J*!)0(\!S*@(_$<>Y2D5U0T(9XGI6-^48!8C/!DEA\S1KN`
+M-F$[@RA`:L4HQ(B`<581906Q%>/7E(D,@1OY0"=D#>S,([;P.8^.(@:A(Y)0
+MOF,2/]\IT)$($0^E%\>(19LMQ^]QH<\V3?C,,G0#2\V`>/M@'/4#_&\$JBUA
+MCC[_,=)0B,VH,B]+N!<?,J.9'\C@LFYEH$H927[/8)'L]\\>927&CHVB,N9(
+M/4?$YG-XRIJ/B-K-1Q@3$A["I?$<)WYP/G2^R>$*WV%_L@]15EW>W*]G\*[G
+M(]G\*"S!T&OS<H:*FP>4*1_P$A>S+HXZ<X."_#9T0'$O=>/EUH#N7M;?-1O)
+M&Z#1'!=1DYID/\(CP#[-0I=O"(U`T\;CQPGBJL&(WB,0MK&R;=3^S>5I!`G%
+MC$HN"<N0S]@WR8?E^>+A?IE4R<>;)<X>KL&._'GU<0FF&!&LV=CYI^S2$`IC
+M$7]:G)/)&)'*FDU-@N%Q,C)"?CC%RYP$`.;.:(J=(/(>A02>,7/B=?Y#T,'L
+M*$-B5+&XR(.HH`G/+3H2L\8!W/DBI5EQO5\OU@_WH%B__<.,)=_%#T]N'M:S
+*_P*08Q%?G<P`````
 `
 end

Tst/Long/hnoether_l.stat

@@ -1 +1 @@
 Status Output of tst_status.out
-init >> USER    :obachman
+init >> USER    :hannes
 init >> HOSTNAME:nepomuck.mathematik.uni-kl.de
 init >> uname -a:Linux nepomuck.mathematik.uni-kl.de 2.0.33 #1 Wed Jan 21 18:50:57 MET 1998 i686 unknown
-init >> date    :Mon Oct 26 16:47:12 MET 1998
-init >> version :1300
+init >> date    :Tue Apr 13 15:32:07 MET DST 1999
+init >> version :1302
 init >> ticks   :100
-1 >> tst_memory_0 :: nepomuck.mathematik.uni-kl.de:1810795
-1 >> tst_memory_1 :: nepomuck.mathematik.uni-kl.de:9102223
-1 >> tst_memory_2 :: nepomuck.mathematik.uni-kl.de:11497472
-1 >> tst_timer_1 :: nepomuck.mathematik.uni-kl.de:19742
+1 >> tst_memory_0 :: nepomuck.mathematik.uni-kl.de:318066
+1 >> tst_memory_1 :: nepomuck.mathematik.uni-kl.de:9174842
+1 >> tst_memory_2 :: nepomuck.mathematik.uni-kl.de:16056320
+1 >> tst_timer_1 :: nepomuck.mathematik.uni-kl.de:20420

Tst/Long/hnoether_l.tst

@@ -58 +58 @@
 develop(a5+i2*a4+2i*a2b+b2);
 kill r;
+ring r=(0,i),(a,b),dp;
+minpoly=i2+1;
+develop(a2+ib3);
+develop(a5+i2*a4+2i*a2b+b2);
+develop((a+2b)^2+ib5);
+kill r;
 ring r=(7,i),(x,y),dp;
 develop(x+y);
@@ -276 +282 @@
 kill HNEring;
 // ----------------------------------------------------------------------------
-// ------- test of invariants, generators, intersection,                    ---
-// -------         stripHNE, puiseux2generators, multiplicities, newtonpoly ---
+// ------- test of invariants, intersection, stripHNE, puiseux2generators,  ---
+// -------         multiplicities, newtonpoly                               ---
 example invariants;
-example generators;
 setring r;
 list hne=reddevelop((x2-y3)*(x2+y3));
@@ -289 +294 @@
 example newtonpoly;
 // ------- test of getnm, T_Transform, T1_Transform, T2_Transform, koeff, -----
-// -------         redleit, squarefree, allsquarefree, set_list           -----
+// -------  redleit, squarefree, allsquarefree, set_list, referencepoly   -----
 example getnm;
 T_Transform(y2+x3,1,2);
 T1_Transform(y-x2+x3,1,2);
-T2_Transform(y2+x3,-1,3,2);
+T2_Transform(y2+x3-x2y,-1,3,2,referencepoly(newtonpoly(y2+x3-x2y)));
 koeff(x2+2xy+3xy2-x2y-2y3,1,2);
 example redleit;

Tst/Short/hnoether_s.res.gz.uu

@@ -1 @@
-begin 644 hnoether_s.res.gz
-M'XL("#P[IC4``VAN;V5T:&5R7W,N<F5S`.5;^X_<MA'^??\*.BB0/4LZBP^1
-MTKE[0!\):L`-@N:`MC!L0][3W0G9V]VLM+:4HOG;^PWUHO9Q#S_2%%TG%D4.
-MA^3,<.;C4/[AXL\OOF.,\7/V[!G[-E]D9^QFN<K*FVSSMC@MBW+R0TLB3HGD
-MAYO5IF1E5I0%NUIM>F*VR-_UI/*4O7SQ1_85NI^B_JOG?8LZ9ZA\FR_S<GKR
-M?$)/=M[4%65:;HO3U788,CIO^'2#[##3=M*!\[,38ZLK=IF]SQ:K]=FHM?WU
-M_<TIV^3+:[:9A?ZT\NL3_[(8N,?G'9=I);Q:8+KLXB9CU_G[;,F^7RWJY>HV
-M3Q<L+]@FN]S.\W>+C#V9O.*OSR;H__85]_GK63UY)9J*</)*-J6`3UZIKK(;
-M+QF/UXR83D-?G+"9[3)F''9E\7I&K6+@+?L!VU&(6R`J47N5Z@;DX3E;8Q5L
-M_99C@%IXE>Q7SWG?*-`(DC>">:R*ZH%$]"32DHB&Y`T/V5-T&`@E"--->COM
-MUH?6$RSN9AK2TCA6R?M5DHC_\MTW)-4K,H_LR02+Q!(K@0*MM9(]9[7/61[E
-M?#/E5!*H%$ZEZ"IE7TEEV53#P)X^97]/-TM8RAD476P7)4TNJ])YR;9K5J[8
-M:G.)'9"P?,DJEBXOL60JUZR?>^SQL$H")2H>HAA6G`=<1Q47GI"JXC(0B:ZX
-M\H0!211PA4KM2;R89MD@#3@ZR*:["F0"D@AOBH,T$*$P(/8DC\$HQE`QVA-/
-MQ6%<B3!0G,,`N"<4N@L1Q.`MP$R@=;"):#!"B-(/^*<+\PZSK;JR[.N%0R-:
-MTVY?9-]!.D32)9(.D7*(E$NDB&C8EI@)_@3RX+8158U](P.)O8,"-HFHI2<K
-MY:E*UH%"M<#?-2AJ!8((/50-J:)5>)S:I:>K6GDUE(IV<%&@$/20Z`;IVXYU
-M!([&XW&E:T]J$&(HXD7Z!J7R0!@%41533P,V1`DV(4@EZA5(=)5XW%0QYAV"
-M1E!7C5880AB0`=;T=TRL88`>K"FL`QA6KWX]5K_ZK%N)BLI6FT<:!??5XPQ$
-M.!T>9"S2Z7"WX8BNC`ZTD+$5'7:^9$5C"SIH/3"/0)/Y6-O8-1]/))4.DM!:
-MCXIWK(?L`>:C--F/")4U(!XI:T'"L2`)"XI":T*1;&TH$M:(=&BMB'K#CD02
-MD25Q:8F%)\$,QN3%9'$*AA1J,BMAC"+#$AI/F%:@8[(]+"D".;AI<F7<TR&W
-M]N;)!`XIH=D)2<8(XS58*;DW;F#YG-/,-'E*<.-"D]UB%W`>:>O^$D4>$[$L
-MAF\C<N$IB`7D\*)A;"1Y1Z$%5LTA9<XUE00M024)N5<40O*2$'42AY9,0"C&
-M1.1)%>A1AZTJE217BYX:[C,D]QH)'A-5'9@X-#%Y6FD,D1DPD]8WD_#"$%1Q
-M#7U%D*X(O<AHJ%60VT='>.!^TYDVCMYDM]FLJF,/_T$1VAJ)]D@WD:>M,$G"
-MTK.2\905(FUD1'4NAG`+X++(`8-NEMFLV\W$^Q,WL[.7=3\60,L:&*J<8C#L
-M:0P1^I7/0A_/@*/H/+G/-.MZ"J"/'_/%@FWZB0M@CA:/"8O'_'*$R$0'.*YF
-M!%8@;YAI%0_M>SCCBK!`%[R?L'^NMNPF?9_!QP%:9)<(W2MVFRYK]C[=Y"G@
-M6_%DPOZ`2?7O"//S;`W`"U1RE6\@U?+#BGV@B;_+6'Z]7`'Z/;$P335":D6L
-M!A'SQX"(R`$1?`0BRA;_E+%7)OV:U;X8H^.P&)-]"#(6>A\9KX<!8+`#HRF<
-M4DV!HD%K%KM=K;;+R_T*QG[YY9=V]6=,,/9NDR[G-].L.&'%=C[/BN)JNX""
-MYZO;];:$@D#?AXKNN1,U=@+'3NS8"1E#U.#.:Q<&.E_>N'-;(_L:V[]SZ8U_
-M%U]B8L%GF%FG*'B"(BL;30[J2UJ3@6*HJ6^0H>,X'`5/@1'H<'#RU):`OT^^
-MH+J[R?!#<Y?BV-SER":GE0D(/&':%*KJ"'-'E45><)QM'59!L\6^6"VS=G;M
-MW(_5.XO\B.:Q1-0G;P`^MK-`[-@*0.W=IE+C-!)5-4X)P`8Q80A9FR");?@A
-M*&("PA`4@"2%?8V#26@CD04#46`TQ7IJ-!:(&$(BTN*`)KA[](+#"D&$J`E9
-M.'@DA`]LR/:BN`GT%/@]9<.9+1-`X!85"`K>@8W]",9W;#NU(P[^3'V,0*25
-M2*2L3``M&JEX(M9&#((A0,+#1C:$3"(*U432R(<;"]"!ZDW$92,E'D;:$92G
-MHM@`'!`>ES$=RP@,"<+OZ)]H;7&2%XM$6<$%=((C*)3$A,D(NTO18H&$1Q;2
-M&QV/)"@((5FX2#),!B'*7\NILC$&9ST,Y\[K83_W$!^LOL0ZQ*^^CLZ-J6/^
-MS0;UG7!-\.%V32CE0U[>L/E-NKS."$I8KYE59;8L\M6RY]%%];_-)/"IW(_L
-M<C>R>S:RLS\UG.'2WJ5%9GDL,_)6Z:9^\N1_+/)/TY/?:NR?!I]C;ITRXV.V
-ME+0X^UO1`NV1$:AP9`0NU+XC8(XUS#^WAL-C8K2I`3<.1F.9ZT?Z++=5C5^C
-M\:MN^SK:47Y@[@LP'AW@Z']A,Z[T%XZA"!\>MEME>BWP(]I3X@Y/T#B"6QQ*
-M<&))EU9-5M6-;^AYR-83?"MG!]R`4D>`8"4#2F#4!`6;G#B>"H"PMDN"LWB`
-MM_BMMR^S#^P6#NPV7=CC9I/E/V.4A)%![?%[.5`*&]9_N;J%M>-8ER]3>,/6
-M/7]("_2ZO&,<Q.L:H9R@""4#C->.+.S@]SO;_U+%V`,DCX/["O'M-EVSB^<X
-M\^)H/-BB[@_]#S"_H1LB&5U/3?,9!\O?SXK\YXR2%"=X\[P3]J^>,CYE[&+6
-M*=)O,@B4SLA?#_RBD*BF5TZ-.&7_GH1[?[IF>63_1NKX\1PA^R''\R@Z/7`V
-MBO2!O`^)B203U-$=R?R.`X0V3(%DX-,=U/VYVD,YV2$QZB1%AWNO2N-,0(Y/
-M>=*F0>EV*J"Y8L;]A.*]"2E[*<;;1/)C;Q<>GDCN&]3G6TVRMQH>[BR'RMJ6
-MI2W'37UH7WC8M,2?L&K>AS$W.E+9..78*2=.F8<?)[Z="-J&S^8T1B_&:8BI
-M1_^6N`.&U">^3QD\I!LNY27VHLN+3&CSKZ&QR5I*T-(5BS24Z^6Q3?#:$QQ7
-M06QL8IGRNB(P<9.OIH=G3[,X2''*B2<V;8[3&#&R^7BZ?[E#];K+=D+I_8;5
-M_+@GL%[HH!,8>0(-)S1.>=H-_Q&7J[*[7.WSTGHOG6H!"VS\*/M'Y#G%D.?<
-MO2O=O^?5=_C,R[Q8+](:J[K39VKXS`XD#5V>TY37F]7<J6-7&P3N1?Z.N9\=
-M3+[YQQ_^^OW+;\C"#J1&61>D("![R5,+JFS]\6Q(2!^1'',F`,_0`&TKCMK[
-M&1V>_CSE)[;.2B:@US=BTJ]N_U.(3_WUK,VIP[H7>[ZT.?)E6?C=U%\X5=?9
-M,MNDY6J#,@)ZMBFR>8FSJ,]<UO&(=?<K$-G66*K/UMN\R+:5<+G=PJ3R]2*?
-MYV6>X1TPJEPMK?1=ULF@[F&J@[J'NGO5W1ZFZ3%6^5ZPI=NN!M%K`O2/NF^A
-MLKU;H22>Y9QMKF?#-!OL,J%:F,5SMO_#TNB6`C!S@\T&,%.4^1P37^,0``83
-MY6O?-`S$:Y\><LRG9=`*'7L_WQ2T-=?I_$>@-<"IVXGT#;/Y#.JO7K-G3.S.
-MI65SF2W*-.@7,(F;/M%=<R^RG[;9<FZ1]5C/F#W=KW:'M8,_,+E8=<9H^3E:
-MMF>BKY?Y/%O47T.K>S;;"?B8_!@[8ZT(QQ)R?V?,WI9-#?["&-GU)K.+L8I9
-M+2^W<QBQI>-ZTHAHF.2(#\0U6#VQ*++;_'JS@@_M9L(1/H]+C&@:D75[PH3G
-MNR[PQ8&ML=?T6]PA_X_JXX/Z!MZ#WISQ/BV"\2@0G+Y%BNW].>6,`ZXM,!+-
-M?7M`B7FOR333C3VEH(6RN6F;J1YV*76D6P"A;=Z[N<6.;=+<WFX'O(Z=0)G=
-M$RD/F09E^0]\>A(/U]5<0!V.?%I;B7T.%MJ/Y"!C<2SS@<-W=^S\-:Z_#,"7
-M&S?;^W6?'H+.I?T5O%&#6721<S"*KN8C3>+H>?(XCK$(]\L<&57S":,%U@-,
-M:+7Y188,!\N(S@_`D2ET]#Z;P]",SR-?XD0E857FQ&\;A-__(:O1RD^T+\+8
-M5T+Y<80IF5#[4O$>ZQI]Z.+3X&@^=A`#XH^\VHP@^4'W>0#Z1]:_="/$@QT-
-MF&JP)`=G/<R6=@+"HG!]3&3C0&"3H)(^?H,KJ`U1#.-8']"I-?1UKRP"()VN
-M(.Y>6Y%/VLWF-RLL.1QDEYP?0K#76;F\]=G%VPOLRX+0#5[XZ$VX;S^NLJLK
-MGXW`<1P>1+#P'(LL+WU6_+1--]D5PHC/TL7"?86.W]KM-?S&K/FIX^XQ5=?3
-MX_5^+;1;FF3A?-[,.B6@'FJ@[\,"VE'*-EG65O""1;WQQW"+CIR:@Z#/;7:H
-M<HZY,;R6*\+NRX&.5#JD<%NN?%N>`??E*.E4NQ\V=WVQ%ZTVR!WAM$46)`+[
-M?5W=C=7OIU@/=MWJ99!D6W&W+(\8=.,A6P[36MM/#<20T==^[QQ$[P^4;[]\
-M!D%'6JM!S,9QY;VI.,Z\KWL4)',S_`Z/*:FCT\JX'K5\7&75-Z["$JD2CU']
-MM`+7-Q*A,L`3_6B#M)7D?!:KHIR@[4`G->XTI`]L<],XH4@\''QCQVN--M@@
-MM5'UXWR7.82/FKF:=JYQW[*8.0NB'83P:=<!N@82L'?9/-T6&3/L<I45;+DJ
-M`63?YY<9\*(5R7BRTRM_T8@"U>PJG5MPYPBC11H[(DE:#/-R1H^I=:5$[6.@
-M=&%7-*2QD_"\=T73ET/8XB<^[6SC;$6:8;<9;:JF-E[5?@XKZ(OJCB5W_T$'
-38M'SWTWX@7_E\1\)I->'?#(`````
+begin 640 hnoether_s.res.gz
+M'XL(",%%$S<``VAN;V5T:&5R7W,N<F5S`.5;^8_<MA7^??X*.BB064M:BX=(
+M:=U9H$>"&G"#H#'0%H9MR+.:72&S,Y.1QI92-'][OT==U!SK71]IBHX3BR(?
+M'\EW?B3E'U[\^=EWC#%^R9X\8=_FR^R"W:S667F3;=\4YV513GYH2<0YD?QP
+ML]Z6K,R*LF"+];8G9LO\;4\JS]GS9W]D7Z'[.>J_>MJWJ$N&RC?Y*B^G9T\G
+M]&2735U1IN6N.%_OAB&CRX9/-\@>,VTG'3@_.S&V7K"K[%VV7&\N1JWMK^]O
+MSMDV7UVS[2STIY5?G_E7Q<`]ONRX3"OAU0+392]N,G:=O\M6;+->UJOU;9XN
+M65ZP;7:UF^=OEQE[-'G)7UU,T/_-2^[S5[-Z\E(T%>'DI6Q*`9^\5%UE-UXR
+M'J\9,9V&OCAC,]MES#CLRN+5C%K%P%OV`[:C$+=`5*+V*M4-R,-+NPJV><,Q
+M0"V\2O:KY[QO%&@$R6O!/%9%]4`B>A)I241#\IJ'[#$Z#(02A.DVO9UVZT/K
+M&19W,PUI:1RKY/TJ2<1_^>X;DNJ"S"-[-,$BL<1*H$!KK63/61UREB<YWTPY
+ME00JA5,INDK95U)9-M4PL,>/V=_3[0J6<@%%%[ME29/+JG1>LMV&E6NVWE[!
+M`Q*6KUC%TM45EDSEFO5SCST>5DF@1,5#%,.*\X#KJ.+"$U)57`8BT157GC`@
+MB0*N4*D]B1?3+!ND`4<'V717@4Q`$N%-<9`&(A0&Q)[D,1C%&"I&>^*I.(PK
+M$0:*<Q@`]X1"=R&"&+P%F`FT#C81#48(4?H!_W1AWF&V55>6?;UP:$1KVNV+
+M[#M(ATBZ1-(A4@Z1<HD4$0UNB9G@3R"/NHVH:OB-#"1\!P4XB:BE)ROEJ4K6
+M@4*UP-\U*&H%@@@]5`VIHE5XG-JEIZM:>364BG9P4:`0])#H!NG;CG4$CL;C
+M<:5K3VH08BCB1?H&I?)`&`51%5-/`S9$"38A2"7J%4ATE7C<5#'F'8)&4%>-
+M5AA"&)`!UO1W3*QA@!ZL*:P#&%:O?CU6O_JLKD1%9:O-`XV"^^IA!B*<#O<R
+M%NETN-MP1%=&!UK(V(J.!U^RHK$%';4>F$>@R7RL;>R;CR>22@=):*U'Q7O6
+M0_8`\U&:[$>$RAH0CY2U(.%8D(0%1:$UH4BV-A0):T0ZM%9$O6%'(HG(DKBT
+MQ,*38`9C\F*R.`5#"C69E3!&D6$)C2=,*]`QV1Z6%($<W#2%,N[ID%M[\V2"
+M@)30[(0D8X3Q&JR4PALWL'S.:6::(B6X<:');N$%G$?:AK]$4<1$+HL1VXA<
+M>`IB`3FB:!@;2=%1:(%5<TB9<TTE04M024+A%860HB1$G<2A)1,0BC$115(%
+M>M3!5:62%&K14R-\AA1>(\%CHJH#$X<FID@KC2$R`V;2QF827AB"*JZAKPC2
+M%:$7&0VU"@K[Z(@(W#N=:?/H37:;S:HZ]O`?%*&MD6B/=!-YV@J3)"P]*QE/
+M62&2(R.K<S&D6P"790X8=+/*9ITW$^]/=&;'EW4_%D#+!ABJG&(P^#2&"/W*
+M9Z&/9\!1=)[<9YIU/070QX_Y<LFV_<0%,$>+QX3%8WXY0F2B`QR+&8$5R!MF
+M6L5#^P'.6!`6Z)+W(_;/]8[=I.\RQ#A`B^P*J7O-;M-5S=ZEVSP%?"L>3=@?
+M,*G^'6E^GFT`>(%*%OD64BW?K]E[FOC;C.77JS6@WR,+TU0CI%;$:A`Q?PB(
+MB!P0P4<@HFSQ3QE[9=*O61V*,3H-BS'9^R!CH0^1\688``8[,)HB*-64*!JT
+M9K';8KU;71U6,/;++[^TJ[]@@K&WVW0UOYEFQ1DK=O-Y5A2+W1(*GJ]O-[L2
+M"@)]GRJZYU[6V$L<>[EC+V4,68,[KUT:Z&)Y$\YMC>QK;/\NI#?Q77R)B06?
+M86:=HA`)BJQL-#FH+VE-!HJAIKY!AD[@<!0\!4:@S<'98UL"_C[[@NKN)L./
+MS5V*4W.7(YN<5B8@\(1I4ZJJ(\P=519Y(7"V=5@%S19^L5YE[>S:N9^J=Q;Y
+M$<UCB:A/=@`^MK-`[-D*0.W=IE)C-Q)5-78)P`8Q80A9FR");?HA*&("PA"4
+M@"2E?8V-26@SD04#46`TY7IJ-!:(&$(BTN*`)KE[](+-"D&$J$E9V'@DA`]L
+MRO:BN$GTE/@]9=.9+1-`X!85"$K>@<W]2,9WN)W:$P=_HCY&(-)*)%)6)H`6
+MC50\$6LC!L$0(.%A(QM")A&E:B)IY,.-!>A`]2;BLI$2#R/M",I346P`#@B/
+MRYBV902&!.%W]$^TMCC)BT6BK.`"VL$1%$IBPF2$W:5HL4#"(POIC8Y'$A2$
+MD"Q<)!DF@Q#EKQ54V1B#LQZ&<^?U>)R[3PQ67V(=XE=?1Q?&U*GX9I/Z7KHF
+M^'"[(93R/B]OV/PF75UG!"5LU,RJ,EL5^7K5\^BR^M]F$OA4'F9VN9_9/9O9
+MV9\:S@AI;],BLSQ6&46K=%L_>O0_EOFGZ=EO-?=/@\\QMTZ9\2E;2EJ<_:UH
+M@?;("%0X,@(7:M^1,,<:YI];P^$I,=JC`3</1F.9ZP?&++=5C5^C\:MN^SK:
+M47Y@/I1@/-K`T?_"GKC27]B&(GUX<+?*]%K@)[2GQ!V1H`D$M]B48,>2KJR:
+MK*J;V-#SD&TD^%;.CH0!I4X`P4H&=(!1$Q1LSL3Q5`"$M5T2@L4]HL5OO1U[
+MIU7VGMTBAMVF2^>@_X*EVDLC+U5>*KV4@/H7'(H++^4\2'D8I(F7QD$W>)#*
+M($5JOT?8_2]5C&-!\C#@KY#I;M,->_$4NU]LD@>KU/WV_QZ&.'1#3J.+JFD^
+MXV#Y^UF1_YS1<<49WCSOC/VKIXS/&7LQZS3E-V<)=+"1OQKX12%131=.C3AG
+M_YZ$!W^Z9GG"DR-U>J..Y'V?C7H4G1_9)47ZR`D0B8DD$]31'<?Z'0<(;9@"
+MR<"GVZ@/G]H>.YT=CDB=X]'A!JS2V!U0"%2>M`>B=$\5T%PQXWY"\<&$E+T>
+MX^V1\D/O&>Y_I-PWJ,^WFN1@-3S<6PZ5M2U+6XZ;^M"^\+!IB3]AU;Q/:&Z>
+MI+)QRK%33IPR#S].?'NYM$VDS;Z,7HS3$%./_BUQ!PRI3_PA9?"0[KJ4E]@K
+M+R\RH3V)#8T]MJ6C6KILD89.?7ELCWKM7HZK(#;VB)E.>$5@XN;DFAZ>W==B
+M2\7I=#RQ!^C8EQ$C>S)/-S%WJ%YWYYY0>N^PFI^.!#8*'0T"HTB@$83&AY_6
+MX3_BFE5VUZS]";4^.%BUT`4V?I+]`TX\Q7#BN7]K>GCCJ^^(F5=YL5FF-59U
+M9\S4B)D=7!JZ/*4I;[;KN5/'%MOU+7W8P-P/$";?_.,/?_W^^3=D84<.25F7
+MI"`@>]U3"ZILX_%L.)H^(3GF3`"1H8'<5ARU]S,Z//YYRL]LG95,0*^OQ:1?
+MW>%'$9_ZZUF;<X=U+_9\94_+5V7A=U-_YE0AB6?;(IN7V(GZK$"NVF#R/KS3
+M91V/6'>_S2XOLETEKK-5MDW+]1;\;F%(^6:9S_,RS_`.`%6N5U;FP\]EG0SJ
+M'J8ZJ'NH^Z"ZVVTU/<8J/TBV=._58'M-T/Y!-R]4MK<L=)QG.6?;Z]DPS0:[
+M3*@69O&4'?ZP-+JO`.;?PMD`9HHRGV/B&VP'P&"B?.V;AH&XB\$@=M(SU139
+M;7Z]7<-]4?$N7>ZRAAN7#3OYRJ>'&G-MV7W?:!.A)`='>/HFG?\(\`=T=CN1
+MOF'VH(3Z1Z_8$R;V9]:RN<J691KT\IC$31]]UTJ*[*==MII;)#XV($R?+FZ[
+M7>#1'YB\6'>V;?DY1F,W6U^O\GFVK+^&D1RX0*>O4^I@[(*U&AD+?!!V1T)B
+M'DO1_5TP>U4W-?@+\\BNMUG6*6Z^7EWMYN!LZ;B>-&(<%C+B`Y&>EAA-I1%9
+MYV(FO-R/J,^.>-I!TV_1X?X?U<=/;?=%T.^P?HT['R,N1^FBO53VZ2%H"];?
+M.QLY6%R74@9#ZVH^,G^?W#J=3MD6S'V9W9%JOMNS&)+U2VNM\HL,&0Z60=_7
+M'>3@*73T+IO#6HW/(U]B\R!]+LR9WS8(O_]#5J.5GVA?A+&OA/+C"%,RH?:E
+MXCVL,]&QVSX#+#,VW@'<1EYM1NCSJ&L?0;F1M?UN!#/8T0`D!DMRP,7];&DO
+M6"T+%Q!&-D8%]N1/TA=?M0YJ0Q3#.!88=FH-?=TKBY)CIRN(N]=6Y)-VL_G-
+M&DL.!]G%E\?`VG56KFY]]N+-"_AE09D7+WST)MRW']?98N&S$0XTR1BL(60L
+ML[P$N/MIEVZS!>*6S]+ETGV%<M^07_F@7F1;"DTM9!NQCL,!K-FI#JJPKQ_6
+M0NO2)`OGFU[6*0'U4`-]%!601RG;9%E;P0L6]<8?(RPZ<FKV/#ZW!R&5LZ.+
+M$;5<$7;7Y1VI=$@1MESYMCP#;-%AE?;%T7[M?M/;<5"#P8XD.0AJ+."/2K$D
+ML1&;*>FN\WOZU&5P==F7(Y_W9>.'9^2>S5=GLCG?-H-LX>_6M"BV8I=$[B`"
+M^X5<W0FN#PZQ=M=L;<U=K:VX>YTGO+,)]RV'::WMQP)B.)/7?A_I1+\RY=MO
+MET'0D=9J6)<33P;S=S)37_<@Q;AG]`Z/*=E69V+C>M3R<96UQ7$5EDB5>(SJ
+MIQ6XOI;(^P&>Z$?>WE92)%VNBW*"MB.=U+C3L.VWS4WCA&#%L&&-XT%DHZ`Q
+M2&U4_;!`;([MS)NYFG:N<=^RG#D+HG``+&#7`;H&W["WV3S=%1DS[&J=%6RU
+M+H$8W^57&4"7%<EXLM.%OVQ$@6JV2.<6'#K":&'3GDB2%I`]GUF_LQY(U#X&
+M2I=V1</Q<Q)>]N%U^GQP3#@CA2GC1!2:81=3[!%+;>">+3B@;Z([EMS])QE(
+3K$]_-^%'_IW&?P`(#+9S/C(`````
 `
 end

Tst/Short/hnoether_s.stat

@@ -1 +1 @@
 Status Output of tst_status.out
-init >> USER    :obachman
+init >> USER    :hannes
 init >> HOSTNAME:nepomuck.mathematik.uni-kl.de
-init >> uname -a:Linux nepomuck.mathematik.uni-kl.de 2.0.33 #1 Wed Jan 21 18:50:57 MET 1998 i586 unknown
-init >> date    :Fri Jul 10 18:03:01 MET DST 1998
-init >> version :1200
+init >> uname -a:Linux nepomuck.mathematik.uni-kl.de 2.0.33 #1 Wed Jan 21 18:50:57 MET 1998 i686 unknown
+init >> date    :Tue Apr 13 15:25:18 MET DST 1999
+init >> version :1302
 init >> ticks   :100
-1 >> tst_memory_0 :: urmel:421708  nepomuck.mathematik.uni-kl.de:397222
-1 >> tst_memory_1 :: urmel:355148  nepomuck.mathematik.uni-kl.de:355958
-1 >> tst_memory_2 :: urmel:606208  nepomuck.mathematik.uni-kl.de:401408
-1 >> tst_timer_1 :: urmel:1882  nepomuck.mathematik.uni-kl.de:616
+1 >> tst_memory_0 :: nepomuck.mathematik.uni-kl.de:228005
+1 >> tst_memory_1 :: nepomuck.mathematik.uni-kl.de:314357
+1 >> tst_memory_2 :: nepomuck.mathematik.uni-kl.de:385024
+1 >> tst_timer_1 :: nepomuck.mathematik.uni-kl.de:326

Tst/Short/hnoether_s.tst

@@ -63 +63 @@
 example displayHNE;
 // ----------------------------------------------------------------------------
-// ------- test of invariants, displayInvariants, generators, intersection, ---
-// -------         stripHNE, puiseux2generators, multiplicities, newtonpoly ---
+// ------- test of invariants, displayInvariants, intersection, stripHNE,   ---
+// -------         puiseux2generators, multiplicities, newtonpoly           ---
 example invariants;
 example displayInvariants;
-example generators;
 list hne=reddevelop((x2-y3)*(x2+y3));
 intersection(hne[1],hne[2]);
@@ -76 +75 @@
 example newtonpoly;
 // ------- test of getnm, T_Transform, T1_Transform, T2_Transform, koeff, -----
-// -------         redleit, squarefree, allsquarefree, set_list           -----
+// -------  redleit, squarefree, allsquarefree, set_list, referencepoly   -----
 example getnm;
 T_Transform(y2+x3,1,2);
 T1_Transform(y-x2+x3,1,2);
-T2_Transform(y2+x3,-1,3,2);
+T2_Transform(y2+x3,-1,3,2,y2+x3);
+example referencepoly;
 koeff(x2+2xy+3xy2-x2y-2y3,1,2);
 example redleit;