Index: Singular/LIB/algebra.lib
===================================================================
--- Singular/LIB/algebra.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/algebra.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -76,5 +76,5 @@
     //-----------------
     // ---------- create new ring with extra variables --------------------
-    list l3;  
+    list l3;
     for (int zz = 1; zz <= n; zz++)
     {
@@ -188,5 +188,5 @@
   { int m=ncols(S);
   // ---------- create new ring with extra variables --------------------
-    list l4;  
+    list l4;
     for (int xx = 1; xx <= n; xx++)
     {
@@ -295,5 +295,5 @@
   //the intersection of ideal nett=(p-y(0),I[1]-y(1),...)
   //with the ring k[y(0),...,y(n)] is computed, the result is ker
-  list l5;  
+  list l5;
   for (int xx = 1; xx <= n; xx++)
   {
@@ -390,5 +390,5 @@
     if ( tt == 1 )
     {
-      list l6;  
+      list l6;
       for (@xx = 1; @xx <= m; @xx++)
       {
@@ -402,5 +402,5 @@
     }
  // ---------- create new ring with extra variables --------------------
-    list l7;  
+    list l7;
     for (@xx = n; @xx >= 1; @xx--)
     {
@@ -436,5 +436,5 @@
  // order
        {
-        list l8;  
+        list l8;
         for (@xx = n; @xx >=1; @xx--)
         {
@@ -542,5 +542,5 @@
     // algDependent is called with "bestoption" if tt = 0
     def S = L[2];
-    list l9;  
+    list l9;
     for (int xx = 1; xx <= n; xx++)
     {
@@ -694,5 +694,5 @@
     int ii,t=1,1;
   // ------------ create new ring with extra variables ---------------------
-    list l10;  
+    list l10;
     for (int yy = 1; yy <= n; yy++)
     {
@@ -774,5 +774,5 @@
     int ii,t = 1,1;
   // ------------ create new ring with extra variables ---------------------
-    list l11;  
+    list l11;
     for (int yy = 1; yy <= n; yy++)
     {
@@ -1099,5 +1099,5 @@
 
   // --------------------------- enlarging ring -----------------------------
-  list l12;  
+  list l12;
   for (int yy = 1; yy <= m; yy++)
   {
Index: Singular/LIB/autgradalg.lib
===================================================================
--- Singular/LIB/autgradalg.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/autgradalg.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -1247,5 +1247,5 @@
   for (ii = 1; ii <= n0; ii++)
   {
-   l3[ii] = "T("+string(ii)+")"; 
+   l3[ii] = "T("+string(ii)+")";
   }
   for (ii = 1; ii <= n0*n; ii++)
@@ -1805,5 +1805,5 @@
   for (ii = 1; ii <= n0; ii++)
   {
-   l4[ii] = "T("+string(ii)+")"; 
+   l4[ii] = "T("+string(ii)+")";
   }
   for (ii = 1; ii <= n1; ii++)
@@ -3060,5 +3060,5 @@
   for (int ii = 1; ii <= size(V); ii++)
   {
-   l5[ii] = "T("+string(ii)+")"; 
+   l5[ii] = "T("+string(ii)+")";
   }
   ring S = create_ring(ring_list(RR)[1], l5, "dp", "no_minpoly");
Index: Singular/LIB/customstd.lib
===================================================================
--- Singular/LIB/customstd.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/customstd.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -67,5 +67,5 @@
 NOTE:    The result is a standard basis of a partially saturated ideal wrt. the
          the variables in J.
-	 If the I is homogeneous and the ordering dp, the result is completely 
+	 If the I is homogeneous and the ordering dp, the result is completely
 	 saturated wrt. to the last variable (wrt. to the first for Dp).
 KEYWORDS: standard bases, saturation
Index: Singular/LIB/dmod.lib
===================================================================
--- Singular/LIB/dmod.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/dmod.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -697,5 +697,5 @@
   return(@R2);
   string  strr1 = "Printing from ALTannfsBM";     // comment by sachin
-  strr1;    // comment by sachin  
+  strr1;    // comment by sachin
 }
 example
@@ -4304,6 +4304,6 @@
   // continue with dp 1,1,1,1...
   tmp[1] = "dp";  // string
-  iv=1:Nnew; 
-  kill s; 
+  iv=1:Nnew;
+  kill s;
   kill NName;
   tmp[2]      = iv;
@@ -4605,8 +4605,8 @@
 @*           for the given rational number n
 ASSUME: basering is commutative, the number n is rational.
-NOTE: Activate the output ring by @code{setring} command. 
+NOTE: Activate the output ring by @code{setring} command.
 In the ring the ideal called @code{annfalpha} is exported.
 @* We compute the real annihilator for any rational value of n (both
-@*    generic and exceptional). The implementation fixes a bug in 
+@*    generic and exceptional). The implementation fixes a bug in
 @*    the Algorithm 5.3.15 from Saito-Sturmfels-Takayama.
 DISPLAY: If printlevel=1, progress debug messages will be printed,
@@ -4615,5 +4615,5 @@
 "
 {
-   // using dmodideal.lib 
+   // using dmodideal.lib
   ideal f = F;
   ideal alpha = n;
@@ -4625,8 +4625,8 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  poly F = x3-y2;  
-  bernsteinBM(F); // the roots of Bernstein-Sato poly: -7/6, -1, -5/6 
+  poly F = x3-y2;
+  bernsteinBM(F); // the roots of Bernstein-Sato poly: -7/6, -1, -5/6
   // *** first example: generic root
-  def A = annfspecial(F,-5/6); 
+  def A = annfspecial(F,-5/6);
   setring A; print(annfalpha); kill A; setring r;
   // *** second example:  exceptional root since its distance to -1 is integer 2
Index: Singular/LIB/dmodapp.lib
===================================================================
--- Singular/LIB/dmodapp.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/dmodapp.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -137,5 +137,5 @@
   - changed charVariety: no homogenization is needed
   - changed inForm: code is much simpler using jet
- 
+
   06.04.20 by VL:
   - engine updated with 2 more modular choices
@@ -300,5 +300,5 @@
       // modular slimgb with final exactness check
       J = ncmodslimgb(I,1);
-  } 
+  }
   return(J);
 }
Index: Singular/LIB/dmodvar.lib
===================================================================
--- Singular/LIB/dmodvar.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/dmodvar.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -141,5 +141,5 @@
    l1[size(l1)+1] = "z("+string(zz)+")";
   }
-  ring @Z = create_ring(0, l1, ORD);   
+  ring @Z = create_ring(0, l1, ORD);
   list L = ringlist(@Z)[3];
   kill @Z;
Index: Singular/LIB/equising.lib
===================================================================
--- Singular/LIB/equising.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/equising.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -509,5 +509,5 @@
       else // no minpoly given
       {
-        list l5;  
+        list l5;
         for (int zz = 1; zz <= npars(basering); zz++)
         {
@@ -1276,5 +1276,5 @@
   {
     ideal qIdeal = ideal(basering);
-    ring ESSring = create_ring("("+ string(char(basering))+ "," + parstr(myRing) +")", "("+ varstr(basering)+")", "("+ ordstr(basering) +")"); 
+    ring ESSring = create_ring("("+ string(char(basering))+ "," + parstr(myRing) +")", "("+ varstr(basering)+")", "("+ ordstr(basering) +")");
     execute(minPolyStr);
     // basering has changed to ESSring
Index: Singular/LIB/ffsolve.lib
===================================================================
--- Singular/LIB/ffsolve.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/ffsolve.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -854,5 +854,5 @@
 
   def ring_for_var_change = addNvarsTo(original_ring, number_of_monomials, "@y", 2);
- 
+
   setring ring_for_var_change;
   if( prime_field == 0)
Index: Singular/LIB/finvar.lib
===================================================================
--- Singular/LIB/finvar.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/finvar.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -439,5 +439,5 @@
     }
     if (minpoly<>0 && mol_flag==0)
-    { 
+    {
       if (v)
       { "  Since it is impossible for this program to calculate the Molien series for";
@@ -710,8 +710,8 @@
         {
           rl[1][1]=0;
-        }  
+        }
         def newring=ring(rl);
         setring newring;
-        
+
       }
     }
@@ -728,5 +728,5 @@
       {
         rl[1][1]=0;
-      }  
+      }
       def newring=ring(rl);
       setring newring;
@@ -1106,5 +1106,5 @@
     if (minpoly==0)
     { if (i>size(chst))
-      { 
+      {
          ring newring = create_ring(0, "("+varstr(br)+")", "("+ordstr(br)+")");
       }
@@ -1119,7 +1119,7 @@
         {
           rl[1][1]=0;
-        }  
+        }
         def newring=ring(rl);
-        setring newring; 
+        setring newring;
       }
     }
@@ -1136,7 +1136,7 @@
       {
         rl[1][1]=0;
-      }  
+      }
       def newring=ring(rl);
-      setring newring;  
+      setring newring;
       execute("minpoly="+minp);
     }
Index: Singular/LIB/freegb.lib
===================================================================
--- Singular/LIB/freegb.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/freegb.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -2865,5 +2865,5 @@
 RETURN: list L
 NOTE: - L[1] is NF(p,I)
-      - L[2] is the list of expressions [i,l_(ij),r_(ij)] with \sum_(i,j) l_(ij) g_i r_(ij) = p - NF(p,I) 
+      - L[2] is the list of expressions [i,l_(ij),r_(ij)] with \sum_(i,j) l_(ij) g_i r_(ij) = p - NF(p,I)
       - procedure lpGBPres2Poly, applied to L, reconstructs p
 EXAMPLE: example lpDivision; shows examples
@@ -2937,5 +2937,5 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  ring R = freeAlgebra(r, 4); 
+  ring R = freeAlgebra(r, 4);
   ideal I = x*x + y*y - 1; // 2D sphere
   ideal J = twostd(I); // compute a two-sided Groebner basis
@@ -2967,10 +2967,10 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  ring R = freeAlgebra(r, 4); 
+  ring R = freeAlgebra(r, 4);
   ideal I = x*x + y*y - 1; // 2D sphere
   ideal J = twostd(I); // compute a two-sided Groebner basis
   J; // it is finite and nice
   poly h = x*x*y-y*x*x+x*y;
-  list L = lpDivision(h,J); 
+  list L = lpDivision(h,J);
   L[1]; // what means that the normal form (or the remainder) of h wrt J is x*y
   lpGBPres2Poly(L,J); // we see, that it is equal to h from above
@@ -3785,5 +3785,5 @@
 }
 
-proc testLift(ideal M, matrix T) 
+proc testLift(ideal M, matrix T)
 "USAGE: testLift(M,T); module M, matrix T
 RETURN: module
Index: Singular/LIB/gmssing.lib
===================================================================
--- Singular/LIB/gmssing.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/gmssing.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -196,5 +196,5 @@
   }
 
-  ring G = create_ring(string(charstr(@R)), "("+s+","+varstr(@R)+")", "(ws("+string(deg(highcorner(g))+2*gmsmaxdeg)+"),"+os+",c)"); 
+  ring G = create_ring(string(charstr(@R)), "("+s+","+varstr(@R)+")", "(ws("+string(deg(highcorner(g))+2*gmsmaxdeg)+"),"+os+",c)");
 
   poly gmspoly=imap(@R,t);
Index: Singular/LIB/hnoether.lib
===================================================================
--- Singular/LIB/hnoether.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/hnoether.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -2937,5 +2937,5 @@
     string pa=parstr(altring);
     list rl=ringlist(altring);
-    rl=rl[1]; rl[1]=p; 
+    rl=rl[1]; rl[1]=p;
     ring HNhelpring=ring(rl);
     execute("poly mipo="+mipl+";");  // Minimalpolynom in Polynom umgewandelt
Index: Singular/LIB/involut.lib
===================================================================
--- Singular/LIB/involut.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/involut.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -602,5 +602,5 @@
   if (Par=="") // if there are no parameters
   {
-    ring @@@KK = create_ring(0, "("+varstr(@B)+","+@ss+")", "dp"); //new ring with new variables 
+    ring @@@KK = create_ring(0, "("+varstr(@B)+","+@ss+")", "dp"); //new ring with new variables
   }
   else //if there exist parameters
@@ -656,9 +656,9 @@
   if ( Par=="" ) //initializes the ring of relations
   {
-    ring @@KK = create_ring(0, "("+@ss+")", "dp"); 
+    ring @@KK = create_ring(0, "("+@ss+")", "dp");
   }
   else
   {
-    ring @@KK = create_ring("(0,"+Par+")", "("+@ss+")", "dp");  
+    ring @@KK = create_ring("(0,"+Par+")", "("+@ss+")", "dp");
   }
 
@@ -812,5 +812,5 @@
   if (( Par=="" ) && (n!=0)) //initializes the ring of relations
   {
-    ring @@KK = create_ring(0, "("+@ss+")", "dp"); 
+    ring @@KK = create_ring(0, "("+@ss+")", "dp");
   }
   if (( Par=="" ) && (n==0)) //initializes the ring of relations
@@ -820,5 +820,5 @@
   if ( Par!="" )
   {
-    ring @@KK = create_ring("(0,"+Par+")", "("+@ss+")", "dp"); 
+    ring @@KK = create_ring("(0,"+Par+")", "("+@ss+")", "dp");
   }
   //  basering;
Index: Singular/LIB/moddiq.lib
===================================================================
--- Singular/LIB/moddiq.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/moddiq.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -12,6 +12,6 @@
 
 REFERENCES:
-  M. Noro, K. Yokoyama: Usage of Modular Techniques for Efficient Computation of Ideal Operations. 
-  Math.Comput.Sci. 12: 1, 1-32. (2017). 
+  M. Noro, K. Yokoyama: Usage of Modular Techniques for Efficient Computation of Ideal Operations.
+  Math.Comput.Sci. 12: 1, 1-32. (2017).
 
 PROCEDURES:
@@ -49,5 +49,5 @@
     ring r=0,x(1..6),dp;
     ideal i=cyclic(6);
-    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6); 
+    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6);
     modQuotient(i,modQuotient(i,j));
     ideal id2=x(1)^2+x(1)*x(2)*x(3),x(2)^2-x(3)^3*x(2),x(3)^3+x(2)^5*x(1)*x(3);
@@ -55,5 +55,5 @@
 }
 
