OpenXM_contrib2/asir2000/builtin/gr.c - diff

Return to gr.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/gr.c between version 1.7 and 1.30

-version 1.7, 2000/07/14 08:26:39
+version 1.30, 2001/09/17 01:18:34
 Line 1
 Line 1
 Line 1
- /* $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.6 2000/07/13 05:09:00 noro Exp $ */
+ /*
+  * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
+  * All rights reserved.
+  *
+  * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
+  * non-exclusive and royalty-free license to use, copy, modify and
+  * redistribute, solely for non-commercial and non-profit purposes, the
+  * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
+  * conditions of this Agreement. For the avoidance of doubt, you acquire
+  * only a limited right to use the SOFTWARE hereunder, and FLL or any
+  * third party developer retains all rights, including but not limited to
+  * copyrights, in and to the SOFTWARE.
+  *
+  * (1) FLL does not grant you a license in any way for commercial
+  * purposes. You may use the SOFTWARE only for non-commercial and
+  * non-profit purposes only, such as academic, research and internal
+  * business use.
+  * (2) The SOFTWARE is protected by the Copyright Law of Japan and
+  * international copyright treaties. If you make copies of the SOFTWARE,
+  * with or without modification, as permitted hereunder, you shall affix
+  * to all such copies of the SOFTWARE the above copyright notice.
+  * (3) An explicit reference to this SOFTWARE and its copyright owner
+  * shall be made on your publication or presentation in any form of the
+  * results obtained by use of the SOFTWARE.
+  * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
+  * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
+  * for such modification or the source code of the modified part of the
+  * SOFTWARE.
+  *
+  * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
+  * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
+  * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
+  * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
+  * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
+  * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
+  * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
+  * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
+  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
+  * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
+  * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
+  * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
+  * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
+  * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
+  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
+  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
+  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
+  *
+  * $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.29 2001/09/13 03:19:56 noro Exp $
+ */
  #include "ca.h"
  #include "parse.h"
  #include "base.h"
  #include "ox.h"
+ #if defined(__GNUC__)
+ #define INLINE inline
+ #elif defined(VISUAL)
+ #define INLINE __inline
+ #else
+ #define INLINE
+ #endif
  #define ITOS(p) (((unsigned int)(p))&0x7fffffff)
  #define STOI(i) ((P)((unsigned int)(i)|0x80000000))
-Line 26  typedef struct dp_pairs *DP_pairs;
+Line 82  typedef struct dp_pairs *DP_pairs;
 Line 26  typedef struct dp_pairs *DP_pairs;
 Line 82  typedef struct dp_pairs *DP_pairs;
  #define NEXTDPP(r,c) \
  if(!(r)){NEWDPP(r);(c)=(r);}else{NEWDPP(NEXT(c));(c)=NEXT(c);}
- struct oEGT eg_up,eg_sp,eg_spm,eg_nf,eg_nfm;
+ struct oEGT eg_nf,eg_nfm;
- struct oEGT eg_znfm,eg_pz,eg_np,eg_mp,eg_ra,eg_mc,eg_gc;
+ struct oEGT eg_znfm,eg_pz,eg_np,eg_ra,eg_mc,eg_gc;
  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
  #define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))
-Line 35  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
+Line 91  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
 Line 35  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
 Line 91  int TP,NBP,NMP,NFP,NDP,ZR,NZR;
  extern int (*cmpdl)();
  extern int do_weyl;
- void Pdp_gr_flags(), Pdp_gr_print();
+ extern DP_Print;
- void Pdp_gr_main(),Pdp_gr_mod_main(),Pdp_f4_main(),Pdp_f4_mod_main();
+ void _tf_to_vect_compress(NODE,DL *,CDP *);
+ NODE mul_dllist(DL,DP);
+ void dp_imul_d(DP,Q,DP *);
  void print_stat(void);
  void init_stat(void);
  int dp_load_t(int,DP *);
-Line 57  DP_pairs criterion_M(DP_pairs);
+Line 115  DP_pairs criterion_M(DP_pairs);
 Line 57  DP_pairs criterion_M(DP_pairs);
 Line 115  DP_pairs criterion_M(DP_pairs);
  DP_pairs criterion_B(DP_pairs,int);
  DP_pairs newpairs(NODE,int);
  DP_pairs updpairs(DP_pairs,NODE,int);
- void _dp_nf_ptozp(NODE,DP,DP *,int,int,DP *);
- void _dp_nf_ptozp_mpi(NODE,DP,DP *,int,int,DP *);
  void _dp_nf(NODE,DP,DP *,int,DP *);
- void _dp_nf_mod(NODE,DP,DP *,int,int,DP *);
+ void _dp_nf_z(NODE,DP,DP *,int,int,DP *);
- void interreduce_mod(NODE,int,int);
  NODE gb_mod(NODE,int);
  NODE gbd(NODE,int,NODE,NODE);
  NODE gb(NODE,int,NODE);
-Line 90  void pltovl(LIST,VL *);
+Line 145  void pltovl(LIST,VL *);
 Line 90  void pltovl(LIST,VL *);
 Line 145  void pltovl(LIST,VL *);
  void printdl(DL);
  int DPPlength(DP_pairs);
  void dp_gr_mod_main(LIST,LIST,Num,int,struct order_spec *,LIST *);
- void dp_gr_main(LIST,LIST,Num,int,struct order_spec *,LIST *);
+ void dp_gr_main(LIST,LIST,Num,int,int,struct order_spec *,LIST *);
  void dp_f4_main(LIST,LIST,struct order_spec *,LIST *);
  void dp_f4_mod_main(LIST,LIST,int,struct order_spec *,LIST *);
  double get_rtime();
  void _dpmod_to_vect(DP,DL *,int *);
  void dp_to_vect(DP,DL *,Q *);
- NODE dp_dllist(DP f),symb_merge(NODE,NODE,int);
+ NODE dp_dllist(DP f);
+ NODE symb_merge(NODE,NODE,int),_symb_merge(NODE,NODE,int);
  extern int dp_nelim;
  extern int dp_fcoeffs;
  static DP *ps,*psm;
-Line 106  static P *psc;
+Line 161  static P *psc;
 Line 106  static P *psc;
 Line 161  static P *psc;
  static int *pss;
  static int psn,pslen;
- static int NVars,CNVars,PCoeffs;
+ static int NVars,CNVars;
  static VL VC;
+ int PCoeffs;
+ int DP_Print = 0;
+ int DP_Multiple = 0;
+ int DP_NFStat = 0;
+ LIST Dist = 0;
+ int NoGCD = 0;
+ int GenTrace = 0;
+ int OXCheck = -1;
  static int NoSugar = 0;
  static int NoCriB = 0;
  static int NoGC = 0;
  static int NoMC = 0;
  static int NoRA = 0;
- int Print = 0;
+ static int DP_PrintShort = 0;
- static int PrintShort = 0;
  static int ShowMag = 0;
  static int Stat = 0;
- static int Multiple = 0;
  static int Denominator = 1;
  static int Top = 0;
  static int Reverse = 0;
- static int InterReduce = 0;
  static int Max_mag = 0;
  static char *Demand = 0;
  static int PtozpRA = 0;
- LIST Dist = 0;
- int NoGCD = 0;
- int GenTrace = 0;
- int OXCheck = -1;
  int doing_f4;
  NODE TraceList;
+ NODE AllTraceList;
- void Pdp_gr_flags(arg,rp)
+ INLINE int eqdl(nv,dl1,dl2)
- NODE arg;
- LIST *rp;
- {
-         Obj name,value;
-         NODE n;
-         if ( arg ) {
-                 asir_assert(ARG0(arg),O_LIST,"dp_gr_flags");
-                 n = BDY((LIST)ARG0(arg));
-                 while ( n ) {
-                         name = (Obj)BDY(n); n = NEXT(n);
-                         if ( !n )
-                                 break;
-                         else {
-                                 value = (Obj)BDY(n); n = NEXT(n);
-                         }
-                         dp_set_flag(name,value);
-                 }
-         }
-         dp_make_flaglist(rp);
- }
- void Pdp_gr_print(arg,rp)
- NODE arg;
- Q *rp;
- {
-         Q q;
-         if ( arg ) {
-                 asir_assert(ARG0(arg),O_N,"dp_gr_print");
-                 q = (Q)ARG0(arg); Print = QTOS(q);
-         } else
-                 STOQ(Print,q);
-         *rp = q;
- }
- void Pdp_gr_main(arg,rp)
- NODE arg;
- LIST *rp;
- {
-         LIST f,v;
-         Num homo;
-         Q m;
-         int modular;
-         struct order_spec ord;
-         asir_assert(ARG0(arg),O_LIST,"dp_gr_main");
-         asir_assert(ARG1(arg),O_LIST,"dp_gr_main");
-         asir_assert(ARG2(arg),O_N,"dp_gr_main");
-         asir_assert(ARG3(arg),O_N,"dp_gr_main");
-         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
-         homo = (Num)ARG2(arg);
-         m = (Q)ARG3(arg);
-         if ( !m )
-                 modular = 0;
-         else if ( PL(NM(m))>1 || (PL(NM(m)) == 1 && BD(NM(m))[0] >= 0x80000000) )
-                 error("dp_gr_main : too large modulus");
-         else
-                 modular = QTOS(m);
-         create_order_spec(ARG4(arg),&ord);
-         dp_gr_main(f,v,homo,modular,&ord,rp);
- }
- void Pdp_f4_main(arg,rp)
- NODE arg;
- LIST *rp;
- {
-         LIST f,v;
-         struct order_spec ord;
-         asir_assert(ARG0(arg),O_LIST,"dp_f4_main");
-         asir_assert(ARG1(arg),O_LIST,"dp_f4_main");
-         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
-         create_order_spec(ARG2(arg),&ord);
-         dp_f4_main(f,v,&ord,rp);
- }
- void Pdp_f4_mod_main(arg,rp)
- NODE arg;
- LIST *rp;
- {
-         LIST f,v;
-         int m;
-         struct order_spec ord;
-         asir_assert(ARG0(arg),O_LIST,"dp_f4_main");
-         asir_assert(ARG1(arg),O_LIST,"dp_f4_main");
-         asir_assert(ARG2(arg),O_N,"dp_f4_main");
-         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg); m = QTOS((Q)ARG2(arg));
-         create_order_spec(ARG3(arg),&ord);
-         dp_f4_mod_main(f,v,m,&ord,rp);
- }
- void Pdp_gr_mod_main(arg,rp)
- NODE arg;
- LIST *rp;
- {
-         LIST f,v;
-         Num homo;
-         int m;
-         struct order_spec ord;
-         asir_assert(ARG0(arg),O_LIST,"dp_gr_mod_main");
-         asir_assert(ARG1(arg),O_LIST,"dp_gr_mod_main");
-         asir_assert(ARG2(arg),O_N,"dp_gr_mod_main");
-         asir_assert(ARG3(arg),O_N,"dp_gr_mod_main");
-         f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);
-         homo = (Num)ARG2(arg); m = QTOS((Q)ARG3(arg));
-         create_order_spec(ARG4(arg),&ord);
-         dp_gr_mod_main(f,v,homo,m,&ord,rp);
- }
- int eqdl(nv,dl1,dl2)
  int nv;
  DL dl1,dl2;
  {
-Line 280  int *b;
+Line 227  int *b;
 Line 280  int *b;
 Line 227  int *b;
          }
  }
