Index: Singular/Makefile.in
===================================================================
--- Singular/Makefile.in	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/Makefile.in	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -82,11 +82,11 @@
     mpsr_Put.cc mpsr_PutPoly.cc mpsr_Tok.cc mpsr_GetPoly.cc \
     mpsr_Get.cc mpsr_GetMisc.cc mpsr_Error.cc \
-    ndbm.cc spSpolyLoop.cc libparse.cc mod_raw.cc\
-	pcv.cc
+    ndbm.cc spSpolyLoop.cc libparse.cc mod_raw.cc \
+    pcv.cc kbuckets.cc kbPolyProcs.cc
 
 CSOURCES=gmalloc.c mmalloc.c mmheap.c mmpage.c mmcheck.c  mmisc.c mmtables.c \
     mmbt.c weight0.c find_exec.c getopt.c fereadl.c page.c
 
-SOURCES=${CSOURCES} ${CXXSOURCES} grammar.y scanner.l libparse.l spSpolyLoop.pl
+SOURCES=${CSOURCES} ${CXXSOURCES} grammar.y scanner.l libparse.l spSpolyLoop.pl generate.pl
 
 HEADERS=algmap.h hutil.h lists.h stairc.h attrib.h ideals.h \
@@ -103,5 +103,5 @@
 	kutil.h mpsr_Put.h spolys0.h sing_dld.h\
 	ndbm.h spSpolyLoop.h polys-impl.h polys-comp.h getopt.h libparse.h \
-	pcv.h mod_raw.h
+	pcv.h mod_raw.h kbuckets.h kbPolyProcs.h
 
 INCS=febase.inc polys.inc iparith.inc mpsr_Tok.inc spSpolyLoop.inc
@@ -131,5 +131,5 @@
      mpsr_Get.o mpsr_GetMisc.o ndbm.o spSpolyLoop.o libparse.o \
      find_exec.o getopt.o fereadl.o  mod_raw.o sdb.o \
-	pcv.o
+     pcv.o kbuckets.o kbPolyProcs.o
 
 ##
@@ -195,4 +195,13 @@
            configure.in
 	echo "#define SINGULAR_VERSION_ID " `date '+%y%m%d%H'` >version.h
+
+kbPolyProcs.cc kbPolyProcs.dd : kbPolyProcs.pin 
+
+kbPolyProcs.pin : generate.pl
+	@if test "x${PERL5}" = x; then \
+		echo Error: no perl5 given. Can not rebuild $@;\
+		exit 1;\
+	fi
+	${PERL5} generate.pl kb_n_Mult_p kb_p_Mult_m kb_p_Add_q kb_p_Minus_m_Mult_q > $@
 
 spSpolyLoop.cc spSpolyLoop.dd : spSpolyLoop.inc
@@ -347,5 +356,5 @@
      mpsr_Get.og mpsr_GetMisc.og \
      ndbm.og spSpolyLoop.og libparse.og  mod_raw.og \
-	pcv.og
+     pcv.og kbuckets.og kbPolyProcs.og
 
 OBJG2= mmalloc.og mmheap.og mmpage.og mmcheck.og mmbt.og page.og \
@@ -423,5 +432,5 @@
      mpsr_Get.op mpsr_GetMisc.op \
      ndbm.op spSpolyLoop.op libparse.op  mod_raw.op \
-	pcv.op
+     pcv.op kbuckets.op kbPolyProcs.op
 
 OBJP2= mmalloc.op mmheap.op mmpage.op mmcheck.op mmbt.op page.op \