-/* test if a prime number p is permissible for an ideal I 
+/* test if a prime number p is permissible for an ideal I
  * i.e. it does not divide the denominator of any of the coefficients
  * or numerator of any of the leading coefficients */
@@ -130,5 +130,5 @@
         }
     }
-    
+
     /* test if Gp is in (Ip:Jp) */
     ideal GpJp=Gp*Jp;
@@ -175,5 +175,5 @@
     ring r=0,x(1..6),dp;
     ideal i=cyclic(6);
-    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6); 
+    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6);
     modSat(i,modSat(i,j)[1])[1];
     poly F     = x(1)^5+x(2)^5+(x(1)-x(2))^2*x(1)*x(2)*x(3);
@@ -190,5 +190,5 @@
 /* find entries in modresults which come from unlucky primes.
  * For this, sort the entries into categories depending on their leading
- * ideal and return the indices in all but the biggest category. 
+ * ideal and return the indices in all but the biggest category.
  * Referring to Modstd::deleteUnlickyPrimes_std. */
 static proc deleteUnluckyPrimes_sat(alias list modresults)
@@ -290,5 +290,5 @@
         }
     }
-    
+
     /* test if Gp is in (Ip:Jp^\infty) */
     for (i = ncols(Gp); i > 0; i--)
Index: Singular/LIB/ncModslimgb.lib
===================================================================
--- Singular/LIB/ncModslimgb.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/ncModslimgb.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -6,5 +6,5 @@
                          defined over the rationals using modular techniques.
 