+ /* create compressed poly */
+ void _dpmod_to_vect_compress(f,at,b)
+ DP f;
+ DL *at;
+ CDP *b;
+ {
+         int i,j,nv,len;
+         MP m;
+         CDP r;
+         nv = f->nv;
+         for ( m = BDY(f), len = 0; m; m = NEXT(m), len++ );
+         r = (CDP)MALLOC(sizeof(struct oCDP));
+         r->len = len;
+         r->body = (CM)MALLOC_ATOMIC(sizeof(struct oCM)*len);
+         for ( m = BDY(f), i = j = 0; m; m = NEXT(m), j++ ) {
+                 for ( ; !eqdl(nv,m->dl,at[i]); i++ );
+                 r->body[j].index = i;
+                 r->body[j].c = ITOS(m->c);
+         }
+         *b = r;
+ }
+ /* [t,findex] -> tf -> compressed vector */
+ void _tf_to_vect_compress(tf,at,b)
+ NODE tf;
+ DL *at;
+ CDP *b;
+ {
+         int i,j,k,nv,len;
+         DL t,s,d1;
+         DP f;
+         MP m;
+         CDP r;
+         t = (DL)BDY(tf);
+         f = ps[(int)BDY(NEXT(tf))];
+         nv = f->nv;
+         for ( m = BDY(f), len = 0; m; m = NEXT(m), len++ );
+         r = (CDP)MALLOC(sizeof(struct oCDP));
+         r->len = len;
+         r->body = (CM)MALLOC_ATOMIC(sizeof(struct oCM)*len);
+         NEWDL(s,nv);
+         for ( m = BDY(f), i = j = 0; m; m = NEXT(m), j++ ) {
+                 d1 = m->dl;
+                 s->td = t->td+d1->td;
+                 for ( k = 0; k < nv; k++ )
+                         s->d[k] = t->d[k]+d1->d[k];
+                 for ( ; !eqdl(nv,s,at[i]); i++ );
+                 r->body[j].index = i;
+                 r->body[j].c = ITOS(m->c);
+         }
+         *b = r;
+ }
+ /* dense vector -> CDP  */
+ void compress_vect(a,n,rp)
+ int *a;
+ int n;
+ CDP *rp;
+ {
+         int i,j,nz;
+         CDP r;
+         for ( i = 0, nz = 0; i < n; i++ )
+                 if ( a[i] ) nz++;
+         *rp = r = (CDP)MALLOC(sizeof(struct oCDP));
+         r->len = nz;
+         r->body = (CM)MALLOC(sizeof(struct oCM)*nz);
+         for ( i = 0, j = 0; i < n; i++ ) {
+                 if ( a[i] ) {
+                         r->body[j].index = i;
+                         r->body[j].c = ITOS(a[i]);
+                         j++;
+                 }
+         }
+ }
  void dp_to_vect(f,at,b)
  DP f;
  DL *at;
-Line 311  DP f;
+Line 341  DP f;
 Line 311  DP f;
 Line 341  DP f;
          return mp0;
  }
+ NODE mul_dllist(d,f)
+ DL d;
+ DP f;
+ {
+         MP m;
+         NODE mp,mp0;
+         DL t,d1;
+         int i,nv;
+         if ( !f )
+                 return 0;
+         nv = NV(f);
+         mp0 = 0;
+         for ( m = BDY(f); m; m = NEXT(m) ) {
+                 NEXTNODE(mp0,mp);
+                 NEWDL(t,nv);
+                 d1 = m->dl;
+                 t->td = d->td+d1->td;
+                 for ( i = 0; i < nv; i++ )
+                         t->d[i] = d->d[i]+d1->d[i];
+                 BDY(mp) = (pointer)t;
+         }
+         NEXT(mp) = 0;
+         return mp0;
+ }
  void pdl(f)
  NODE f;
  {
-Line 321  NODE f;
+Line 377  NODE f;
 Line 321  NODE f;
 Line 377  NODE f;
          printf("\n");
  }
- void dp_gr_main(f,v,homo,modular,ord,rp)
+ void dp_gr_main(f,v,homo,modular,field,ord,rp)
  LIST f,v;
  Num homo;
- int modular;
+ int modular,field;
  struct order_spec *ord;
  LIST *rp;
  {
          int i,mindex,m,nochk;
          struct order_spec ord1;
+         Q q;
          VL fv,vv,vc;
          NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;
+         NODE ind,ind0;
+         LIST trace,gbindex;
-         mindex = 0; nochk = 0; dp_fcoeffs = 0;
+         mindex = 0; nochk = 0; dp_fcoeffs = field;
          get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);
          NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc;
          CNVars = homo ? NVars+1 : NVars;
-Line 360  LIST *rp;
+Line 419  LIST *rp;
 Line 360  LIST *rp;
 Line 419  LIST *rp;
                  modular = -modular; nochk = 1;
          }
          if ( modular )
-                 m = modular > 1 ? modular : lprime[mindex];
+                 m = modular > 1 ? modular : get_lprime(mindex);
          else
                  m = 0;
          makesubst(vc,&subst);
-Line 370  LIST *rp;
+Line 429  LIST *rp;
 Line 370  LIST *rp;
 Line 429  LIST *rp;
                  if ( homo ) {
                          initd(&ord1); CNVars = NVars+1;
                  }
-                 if ( Print && modular ) {
+                 if ( DP_Print && modular ) {
                          fprintf(asir_out,"mod= %d, eval = ",m); printsubst(subst);
                  }
                  x = gb(s,m,subst);
-Line 390  LIST *rp;
+Line 449  LIST *rp;
 Line 390  LIST *rp;
 Line 449  LIST *rp;
                          if ( modular > 1 ) {
                                  *rp = 0; return;
                          } else
-                                 m = lprime[++mindex];
+                                 m = get_lprime(++mindex);
                  makesubst(vc,&subst);
                  psn = length(s);
                  for ( i = psn; i < pslen; i++ ) {
                          pss[i] = 0; psh[i] = 0; psc[i] = 0; ps[i] = 0;
                  }
          }
-         for ( r0 = 0; x; x = NEXT(x) ) {
+         for ( r0 = 0, ind0 = 0; x; x = NEXT(x) ) {
                  NEXTNODE(r0,r); dp_load((int)BDY(x),&ps[(int)BDY(x)]);
                  dtop(CO,vv,ps[(int)BDY(x)],(P *)&BDY(r));
+                 NEXTNODE(ind0,ind);
+                 STOQ((int)BDY(x),q); BDY(ind) = q;
          }
          if ( r0 ) NEXT(r) = 0;
+         if ( ind0 ) NEXT(ind) = 0;
          MKLIST(*rp,r0);
+         MKLIST(gbindex,ind0);
+         if ( GenTrace && OXCheck < 0 ) {
+                 x = AllTraceList;
+                 for ( r = 0; x; x = NEXT(x) ) {
+                         MKNODE(r0,BDY(x),r); r = r0;
+                 }
+                 MKLIST(trace,r);
+                 r0 = mknode(3,*rp,gbindex,trace);
+                 MKLIST(*rp,r0);
+         }
          print_stat();
          if ( ShowMag )
                  fprintf(asir_out,"\nMax_mag=%d\n",Max_mag);
-Line 419  LIST *rp;
+Line 493  LIST *rp;
 Line 419  LIST *rp;
 Line 493  LIST *rp;
          VL fv,vv,vc;
          NODE fd,fd0,r,r0,t,x,s,xx;
          DP a,b,c;
+ extern struct oEGT eg_red_mod;
          get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);
          NVars = length((NODE)vv); PCoeffs = vc ? 1 : 0; VC = vc;
-Line 456  LIST *rp;
+Line 531  LIST *rp;
 Line 456  LIST *rp;
 Line 531  LIST *rp;
          if ( homo ) {
                  initd(&ord1); CNVars = NVars+1;
          }
+ /* init_eg(&eg_red_mod); */
          x = gb_mod(s,m);
