Index: Singular/LIB/brnoeth.lib
===================================================================
--- Singular/LIB/brnoeth.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/brnoeth.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -4398,5 +4398,5 @@
   int m=deg_D(G,Places);
   int genusX=EC[2][2];
-  int e=(m+1-3*genusX)/2;
+  int e=(m+1-3*genusX) div 2;
   if (e<1)
   {
@@ -4559,5 +4559,5 @@
       // on the other hand, if Hamming_wt(sol) is too large the decoding may
       //     not be acceptable
-      if ( Hamming_wt(sol) <= (K[n+3][2]-1)/2 )
+      if ( Hamming_wt(sol) <= (K[n+3][2]-1) div 2 )
       {
         option(set,opgt);
Index: Singular/LIB/classify.lib
===================================================================
--- Singular/LIB/classify.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/classify.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -1954,5 +1954,5 @@
 "USAGE:    parity()"
 {
-  int r = e/2;
+  int r = e div 2;
   if( 2*r == e ) { return(0); }
   return(1);
@@ -2000,5 +2000,5 @@
     if( parity(sg[2])) { // sg[2] ist ungerade
       if(sg[2]<=sg[3]) {
-        k = (sg[2]+1)/2;
+        k = (sg[2]+1) div 2;
         if(k>1) {
           cnt++;
@@ -2007,5 +2007,5 @@
       }
       if(sg[2]==sg[3]+2) {                              // E[6k+2]
-        k = (sg[2]-1)/2;
+        k = (sg[2]-1) div 2;
         if(k>0) {cnt++; SG_Typ=SG_Typ+" E[6k+2]=E[" + string(6*k+2) + "]"; }
       }
@@ -2013,7 +2013,7 @@
     else {              // sg[2] ist gerade
       if( sg[2] == sg[3]+1) {                           // E[6k]
-        k = sg[2]/2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]"; }
+        k = sg[2] div 2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]"; }
       if( sg[2] == sg[3]) {                             // E[6k+1]
-        k=sg[2]/2; cnt++; SG_Typ=SG_Typ+" E[6k+1]=E["+string(6*k+1)+"]"; }
+        k=sg[2] div 2; cnt++; SG_Typ=SG_Typ+" E[6k+1]=E["+string(6*k+1)+"]"; }
     }
   }
@@ -2044,5 +2044,5 @@
   debug_log(2, "entering HKclass5_teil_1", sg);
   if(parity(sg[3])) {  // Dritte Stelle soll ungerade sein
-    k = (sg[3]+1)/2;
+    k = (sg[3]+1) div 2;
     if(sg[3] > sg[4]) {
       k--;
@@ -2066,5 +2066,5 @@
       if( sg[4] == sg[5]) {
         if(parity(sg[4])) {                                  // Z[k,r,0]
-          r = (sg[4] - sg[3])/2;
+          r = (sg[4] - sg[3]) div 2;
           if( r>0 ) { cnt++;
             SG_Typ = SG_Typ + " Z[k,r,0]=Z["+string(k)+","+string(r)+",0]";
@@ -2072,5 +2072,5 @@
         }
         else {                                                // Z[k,12k+6r]
-          r = (sg[4] - 2*k)/2; cnt++;
+          r = (sg[4] - 2*k) div 2; cnt++;
           SG_Typ = SG_Typ+" Z[k,12k+6r]=Z["+string(k)+","+string(12*k+6*r)+"]";
         }
@@ -2079,10 +2079,10 @@
       if( parity(sg[4]) ) {  // 4. Stelle ist ungerade
         if(sg[4] == sg[5]+2) {                              // Z[k,12k+6r+1]
-          r = (sg[4]-2*k-1)/2; cnt++;
+          r = (sg[4]-2*k-1) div 2; cnt++;
           SG_Typ=SG_Typ+" Z[k,12k+6r+1]=Z["+string(k)+",";
           SG_Typ=SG_Typ+string(12*k+6*r+1)+"]";
        }
        if( (sg[5]>sg[4]) && (sg[4]>sg[3]) ) {           // Z[k,r,s]
-          r = (sg[4] - sg[3])/2; cnt++;
+          r = (sg[4] - sg[3]) div 2; cnt++;
           s = sg[5] - sg[4];
           SG_Typ = SG_Typ + " Z[k,r,s]=";
@@ -2092,5 +2092,5 @@
       else {  // 4. Stelle ist gerade
         if( sg[4] == sg[5]+1) {                             // Z[k,12k+6r-1]
-          r = (sg[4] - 2*k)/2; cnt++;
+          r = (sg[4] - 2*k) div 2; cnt++;
           SG_Typ=SG_Typ+" Z[k,12k+6r-1]=Z["+string(k)+",";
           SG_Typ=SG_Typ+string(12*k+6*r-1)+"]";
@@ -2108,5 +2108,5 @@
   }
   else {  // Dritte Stelle soll gerade sein
-    k = sg[3]/2;
+    k = sg[3] div 2;
     // sortiere verschiedene W's
     if(k>0) {
@@ -2157,16 +2157,16 @@
     if(parity(sg[4])) { // 4. Stelle ist ungerade.
       if(sg[4]==sg[5]) {                                // Q[6k+4]
-        k=(sg[4]+1)/2; cnt++; SG_Typ=SG_Typ+" Q[6k+4]=Q["+string(6*k+4)+"]";
+        k=(sg[4]+1) div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+4]=Q["+string(6*k+4)+"]";
       }
       if(sg[4]+1==sg[5]) {                      // Q[6k+5]
-        k=sg[5]/2; cnt++; SG_Typ=SG_Typ+" Q[6k+5]=Q["+string(6*k+5)+"]";
+        k=sg[5] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+5]=Q["+string(6*k+5)+"]";
       }
     }
     else { // 4. Stelle ist gerade.
       if(sg[4]==sg[5]+1) {                      // Q[6k+6]
-        k=sg[4]/2; cnt++; SG_Typ=SG_Typ+" Q[6k+6]=Q["+string(6*k+6)+"]";
+        k=sg[4] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+6]=Q["+string(6*k+6)+"]";
       }
       if(sg[4]<sg[5]) {                 // Q[k,r]
-        k = (sg[4]+2)/2;
+        k = (sg[4]+2) div 2;
         if(k>=2) {
           r=sg[5]+1-2*k; cnt++;
@@ -2178,5 +2178,5 @@
   else {           // S[...]
     if(parity(sg[3])) {  // 3. Stelle ist ungerade.
-      k = (sg[3]-1)/2;
+      k = (sg[3]-1) div 2;
       if(sg[3]==sg[4]+3 && sg[3]==sg[5]+2) {    // S[12k-1]
         cnt++; SG_Typ = SG_Typ + " S[12k-1]=S["+string(12*k-1)+"]";
@@ -2200,9 +2200,9 @@
     else { // 3. Stelle ist gerade.
       if(sg[3]==sg[5]+1 && sg[5]==sg[4]+3) {    // S[12k+4]
-        k = (sg[3]-2)/2; cnt++;
+        k = (sg[3]-2) div 2; cnt++;
         SG_Typ = SG_Typ + " S[12k+4]=S["+string(12*k+4)+"]";
       }
       if(sg[3]==sg[5]+2 && sg[5]==sg[4]+1) {    // S[12k+5]
-        k = (sg[3]-2)/2; cnt++;
+        k = (sg[3]-2) div 2; cnt++;
         SG_Typ = SG_Typ + " S[12k+5]=S["+string(12*k+5)+"]";
       }
@@ -2707,5 +2707,5 @@
     if( t > 1 ) {
       i = k;
-      k = k/t;
+      k = k div t;
       b = i - t*k;
       if( (s1 == "Q[") && (b==0) ) { k=k-1; b=6; }
@@ -2745,5 +2745,5 @@
       if(Typ[2] == "#") {
         i = r+1;
-        r = i/2;
+        r = i div 2;
         b = i - 2*r;
         if( b == 1 ) { s4 = "2r"; }
Index: Singular/LIB/dmod.lib
===================================================================
--- Singular/LIB/dmod.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/dmod.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -1512,5 +1512,5 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -1588,5 +1588,5 @@
   temp[1] = nL[1];
   temp[4] = nL[4];
-  int @n = int((nvars(@R2)-1)/2); // # of x's
+  int @n = int((nvars(@R2)-1) div 2); // # of x's
   int i;
   for (i=1; i<=@n; i++)
@@ -1707,5 +1707,5 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -4790,5 +4790,5 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -5660,5 +5660,5 @@
   int N = nvars(basering);
   int Nnew = N-1;
-  int n = Nnew / 2;
+  int n = Nnew div 2;
   int i;
   string s;
@@ -5800,5 +5800,5 @@
   def save = basering;
   int N = nvars(basering);
-  int n = (N-1) / 2;
+  int n = (N-1) div 2;
   int i;
   string s;
@@ -6111,5 +6111,5 @@
   def @R2 = basering;
   int Nnew = nvars(@R2);
-  int N = Nnew/2;
+  int N = Nnew div 2;
   int ppl = printlevel-voice+2;
   // we're in D_n[s], where the elim ord for s is set
Index: Singular/LIB/equising.lib
===================================================================
--- Singular/LIB/equising.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/equising.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -1526,5 +1526,5 @@
     for (j=1;j<=ncols(Mult);j++)
     {
-      conditions=conditions+(Mult[i,j]*(Mult[i,j]+1)/2);
+      conditions=conditions+(Mult[i,j]*(Mult[i,j]+1) div 2);
     }
   }
Index: Singular/LIB/finvar.lib
===================================================================
--- Singular/LIB/finvar.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/finvar.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -276,5 +276,5 @@
             o2++;
           }
-          o1=o1*o2/gcd(o1,o2);         // lowest common multiple of the element
+          o1=o1*o2 div gcd(o1,o2);         // lowest common multiple of the element
         }                              // orders -
         REY=concat(REY,P(k)*vars);     // adding new mapping to REY
Index: Singular/LIB/mondromy.lib
===================================================================
--- Singular/LIB/mondromy.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/mondromy.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -319,5 +319,5 @@
   list b=pcvbasis(N-of+2,N+dN-of+2);
   list P2;
-  P2[size(b)*((nvars(basering)-1)*nvars(basering))/2]=0;
+  P2[size(b)*((nvars(basering)-1)*nvars(basering)) div 2]=0;
   int i,j,k,l;
   intvec alpha;
Index: Singular/LIB/monomialideal.lib
===================================================================
--- Singular/LIB/monomialideal.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/monomialideal.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -3277,5 +3277,5 @@
         else
         {
-          median = xiexp[(size(xiexp) + 1) / 2];
+          median = xiexp[(size(xiexp) + 1) div 2];
         }
       }
Index: Singular/LIB/nctools.lib
===================================================================
--- Singular/LIB/nctools.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/nctools.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -1589,5 +1589,5 @@
   int N = nvars(basering);
   if (N mod 2 <> 0) { return(notW); } // odd number of generators
-  int n = N/2;
+  int n = N div 2;
   list L = ringlist(basering);
   if (size(L) < 6) { return(notW); } // basering is commutative
Index: Singular/LIB/primdec.lib
===================================================================
--- Singular/LIB/primdec.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/primdec.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -476,5 +476,5 @@
         {
           f=f*char(basering);
-          e=e/char(basering);
+          e=e div char(basering);
         }
       }
Index: Singular/LIB/tst.lib
===================================================================
--- Singular/LIB/tst.lib	(revision 4173c743f8fca0f499b55fc60e21623199cb2dac)
+++ Singular/LIB/tst.lib	(revision 85ba0aaf4c7c467f1fa0dbf0a8b22f8cc10cf672)
@@ -746,5 +746,5 @@
     if (products[i] > 1 && products[i] <= n_vars)
     {
-      nn_vars = n_vars / products[i];
+      nn_vars = n_vars div products[i];
       nb_orderings = tst_rgen_generate_blocks(nn_vars, simple_orderings, extra_weights);
       for (j=1; j<=size(nb_orderings); j++)