-AUTHORS: Wolfram Decker, Christian Eder, Viktor Levandovskyy, and 
+AUTHORS: Wolfram Decker, Christian Eder, Viktor Levandovskyy, and
 Sharwan K. Tiwari shrawant@gmail.com
 
@@ -45,5 +45,5 @@
 NOTE:  - If the given algebra and ideal are graded (it is not checked by this command), then the computed Groebner
 basis will be exact. Otherwise, the result will be correct with a very high probability.
-- The optional parameter `exactness` justifies, whether the final (expensive) 
+- The optional parameter `exactness` justifies, whether the final (expensive)
 verification step will be performed or not (exactness=0, default value is 1).
 - The optional parameter `ncores` (default value is 1) provides an integer to use
Index: Singular/LIB/ncrat.lib
===================================================================
--- Singular/LIB/ncrat.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/ncrat.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -728,5 +728,5 @@
     }
   }
-  s = s + ")"; 
+  s = s + ")";
   ring NCRING = create_ring("(0, I)", s, "dp");
   minpoly = I^2+1;
Index: Singular/LIB/numerDecom.lib
===================================================================
--- Singular/LIB/numerDecom.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/numerDecom.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -611,5 +611,5 @@
          l2[size(l2)+1] = "z("+string(ii)+")";
         }