+ /* print_eg("Red_mod",&eg_red_mod); */
          if ( homo ) {
                  reducebase_dehomo(x,&xx); x = xx;
                  initd(ord); CNVars = NVars;
-Line 480  LIST f,v;
+Line 557  LIST f,v;
 Line 480  LIST f,v;
 Line 557  LIST f,v;
  struct order_spec *ord;
  LIST *rp;
  {
-         int i,mindex,m,nochk;
+         int i,mindex,m,nochk,homogen;
          struct order_spec ord1;
          VL fv,vv,vc;
          NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;
-Line 492  LIST *rp;
+Line 569  LIST *rp;
 Line 492  LIST *rp;
 Line 569  LIST *rp;
          if ( ord->id && NVars != ord->nv )
                  error("dp_f4_main : invalid order specification");
          initd(ord);
-         for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
+         for ( fd0 = 0, t = BDY(f), homogen = 1; t; t = NEXT(t) ) {
                  NEXTNODE(fd0,fd); ptod(CO,vv,(P)BDY(t),(DP *)&BDY(fd));
+                 if ( homogen )
+                         homogen = dp_homogeneous(BDY(fd));
          }
          if ( fd0 ) NEXT(fd) = 0;
          setup_arrays(fd0,0,&s);
          x = gb_f4(s);
-         reduceall(x,&xx); x = xx;
+         if ( !homogen ) {
+                 reduceall(x,&xx); x = xx;
+         }
          for ( r0 = 0; x; x = NEXT(x) ) {
                  NEXTNODE(r0,r); dp_load((int)BDY(x),&ps[(int)BDY(x)]);
                  dtop(CO,vv,ps[(int)BDY(x)],(P *)&BDY(r));
-Line 513  int m;
+Line 594  int m;
 Line 513  int m;
 Line 594  int m;
  struct order_spec *ord;
  LIST *rp;
  {
-         int i;
+         int i,homogen;
          struct order_spec ord1;
          VL fv,vv,vc;
          DP b,c,c1;
-Line 526  LIST *rp;
+Line 607  LIST *rp;
 Line 526  LIST *rp;
 Line 607  LIST *rp;
          if ( ord->id && NVars != ord->nv )
                  error("dp_f4_mod_main : invalid order specification");
          initd(ord);
-         for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) {
+         for ( fd0 = 0, t = BDY(f), homogen = 1; t; t = NEXT(t) ) {
                  ptod(CO,vv,(P)BDY(t),&b);
+                 if ( homogen )
+                         homogen = dp_homogeneous(b);
                  _dp_mod(b,m,0,&c);
                  _dp_monic(c,m,&c1);
                  if ( c ) {
-Line 537  LIST *rp;
+Line 620  LIST *rp;
 Line 537  LIST *rp;
 Line 620  LIST *rp;
          if ( fd0 ) NEXT(fd) = 0;
          setup_arrays(fd0,m,&s);
          x = gb_f4_mod(s,m);
-         reduceall_mod(x,m,&xx); x = xx;
+         if ( !homogen ) {
+                 reduceall_mod(x,m,&xx); x = xx;
+         }
          for ( r0 = 0; x; x = NEXT(x) ) {
                  NEXTNODE(r0,r); _dtop_mod(CO,vv,ps[(int)BDY(x)],(P *)&BDY(r));
          }
-Line 579  NODE f;
+Line 664  NODE f;
 Line 579  NODE f;
 Line 664  NODE f;
          while ( d ) {
                  get_eg(&tmp0);
                  minsugar(d,&dm,&dr); d = dr;
-                 if ( Print )
+                 if ( DP_Print )
                          fprintf(asir_out,"sugar=%d\n",dm->sugar);
                  blist = 0; s0 = 0;
                  /* asph : sum of all head terms of spoly */
-Line 620  NODE f;
+Line 705  NODE f;
 Line 620  NODE f;
 Line 705  NODE f;
                          dp_to_vect(BDY(r),at,(Q *)mat->body[i]);
                  get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);
                  init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);
-                 if ( Print ) {
+                 if ( DP_Print ) {
                          print_eg("Symb",&eg_split_symb);
                          fprintf(asir_out,"mat : %d x %d",row,col);
                          fflush(asir_out);
-Line 630  NODE f;
+Line 715  NODE f;
 Line 630  NODE f;
 Line 715  NODE f;
  #else
                  rank = generic_gauss_elim(mat,&nm,&dn,&rind,&cind);
  #endif
-                 if ( Print )
+                 if ( DP_Print )
                          fprintf(asir_out,"done rank = %d\n",rank,row,col);
                  for ( i = 0; i < rank; i++ ) {
                          for ( k = 0; k < nred; k++ )
-Line 655  NODE f;
+Line 740  NODE f;
 Line 655  NODE f;
 Line 740  NODE f;
                          }
                  }
          }
-         if ( Print ) {
+         if ( DP_Print ) {
                  print_eg("Symb",&eg_symb);
                  print_eg("Mod",&eg_mod); print_eg("GaussElim",&eg_elim);
                  print_eg("ChRem",&eg_chrem); print_eg("IntToRat",&eg_intrat);
-Line 676  int m;
+Line 761  int m;
 Line 676  int m;
 Line 761  int m;
          DP_pairs d,dm,dr,t;
          DP h,nf,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;
          MP mp,mp0;
-         NODE blist,bt,nt;
+         NODE blist,bt,nt,bt1,dt,rhtlist;
          DL *ht,*at,*st;
-         int **spmat,**redmat;
+         int **spmat;
-         int *colstat,*w;
+         CDP *redmat;
+         int *colstat,*w,*w1;
          int rank,nred,nsp,nonzero,spcol;
-         int *indred,*isred,*ri;
+         int *indred,*isred;
+         CDP ri;
          struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim1,eg_split_elim2;
          extern struct oEGT eg_symb,eg_elim1,eg_elim2;
-Line 697  int m;
+Line 784  int m;
 Line 697  int m;
 Line 784  int m;
          while ( d ) {
                  get_eg(&tmp0);
                  minsugar(d,&dm,&dr); d = dr;
-                 if ( Print )
+                 if ( DP_Print )
                          fprintf(asir_out,"sugar=%d\n",dm->sugar);
                  blist = 0; s0 = 0;
                  /* asph : sum of all head terms of spoly */
-Line 708  int m;
+Line 795  int m;
 Line 708  int m;
 Line 795  int m;
                                  s0 = symb_merge(s0,dp_dllist(sp),nv);
                          }
                  }
-                 /* s0 : all the terms appeared in symbolic redunction */
+                 /* s0 : all the terms appeared in symbolic reduction */
+                 rhtlist = 0;
                  for ( s = s0, nred = 0; s; s = NEXT(s) ) {
                          for ( r = gall; r; r = NEXT(r) )
                                  if ( _dl_redble(BDY(ps[(int)BDY(r)])->dl,BDY(s),nv) )
-Line 716  int m;
+Line 804  int m;
 Line 716  int m;
 Line 804  int m;
                          if ( r ) {
                                  dltod(BDY(s),nv,&tdp);
                                  dp_subd(tdp,ps[(int)BDY(r)],&sd);
-                                 _dp_mod(sd,m,0,&sdm);
+                                 dt = mul_dllist(BDY(sd)->dl,ps[(int)BDY(r)]);
-                                 _mulmd(CO,m,sdm,ps[(int)BDY(r)],&f2);
+                                 /* list of [t,f] */
-                                 MKNODE(bt,f2,blist); blist = bt;
+                                 bt1 = mknode(2,BDY(sd)->dl,BDY(r));
-                                 s = symb_merge(s,dp_dllist(f2),nv);
+                                 MKNODE(bt,bt1,blist); blist = bt;
+                                 MKNODE(bt,BDY(dt),rhtlist); rhtlist = bt;
+                                 symb_merge(s,dt,nv);
                                  nred++;
                          }
                  }
-                 get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);
-                 init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);
                  /* the first nred polys in blist are reducers */
                  /* row = the number of all the polys */
-Line 733  int m;
+Line 820  int m;
 Line 733  int m;
 Line 820  int m;
                  /* head terms of reducers */
                  ht = (DL *)MALLOC(nred*sizeof(DL));
-                 for ( r = blist, i = 0; i < nred; r = NEXT(r), i++ )
+                 for ( r = rhtlist, i = 0; i < nred; r = NEXT(r), i++ )
-                         ht[i] = BDY((DP)BDY(r))->dl;
+                         ht[i] = BDY(r);
                  /* col = number of all terms */
                  for ( s = s0, col = 0; s; s = NEXT(s), col++ );
-Line 748  int m;
+Line 835  int m;
 Line 748  int m;
 Line 835  int m;
                  nsp = row-nred;
                  /* reducer matrix */
-                 redmat = (int **)almat(nred,col);
+                 /* indred : register the position of the head term */
+                 redmat = (CDP *)MALLOC(nred*sizeof(CDP));
                  for ( i = 0, r = blist; i < nred; r = NEXT(r), i++ )
-                         _dpmod_to_vect(BDY(r),at,redmat[i]);
+                         _tf_to_vect_compress(BDY(r),at,&redmat[i]);
                  /* XXX */
  /*              reduce_reducers_mod(redmat,nred,col,m); */
                  /* register the position of the head term */
-Line 760  int m;
+Line 848  int m;
 Line 760  int m;
 Line 848  int m;
                  bzero(isred,col*sizeof(int));
                  for ( i = 0; i < nred; i++ ) {
                          ri = redmat[i];
-                         for ( j = 0; j < col && !ri[j]; j++ );
+                         indred[i] = ri->body[0].index;
-                         indred[i] = j;
+                         isred[indred[i]] = 1;
-                         isred[j] = 1;
                  }
                  spcol = col-nred;
-Line 771  int m;
+Line 858  int m;
 Line 771  int m;
 Line 858  int m;
                  for ( j = 0, k = 0; j < col; j++ )
                          if ( !isred[j] )
                                  st[k++] = at[j];
+                 get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);
+                 init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);
+                 get_eg(&tmp1);
                  /* spoly matrix; stored in reduced form; terms in ht[] are omitted */
-                 spmat = almat(nsp,spcol);
+                 spmat = (int **)MALLOC(nsp*sizeof(int *));
                  w = (int *)MALLOC(col*sizeof(int));
-                 for ( ; i < row; r = NEXT(r), i++ ) {
+                 /* skip reducers in blist */
+                 for ( i = 0, r = blist; i < nred; r = NEXT(r), i++ );
+                 for ( i = 0; r; r = NEXT(r) ) {
                          bzero(w,col*sizeof(int));
                          _dpmod_to_vect(BDY(r),at,w);
-                         reduce_sp_by_red_mod(w,redmat,indred,nred,col,m);
+                         reduce_sp_by_red_mod_compress(w,redmat,indred,nred,col,m);
-                         for ( j = 0, k = 0; j < col; j++ )
+                         for ( j = 0; j < col; j++ )
-                                 if ( !isred[j] )
+                                 if ( w[j] )
-                                         spmat[i-nred][k++] = w[j];
+                                         break;
+                         if ( j < col ) {
+                                 w1 = (int *)MALLOC_ATOMIC(spcol*sizeof(int));
+                                 for ( j = 0, k = 0; j < col; j++ )
+                                         if ( !isred[j] )
+                                                 w1[k++] = w[j];
+                                 spmat[i] = w1;
+                                 i++;
+                         }
                  }
+                 /* update nsp */
+                 nsp = i;
+                 /* XXX free redmat explicitly */
+                 for ( k = 0; k < nred; k++ ) {
+                         GC_free(BDY(redmat[k]));
+                         GC_free(redmat[k]);
+                 }
                  get_eg(&tmp0); add_eg(&eg_elim1,&tmp1,&tmp0);
                  init_eg(&eg_split_elim1); add_eg(&eg_split_elim1,&tmp1,&tmp0);
                  colstat = (int *)MALLOC_ATOMIC(spcol*sizeof(int));
+                 bzero(colstat,spcol*sizeof(int));
                  for ( i = 0, nonzero=0; i < nsp; i++ )
                          for ( j = 0; j < spcol; j++ )
                                  if ( spmat[i][j] )
                                          nonzero++;
-                 if ( Print )
+                 if ( DP_Print && nsp )
                          fprintf(asir_out,"spmat : %d x %d (nonzero=%f%%)...",
                                  nsp,spcol,((double)nonzero*100)/(nsp*spcol));
-                 rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat);
+                 if ( nsp )
+                         rank = generic_gauss_elim_mod(spmat,nsp,spcol,m,colstat);
+                 else
+                         rank = 0;
                  get_eg(&tmp1); add_eg(&eg_elim2,&tmp0,&tmp1);
                  init_eg(&eg_split_elim2); add_eg(&eg_split_elim2,&tmp0,&tmp1);
-                 if ( Print ) {
+                 if ( DP_Print ) {
                          fprintf(asir_out,"done rank = %d\n",rank,row,col);
                          print_eg("Symb",&eg_split_symb);
                          print_eg("Elim1",&eg_split_elim1);
                          print_eg("Elim2",&eg_split_elim2);
                          fprintf(asir_out,"\n");
                  }
+                 if ( !rank )
+                         continue;
                  for ( j = 0, i = 0; j < spcol; j++ )
                          if ( colstat[j] ) {
                                  mp0 = 0;
-Line 824  int m;
+Line 940  int m;
 Line 824  int m;
 Line 940  int m;
                                  gall = append_one(gall,nh);
                                  i++;
                          }
+                 /* XXX free spmat[] explicitly */
+                 for ( j = 0; j < nsp; j++ ) {
+                         GC_free(spmat[j]);
+                 }
          }
-         if ( Print ) {
+         if ( DP_Print ) {
                  print_eg("Symb",&eg_symb);
                  print_eg("Elim1",&eg_elim1);
                  print_eg("Elim2",&eg_elim2);
-Line 961  int m;
+Line 1082  int m;
 Line 961  int m;
 Line 1082  int m;
          int i;
          NODE s,s0,f0;
+ #if 1
          f0 = f = NODE_sortb(f,1);
+ #else
+         f0 = f;
+ #endif
          psn = length(f); pslen = 2*psn;
          ps = (DP *)MALLOC(pslen*sizeof(DP));
          psh = (DL *)MALLOC(pslen*sizeof(DL));
-Line 975  int m;
+Line 1100  int m;
 Line 975  int m;
 Line 1100  int m;
                  pss[i] = ps[i]->sugar;
                  psc[i] = BDY(ps[i])->c;
          }
-         if ( GenTrace && (OXCheck >= 0) ) {
+         if ( GenTrace ) {
                  Q q;
                  STRING fname;
                  LIST input;
-                 NODE arg;
+                 NODE arg,t,t1;
                  Obj dmy;
+                 t = 0;
+                 for ( i = psn-1; i >= 0; i-- ) {
+                         MKNODE(t1,ps[i],t);
+                         t = t1;
+                 }
+                 MKLIST(input,t);
-                 STOQ(OXCheck,q);
+                 if ( OXCheck >= 0 ) {
-                 MKSTR(fname,"register_input");
+                         STOQ(OXCheck,q);
-                 MKLIST(input,f0);
+                         MKSTR(fname,"register_input");
-                 arg = mknode(3,q,fname,input);
+                         arg = mknode(3,q,fname,input);
-                 Pox_cmo_rpc(arg,&dmy);
+                         Pox_cmo_rpc(arg,&dmy);
+                 } else if ( OXCheck < 0 ) {
+                         MKNODE(AllTraceList,input,0);
+                 }
          }
          for ( s0 = 0, i = 0; i < psn; i++ ) {
                  NEXTNODE(s0,s); BDY(s) = (pointer)i;
-Line 1014  int m;
+Line 1149  int m;
 Line 1014  int m;
 Line 1149  int m;
                  else
                          dp_ptozp(f,r);
                  if ( GenTrace && TraceList ) {
+                         /* adust the denominator according to the final
+                            content reduction */
                          divsp(CO,BDY(f)->c,BDY(*r)->c,&d);
                          mulp(CO,(P)ARG3(BDY((LIST)BDY(TraceList))),d,&t);
                          ARG3(BDY((LIST)BDY(TraceList))) = t;
-Line 1100  NODE *h;
+Line 1237  NODE *h;
 Line 1100  NODE *h;
 Line 1237  NODE *h;
          if ( NoRA ) {
                  *h = in; return;
          }
-         if ( Print || PrintShort ) {
+         if ( DP_Print || DP_PrintShort ) {
                  fprintf(asir_out,"reduceall\n"); fflush(asir_out);
          }
          r = NODE_sortbi(in,0);
-Line 1126  NODE *h;
+Line 1263  NODE *h;
 Line 1126  NODE *h;
 Line 1263  NODE *h;
                          MKLIST(hist,node);
                          MKNODE(TraceList,hist,0);
                  }
-                 if ( !PtozpRA || !Multiple )
+                 _dp_nf(top,ps[w[i]],ps,1,&g);
-                         _dp_nf(top,ps[w[i]],ps,1,&g);
-                 else
- #if MPI
-                         _dp_nf_ptozp_mpi(top,ps[w[i]],ps,1,Multiple,&g);
- #else
-                         _dp_nf_ptozp(top,ps[w[i]],ps,1,Multiple,&g);
- #endif
                  prim_part(g,0,&g1);
                  get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);
-                 if ( Print || PrintShort ) {
+                 if ( DP_Print || DP_PrintShort ) {
                          fprintf(asir_out,"."); fflush(asir_out);
                  }
                  w[i] = newps(g1,0,(NODE)0);
-Line 1145  NODE *h;
+Line 1275  NODE *h;
 Line 1145  NODE *h;
 Line 1275  NODE *h;
                  MKNODE(t,(pointer)w[j],top); top = t;
          }
          *h = top;
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"\n");
  }
-Line 1157  NODE *h;
+Line 1287  NODE *h;
 Line 1157  NODE *h;
 Line 1287  NODE *h;
          NODE r,t,top;
          int n,i,j;
          int *w;
-         DP g;
+         DP g,p;
          struct oEGT tmp0,tmp1;
          if ( NoRA ) {
                  *h = in; return;
          }
-         if ( Print || PrintShort ) {
+         if ( DP_Print || DP_PrintShort ) {
                  fprintf(asir_out,"reduceall\n"); fflush(asir_out);
          }
          r = NODE_sortbi(in,0);
-Line 1179  NODE *h;
+Line 1309  NODE *h;
 Line 1179  NODE *h;
 Line 1309  NODE *h;
                  get_eg(&tmp0);
                  if ( PCoeffs )
                          dp_nf_mod(top,ps[w[i]],ps,m,1,&g);
-                 else
+                 else {
-                         _dp_nf_mod(top,ps[w[i]],ps,m,1,&g);
+                         dpto_dp(ps[w[i]],&p);
+                         _dp_nf_mod_destructive(top,p,ps,m,1,&g);
+                 }
                  get_eg(&tmp1); add_eg(&eg_ra,&tmp0,&tmp1);
-                 if ( Print || PrintShort ) {
+                 if ( DP_Print || DP_PrintShort ) {
                          fprintf(asir_out,"."); fflush(asir_out);
                  }
                  w[i] = newps_mod(g,m);
-Line 1191  NODE *h;
+Line 1323  NODE *h;
 Line 1191  NODE *h;
 Line 1323  NODE *h;
                  MKNODE(t,(pointer)w[j],top); top = t;
          }
          *h = top;
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"\n");
  }
-Line 1226  NODE subst;
+Line 1358  NODE subst;
 Line 1226  NODE subst;
 Line 1358  NODE subst;
                  _dp_mod(a,m,subst,&psm[psn]);
          if ( GenTrace ) {
                  NODE tn,tr,tr1;
-                 LIST trace;
+                 LIST trace,trace1;
+                 NODE arg;
+                 Q q1,q2;
+                 STRING fname;
+                 Obj dmy;
                  /* reverse the TraceList */
                  tn = TraceList;
-Line 1235  NODE subst;
+Line 1371  NODE subst;
 Line 1235  NODE subst;
 Line 1371  NODE subst;
                  }
                  MKLIST(trace,tr);
                  if ( OXCheck >= 0 ) {
-                         NODE arg;
-                         Q q1,q2;
-                         STRING fname;
-                         Obj dmy;
                          STOQ(OXCheck,q1);
                          MKSTR(fname,"check_trace");
                          STOQ(psn,q2);
                          arg = mknode(5,q1,fname,a,q2,trace);
                          Pox_cmo_rpc(arg,&dmy);
+                 } else if ( OXCheck < 0 ) {
+                         STOQ(psn,q1);
+                         tn = mknode(2,q1,trace);
+                         MKLIST(trace1,tn);
+                         MKNODE(tr,trace1,AllTraceList);
+                         AllTraceList = tr;
                  } else
                          dp_save(psn,(Obj)trace,"t");
                  TraceList = 0;
-Line 1445  NODE subst;
+Line 1582  NODE subst;
 Line 1445  NODE subst;
 Line 1582  NODE subst;
                  gall = append_one(gall,i);
          }
          while ( d ) {
-                 get_eg(&tmp0);
+                 l = minp(d,&d);
-                 l = minp(d,&d1); d = d1;
-                 get_eg(&tmp1); add_eg(&eg_mp,&tmp0,&tmp1);
                  if ( m ) {
-                         get_eg(&tspm0);
                          _dp_sp_mod_dup(psm[l->dp1],psm[l->dp2],m,&h);
-                         new_sugar = h->sugar;
+                         if ( h )
-                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1);
+                                 new_sugar = h->sugar;
                          get_eg(&tnfm0);
                          _dp_nf_mod_destructive(gall,h,psm,m,0,&nfm);
                          get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);
                  } else
                          nfm = (DP)1;
                  if ( nfm ) {
-                         get_eg(&tsp0);
                          if ( Demand ) {
                                  if ( dp_load_t(psn,&nf) ) {
                                          skip_nf_flag = 1;
-                                         get_eg(&tsp1); add_eg(&eg_nf,&tsp0,&tsp1);
+                                         tnf1=tsp1;
-                                         tnf0=tsp0; tnf1=tsp1;
                                          goto skip_nf;
                                  } else {
                                          skip_nf_flag = 0;
-Line 1477  NODE subst;
+Line 1609  NODE subst;
 Line 1477  NODE subst;
 Line 1609  NODE subst;
                                  STOQ(l->dp1,q); ARG1(BDY((LIST)BDY(NEXT(TraceList)))) = q;
                                  STOQ(l->dp2,q); ARG1(BDY((LIST)BDY(TraceList))) = q;
                          }
-                         new_sugar = h->sugar;
+                         if ( h )
-                         get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);
+                                 new_sugar = h->sugar;
                          get_eg(&tnf0);
                          t_0 = get_rtime();
-                         if ( !Multiple )
+                         if ( PCoeffs || dp_fcoeffs )
                                  _dp_nf(gall,h,ps,!Top,&nf);
                          else
- #if MPI
+                                 _dp_nf_z(gall,h,ps,!Top,DP_Multiple,&nf);
-                                 _dp_nf_ptozp_mpi(gall,h,ps,!Top,Multiple,&nf);
+                         if ( DP_Print )
- #else
-                                 _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);
- #endif
-                         if ( Print )
                                  fprintf(asir_out,"(%.3g)",get_rtime()-t_0);
                          get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);
                  } else