Index: Singular/ipprint.cc
===================================================================
--- Singular/ipprint.cc	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/ipprint.cc	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ipprint.cc,v 1.12 1999-04-20 11:25:50 Singular Exp $ */
+/* $Id: ipprint.cc,v 1.13 1999-05-26 16:23:55 obachman Exp $ */
 /*
 * ABSTRACT: interpreter: printing
@@ -345,11 +345,23 @@
   {
     res->data = (char*) u->String(NULL, TRUE, dim);
+    if (dim == 2)
+    {
+      char* ns = (char*) AllocL(strlen((char*) res->data) + 2);
+      strcpy(ns, (char*) res->data);
+      FreeL(res->data);
+      strcat(ns, "\n");
+      res->data = ns;
+    }
   }
   else if (strcmp(ns,"%t") == 0)
   {
     SPrintStart();
-    if (u->rtyp==IDHDL) type_cmd((idhdl) (u->data));
-    else type_cmd((idhdl) u);
+    if (u->rtyp==IDHDL) 
+      type_cmd((idhdl) (u->data));
+    else 
+      type_cmd((idhdl) u);
     res->data = SPrintEnd();
+    if (dim != 2) 
+      ((char*)res->data)[strlen((char*)res->data) -1] = '\0';
   }
   else if (strcmp(ns,"%;") == 0)
@@ -357,4 +369,5 @@
     SPrintStart();
     u->Print();
+    if (dim == 2) PrintLn();
     res->data = SPrintEnd();
   }
@@ -363,4 +376,5 @@
     SPrintStart();
     iiExprArith1(res, u, PRINT_CMD);
+    if (dim == 2) PrintLn();
     res->data = SPrintEnd();
   }
@@ -369,4 +383,5 @@
     SPrintStart();
     ipPrintBetti(u);
+    if (dim == 2) PrintLn();
     res->data = SPrintEnd();
   }
@@ -374,4 +389,12 @@
   {
     res->data = u->String(NULL, FALSE, dim);
+    if (dim == 2)
+    {
+      char* ns = (char*) AllocL(strlen((char*) res->data) + 2);
+      strcpy(ns, (char*) res->data);
+      FreeL(res->data);
+      strcat(ns, "\n");
+      res->data = ns;
+    }
   }
     
Index: Singular/kutil.h
===================================================================
--- Singular/kutil.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/kutil.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.h,v 1.13 1998-12-15 10:08:50 pohl Exp $ */
+/* $Id: kutil.h,v 1.14 1999-05-26 16:23:56 obachman Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -155,4 +155,5 @@
 
 rOrderType_t spGetOrderType(ring r, int modrank, int syzcomp);
+extern int spCheckCoeff(number *a, number *b);
 
 inline TSet initT () { return (TSet)Alloc0(setmax*sizeof(TObject)); }
Index: Singular/modulop.h
===================================================================
--- Singular/modulop.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/modulop.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: modulop.h,v 1.4 1999-05-10 15:10:51 Singular Exp $ */
+/* $Id: modulop.h,v 1.5 1999-05-26 16:23:57 obachman Exp $ */
 /*
 * ABSTRACT: numbers modulo p (<=32003)
@@ -51,4 +51,17 @@
   return (number)npExpTable[x<npPminus1M ? x : x-npPminus1M];
 }
+
+inline number npAddM(number a, number b)
+{
+  int ka = (int)a + (int)b;
+  if (ka >= npPrimeM) ka -= npPrimeM;
+  return (number)ka;
+}
+
+inline BOOLEAN npIsZeroM (number  a)
+{
+  return 0 == (int)a;
+}
+
 /*
 *inline number npMultM(number a, number b)
Index: Singular/polys-comp.h
===================================================================
--- Singular/polys-comp.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/polys-comp.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys-comp.h,v 1.9 1998-06-12 17:41:32 obachman Exp $ */
+/* $Id: polys-comp.h,v 1.10 1999-05-26 16:23:57 obachman Exp $ */
 
 /***************************************************************
@@ -14,4 +14,5 @@
 
 #include "polys-impl.h"
+#include "syz.h"
 
 #ifdef WORDS_BIGENDIAN
@@ -221,4 +222,144 @@
 while(0)
 
+
+#define _pMonComp_otSYZDPC_nwONE(p1, p2, d, actionD, actionE)   \
+do                                                              \
+{                                                               \
+  d = *((long*) &(p2->exp[0])) - *((long*) &(p1->exp[0]));      \
+  if (d)                                                        \
+  {                                                             \
+    const long c1 = pGetComp(p1);                               \
+    const long c2 = pGetComp(p2);                               \
+    if (c2 - c1 == d)                                           \
+    {                                                           \
+      d = currcomponents[c1] - currcomponents[c2];              \
+    }                                                           \
+    actionD;                                                    \
+  }                                                             \
+  actionE;                                                      \
+}                                                               \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwTWO(p1, p2, d, actionD, actionE)   \
+do                                                              \
+{                                                               \
+  const long* s1 = (long*) &(p1->exp[0]);                       \
+  const long* s2 = (long*) &(p2->exp[0]);                       \
+  d = *s2 - *s1;                                                \
+  if (d) actionD;                                               \
+  d = *(s2 + 1) - *(s1 + 1);                                    \
+  if (d)                                                        \
+  {                                                             \
+    const long c1 = pGetComp(p1);                               \
+    const long c2 = pGetComp(p2);                               \
+    if (c2 - c1 == d)                                           \
+    {                                                           \
+      d = currcomponents[c1] - currcomponents[c2];              \
+    }                                                           \
+    actionD;                                                    \
+  }                                                             \
+  actionE;                                                      \
+}                                                               \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwEVEN(p1, p2, length, d, actionD, actionE)  \
+do                                                                      \
+{                                                                       \
+  const long* s1 = (long*) &(p1->exp[0]);                               \
+  const long* s2 = (long*) &(p2->exp[0]);                               \
+  const long* const lb = s1 + length-1;                                 \
+                                                                        \
+  for (;;)                                                              \
+  {                                                                     \
+    d = *s2 - *s1;                                                      \
+    if (d) actionD;                                                     \
+    s1++;                                                               \
+    if (s1 == lb) break;                                                \
+    s2++;                                                               \
+    d = *s2 - *s1;                                                      \
+    if (d) actionD;                                                     \
+    s1++;                                                               \
+    s2++;                                                               \
+  }                                                                     \
+                                                                        \
+  d = *(s2 + 1) - *s1;                                                  \
+  if (d)                                                                \
+  {                                                                     \
+    const long c1 = pGetComp(p1);                                       \
+    const long c2 = pGetComp(p2);                                       \
+    if (c2 - c1 == d)                                                   \
+    {                                                                   \
+      d = currcomponents[c1] - currcomponents[c2];                      \
+    }                                                                   \
+    actionD;                                                            \
+  }                                                                     \
+  actionE;                                                              \
+}                                                                       \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwODD(p1, p2, length, d, actionD, actionE)   \
+do                                                                      \
+{                                                                       \
+  const long* s1 = (long*) &(p1->exp[0]);                               \
+  const long* s2 = (long*) &(p2->exp[0]);                               \
+  const long* const lb = s1 + length      -1;                           \
+                                                                        \
+  for (;;)                                                              \
+  {                                                                     \
+    d = *s2 - *s1;                                                      \
+    if (d) actionD;                                                     \
+    s1++;                                                               \
+    s2++;                                                               \
+    d = *s1 - *s2;                                                      \
+    if (d) actionD;                                                     \
+    s1++;                                                               \
+    if (s1 == lb) break;                                                \
+    s2++;                                                               \
+  }                                                                     \
+                                                                        \
+  d = *(s2 + 1) - *s1;                                                  \
+  if (d)                                                                \
+  {                                                                     \
+    const long c1 = pGetComp(p1);                                       \
+    const long c2 = pGetComp(p2);                                       \
+    if (c2 - c1 == d)                                                   \
+    {                                                                   \
+      d = currcomponents[c1] - currcomponents[c2];                      \
+    }                                                                   \
+    actionD;                                                            \
+  }                                                                     \
+  actionE;                                                              \
+}                                                                       \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwGEN(p1, p2, length, d, actionD, actionE)   \
+do                                                                      \
+{                                                                       \
+  const long* s1 = (long*) &(p1->exp[0]);                               \
+  const long* s2 = (long*) &(p2->exp[0]);                               \
+  const long* const lb = s1 + length -1;                                \
+                                                                        \
+  for (;;)                                                              \
+  {                                                                     \
+    d = *s2 - *s1;                                                      \
+    if (s1 == lb) break;                                                \
+    if (d) actionD;                                                     \
+    s1++;                                                               \
+    s2++;                                                               \
+  }                                                                     \
+                                                                        \
+  if (d)                                                                \
+  {                                                                     \
+    const long c1 = pGetComp(p1);                                       \
+    const long c2 = pGetComp(p2);                                       \
+    if (c2 - c1 == d)                                                   \
+    {                                                                   \
+      d = currcomponents[c1] - currcomponents[c2];                      \
+    }                                                                   \
+    actionD;                                                            \
+  }                                                                     \
+  actionE;                                                              \
+}                                                                       \
+while(0)
 
 #else //  ! WORDS_BIGENDIAN
@@ -419,5 +560,5 @@
   }                                                                     \
                                                                         \
-  d = *s1 - *s2;                                                  \
+  d = *s1 - *s2;                                                        \
   if (d)                                                                \
   {                                                                     \
@@ -430,4 +571,146 @@
 while(0)
 
+#define _pMonComp_otSYZDPC_nwODD(p1, p2, length, d, actionD, actionE)       \
+do                                                                          \
+{                                                                           \
+  const long* s1 = ((long*) p1) + pMonomSizeW-1;                            \
+  const long* s2 = ((long*) p2)  + pMonomSizeW-1;                           \
+  const long* const lb = s1 - length +1;                                    \
+                                                                            \
+  for (;;)                                                                  \
+  {                                                                         \
+    d = *s2 - *s1;                                                          \
+    if (d) actionD;                                                         \
+    s1--;                                                                   \
+    s2--;                                                                   \
+    d = *s2 - *s1;                                                          \
+    if (d) actionD;                                                         \
+    s1--;                                                                   \
+    if (s1 == lb) break;                                                    \
+    s2--;                                                                   \
+  }                                                                         \
+                                                                            \
+  d = *(s2 - 1) - *s1;                                                      \
+  if (d)                                                                    \
+  {                                                                         \
+    const long c1 = pGetComp(p1);                                           \
+    const long c2 = pGetComp(p2);                                           \
+    if (c2 - c1 == d)                                                       \
+    {                                                                       \
+      d = currcomponents[c1] - currcomponents[c2];                          \
+    }                                                                       \
+    actionD;                                                                \
+  }                                                                         \
+  actionE;                                                                  \
+}                                                                           \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwEVEN(p1, p2, length, d, actionD, actionE) \
+do                                                                      \
+{                                                                       \
+  const long* s1 = ((long*) p1) + pMonomSizeW-1;                        \
+  const long* s2 = ((long*) p2)  + pMonomSizeW-1;                       \
+  const long* const lb = s1 - length +1;                                \
+                                                                        \
+  for (;;)                                                              \
+  {                                                                     \
+    d = *s2 - *s1;                                                      \
+    if (d) actionD;                                                     \
+    s1--;                                                               \
+    if (s1 == lb) break;                                                \
+    s2--;                                                               \
+    d = *s2 - *s1;                                                      \
+    if (d) actionD;                                                     \
+    s1--;                                                               \
+    s2--;                                                               \
+  }                                                                     \
+                                                                        \
+  d = *(s2 - 1) - *s1;                                                  \
+  if (d)                                                                    \
+  {                                                                         \
+    const long c1 = pGetComp(p1);                                           \
+    const long c2 = pGetComp(p2);                                           \
+    if (c2 - c1 == d)                                                       \
+    {                                                                       \
+      d = currcomponents[c1] - currcomponents[c2];                          \
+    }                                                                       \
+    actionD;                                                                \
+  }                                                                         \
+  actionE;                                                              \
+}                                                                       \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwTWO(p1, p2, d, actionD, actionE)           \
+do                                                                      \
+{                                                                       \
+  const long* s1 = ((long*) p1) + pMonomSizeW-1;                        \
+  const long* s2 = ((long*) p2)  + pMonomSizeW-1;                       \
+  d = *s2 - *s1;                                                        \
+  if (d) actionD;                                                       \
+  d = *s2 - *s1;                                                        \
+  if (d) actionD;                                                       \
+  d = *(s2 -1) - *(s1 -1);                                              \
+  if (d)                                                                    \
+  {                                                                         \
+    const long c1 = pGetComp(p1);                                           \
+    const long c2 = pGetComp(p2);                                           \
+    if (c2 - c1 == d)                                                       \
+    {                                                                       \
+      d = currcomponents[c1] - currcomponents[c2];                          \
+    }                                                                       \
+    actionD;                                                                \
+  }                                                                         \
+  actionE;                                                              \
+}                                                                       \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwONE(p1, p2, d, actionD, actionE)               \
+do                                                                          \
+{                                                                           \
+  d = *(((long*) p2) + pMonomSizeW-1) - *(((long*) p1)  + pMonomSizeW-1);   \
+  if (d)                                                                    \
+  {                                                                         \
+    const long c1 = pGetComp(p1);                                           \
+    const long c2 = pGetComp(p2);                                           \
+    if (c2 - c1 == d)                                                       \
+    {                                                                       \
+      d = currcomponents[c1] - currcomponents[c2];                          \
+    }                                                                       \
+    actionD;                                                                \
+  }                                                                         \
+  actionE;                                                                  \
+}                                                                           \
+while(0)
+
+#define _pMonComp_otSYZDPC_nwGEN(p1, p2, length, d, actionD, actionE)   \
+do                                                                      \
+{                                                                       \
+  const long* s1 = ((long*) p1) + pMonomSizeW-1;                        \
+  const long* s2 = ((long*) p2)  + pMonomSizeW-1;                       \
+  const long* const lb = s1 - length +1;                                \
+                                                                        \
+  for (;;)                                                              \
+  {                                                                     \
+    d = *s2 - *s1;                                                      \
+    if (s1 == lb) break;                                                \
+    if (d) actionD;                                                     \
+    s1--;                                                               \
+    s2--;                                                               \
+  }                                                                     \
+                                                                        \
+  if (d)                                                                \
+  {                                                                     \
+    const long c1 = pGetComp(p1);                                       \
+    const long c2 = pGetComp(p2);                                       \
+    if (c2 - c1 == d)                                                   \
+    {                                                                   \
+      d = currcomponents[c1] - currcomponents[c2];                      \
+    }                                                                   \
+    actionD;                                                            \
+  }                                                                     \
+  actionE;                                                              \
+}                                                                       \
+while(0)
+
 #endif // WORDS_BIGENDIAN
 
Index: Singular/polys.cc
===================================================================
--- Singular/polys.cc	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/polys.cc	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.cc,v 1.38 1999-05-25 16:49:39 obachman Exp $ */
+/* $Id: polys.cc,v 1.39 1999-05-26 16:23:59 obachman Exp $ */
 
 /*
@@ -1927,4 +1927,107 @@
 }
 
+
+// Splits *p into two polys: *q which consists of all monoms with
+// component == comp and *p of all other monoms *lq == pLength(*q)
+void pTakeOutComp(poly *r_p, Exponent_t comp, poly *r_q, int *lq)
+{
+  spolyrec pp, qq;
+  poly p, q, p_prev;
+  int l = 0;
+
+#ifdef HAVE_ASSUME
+  int lp = pLength(*r_p);
+#endif
+
+  pNext(&pp) = *r_p;
+  p = *r_p;
+  p_prev = &pp;
+  q = &qq;
+
+  while(p != NULL)
+  {
+    while (pGetComp(p) == comp)
+    {
+      pNext(q) = p;
+      pIter(q);
+      pSetComp(p, 0);
+      pIter(p);
+      l++;
+      if (p == NULL)
+      {
+        pNext(p_prev) = NULL;
+        goto Finish;
+      }
+    }
+    pNext(p_prev) = p;
+    p_prev = p;
+    pIter(p);
+  }
+
+  Finish:
+  pNext(q) = NULL;
+  *r_p = pNext(&pp);
+  *r_q = pNext(&qq);
+  *lq = l;
+#ifdef HAVE_ASSUME
+  assume(pLength(*r_p) + pLength(*r_q) == lp);
+#endif
+  pTest(*r_p);
+  pTest(*r_q);
+}
+
+void pDecrOrdTakeOutComp(poly *r_p, Exponent_t comp, Order_t order,
+                         poly *r_q, int *lq)
+{
+  spolyrec pp, qq;
+  poly p, q, p_prev;
+  int l = 0;
+
+  pNext(&pp) = *r_p;
+  p = *r_p;
+  p_prev = &pp;
+  q = &qq;
+
+#ifdef HAVE_ASSUME
+  if (p != NULL)
+  {
+    while (pNext(p) != NULL)
+    {
+      assume(pGetOrder(p) >= pGetOrder(pNext(p)));
+      pIter(p);
+    }
+  }
+  p = *r_p;
+#endif
+
+  while (p != NULL && pGetOrder(p) > order) pIter(p);
+
+  while(p != NULL && pGetOrder(p) == order)
+  {
+    while (pGetComp(p) == comp)
+    {
+      pNext(q) = p;
+      pIter(q);
+      pIter(p);
+      pSetComp(p, 0);
+      l++;
+      if (p == NULL || pGetOrder(p) != order)
+      {
+        pNext(p_prev) = p;
+        goto Finish;
+      }
+    }
+    pNext(p_prev) = p;
+    p_prev = p;
+    pIter(p);
+  }
+
+  Finish:
+  pNext(q) = NULL;
+  *r_p = pNext(&pp);
+  *r_q = pNext(&qq);
+  *lq = l;
+}
+
 poly pTakeOutComp1(poly * p, int k)
 {
Index: Singular/polys.h
===================================================================
--- Singular/polys.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/polys.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys.h,v 1.19 1998-12-03 11:02:37 obachman Exp $ */
+/* $Id: polys.h,v 1.20 1999-05-26 16:24:00 obachman Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate polynomials
@@ -298,6 +298,17 @@
 BOOLEAN   pVectorHasUnitB(poly p, int * k);
 void      pVectorHasUnit(poly p, int * k, int * len);
+poly      pTakeOutComp1(poly * p, int k);
+// Splits *p into two polys: *q which consists of all monoms with 
+// component == comp and *p of all other monoms *lq == pLength(*q)
+// On rreturn all components pf *q == 0
+void pTakeOutComp(poly *p, Exponent_t comp, poly *q, int *lq);
+// Similar to pTakeOutComp, except that only those components are
+// taken out whose Order == order
+// ASSUME: monomial ordering is Order compatible, i.e., if m1, m2 Monoms then
+//         m1 >= m2 ==> pGetOrder(m1) >= pGetOrder(m2)
+void pDecrOrdTakeOutComp(poly *p, Exponent_t comp, Order_t order,
+                         poly *q, int *lq);
+// This is something weird -- Don't use it, unless you know what you are doing 
 poly      pTakeOutComp(poly * p, int k);
-poly      pTakeOutComp1(poly * p, int k);
 void      pDeleteComp(poly * p,int k);
 void      pNorm(poly p);
Index: Singular/ring.h
===================================================================
--- Singular/ring.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/ring.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -7,5 +7,5 @@
 * ABSTRACT - the interpreter related ring operations
 */