-        ring T(qq) = create_ring("(complex,16,I)", l2, "dp"); 
+        ring T(qq) = create_ring("(complex,16,I)", l2, "dp");
         list W(qq-1)=var(1);
        }
Index: Singular/LIB/pfd.lib
===================================================================
--- Singular/LIB/pfd.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/pfd.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -16,5 +16,5 @@
 matrix of rational functions given as one (possibly very big) txt-file.
 If you use the library pfd.lib, please cite the corresponding paper
-[J. Boehm, M. Wittmann, Z. Wu, Y. Xu, Y. Zhang: 'IBP reduction coefficients 
+[J. Boehm, M. Wittmann, Z. Wu, Y. Xu, Y. Zhang: 'IBP reduction coefficients
 made simple'] (preprint 2020).
 
Index: Singular/LIB/primdec.lib
===================================================================
--- Singular/LIB/primdec.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/primdec.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -4042,5 +4042,5 @@
    ideal F=imap(R,F);
 
-   list l2;  
+   list l2;
    for (int zz = 1; zz <= m; zz++)
    {
Index: Singular/LIB/ratgb.lib
===================================================================
--- Singular/LIB/ratgb.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/ratgb.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -297,5 +297,5 @@
   def LGG = groebner(LG); // cosmetics
   int d = dim(LGG);
-  int Ddim = d; 
+  int Ddim = d;
   dbprint(ppl,"the D-dimension is "+string(d));
   export Ddim;
Index: Singular/LIB/realclassify.lib
===================================================================
--- Singular/LIB/realclassify.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/realclassify.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -273,5 +273,5 @@
           a1=int(a);
           b1=int(b);
-          t1=int(t);          
+          t1=int(t);
           g1=gcd(gcd(a1,b1),t1 div a1);
           setring C;
Index: Singular/LIB/resolve.lib
===================================================================
--- Singular/LIB/resolve.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/resolve.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -734,5 +734,5 @@
     l3[size(l3)+1] = "y("+string(ii)+")";
    }
-   ring S = create_ring(ring_list(R)[1], l3, "dp", "no_minpoly"); 
+   ring S = create_ring(ring_list(R)[1], l3, "dp", "no_minpoly");
    list resu;
    list B;
Index: Singular/LIB/surfex.lib
===================================================================
--- Singular/LIB/surfex.lib	(revision 8eeddafc83e9d052d7ffa21597c4229513b7e886)
+++ Singular/LIB/surfex.lib	(revision e782369abe3cd5d544d0c0f9686417b8b300be19)
@@ -286,5 +286,5 @@
                                     string str_num_mp = "number "+parstr(1)+"="+
                                         decstr2ratstr(rootminpoly())+";";
-                                    ring Iring = create_ring(0, "("+string(coords)+")", "dp"); 
+                                    ring Iring = create_ring(0, "("+string(coords)+")", "dp");
                                     basering;
                                     execute(str_num_mp);
@@ -306,5 +306,5 @@
                             string str_tmp_l = "ideal eqd_tmp = "+string(tmp_l)+";";
                             def cur_ring = basering;
-                            ring Iring = create_ring("(real,30)", "("+string(coords)+")", "("+ordstr(oring)+")"); 
+                            ring Iring = create_ring("(real,30)", "("+string(coords)+")", "("+ordstr(oring)+")");
 //                            basering;
                             execute(str_I);