-Line 1516  skip_nf:
+Line 1644  skip_nf:
 Line 1516  skip_nf:
 Line 1644  skip_nf:
                                          mag += p_mag((P)mp->c);
                                  Max_mag = MAX(Max_mag,mag);
                          }
-                         if ( Print ) {
+                         if ( DP_Print ) {
                                  if ( !prev )
                                          fprintf(asir_out,"\n");
                                  print_split_e(&tnf0,&tnf1); print_split_e(&tpz0,&tpz1);
-Line 1527  skip_nf:
+Line 1655  skip_nf:
 Line 1527  skip_nf:
 Line 1655  skip_nf:
                                  if ( ShowMag )
                                          fprintf(asir_out,",mag=%d",mag);
                                  fprintf(asir_out,"\n"); fflush(asir_out);
-                         } else if ( PrintShort ) {
+                         } else if ( DP_PrintShort ) {
                                  fprintf(asir_out,"+"); fflush(asir_out);
                          }
                          prev = 1;
-Line 1535  skip_nf:
+Line 1663  skip_nf:
 Line 1535  skip_nf:
 Line 1663  skip_nf:
                          if ( m )
                                  add_eg(&eg_znfm,&tnfm0,&tnfm1);
                          ZR++;
-                         if ( Print || PrintShort ) {
+                         if ( DP_Print || DP_PrintShort ) {
                                  if ( new_sugar != prev_sugar ) {
                                          fprintf(asir_out,"[%d]",new_sugar);
                                          prev_sugar = new_sugar;
-Line 1544  skip_nf:
+Line 1672  skip_nf:
 Line 1544  skip_nf:
 Line 1672  skip_nf:
                          }
                  }
          }
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"gb done\n");
          return g;
  }
- NODE gbd(f,m,subst,dlist)
- NODE f;
- int m;
- NODE subst;
- NODE dlist;
- {
-         int i,nh,prev;
-         NODE r,g,gall;
-         struct dp_pairs ol;
-         DP_pairs l;
-         NODE pair;
-         DP h,nf,nfm,dp1,dp2;
-         struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1;
-         prev = 1;
-         l = &ol;
-         if ( m ) {
-                 psm = (DP *)MALLOC(pslen*sizeof(DP));
-                 for ( i = 0; i < psn; i++ )
-                         if ( psh[i] && !validhc(psc[i],m,subst) )
-                                 return 0;
-                         else
-                                 _dp_mod(ps[i],m,subst,&psm[i]);
-         }
-         for ( gall = g = 0, r = f; r; r = NEXT(r) ) {
-                 i = (int)BDY(r);
-                 g = updbase(g,i);
-                 gall = append_one(gall,i);
-         }
-         while ( dlist ) {
-                 pair = BDY((LIST)BDY(dlist)); dlist = NEXT(dlist);
-                 l->dp1 = QTOS((Q)BDY(pair)); pair = NEXT(pair);
-                 l->dp2 = QTOS((Q)BDY(pair));
-                 if ( m ) {
-                         get_eg(&tspm0);
-                         _dp_sp_mod_dup(ps[l->dp1],ps[l->dp2],m,&h);
-                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1);
-                         get_eg(&tnfm0);
-                         _dp_nf_mod_destructive(gall,h,ps,m,!Top,&nf);
-                         get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);
-                 } else
-                         nfm = (DP)1;
-                 if ( nfm ) {
-                         get_eg(&tsp0);
-                         if ( Demand ) {
-                                 dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2);
-                                 dp_sp(dp1,dp2,&h);
-                         } else
-                                 dp_sp(ps[l->dp1],ps[l->dp2],&h);
-                         get_eg(&tsp1); add_eg(&eg_sp,&tsp0,&tsp1);
-                         get_eg(&tnfm0);
-                         get_eg(&tnf0);
-                         if ( !Multiple )
-                                 _dp_nf(gall,h,ps,!Top,&nf);
-                         else
-                                 _dp_nf_ptozp(gall,h,ps,!Top,Multiple,&nf);
-                         get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);
-                 } else
-                         nf = 0;
-                 if ( nf ) {
-                         NZR++;
-                         get_eg(&tpz0);
-                         prim_part(nf,0,&h);
-                         get_eg(&tpz1); add_eg(&eg_pz,&tpz0,&tpz1);
-                         get_eg(&tnp0);
-                         nh = newps(h,m,subst);
-                         get_eg(&tnp1); add_eg(&eg_np,&tnp0,&tnp1);
-                         if ( nh < 0 )
-                                 return 0;
-                         g = updbase(g,nh);
-                         gall = append_one(gall,nh);
-                         if ( Print ) {
-                                 if ( !prev )
-                                         fprintf(asir_out,"\n");
-                                 print_split_eg(&tnf0,&tnf1); fflush(asir_out);
-                                 fprintf(asir_out,"(%d,%d),nb=%d,nab=%d,rp=%d,sugar=%d",l->dp1,l->dp2,length(g),length(gall),length(dlist),pss[nh]);
-                                 printdl(psh[nh]); fprintf(asir_out,"\n"); fflush(asir_out);
-                         }
-                         prev = 1;
-                 } else {
-                         if ( m )
-                                 add_eg(&eg_znfm,&tnfm0,&tnfm1);
-                         ZR++;
-                         if ( Print ) {
-                                 fprintf(asir_out,"."); fflush(asir_out); prev = 0;
-                         }
-                 }
-         }
-         if ( Print )
-                 fprintf(asir_out,"gb done\n");
-         return g;
- }
  NODE gb_mod(f,m)
  NODE f;
  int m;
