Index: kernel/ideals.cc
===================================================================
--- kernel/ideals.cc	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/ideals.cc	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.cc,v 1.4 2004-05-12 11:24:37 levandov Exp $ */
+/* $Id: ideals.cc,v 1.5 2004-07-16 08:42:59 Singular Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -2988,4 +2988,48 @@
 }
 
+BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
+{
+  if ((Q!=NULL) && (!idHomIdeal(Q,NULL)))  { PrintS(" Q not hom\n"); return FALSE;}
+  if (idIs0(m)) return TRUE;
+
+  int cmax=-1;
+  int i;
+  poly p=NULL;
+  int length=IDELEMS(m);
+  polyset P=m->m;
+  for (i=length-1;i>=0;i--)
+  {
+    p=P[i];
+    if (p!=NULL) cmax=si_max(cmax,(int)pMaxComp(p)+1);
+  }
+  if (w->length()+1 < cmax)
+  { 
+    // Print("length: %d - %d \n", w->length(),cmax);
+    return FALSE;
+  }
+  pSetModDeg(w);
+  for (i=length-1;i>=0;i--)
+  {
+    p=P[i];
+    poly q=p;
+    if (p!=NULL)
+    {
+      int d=pFDeg(p);
+      loop
+      {
+        pIter(p);
+        if (p==NULL) break;
+        if (d!=pFDeg(p)) 
+        {
+          // pWrite(q); wrp(p); Print(" -> %d - %d\n",d,pFDeg(p)); 
+          return FALSE; 
+        }
+      }
+    }
+  }
+  pSetModDeg(NULL);
+  return TRUE;
+}
+
 ideal idJet(ideal i,int d)
 {
Index: kernel/ideals.h
===================================================================
--- kernel/ideals.h	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/ideals.h	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.h,v 1.1.1.1 2003-10-06 12:15:53 Singular Exp $ */
+/* $Id: ideals.h,v 1.2 2004-07-16 08:43:00 Singular Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -67,4 +67,5 @@
 BOOLEAN idHomIdeal (ideal id, ideal Q=NULL);
 BOOLEAN idHomModule(ideal m, ideal Q,intvec **w);
+BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w);
 
 ideal idMinBase (ideal h1);
Index: kernel/intvec.h
===================================================================
--- kernel/intvec.h	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/intvec.h	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: intvec.h,v 1.1.1.1 2003-10-06 12:15:55 Singular Exp $ */
+/* $Id: intvec.h,v 1.2 2004-07-16 08:43:00 Singular Exp $ */
 /*
 * ABSTRACT: class intvec: lists/vectors of integers
@@ -20,5 +20,5 @@
 public:
 
-  intvec(int l = 1)
+  inline intvec(int l = 1)
     {
       v = (int *)omAlloc0(sizeof(int)*l);
@@ -31,9 +31,9 @@
 
   void resize(int new_length);
-  int range(int i)
+  inline int range(int i)
     { return ((i<row) && (i>=0) && (col==1)); }
-  int range(int i, int j)
+  inline int range(int i, int j)
     { return ((i<row) && (i>=0) && (j<col) && (j>=0)); }
-  int& operator[](int i)
+  inline int& operator[](int i)
     {
 #ifndef NDEBUG
@@ -54,15 +54,13 @@
   int compare(intvec* o);
   int compare(int o);
-  int  length() const { return col*row; }
-  int  cols() const { return col; }
-  int  rows() const { return row; }
-  void length(int l) { row = l; col = 1; }
-  void show(int notmat=1,int spaces=0);
-  void makeVector() { row*=col;col=1; }
-  // keiner (ausser obachman) darf das folgenden benutzen !!!
-  int * ivGetVec() { return v; }
+  inline int  length() const { return col*row; }
+  inline int  cols() const { return col; }
+  inline int  rows() const { return row; }
+  inline void length(int l) { row = l; col = 1; }
+  void show(int mat=0,int spaces=0);
+  inline void makeVector() { row*=col;col=1; }
   char * String(int dim = 2);
   char * ivString(int mat=0,int spaces=0, int dim=2);
-  ~intvec()
+  inline ~intvec()
     {
       if (v!=NULL)
@@ -72,8 +70,16 @@
       }
     }
-  void ivTEST()
+  inline void ivTEST()
     {
       omCheckAddrSize((ADDRESS)v,sizeof(int)*row*col);
     }
+  inline int min_in()
+  {
+    int m=v[0];
+    for (int i=row*col; i>0; i--) if (v[i]<m) m=v[i];
+    return m;
+  }
+  // keiner (ausser obachman) darf das folgenden benutzen !!!
+  inline int * ivGetVec() { return v; }
 };
 intvec * ivCopy(intvec * o);
Index: kernel/mmstd.c
===================================================================
--- kernel/mmstd.c	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/mmstd.c	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: mmstd.c,v 1.1.1.1 2003-10-06 12:15:57 Singular Exp $ */
+/* $Id: mmstd.c,v 1.2 2004-07-16 08:43:00 Singular Exp $ */
 /*
 * ABSTRACT: standard version of C-memory management alloc func 
@@ -22,9 +22,11 @@
 // and OM_TRACK are used, but only provide them if omalloc is not based
 // on them
-#ifndef OMALLOC_USES_MALLOC
+// already provided in libomalloc
+#if !defined(OMALLOC_USES_MALLOC) && !defined(X_OMALLOC)
 
 // define this so that all addr allocated there are marked 
 // as static, i.e. not metioned by omPrintUsedAddr
 #define OM_MALLOC_MARK_AS_STATIC
+#define strdup_ strdup__
 #include <omalloc.c>
 #else
Index: kernel/polys1.cc
===================================================================
--- kernel/polys1.cc	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/polys1.cc	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: polys1.cc,v 1.4 2004-04-23 14:04:42 Singular Exp $ */
+/* $Id: polys1.cc,v 1.5 2004-07-16 08:43:01 Singular Exp $ */
 
 /*
@@ -40,5 +40,9 @@
 static long pModDeg(poly p, ring r = currRing)
 {
-  return pOldFDeg(p, r)+(*pModW)[p_GetComp(p, r)-1];
+  long d=pOldFDeg(p, r);
+  int c=p_GetComp(p, r);
+  if ((c>0) && (pModW->range(c-1))) d+= (*pModW)[c-1];
+  return d;
+  //return pOldFDeg(p, r)+(*pModW)[p_GetComp(p, r)-1];
 }
 
Index: kernel/syz.h
===================================================================
--- kernel/syz.h	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/syz.h	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -4,5 +4,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz.h,v 1.1.1.1 2003-10-06 12:15:54 Singular Exp $ */
+/* $Id: syz.h,v 1.2 2004-07-16 08:43:01 Singular Exp $ */
 /*
 * ABSTRACT: Resolutions
@@ -99,5 +99,5 @@
 void syDeleteRes(resolvente * res,int length);
 void syKillComputation(syStrategy syzstr, ring r=currRing);
-intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim=TRUE,int * row_shift=NULL);
+intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim=TRUE,int * row_shift=NULL, intvec *weights=NULL);
 BOOLEAN syBetti1(leftv res, leftv u);
 BOOLEAN syBetti2(leftv res, leftv u, leftv w);
Index: kernel/syz1.cc
===================================================================
--- kernel/syz1.cc	(revision 654b44a579d2278ad9f452357b30484f749a343f)
+++ kernel/syz1.cc	(revision 30b838145df6c7794d3f78e3503f9c472653bbf5)
@@ -2,5 +2,5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz1.cc,v 1.8 2004-06-02 17:05:07 Singular Exp $ */
+/* $Id: syz1.cc,v 1.9 2004-07-16 08:43:01 Singular Exp $ */
 /*
 * ABSTRACT: resolutions
@@ -1728,284 +1728,4 @@
 }
 
-/*3
-* read out the Betti numbers from resolution
-* (if not LaScala calls the traditional Betti procedure)
-*/
-intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim,int * row_shift)
-{
-  int dummy;
-  if (syzstr->betti!=NULL)
-  {
-    if (minim || (syzstr->resPairs!=NULL))
-      return ivCopy(syzstr->betti);
-  }
-  intvec *result;
-  if (syzstr->resPairs!=NULL)
-  {
-    int i,j=-1,jj=-1,l,sh=0;
-    SRes rP=syzstr->resPairs;
-
-    if (syzstr->hilb_coeffs!=NULL) sh = 1;
-    l = syzstr->length;
-    while ((l>0) && (rP[l-1]==NULL)) l--;
-    if (l==0) return NULL;
-    l--;
-    while (l>=sh)
-    {
-      i = 0;
-      while ((i<(*syzstr->Tl)[l]) &&
-        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)))
-      {
-        if (rP[l][i].isNotMinimal==NULL)
-        {
-          if (j<rP[l][i].order-l)
-            j = rP[l][i].order-l;
-          if (jj<l)
-            jj = l;
-        }
-        i++;
-      }
-      l--;
-    }
-    j = j+sh;
-    jj = jj+2;
-    result=new intvec(j,jj-sh,0);
-    IMATELEM(*result,1,1)
-      = si_max(1,(int)idRankFreeModule(syzstr->res[1],
-                               (syzstr->syRing!=NULL?syzstr->syRing:currRing)));
-    for (i=sh;i<jj;i++)
-    {
-      j = 0;
-      while (j<(*syzstr->Tl)[i])
-      {
-        if ((rP[i][j].isNotMinimal==NULL)&&
-           ((rP[i][j].lcm!=NULL) || (rP[i][j].syz!=NULL)))
-          IMATELEM(*result,rP[i][j].order-i+sh,i+2-sh)++;
-        j++;
-      }
-    }
-  }
-  else if (syzstr->fullres!=NULL)
-    result = syBetti(syzstr->fullres,syzstr->length,&dummy,NULL,minim,row_shift);
-  else
-    result = syBetti(syzstr->minres,syzstr->length,&dummy,NULL,minim,row_shift);
-  if ((result!=NULL) && ((minim) || (syzstr->resPairs!=NULL)))
-    syzstr->betti = ivCopy(result);
-  return result;
-}
-
-/*3
-* computes the allocated length of the resolution
-*/
-int syLength(syStrategy syzstr)
-{
-  return syzstr->length;
-}
-
-/*3
-* computes the real length of the resolution
-*/
-int sySize(syStrategy syzstr)
-{
-  resolvente r=syzstr->res;
-  if (r==NULL)
-    r = syzstr->fullres;
-  if (r==NULL)
-    r = syzstr->minres;
-  if (r==NULL)
-  {
-    WerrorS("No resolution found");
-    return 0;
-  }
-  int i=syzstr->length;
-  while ((i>0) && (r[i-1]==NULL)) i--;
-  return i;
-}
-
-/*3
-* computes the cohomological dimension of res[1]
-*/
-int syDim(syStrategy syzstr)
-{
-  int i,j=-1,l;
-  if (syzstr->resPairs!=NULL)
-  {
-    SRes rP=syzstr->resPairs;
-
-    l = syzstr->length;
-    while ((l>0) && (rP[l-1]==NULL)) l--;
-    if (l==0) return -1;
-    l--;
-    while (l>=0)
-    {
-      i = 0;
-      while ((i<(*syzstr->Tl)[l]) &&
-        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
-        (rP[l][i].isNotMinimal!=NULL))
-      {
-        i++;
-      }
-      if ((i<(*syzstr->Tl)[l]) &&
-        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
-        (rP[l][i].isNotMinimal==NULL))
-        return l;
-      l--;
-    }
-    return l;
-  }
-  else
-    return sySize(syzstr);
-}
-
-/*3
-* copies the resolution (by increment the reference counter)
-*/
-syStrategy syCopy(syStrategy syzstr)
-{
-  syStrategy result=syzstr;
-  (result->references)++;
-  return result;
-}
-
-/*2
-* local print procedure used in syPrint
-*/
-static void syPrintEmptySpaces(int i)
-{
-  if (i!=0)
-  {
-    PrintS(" ");
-    syPrintEmptySpaces(i/10);
-  }
-}
-
-/*2
-* local print procedure used in syPrint
-*/
-static void syPrintEmptySpaces1(int i)
-{
-  if (i!=0)
-  {
-    PrintS(" ");
-    syPrintEmptySpaces1(i-1);
-  }
-}
-
-/*2
-* local print procedure used in syPrint
-*/
-static int syLengthInt(int i)
-{
-  int j=0;
-
-  if (i==0) return 1;
-  while (i!=0)
-  {
-    j++;
-    i = i/10;
-  }
-  return j;
-}
-
-/*3
-* prints the resolution as sequence of free modules
-*/
-void syPrint(syStrategy syzstr)
-{
-  if ((syzstr->resPairs==NULL) && (syzstr->fullres==NULL)
-     && (syzstr->minres==NULL))
-  {
-    PrintS("No resolution defined\n");
-    return;
-  }
-  int l=0;
-  if (syzstr->resolution==NULL)
-  {
-    int j;
-    if (syzstr->resPairs!=NULL)
-    {
-      syzstr->resolution = new intvec(syzstr->length+1);
-      SRes rP=syzstr->resPairs;
-      (*syzstr->resolution)[0]
-        = si_max(1,(int)idRankFreeModule(syzstr->res[1],
-                                 (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
-      while ((l<syzstr->length) && (rP[l]!=NULL))
-      {
-        j=0;
-        while ((j<(*syzstr->Tl)[l]) &&
-          ((rP[l][j].lcm!=NULL) || (rP[l][j].syz!=NULL)))
-        {
-          if (rP[l][j].isNotMinimal==NULL)
-            ((*syzstr->resolution)[l+1])++;
-          j++;
-        }
-        l++;
-      }
-    }
-    else
-    {
-      resolvente rr;
-      syzstr->resolution = new intvec(syzstr->length+2);
-      if (syzstr->minres!=NULL)
-        rr = syzstr->minres;
-      else
-        rr = syzstr->fullres;
-      (*syzstr->resolution)[0]
-        = si_max(1,(int)idRankFreeModule(rr[0],
-                                 (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
-      while ((l<syzstr->length) && (rr[l]!=NULL))
-      {
-        j = IDELEMS(rr[l]);
-        while ((j>0) && (rr[l]->m[j-1]==NULL)) j--;
-        ((*syzstr->resolution)[l+1]) = j;
-        l++;
-      }
-    }
-  }
-  char *sn=currRingHdl->id;
-  int sl=strlen(sn);
-  syPrintEmptySpaces1(sl);
-  l = 0;
-  loop
-  {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
-      break;
-    Print("%d",(*syzstr->resolution)[l]);
-    syPrintEmptySpaces1(sl+5);
-    l++;
-  }
-  PrintLn();
-  l = 0;
-  loop
-  {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
-      break;
-    PrintS(sn);
-    if (((l+1)>=syzstr->resolution->length()) || ((*syzstr->resolution)[(l+1)]==0))
-      break;
-    PrintS(" <-- ");
-    syPrintEmptySpaces((*syzstr->resolution)[l]);
-    l++;
-  }
-  PrintLn();
-  PrintLn();
-  l = 0;
-  loop
-  {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
-      break;
-    Print("%d",l);
-    syPrintEmptySpaces1(sl+5+syLengthInt((*syzstr->resolution)[l])-
-                         syLengthInt(l));
-    l++;
-  }
-  PrintLn();
-  if (syzstr->minres==NULL)
-  {
-    PrintS("resolution not minimized yet");
-    PrintLn();
-  }
-}
-
 /*2
 * divides out the weight monomials (given by the Schreyer-ordering)
@@ -2122,4 +1842,273 @@
 }
 
+/*3
+* read out the Betti numbers from resolution
+* (if not LaScala calls the traditional Betti procedure)
+*/
+intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim,int * row_shift,
+                              intvec* weights)
+{
+  int dummy;
+  BOOLEAN std_weights=TRUE;
+  if ((weights!=NULL)
+  && (syzstr->betti!=NULL)
+  && (syzstr->weights!=NULL) && (syzstr->weights[0]!=NULL))
+  {
+    int i;
+    for(i=weights->length()-1; i>=0; i--)
+    {
+      //Print("test %d: %d - %d\n",i,(*weights)[i], (*(syzstr->weights[0]))[i]);
+      if ((*weights)[i]!=(*(syzstr->weights[0]))[i])
+      {
+        std_weights=FALSE;
+        break;
+      }
+    }
+  }
+  if ((syzstr->betti!=NULL)
+  && (std_weights))
+  {
+    if (minim || (syzstr->resPairs!=NULL))
+      return ivCopy(syzstr->betti);
+  }
+  if ((syzstr->fullres==NULL) && (syzstr->minres==NULL))
+  {
+     if (syzstr->hilb_coeffs==NULL)
+     {
+        syzstr->fullres = syReorder(syzstr->res,syzstr->length,syzstr);
+     }
+     else
+     {
+        syzstr->minres = syReorder(syzstr->orderedRes,syzstr->length,syzstr);
+        syKillEmptyEntres(syzstr->minres,syzstr->length);
+     }
+   }
+  intvec *result=NULL;
+  if (syzstr->fullres!=NULL)
+    result = syBetti(syzstr->fullres,syzstr->length,&dummy,weights,minim,row_shift);
+  else
+    result = syBetti(syzstr->minres,syzstr->length,&dummy,weights,minim,row_shift);
+  if ((result!=NULL)
+  && ((minim) || (syzstr->resPairs!=NULL))
+  && std_weights)
+  {
+    syzstr->betti = ivCopy(result);
+  }
+  return result;
+}
+
+/*3
+* computes the allocated length of the resolution
+*/
+int syLength(syStrategy syzstr)
+{
+  return syzstr->length;
+}
+
+/*3
+* computes the real length of the resolution
+*/
+int sySize(syStrategy syzstr)
+{
+  resolvente r=syzstr->res;
+  if (r==NULL)
+    r = syzstr->fullres;
+  if (r==NULL)
+    r = syzstr->minres;
+  if (r==NULL)
+  {
+    WerrorS("No resolution found");
+    return 0;
+  }
+  int i=syzstr->length;
+  while ((i>0) && (r[i-1]==NULL)) i--;
+  return i;
+}
+
+/*3
+* computes the cohomological dimension of res[1]
+*/
+int syDim(syStrategy syzstr)
+{
+  int i,j=-1,l;
+  if (syzstr->resPairs!=NULL)
+  {
+    SRes rP=syzstr->resPairs;
+
+    l = syzstr->length;
+    while ((l>0) && (rP[l-1]==NULL)) l--;
+    if (l==0) return -1;
+    l--;
+    while (l>=0)
+    {
+      i = 0;
+      while ((i<(*syzstr->Tl)[l]) &&
+        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
+        (rP[l][i].isNotMinimal!=NULL))
+      {
+        i++;
+      }
+      if ((i<(*syzstr->Tl)[l]) &&
+        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
+        (rP[l][i].isNotMinimal==NULL))
+        return l;
+      l--;
+    }
+    return l;
+  }
+  else
+    return sySize(syzstr);
+}
+
+/*3
+* copies the resolution (by increment the reference counter)
+*/
+syStrategy syCopy(syStrategy syzstr)
+{
+  syStrategy result=syzstr;
+  (result->references)++;
+  return result;
+}
+
+/*2
+* local print procedure used in syPrint
+*/
+static void syPrintEmptySpaces(int i)
+{
+  if (i!=0)
+  {
+    PrintS(" ");
+    syPrintEmptySpaces(i/10);
+  }
+}
+
+/*2
+* local print procedure used in syPrint
+*/
+static void syPrintEmptySpaces1(int i)
+{
+  if (i!=0)
+  {
+    PrintS(" ");
+    syPrintEmptySpaces1(i-1);
+  }
+}
+
+/*2
+* local print procedure used in syPrint
+*/
+static int syLengthInt(int i)
+{
+  int j=0;
+
+  if (i==0) return 1;
+  while (i!=0)
+  {
+    j++;
+    i = i/10;
+  }
+  return j;
+}
+
+/*3
+* prints the resolution as sequence of free modules
+*/
+void syPrint(syStrategy syzstr)
+{
+  if ((syzstr->resPairs==NULL) && (syzstr->fullres==NULL)
+     && (syzstr->minres==NULL))
+  {
+    PrintS("No resolution defined\n");
+    return;
+  }
+  int l=0;
+  if (syzstr->resolution==NULL)
+  {
+    int j;
+    if (syzstr->resPairs!=NULL)
+    {
+      syzstr->resolution = new intvec(syzstr->length+1);
+      SRes rP=syzstr->resPairs;
+      (*syzstr->resolution)[0]
+        = si_max(1,(int)idRankFreeModule(syzstr->res[1],
+                                 (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
+      while ((l<syzstr->length) && (rP[l]!=NULL))
+      {
+        j=0;
+        while ((j<(*syzstr->Tl)[l]) &&
+          ((rP[l][j].lcm!=NULL) || (rP[l][j].syz!=NULL)))
+        {
+          if (rP[l][j].isNotMinimal==NULL)
+            ((*syzstr->resolution)[l+1])++;
+          j++;
+        }
+        l++;
+      }
+    }
+    else
+    {
+      resolvente rr;
+      syzstr->resolution = new intvec(syzstr->length+2);
+      if (syzstr->minres!=NULL)
+        rr = syzstr->minres;
+      else
+        rr = syzstr->fullres;
+      (*syzstr->resolution)[0]
+        = si_max(1,(int)idRankFreeModule(rr[0],
+                                 (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
+      while ((l<syzstr->length) && (rr[l]!=NULL))
+      {
+        j = IDELEMS(rr[l]);
+        while ((j>0) && (rr[l]->m[j-1]==NULL)) j--;
+        ((*syzstr->resolution)[l+1]) = j;
+        l++;
+      }
+    }
+  }
+  char *sn=currRingHdl->id;
+  int sl=strlen(sn);
+  syPrintEmptySpaces1(sl);
+  l = 0;
+  loop
+  {
+    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+      break;
+    Print("%d",(*syzstr->resolution)[l]);
+    syPrintEmptySpaces1(sl+5);
+    l++;
+  }
+  PrintLn();
+  l = 0;
+  loop
+  {
+    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+      break;
+    PrintS(sn);
+    if (((l+1)>=syzstr->resolution->length()) || ((*syzstr->resolution)[(l+1)]==0))
+      break;
+    PrintS(" <-- ");
+    syPrintEmptySpaces((*syzstr->resolution)[l]);
+    l++;
+  }
+  PrintLn();
+  PrintLn();
+  l = 0;
+  loop
+  {
+    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+      break;
+    Print("%d",l);
+    syPrintEmptySpaces1(sl+5+syLengthInt((*syzstr->resolution)[l])-
+                         syLengthInt(l));
+    l++;
+  }
+  PrintLn();
+  if (syzstr->minres==NULL)
+  {
+    PrintS("resolution not minimized yet");
+    PrintLn();
+  }
+}
+
 /*2
 * deleting all monomials the component of which correspond