-/* $Id: ring.h,v 1.25 1999-05-10 15:10:54 Singular Exp $ */
+/* $Id: ring.h,v 1.26 1999-05-26 16:24:00 obachman Exp $ */
 
 /* includes */
@@ -106,5 +106,8 @@
                           // component is compatible with exp-vector order
   rOrderType_Syz,         // syzygy ordering
-  rOrderType_Schreyer     // Schreyer ordering
+  rOrderType_Schreyer,     // Schreyer ordering
+  rOrderType_Syz2dpc,     // syzcomp2dpc
+  rOrderType_ExpNoComp    // simple ordering, differences in component are 
+                          // not considered
 } rOrderType_t;
 
Index: Singular/spolys0.cc
===================================================================
--- Singular/spolys0.cc	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/spolys0.cc	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: spolys0.cc,v 1.13 1998-11-11 14:44:27 Singular Exp $ */
+/* $Id: spolys0.cc,v 1.14 1999-05-26 16:24:01 obachman Exp $ */
 
 /*
@@ -29,5 +29,5 @@
 *   this value is used to control the spolys
 */
-static int spCheckCoeff(number *a, number *b)
+int spCheckCoeff(number *a, number *b)
 {
   int c = 0;
Index: Singular/structs.h
===================================================================
--- Singular/structs.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/structs.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: structs.h,v 1.19 1999-04-29 11:38:58 Singular Exp $ */
+/* $Id: structs.h,v 1.20 1999-05-26 16:24:02 obachman Exp $ */
 /*
 * ABSTRACT
@@ -54,4 +54,5 @@
 class procinfo;
 class namerec;
+class kBucket;
 #endif
 
@@ -106,4 +107,5 @@
 typedef procinfo *         procinfov;
 typedef namerec *          namehdl;
+typedef kBucket*           kBucket_pt;
 
 struct _scmdnames
Index: Singular/syz.h
===================================================================
--- Singular/syz.h	(revision 6ffb6fd0051336687cab0ad88f2e4354233e4769)
+++ Singular/syz.h	(revision 8c8beadba0f0bc1bfee770f8fd829884d534721c)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz.h,v 1.12 1998-11-12 14:44:37 siebert Exp $ */
+/* $Id: syz.h,v 1.13 1999-05-26 16:24:02 obachman Exp $ */
 /*
 * ABSTRACT: Resolutions
@@ -94,3 +94,5 @@
 syStrategy syMinimize(syStrategy syzstr);
 void syKillEmptyEntres(resolvente res,int length);
+
+extern int *  currcomponents;
 #endif