-Line 1661  int m;
+Line 1696  int m;
 Line 1661  int m;
 Line 1696  int m;
                  gall = append_one(gall,i);
          }
          while ( d ) {
-                 get_eg(&tmp0);
+                 l = minp(d,&d);
-                 l = minp(d,&d1); d = d1;
-                 get_eg(&tmp1); add_eg(&eg_mp,&tmp0,&tmp1); get_eg(&tspm0);
                  if ( PCoeffs ) {
                          dp_sp_mod(ps[l->dp1],ps[l->dp2],m,&h);
-                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1); get_eg(&tnfm0);
+                         get_eg(&tnfm0);
                          dp_nf_mod(gall,h,ps,m,!Top,&nf);
                  } else {
                          _dp_sp_mod_dup(ps[l->dp1],ps[l->dp2],m,&h);
-                         get_eg(&tspm1); add_eg(&eg_spm,&tspm0,&tspm1); get_eg(&tnfm0);
+                         get_eg(&tnfm0);
                          _dp_nf_mod_destructive(gall,h,ps,m,!Top,&nf);
                  }
                  get_eg(&tnfm1); add_eg(&eg_nfm,&tnfm0,&tnfm1);
-Line 1684  int m;
+Line 1717  int m;
 Line 1684  int m;
 Line 1717  int m;
                                  return 0;
                          d = updpairs(d,g,nh);
                          g = updbase(g,nh);
-                         if ( InterReduce )
-                                 interreduce_mod(g,nh,m);
                          gall = append_one(gall,nh);
-                         if ( Print ) {
+                         if ( DP_Print ) {
                                  if ( !prev )
                                          fprintf(asir_out,"\n");
                                  print_split_eg(&tnfm0,&tnfm1); fflush(asir_out);
                                  fprintf(asir_out,"(%d,%d),nb=%d,nab=%d,rp=%d,sugar=%d",l->dp1,l->dp2,length(g),length(gall),DPPlength(d),pss[nh]);
                                  printdl(psh[nh]); fprintf(asir_out,"\n"); fflush(asir_out);
-                         } else if ( PrintShort ) {
+                         } else if ( DP_PrintShort ) {
                                  fprintf(asir_out,"+"); fflush(asir_out);
                          }
                          prev = 1;
                  } else {
                          add_eg(&eg_znfm,&tnfm0,&tnfm1);
                          ZR++;
-                         if ( Print || PrintShort ) {
+                         if ( DP_Print || DP_PrintShort ) {
                                  fprintf(asir_out,"."); fflush(asir_out); prev = 0;
                          }
                  }
          }
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"gb_mod done\n");
          return g;
  }
- void interreduce_mod(g,n,m)
- NODE g;
- int n,m;
- {
-         DP nf;
-         NODE gn,t;
-         int i;
-         MKNODE(gn,(pointer)n,0);
-         if ( PCoeffs )
-                 for ( t = g; t; t = NEXT(t) ) {
-                         i = (int)BDY(t);
-                         if ( i != n ) {
-                                 dp_nf_mod(gn,ps[i],ps,m,1,&nf); ps[i] = nf;
-                         }
-                 }
-         else
-                 for ( t = g; t; t = NEXT(t) ) {
-                         i = (int)BDY(t);
-                         if ( i != n ) {
-                                 _dp_nf_mod(gn,ps[i],ps,m,1,&nf); ps[i] = nf;
-                         }
-                 }
- }
- void _dp_nf_mod(b,g,ps,mod,full,rp)
- NODE b;
- DP g;
- DP *ps;
- int mod,full;
- DP *rp;
- {
-         DP u,p,d,s,t;
-         NODE l;
-         MP m,mr;
-         int sugar,psugar;
-         if ( !g ) {
-                 *rp = 0; return;
-         }
-         sugar = g->sugar;
-         for ( d = 0; g; ) {
-                 for ( u = 0, l = b; l; l = NEXT(l) ) {
-                         if ( dp_redble(g,p = ps[(int)BDY(l)]) ) {
-                                 _dp_red_mod(g,p,mod,&u);
-                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
-                                 sugar = MAX(sugar,psugar);
-                                 if ( !u ) {
-                                         if ( d )
-                                                 d->sugar = sugar;
-                                         *rp = d; return;
-                                 }
-                                 break;
-                         }
-                 }
-                 if ( u )
-                         g = u;
-                 else if ( !full ) {
-                         if ( g ) {
-                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;
-                         }
-                         *rp = g; return;
-                 } else {
-                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;
-                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;
-                         _addmd(CO,mod,d,t,&s); d = s;
-                         dp_rest(g,&t); g = t;
-                 }
-         }
-         if ( d )
-                 d->sugar = sugar;
-         *rp = d;
- }
- void _dp_nf(b,g,ps,full,rp)
- NODE b;
- DP g;
- DP *ps;
- int full;
- DP *rp;
- {
-         DP u,p,d,s,t,mult;
-         P coef;
-         NODE l;
-         MP m,mr;
-         int sugar,psugar;
-         if ( !g ) {
-                 *rp = 0; return;
-         }
-         sugar = g->sugar;
-         for ( d = 0; g; ) {
-                 for ( u = 0, l = b; l; l = NEXT(l) ) {
-                         if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {
-                                 dp_load((int)BDY(l),&p);
-                                 /* t+u = coef*(d+g) - mult*p (t = coef*d) */
-                                 dp_red(d,g,p,&t,&u,&coef,&mult);
-                                 psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
-                                 sugar = MAX(sugar,psugar);
-                                 if ( GenTrace ) {
-                                         LIST hist;
-                                         Q cq;
-                                         NODE node,node0;
-                                         STOQ((int)BDY(l),cq);
-                                         node0 = mknode(4,coef,cq,mult,ONE);
-                                         MKLIST(hist,node0);
-                                         MKNODE(node,hist,TraceList); TraceList = node;
-                                 }
-                                 if ( !u ) {
-                                         if ( d )
-                                                 d->sugar = sugar;
-                                         *rp = d; return;
-                                 }
-                                 d = t;
-                                 break;
-                         }
-                 }
-                 if ( u )
-                         g = u;
-                 else if ( !full ) {
-                         if ( g ) {
-                                 MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;
-                         }
-                         *rp = g; return;
-                 } else {
-                         m = BDY(g); NEWMP(mr); mr->dl = m->dl; mr->c = m->c;
-                         NEXT(mr) = 0; MKDP(g->nv,mr,t); t->sugar = mr->dl->td;
-                         addd(CO,d,t,&s); d = s;
-                         dp_rest(g,&t); g = t;
-                 }
-         }
-         if ( d )
-                 d->sugar = sugar;
-         *rp = d;
- }
- #define SAFENM(q) ((q)?NM(q):0)
- double pz_t_e, pz_t_d, pz_t_d1, pz_t_c, im_t_s, im_t_r;
- extern int GenTrace;
- extern NODE TraceList;
- void _dp_nf_ptozp(b,g,ps,full,multiple,r)
- NODE b;
- DP g;
- DP *ps;
- int full,multiple;
- DP *r;
- {
-         DP u,dp,rp,t,t1,t2,red,shift;
-         Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;
-         N gn,tn,cn;
-         NODE l;
-         MP m,mr;
-         int hmag,denom;
-         int sugar,psugar;
-         NODE dist;
-         STRING imul;
-         int ndist;
-         int kara_bit;
-         extern int kara_mag;
-         double get_rtime();
-         double t_0,t_00,tt,ttt,t_p,t_m,t_m1,t_m2,t_s,t_g,t_a;
-         LIST hist;
-         NODE node;
-         Q rcred,mrcred;
-         if ( !g ) {
-                 *r = 0; return;
-         }
-         pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;
-         t_p = t_m = t_m1 = t_m2 = t_s = t_g = t_a = 0;
-         denom = Denominator?Denominator:1;
-         hmag = multiple*HMAG(g)/denom;
-         kara_bit = kara_mag*27; /* XXX */
-         if ( Dist ) {
-                 dist = BDY(Dist);
-                 ndist = length(dist);
-         }
-         sugar = g->sugar;
-         dc = 0; dp = 0; rc = ONE; rp = g;
-         MKSTR(imul,"dp_imul_index");
-         /* g = dc*dp+rc*rp */
-         for ( ; rp; ) {
-                 for ( u = 0, l = b; l; l = NEXT(l) ) {
-                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {
-                                 t_0 = get_rtime();
-                                 dp_load((int)BDY(l),&red);
-                                 hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;
-                                 gcdn(NM(hr),NM(hred),&gn);
-                                 divsn(NM(hred),gn,&tn); NTOQ(tn,SGN(hred),cr);
-                                 divsn(NM(hr),gn,&tn); NTOQ(tn,SGN(hr),cred);
-                                 tt = get_rtime()-t_0; t_p += tt;
-                                 t_0 = get_rtime();
-                                 dp_subd(rp,red,&shift);
- #if INET
-                                 if ( Dist && ndist && HMAG(red) > kara_bit ) {
-                                         NODE n0,n1,n2,n3;
-                                         int i,s,id;
-                                         Obj dmy;
-                                         Q ind;
-                                         if ( Print )
-                                                 fprintf(asir_out,"d");
-                                         i = (int)BDY(l); STOQ(i,ind);
-                                         chsgnp((P)cred,(P *)&mcred);
-                                         MKNODE(n3,ind,0); MKNODE(n2,mcred,n3);
-                                         MKNODE(n1,imul,n2); MKNODE(n0,BDY(dist),n1);
-                                         Pox_rpc(n0,&dmy);
-                                         muldc(CO,rp,(P)cr,&t);
-                                         NEXT(n0)=0;
-                                         Pox_pop_local(n0,&t1);
-                                 } else
- #endif
-                                 {
- /*
-                                         if ( Print )
-                                                 fprintf(asir_out,"l");
- */
-                                         t_00 = get_rtime();
-                                         muldc(CO,rp,(P)cr,&t);
-                                         ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);
-                                         t_00 = get_rtime();
-                                         chsgnp((P)cred,(P *)&mcred);
-                                         muldc(CO,red,(P)mcred,&t1);
-                                         ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);
-                                 }
-                                 t_00 = get_rtime();
-                                 muld(CO,shift,t1,&t2);
-                                 addd(CO,t,t2,&u);
-                                 tt = get_rtime(); t_m += tt-t_0;
-                                 ttt = get_rtime(); t_s += ttt-t_00;
-                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;
-                                 sugar = MAX(sugar,psugar);
-                                 if ( GenTrace ) {
-                                         /* u = cr*rp + (-cred)*shift*red */
-                                         STOQ((int)BDY(l),cq);
-                                         node = mknode(4,cr,cq,0,0);
-                                         mulq(cred,rc,&rcred);
-                                         chsgnnum((Num)rcred,(Num *)&mrcred);
-                                         muldc(CO,shift,(P)mrcred,(DP *)&ARG2(node));
-                                         MKLIST(hist,node);
-                                 }
-                                 if ( !u ) {
-                                         if ( dp )
-                                                 dp->sugar = sugar;
-                                         *r = dp;
-                                         if ( GenTrace ) {
-                                                 ARG3(BDY(hist)) = ONE;
-                                                 MKNODE(node,hist,TraceList); TraceList = node;
-                                         }
-                                         goto final;
-                                 }
-                                 break;
-                         }
-                 }
-                 if ( u ) {
-                         if ( HMAG(u) > hmag ) {
-                                 t_0 = get_rtime();
- #if INET
-                                 if ( Dist && HMAG(u) > kara_bit ) {
-                                         if ( Print )
-                                                 fprintf(asir_out,"D");
-                                         dp_ptozp_d(dist,ndist,u,&t);
-                                 } else {
-                                         if ( Print )
-                                                 fprintf(asir_out,"L");
-                                         dp_ptozp_d(0,0,u,&t);
-                                 }
- #else
-                                 dp_ptozp(u,&t); /* XXX */
- #endif
-                                 tt = get_rtime()-t_0; t_g += tt;
-                                 t_0 = get_rtime();
-                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);
-                                 if ( !dp_fcoeffs && Print ) {
-                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
-                                         fflush(asir_out);
-                                 }
-                                 mulq(cr,dc,&dcq);
-                                 mulq(cont,rc,&rcq);
-                                 gcdn(SAFENM(dcq),SAFENM(rcq),&gn);
-                                 divsn(SAFENM(dcq),gn,&tn); NTOQ(tn,SGN(dcq),dc);
-                                 divsn(SAFENM(rcq),gn,&tn); NTOQ(tn,SGN(rcq),rc);
-                                 tt = get_rtime()-t_0; t_a += tt;
-                                 rp = t;
-                                 hmag = multiple*HMAG(rp)/denom;
-                                 if ( GenTrace ) {
-                                         NTOQ(gn,1,gcd);
-                                         ARG3(BDY(hist)) = (pointer)gcd;
-                                         MKNODE(node,hist,TraceList); TraceList = node;
-                                 }
-                         } else {
-                                 t_0 = get_rtime();
-                                 mulq(cr,dc,&dcq); dc = dcq;
-                                 tt = get_rtime()-t_0; t_a += tt;
-                                 rp = u;
-                                 if ( GenTrace ) {
-                                         ARG3(BDY(hist)) = (pointer)ONE;
-                                         MKNODE(node,hist,TraceList); TraceList = node;
-                                 }
-                         }
-                 } else if ( !full ) {
-                         if ( rp ) {
-                                 MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;
-                         }
-                         *r = rp;
-                         goto final;
-                 } else {
-                         t_0 = get_rtime();
-                         mulq((Q)BDY(rp)->c,rc,&c);
-                         gcdn(SAFENM(dc),SAFENM(c),&gn); NTOQ(gn,1,gcd);
-                         divsn(SAFENM(dc),gn,&tn); NTOQ(tn,SGN(dc),dcq);
-                         divsn(SAFENM(c),gn,&tn); NTOQ(tn,SGN(c),cq);
-                         muldc(CO,dp,(P)dcq,&t1);
-                         m = BDY(rp); NEWMP(mr); mr->dl = m->dl; mr->c = (P)cq;
-                         NEXT(mr) = 0; MKDP(rp->nv,mr,t); t->sugar = mr->dl->td;
-                         addd(CO,t,t1,&dp);
-                         dc = gcd;
-                         dp_rest(rp,&t); rp = t;
-                         tt = get_rtime()-t_0; t_a += tt;
-                 }
-         }
-         if ( GenTrace ) {
-                 mulq(ARG3(BDY((LIST)BDY(TraceList))),dc,&cq);
-                 ARG3(BDY((LIST)BDY(TraceList))) = (pointer)cq;
-         }
-         if ( dp )
-                 dp->sugar = sugar;
-         *r = dp;
- final:
-         if ( Print )
-                 fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",
-                         t_p,t_m,t_m1,t_m2,t_s,
-                         t_g,t_a,
-                         pz_t_e, pz_t_d, pz_t_d1, pz_t_c);
- }
- void dp_imul_d();
- void imulv();
- void _dp_nf_ptozp_mpi(b,g,ps,full,multiple,r)
- NODE b;
- DP g;
- DP *ps;
- int full,multiple;
- DP *r;
- {
-         Obj dmy;
-         DP u,dp,rp,t,t1,t2,red,shift;
-         Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;
-         N gn,tn,cn;
-         NODE l,n0,n1,n2,n3;
-         MP m,mr;
-         int i,n;
-         int hmag,denom;
-         int sugar,psugar;
-         NODE dist;
-         STRING imul;
-         int ndist;
-         int kara_bit;
-         extern int kara_mag;
-         extern int mpi_mag;
-         Q ind;
-         int id;
-         double get_rtime();
-         double t_0,t_00,tt,ttt,t_p,t_m,t_m1,t_m2,t_s,t_g,t_a;
-         if ( !g ) {
-                 *r = 0; return;
-         }
-         pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;
-         t_p = t_m = t_m1 = t_m2 = t_s = t_g = t_a = 0;
-         denom = Denominator?Denominator:1;
-         hmag = multiple*HMAG(g)/denom;
-         kara_bit = kara_mag*27; /* XXX */
-         if ( Dist ) {
-                 dist = BDY(Dist);
-                 ndist = length(dist);
-         }
-         sugar = g->sugar;
-         dc = 0; dp = 0; rc = ONE; rp = g;
-         MKSTR(imul,"dp_imul_index");
-         for ( ; rp; ) {
-                 for ( u = 0, l = b; l; l = NEXT(l) ) {
-                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {
-                                 t_0 = get_rtime();
-                                 dp_load((int)BDY(l),&red);
-                                 hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;
-                                 gcdn(NM(hr),NM(hred),&gn);
-                                 divsn(NM(hred),gn,&tn); NTOQ(tn,SGN(hred),cr);
-                                 divsn(NM(hr),gn,&tn); NTOQ(tn,SGN(hr),cred);
-                                 tt = get_rtime()-t_0; t_p += tt;
-                                 t_0 = get_rtime();
-                                 dp_subd(rp,red,&shift);
-                                 t_00 = get_rtime();
-                                 if ( Dist && ndist
-                                         && HMAG(rp) > mpi_mag && p_mag((P)cr) > mpi_mag ) {
-                                         if ( Print ) fprintf(asir_out,"~");
-                                         dp_imul_d(rp,cr,&t);
-                                 } else {
-                                         if ( Print ) fprintf(asir_out,"_");
-                                         muldc(CO,rp,(P)cr,&t);
-                                 }
-                                 ttt = get_rtime()-t_00; t_m1 += ttt/dp_nt(rp);
-                                 t_00 = get_rtime();
-                                 chsgnp((P)cred,(P *)&mcred);
-                                 if ( Dist && ndist
-                                         && HMAG(red) > mpi_mag && p_mag((P)mcred) > mpi_mag ) {
-                                         if ( Print ) fprintf(asir_out,"=");
-                                         dp_imul_d(red,mcred,&t1);
-                                 } else {
-                                         if ( Print ) fprintf(asir_out,"_");
-                                         muldc(CO,red,(P)mcred,&t1);
-                                 }
-                                 ttt = get_rtime()-t_00; t_m2 += ttt/dp_nt(red);
-                                 t_00 = get_rtime();
-                                 muld(CO,shift,t1,&t2);
-                                 addd(CO,t,t2,&u);
-                                 tt = get_rtime(); t_m += tt-t_0;
-                                 ttt = get_rtime(); t_s += ttt-t_00;
-                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;
-                                 sugar = MAX(sugar,psugar);
-                                 if ( !u ) {
-                                         if ( dp )
-                                                 dp->sugar = sugar;
-                                         *r = dp;
-                                         goto final;
-                                 }
-                                 break;
-                         }
-                 }
-                 if ( u ) {
-                         if ( HMAG(u) > hmag ) {
-                                 t_0 = get_rtime();
-                                 if ( Dist && HMAG(u) > mpi_mag ) {
-                                         if ( Print )
-                                                 fprintf(asir_out,"D");
-                                         dp_ptozp_d(dist,ndist,u,&t);
-                                 } else {
-                                         if ( Print )
-                                                 fprintf(asir_out,"L");
-                                         dp_ptozp_d(0,0,u,&t);
-                                 }
-                                 tt = get_rtime()-t_0; t_g += tt;
-                                 t_0 = get_rtime();
-                                 divsn(NM((Q)BDY(u)->c),NM((Q)BDY(t)->c),&cn); NTOQ(cn,1,cont);
-                                 if ( Print ) {
-                                         fprintf(asir_out,"(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
-                                         fflush(asir_out);
-                                 }
-                                 mulq(cr,dc,&dcq);
-                                 mulq(cont,rc,&rcq);
-                                 gcdn(SAFENM(dcq),SAFENM(rcq),&gn);
-                                 divsn(SAFENM(dcq),gn,&tn); NTOQ(tn,SGN(dcq),dc);
-                                 divsn(SAFENM(rcq),gn,&tn); NTOQ(tn,SGN(rcq),rc);
-                                 tt = get_rtime()-t_0; t_a += tt;
-                                 rp = t;
-                                 hmag = multiple*HMAG(rp)/denom;
-                         } else {
-                                 t_0 = get_rtime();
-                                 mulq(cr,dc,&dcq); dc = dcq;
-                                 tt = get_rtime()-t_0; t_a += tt;
-                                 rp = u;
-                         }
-                 } else if ( !full ) {
-                         if ( rp ) {
-                                 MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;
-                         }
-                         *r = rp;
-                         goto final;
-                 } else {
-                         t_0 = get_rtime();
-                         mulq((Q)BDY(rp)->c,(Q)rc,(Q *)&c);
-                         gcdn(SAFENM(dc),SAFENM(c),&gn); NTOQ(gn,1,gcd);
-                         divsn(SAFENM(dc),gn,&tn); NTOQ(tn,SGN(dc),dcq);
-                         divsn(SAFENM(c),gn,&tn); NTOQ(tn,SGN(c),cq);
-                         muldc(CO,dp,(P)dcq,&t1);
-                         m = BDY(rp); NEWMP(mr); mr->dl = m->dl; mr->c = (P)cq;
-                         NEXT(mr) = 0; MKDP(rp->nv,mr,t); t->sugar = mr->dl->td;
-                         addd(CO,t,t1,&dp);
-                         dc = gcd;
-                         dp_rest(rp,&t); rp = t;
-                         tt = get_rtime()-t_0; t_a += tt;
-                 }
-         }
-         if ( dp )
-                 dp->sugar = sugar;
-         *r = dp;
- final:
-         if ( Print )
-                 fprintf(asir_out,"(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",
-                         t_p,t_m,t_m1,t_m2,t_s,
-                         t_g,t_a,
-                         pz_t_e, pz_t_d, pz_t_d1, pz_t_c);
- }
- void dp_imul_d(p,q,rp)
- DP p;
- Q q;
- DP *rp;
- {
-         int nsep,ndist,i,j,k,l,n;
-         double t0,t1,t2;
-         Q *s;
-         pointer *b;
-         VECT c,cs,ri;
-         VECT *r;
-         MP m;
-         NODE tn,dist,n0,n1,n2;
-         Obj dmy;
-         STRING imul;
-         extern LIST Dist;
-         if ( !p || !q ) {
-                 *rp = 0; return;
-         }
-         dist = BDY(Dist);
-         for ( tn = dist, ndist = 0; tn; tn = NEXT(tn), ndist++ );
-         nsep = ndist + 1;
-         for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );
-         if ( n <= nsep ) {
-                 muldc(CO,p,(P)q,rp); return;
-         }
-         MKSTR(imul,"imulv");
-         t0 = get_rtime();
-         dp_dtov(p,&c);
-         sepvect(c,nsep,&cs);
-         r = (VECT *)CALLOC(nsep,sizeof(VECT *));
-         for ( i = 0, tn = dist, b = BDY(cs); i < ndist; i++, tn = NEXT(tn) ) {
-                 n0 = mknode(4,BDY(tn),imul,b[i],q);
-                 Pox_rpc(n0,&dmy);
-         }
-         t1 = get_rtime();
-         im_t_s += t1 - t0;
-         imulv(b[i],q,&r[i]);
-         t1 = get_rtime();
-         for ( i = 0, tn = dist; i < ndist; i++, tn = NEXT(tn) ) {
-                 MKNODE(n0,BDY(tn),0);
-                 Pox_pop_local(n0,&r[i]);
-                 if ( OID(r[i]) == O_ERR ) {
-                         printexpr(CO,(Obj)r[i]);
-                         error("dp_imul_d : aborted");
-                 }
-         }
-         t2 = get_rtime();
-         im_t_r += t2 - t1;
-         s = (Q *)CALLOC(n,sizeof(Q));
-         for ( i = j = 0; i < nsep; i++ ) {
-                 for ( k = 0, ri = r[i], l = ri->len; k < l; k++, j++ ) {
-                         s[j] = (Q)BDY(ri)[k];
-                 }
-         }
-         dp_vtod(s,p,rp);
- }
- void imulv(w,c,rp)
- VECT w;
- Q c;
- VECT *rp;
- {
-         int n,i;
-         VECT r;
-         n = w->len;
-         MKVECT(r,n); *rp = r;
-         for ( i = 0; i < n; i++ )
-                 mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);
- }
  DP_pairs updpairs( d, g, t)
  DP_pairs d;
  NODE /* of index */ g;
-Line 2308  int t;
+Line 1751  int t;
 Line 2308  int t;
 Line 1751  int t;
          int dl,dl1;
          if ( !g ) return d;
-         get_eg(&tup0);
          if ( !NoCriB && d ) {
                  dl = DPPlength(d);
                  d = criterion_B( d, t );
-Line 2334  int t;
+Line 1776  int t;
 Line 2334  int t;
 Line 1776  int t;
          else
                  dd = d1;
          dl1 = DPPlength(dd); NDP += (dl-dl1);
-         get_eg(&tup1);
-         add_eg(&eg_up,&tup0,&tup1);
          if ( !(nd = d) ) return dd;
          while ( nd = NEXT(d1 = nd) ) ;
          NEXT(d1) = dd;
-Line 2568  NODE f;
+Line 2008  NODE f;
 Line 2568  NODE f;
 Line 2008  NODE f;
                  g = updbase(g,i);
                  gall = append_one(gall,i);
          }
-         if ( Print || PrintShort ) {
+         if ( DP_Print || DP_PrintShort ) {
                  fprintf(asir_out,"gbcheck total %d pairs\n",DPPlength(d)); fflush(asir_out);
          }
          while ( d ) {
                  l = d; d = NEXT(d);
                  get_eg(&tmp0);
-                 dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2); dp_sp(dp1,dp2,&h);
+                 dp_load(l->dp1,&dp1); dp_load(l->dp2,&dp2);
+                 dp_sp(dp1,dp2,&h);
+ /* fprintf(stderr,"{%d,%d}",l->dp1,l->dp2); */
                  _dp_nf(gall,h,ps,1,&nf);
                  get_eg(&tmp1); add_eg(&eg_gc,&tmp0,&tmp1);
-                 if ( Print || PrintShort ) {
+                 if ( DP_Print || DP_PrintShort ) {
                          fprintf(asir_out,"."); fflush(asir_out);
                  }
                  if ( nf )
                          return 0;
          }
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"\n");
          return 1;
  }
-Line 2596  NODE f,x;
+Line 2038  NODE f,x;
 Line 2596  NODE f,x;
 Line 2038  NODE f,x;
          if ( NoMC )
                  return 1;
-         if ( Print || PrintShort ) {
+         if ( DP_Print || DP_PrintShort ) {
                  fprintf(asir_out,"membercheck\n"); fflush(asir_out);
          }
          for ( ; f; f = NEXT(f) ) {
                  get_eg(&tmp0);
                  _dp_nf(x,(DP)BDY(f),ps,1,&g);
                  get_eg(&tmp1); add_eg(&eg_mc,&tmp0,&tmp1);
-                 if ( Print ) {
+                 if ( DP_Print ) {
                          print_split_eg(&tmp0,&tmp1); fflush(asir_out);
-                 } else if ( PrintShort ) {
+                 } else if ( DP_PrintShort ) {
                          fprintf(asir_out,"."); fflush(asir_out);
                  }
                  if ( g )
                          return 0;
          }
-         if ( Print || PrintShort )
+         if ( DP_Print || DP_PrintShort )
                  fprintf(asir_out,"\n");
          return 1;
  }
-Line 2651  Obj name,value;
+Line 2093  Obj name,value;
 Line 2651  Obj name,value;
 Line 2093  Obj name,value;
          else if ( !strcmp(n,"ShowMag") )
                  ShowMag = v;
          else if ( !strcmp(n,"PrintShort") )
-                 PrintShort = v;
+                 DP_PrintShort = v;
          else if ( !strcmp(n,"Print") )
-                 Print = v;
+                 DP_Print = v;
+         else if ( !strcmp(n,"NFStat") )
+                 DP_NFStat = v;
          else if ( !strcmp(n,"Stat") )
                  Stat = v;
          else if ( !strcmp(n,"Reverse") )
                  Reverse = v;
-         else if ( !strcmp(n,"InterReduce") )
-                 InterReduce = v;
          else if ( !strcmp(n,"Multiple") )
-                 Multiple = v;
+                 DP_Multiple = v;
          else if ( !strcmp(n,"Denominator") )
                  Denominator = v;
          else if ( !strcmp(n,"PtozpRA") )
-Line 2679  LIST *list;
+Line 2121  LIST *list;
 Line 2679  LIST *list;
 Line 2121  LIST *list;
          STRING name,path;
          NODE n,n1;
-         STOQ(Multiple,v); MKNODE(n,v,0); MKSTR(name,"Multiple"); MKNODE(n1,name,n); n = n1;
+         STOQ(DP_Multiple,v); MKNODE(n,v,0); MKSTR(name,"DP_Multiple"); MKNODE(n1,name,n); n = n1;
          STOQ(Denominator,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Denominator"); MKNODE(n1,name,n); n = n1;
          MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); MKNODE(n1,name,n); n = n1;
-         STOQ(InterReduce,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"InterReduce"); MKNODE(n1,name,n); n = n1;
          STOQ(Reverse,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Reverse"); MKNODE(n1,name,n); n = n1;
          STOQ(Stat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Stat"); MKNODE(n1,name,n); n = n1;
-         STOQ(Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1;
+         STOQ(DP_Print,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"Print"); MKNODE(n1,name,n); n = n1;
+         STOQ(DP_PrintShort,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"PrintShort"); MKNODE(n1,name,n); n = n1;
+         STOQ(DP_NFStat,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"NFStat"); MKNODE(n1,name,n); n = n1;
          STOQ(OXCheck,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"OXCheck"); MKNODE(n1,name,n); n = n1;
          STOQ(GenTrace,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"GenTrace"); MKNODE(n1,name,n); n = n1;
          STOQ(PtozpRA,v); MKNODE(n1,v,n); n = n1; MKSTR(name,"PtozpRA"); MKNODE(n1,name,n); n = n1;
-Line 2707  LIST *list;
+Line 2150  LIST *list;
 Line 2707  LIST *list;
 Line 2150  LIST *list;
  #define DELIM '/'
- #if defined(THINK_C)
- #undef DELIM
- #define DELIM ':'
- #endif
  void dp_save(index,p,prefix)
  int index;
  Obj p;
-Line 2724  char *prefix;
+Line 2162  char *prefix;
 Line 2724  char *prefix;
 Line 2162  char *prefix;
                  sprintf(path,"%s%c%s%d",Demand,DELIM,prefix,index);
          else
                  sprintf(path,"%s%c%d",Demand,DELIM,index);
- #if defined(VISUAL) || defined(THINK_C)
          if ( !(fp = fopen(path,"wb") ) )
- #else
-         if ( !(fp = fopen(path,"w") ) )
- #endif
                  error("dp_save : cannot open a file");
          savevl(fp,VC); saveobj(fp,p); fclose(fp);
  }
-Line 2744  DP *p;
+Line 2178  DP *p;
 Line 2744  DP *p;
 Line 2178  DP *p;
                  *p = ps[index];
          else {
                  sprintf(path,"%s%c%d",Demand,DELIM,index);
- #if defined(VISUAL) || defined(THINK_C)
                  if ( !(fp = fopen(path,"rb") ) )
- #else
-                 if ( !(fp = fopen(path,"r") ) )
- #endif
                          error("dp_load : cannot open a file");
                  skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp);
          }
-Line 2762  DP *p;
+Line 2192  DP *p;
 Line 2762  DP *p;
 Line 2192  DP *p;
          char path[BUFSIZ];
          sprintf(path,"%s%c%d",Demand,DELIM,index);
- #if defined(VISUAL) || defined(THINK_C)
          if ( !(fp = fopen(path,"rb") ) )
- #else
-         if ( !(fp = fopen(path,"r") ) )
- #endif
                  return 0;
          else {
                  skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); return 1;
-Line 2774  DP *p;
+Line 2200  DP *p;
 Line 2774  DP *p;
 Line 2200  DP *p;
  }
  void init_stat() {
-         init_eg(&eg_up); init_eg(&eg_sp); init_eg(&eg_spm);
          init_eg(&eg_nf); init_eg(&eg_nfm); init_eg(&eg_znfm);
-         init_eg(&eg_pz); init_eg(&eg_np); init_eg(&eg_mp);
+         init_eg(&eg_pz); init_eg(&eg_np);
          init_eg(&eg_ra); init_eg(&eg_mc); init_eg(&eg_gc);
-         ZR = NZR = TP = NBP = NMP = NFP = NDP = 0;
+         ZR = NZR = TP = NBP = NFP = NDP = 0;
  }
  void print_stat() {
-         if ( !Print && !Stat )
+         if ( !DP_Print && !Stat )
                  return;
-         print_eg("UP",&eg_up); print_eg("SP",&eg_sp); print_eg("SPM",&eg_spm);
          print_eg("NF",&eg_nf); print_eg("NFM",&eg_nfm); print_eg("ZNFM",&eg_znfm);
-         print_eg("PZ",&eg_pz); print_eg("NP",&eg_np); print_eg("MP",&eg_mp);
+         print_eg("PZ",&eg_pz); print_eg("NP",&eg_np);
          print_eg("RA",&eg_ra); print_eg("MC",&eg_mc); print_eg("GC",&eg_gc);
          fprintf(asir_out,"T=%d,B=%d M=%d F=%d D=%d ZR=%d NZR=%d\n",TP,NBP,NMP,NFP,NDP,ZR,NZR);
  }
  /*
-  * Old codes
+  * dp_nf used in gb()
+  *
   */
- #if 0
+ double pz_t_e, pz_t_d, pz_t_d1, pz_t_c, im_t_s, im_t_r;
- void _dp_nf_ptozp(b,g,ps,full,multiple,rp)
+ extern int GenTrace;
+ extern NODE TraceList;
+ extern int mpi_mag;
+ void dp_mulc_d(p,c,r)
+ DP p;
+ P c;
+ DP *r;
+ {
+         if ( Dist && BDY(Dist)
+                 && HMAG(p) > mpi_mag
+                 && p_mag((P)c) > mpi_mag ) {
+                 if ( DP_NFStat ) fprintf(asir_out,"~");
+                 dp_imul_d(p,(Q)c,r);
+         } else {
+                 if ( DP_NFStat ) fprintf(asir_out,"_");
+                 muldc(CO,p,c,r);
+         }
+ }
+ void _dp_nf(b,g,ps,full,rp)
  NODE b;
  DP g;
  DP *ps;
- int full,multiple;
+ int full;
  DP *rp;
  {
-         P dmy;
+         DP u,p,d,s,t,mult;
-         DP u,p,d,s,t,dmy1;
+         P coef;
          NODE l;
          MP m,mr;
-         int i,n;
-         int hmag,denom;
          int sugar,psugar;
-         NODE dist;
-         int ndist;
-         int kara_bit;
-         extern int kara_mag;
          if ( !g ) {
                  *rp = 0; return;
          }
-         denom = Denominator?Denominator:1;
-         hmag = multiple*HMAG(g)/denom;
-         kara_bit = kara_mag*27; /* XXX */
-         if ( Dist ) {
-                 dist = BDY(Dist);
-                 ndist = length(dist);
-         }
          sugar = g->sugar;
          for ( d = 0; g; ) {
                  for ( u = 0, l = b; l; l = NEXT(l) ) {
                          if ( dl_redble(BDY(g)->dl,psh[(int)BDY(l)]) ) {
                                  dp_load((int)BDY(l),&p);
-                                 dp_red(d,g,p,&t,&u,&dmy,&dmy1);
+                                 /* t+u = coef*(d+g) - mult*p (t = coef*d) */
+                                 dp_red(d,g,p,&t,&u,&coef,&mult);
                                  psugar = (BDY(g)->dl->td - BDY(p)->dl->td) + p->sugar;
                                  sugar = MAX(sugar,psugar);
+                                 if ( GenTrace ) {
+                                         LIST hist;
+                                         Q cq;
+                                         NODE node,node0;
+                                         STOQ((int)BDY(l),cq);
+                                         node0 = mknode(4,coef,cq,mult,ONE);
+                                         MKLIST(hist,node0);
+                                         MKNODE(node,hist,TraceList); TraceList = node;
+                                 }
                                  if ( !u ) {
                                          if ( d )
                                                  d->sugar = sugar;
-Line 2842  DP *rp;
+Line 2286  DP *rp;
 Line 2842  DP *rp;
 Line 2286  DP *rp;
                                  break;
                          }
                  }
-                 if ( u ) {
+                 if ( u )
                          g = u;
-                         if ( d ) {
-                                 if ( HMAG(d) > hmag ) {
-                                         if ( Dist && HMAG(g) > kara_bit )
-                                                 dp_ptozp2_d(dist,ndist,d,g,&t,&u);
-                                         else
-                                                 dp_ptozp2(d,g,&t,&u);
-                                         d = t; g = u;
-                                         hmag = multiple*HMAG(d)/denom;
-                                 }
-                         } else {
-                                 if ( HMAG(g) > hmag ) {
- #if INET
-                                         if ( Dist && HMAG(g) > kara_bit ) {
-                                                 dp_ptozp_d(dist,ndist,g,&t);
-                                         } else
- #endif
-                                                 dp_ptozp(g,&t);
-                                         g = t;
-                                         hmag = multiple*HMAG(g)/denom;
-                                 }
-                         }
-                 }
                  else if ( !full ) {
                          if ( g ) {
                                  MKDP(g->nv,BDY(g),t); t->sugar = sugar; g = t;
-Line 2883  DP *rp;
+Line 2305  DP *rp;
 Line 2883  DP *rp;
 Line 2305  DP *rp;
          *rp = d;
  }
- int criterion_2(dp1,dp2)
+ void _dp_nf_z(b,g,ps,full,multiple,r)
+ NODE b;
+ DP g;
+ DP *ps;
+ int full,multiple;
+ DP *r;
  {
-         DP g1,g2,g,s1,s2;
+         DP u,dp,rp,t,t1,t2,red,shift;
+         Q dc,rc,dcq,rcq,cont,hr,hred,cr,cred,mcred,c,gcd,cq;
+         N gn,tn,cn;
+         NODE l;
+         MP m,mr;
+         int hmag,denom;
+         int sugar,psugar;
+         NODE dist;
+         STRING imul;
+         int kara_bit;
+         double get_rtime();
+         double t_0,t_00,tt,ttt,t_p,t_m,t_g,t_a;
+         LIST hist;
+         NODE node;
+         Q rcred,mrcred;
-         monomial_gcd(ps[dp1],&g1); monomial_gcd(ps[dp2],&g2);
+         if ( !g ) {
-         dp_gcd(g1,g2,&g);
+                 *r = 0; return;
-         dp_subd(ps[dp1],g,&s1); dp_subd(ps[dp2],g,&s2);
+         }
-         return _criterion_2(s1,s2);
+         pz_t_e = pz_t_d = pz_t_d1 = pz_t_c = 0;
- }
+         t_p = t_m = t_g = t_a = 0;
- int _criterion_2( dp1, dp2 )
+         denom = Denominator?Denominator:1;
- DP dp1, dp2;
+         hmag = multiple*HMAG(g)/denom;
- {
+         sugar = g->sugar;
-         register int i, *d1, *d2;
-         d1 = BDY(dp1)->dl->d; d2 = BDY(dp2)->dl->d;
+         dc = 0; dp = 0; rc = ONE; rp = g;
-         for ( i = CNVars; --i >= 0; d1++, d2++ )
+         MKSTR(imul,"dp_imul_index");
-                 if ( (*d1 <= *d2 ? *d1 : *d2) > 0  ) return 0;
-         return 1;
+         /* g = dc*dp+rc*rp */
+         for ( ; rp; ) {
+                 for ( u = 0, l = b; l; l = NEXT(l) ) {
+                         if ( dl_redble(BDY(rp)->dl,psh[(int)BDY(l)]) ) {
+                                 t_0 = get_rtime();
+                                 dp_load((int)BDY(l),&red);
+                                 hr = (Q)BDY(rp)->c; hred = (Q)BDY(red)->c;
+                                 igcd_cofactor((Q)BDY(rp)->c,(Q)BDY(red)->c,&gcd,&cred,&cr);
+                                 tt = get_rtime(); t_p += tt-t_0;
+                                 dp_subd(rp,red,&shift);
+                                 dp_mulc_d(rp,cr,&t);
+                                 chsgnp((P)cred,(P *)&mcred);
+                                 dp_mulc_d(red,mcred,&t1);
+                                 muld(CO,shift,t1,&t1);
+                                 addd(CO,t,t1,&u);
+                                 t_m += get_rtime()-tt;
+                                 psugar = (BDY(rp)->dl->td - BDY(red)->dl->td) + red->sugar;
+                                 sugar = MAX(sugar,psugar);
+                                 if ( GenTrace ) {
+                                         /* u = cr*rp + (-cred)*shift*red */
+                                         STOQ((int)BDY(l),cq);
+                                         node = mknode(4,cr,cq,0,0);
+                                         mulq(cred,rc,&rcred);
+                                         chsgnnum((Num)rcred,(Num *)&mrcred);
+                                         muldc(CO,shift,(P)mrcred,(DP *)&ARG2(node));
+                                         MKLIST(hist,node);
+                                 }
+                                 if ( !u ) {
+                                         if ( dp )
+                                                 dp->sugar = sugar;
+                                         *r = dp;
+                                         if ( GenTrace ) {
+                                                 ARG3(BDY(hist)) = ONE;
+                                                 MKNODE(node,hist,TraceList); TraceList = node;
+                                         }
+                                         goto final;
+                                 }
+                                 break;
+                         }
+                 }
+                 if ( u ) {
+                         if ( multiple && HMAG(u) > hmag ) {
+                                 t_0 = get_rtime();
+                                 dp_ptozp_d(u,&rp);
+                                 tt = get_rtime(); t_g += tt-t_0;
+                                 divsq((Q)BDY(u)->c,(Q)BDY(rp)->c,&cont);
+                                 if ( !dp_fcoeffs && DP_NFStat ) {
+                                         fprintf(asir_out,
+                                                 "(%d)",p_mag((P)cont)*100/p_mag((P)BDY(u)->c));
+                                         fflush(asir_out);
+                                 }
+                                 mulq(cr,dc,&dcq); mulq(cont,rc,&rcq);
+                                 igcd_cofactor(dcq,rcq,&gcd,&dc,&rc);
+                                 t_a = get_rtime()-tt;
+                                 hmag = multiple*HMAG(rp)/denom;
+                                 if ( GenTrace ) {
+                                         ARG3(BDY(hist)) = (pointer)gcd;
+                                         MKNODE(node,hist,TraceList); TraceList = node;
+                                 }
+                         } else {
+                                 rp = u;
+                                 t_0 = get_rtime();
+                                 mulq(cr,dc,&dc);
+                                 t_a += get_rtime()-t_0;
+                                 if ( GenTrace ) {
+                                         ARG3(BDY(hist)) = (pointer)ONE;
+                                         MKNODE(node,hist,TraceList); TraceList = node;
+                                 }
+                         }
+                 } else if ( !full ) {
+                         if ( rp ) {
+                                 MKDP(rp->nv,BDY(rp),t); t->sugar = sugar; rp = t;
+                         }
+                         *r = rp;
+                         goto final;
+                 } else {
+                         t_0 = get_rtime();
+                         mulq((Q)BDY(rp)->c,rc,&c);
+                         igcd_cofactor(dc,c,&dc,&dcq,&cq);
+                         muldc(CO,dp,(P)dcq,&t);
+                         dp_hm(rp,&t1); BDY(t1)->c = (P)cq;  addd(CO,t,t1,&dp);
+                         dp_rest(rp,&rp);
+                         t_a += get_rtime()-t_0;
+                 }
+         }
+         if ( GenTrace ) {
+                 mulq(ARG3(BDY((LIST)BDY(TraceList))),dc,&cq);
+                 ARG3(BDY((LIST)BDY(TraceList))) = (pointer)cq;
+         }
+         if ( dp )
+                 dp->sugar = sugar;
+         *r = dp;
+ final:
+         if ( DP_NFStat )
+                 fprintf(asir_out,
+                         "(%.3g %.3g %.3g %.3g %.3g %.3g %.3g %.3g)",
+                         t_p,t_m,t_g,t_a,
+                         pz_t_e, pz_t_d, pz_t_d1, pz_t_c);
  }
- void dp_gcd(p1,p2,rp)
+ void imulv();
- DP p1,p2;
+ void dp_imul_d(p,q,rp)
+ DP p;
+ Q q;
  DP *rp;
  {
-         int i,n,td;
+         int nsep,ndist,i,j,k,l,n;
-         DL d1,d2,d;
+         double t0,t1,t2;
+         Q *s;
+         pointer *b;
+         VECT c,cs,ri;
+         VECT *r;
          MP m;
-         DP s;
+         NODE tn,dist,n0,n1,n2;
+         Obj dmy;
+         STRING imul;
+         extern LIST Dist;
-         n = p1->nv; d1 = BDY(p1)->dl; d2 = BDY(p2)->dl;
+         if ( !p || !q ) {
-         NEWDL(d,n);
+                 *rp = 0; return;
-         for ( i = 0, td = 0; i < n; i++ ) {
-                 d->d[i] = MIN(d1->d[i],d2->d[i]);
-                 td += d->d[i];
          }
-         d->td = td;
+         dist = BDY(Dist);
-         NEWMP(m); m->dl = d; m->c = (P)ONE; NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td;
+         for ( tn = dist, ndist = 0; tn; tn = NEXT(tn), ndist++ );
-         *rp = s;
+         nsep = ndist + 1;
+         for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ );
+         if ( n <= nsep ) {
+                 muldc(CO,p,(P)q,rp); return;
+         }
+         MKSTR(imul,"imulv");
+         t0 = get_rtime();
+         dp_dtov(p,&c);
+         sepvect(c,nsep,&cs);
+         r = (VECT *)CALLOC(nsep,sizeof(VECT *));
+         for ( i = 0, tn = dist, b = BDY(cs); i < ndist; i++, tn = NEXT(tn) ) {
+                 n0 = mknode(4,BDY(tn),imul,b[i],q);
+                 Pox_rpc(n0,&dmy);
+         }
+         t1 = get_rtime();
+         im_t_s += t1 - t0;
+         imulv(b[i],q,&r[i]);
+         t1 = get_rtime();
+         for ( i = 0, tn = dist; i < ndist; i++, tn = NEXT(tn) ) {
+                 MKNODE(n0,BDY(tn),0);
+                 Pox_pop_local(n0,&r[i]);
+                 if ( OID(r[i]) == O_ERR ) {
+                         printexpr(CO,(Obj)r[i]);
+                         error("dp_imul_d : aborted");
+                 }
+         }
+         t2 = get_rtime();
+         im_t_r += t2 - t1;
+         s = (Q *)CALLOC(n,sizeof(Q));
+         for ( i = j = 0; i < nsep; i++ ) {
+                 for ( k = 0, ri = r[i], l = ri->len; k < l; k++, j++ ) {
+                         s[j] = (Q)BDY(ri)[k];
+                 }
+         }
+         dp_vtod(s,p,rp);
  }
- void monomial_gcd(p,rp)
+ void imulv(w,c,rp)
- DP p;
+ VECT w;
- DP *rp;
+ Q c;
+ VECT *rp;
  {
-         int n,i,td;
+         int n,i;
-         DL d,d1;
+         VECT r;
-         MP m;
-         DP s;
-         n = p->nv; m = BDY(p); d = m->dl;
+         n = w->len;
-         NEWDL(d1,n);
+         MKVECT(r,n); *rp = r;
          for ( i = 0; i < n; i++ )
-                 d1->d[i] = d->d[i];
+                 mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);
-         for ( m = NEXT(m); m; m = NEXT(m) ) {
-                 d = m->dl;
-                 for ( i = 0; i < n; i++ )
-                         d1->d[i] = MIN(d1->d[i],d->d[i]);
-         }
-         for ( i = 0, td = 0; i < n; i++ )
-                 td += d1->d[i];
-         NEWMP(m); m->dl = d1; m->c = (P)ONE; NEXT(m) = 0; MKDP(n,m,s); s->sugar = d->td;
-         *rp = s;
  }
- #endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>