===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/builtin/gr.c,v
retrieving revision 1.36
retrieving revision 1.52
diff -u -p -r1.36 -r1.52
--- OpenXM_contrib2/asir2000/builtin/gr.c	2001/10/01 01:58:02	1.36
+++ OpenXM_contrib2/asir2000/builtin/gr.c	2003/07/16 05:31:21	1.52
@@ -45,7 +45,7 @@
  * 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.35 2001/09/18 00:56:05 noro Exp $
+ * $OpenXM: OpenXM_contrib2/asir2000/builtin/gr.c,v 1.51 2003/07/09 07:11:07 noro Exp $
 */
 #include "ca.h"
 #include "parse.h"
@@ -60,98 +60,22 @@
 #define INLINE
 #endif
 
-#define NEXTVL(r,c) \
-if(!(r)){NEWVL(r);(c)=(r);}else{NEWVL(NEXT(c));(c)=NEXT(c);}
-
 #define HMAG(p) (p_mag(BDY(p)->c))
 
-struct dp_pairs {
-	int dp1, dp2;
-	DL lcm;
-	int sugar;
-	struct dp_pairs *next;
-};
+#define NEWDP_pairs ((DP_pairs)MALLOC(sizeof(struct dp_pairs)))
 
-typedef struct dp_pairs *DP_pairs;
+static DP_pairs collect_pairs_of_hdlcm( DP_pairs d1, DP_pairs *prest );
+double get_rtime();	
 
-#define NEWDPP(a) ((a)=(DP_pairs)MALLOC(sizeof(struct dp_pairs)))
-
-#define NEXTDPP(r,c) \
-if(!(r)){NEWDPP(r);(c)=(r);}else{NEWDPP(NEXT(c));(c)=NEXT(c);}
-
 struct oEGT eg_nf,eg_nfm;
 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)))
-
 extern int (*cmpdl)();
 extern int do_weyl;
 
 extern DP_Print;
 
-void dptoca(DP,unsigned int **);
-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 *);
-void dp_load(int,DP *);
-void dp_save(int,Obj,char *);
-void dp_make_flaglist(LIST *);
-void dp_set_flag(Obj,Obj);
-int membercheck(NODE,NODE);
-int gbcheck(NODE);
-int dl_redble(DL,DL);
-NODE remove_reducibles(NODE,int);
-NODE updbase(NODE,int);
-DP_pairs criterion_F(DP_pairs);
-int criterion_2(int,int);
-static DP_pairs collect_pairs_of_hdlcm(DP_pairs,DP_pairs *);
-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(NODE,DP,DP *,int,DP *);
-void _dp_nf_z(NODE,DP,DP *,int,int,DP *);
-NODE gb_mod(NODE,int);
-NODE gbd(NODE,int,NODE,NODE);
-NODE gb(NODE,int,NODE);
-NODE gb_f4(NODE);
-NODE gb_f4_mod(NODE,int);
-NODE gb_f4_mod_old(NODE,int);
-DP_pairs minp(DP_pairs, DP_pairs *);
-void minsugar(DP_pairs,DP_pairs *,DP_pairs *);
-NODE append_one(NODE,int);
-void reducebase_dehomo(NODE,NODE *);
-int newps_mod(DP,int);
-int newps_nosave(DP,int,NODE);
-int newps(DP,int,NODE);
-void reduceall_mod(NODE,int,NODE *);
-void reduceall(NODE,NODE *);
-NODE NODE_sortbi(NODE,int);
-NODE NODE_sortbi_insert(int, NODE,int);
-NODE NODE_sortb(NODE,int);
-NODE NODE_sortb_insert(DP,NODE,int);
-void prim_part(DP,int,DP *);
-void setup_arrays(NODE,int,NODE *);
-int validhc(P,int,NODE);
-void vlminus(VL,VL,VL *);
-void printsubst(NODE);
-void makesubst(VL,NODE *);
-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,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);
-NODE symb_merge(NODE,NODE,int),_symb_merge(NODE,NODE,int);
 extern int dp_nelim;
 extern int dp_fcoeffs;
 static DP *ps,*psm;
@@ -165,6 +89,7 @@ static VL VC;
 
 int PCoeffs;
 int DP_Print = 0;
+int DP_PrintShort = 0;
 int DP_Multiple = 0;
 int DP_NFStat = 0;
 LIST Dist = 0;
@@ -177,13 +102,13 @@ static int NoCriB = 0;
 static int NoGC = 0;
 static int NoMC = 0;
 static int NoRA = 0;
-static int DP_PrintShort = 0;
 static int ShowMag = 0;
 static int Stat = 0;
 static int Denominator = 1;
 static int Top = 0;
 static int Reverse = 0;
 static int Max_mag = 0;
+static int Max_coef = 0;
 static char *Demand = 0;
 static int PtozpRA = 0;
 
@@ -191,30 +116,82 @@ int doing_f4;
 NODE TraceList;
 NODE AllTraceList;
 
-INLINE int eqdl(nv,dl1,dl2)
-int nv;
-DL dl1,dl2;
+void Pox_cmo_rpc(NODE,Obj *);
+void Pox_rpc(NODE,Obj *);
+void Pox_pop_local(NODE,Obj *);
+
+INLINE int eqdl(int nv,DL dl1,DL dl2)
 {
 	int i;
-	int *b1,*b2;
+	int *p1,*p2;
 
 	if ( dl1->td != dl2->td )
 		return 0;
-	for ( i = 0, b1 = dl1->d, b2 = dl2->d; i < nv; i++ )
-		if ( b1[i] != b2[i] )
-			break;
-	if ( i == nv )
-		return 1;
-	else
-		return 0;
+	i = nv-1;
+	p1 = dl1->d;
+	p2 = dl2->d;
+	while ( i >= 7 ) {
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		if ( *p1++ != *p2++ ) return 0;
+		i -= 8;
+	}
+	switch ( i ) {
+		case 6:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 5:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 4:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 3:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 2:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 1:
+			if ( *p1++ != *p2++ ) return 0;
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		case 0:
+			if ( *p1++ != *p2++ ) return 0;
+			return 1;
+		default:
+			return 1;
+	}
 }
 
 /* b[] should be cleared */
 
-void _dpmod_to_vect(f,at,b)
-DP f;
-DL *at;
-int *b;
+void _dpmod_to_vect(DP f,DL *at,int *b)
 {
 	int i,nv;
 	MP m;
@@ -228,10 +205,7 @@ int *b;
 
 /* [t,findex] -> tf -> compressed vector */
 
-void _tf_to_vect_compress(tf,at,b)
-NODE tf;
-DL *at;
-CDP *b;
+void _tf_to_vect_compress(NODE tf,DL *at,CDP *b)
 {
 	int i,j,k,nv,len;
 	DL t,s,d1;
@@ -261,10 +235,7 @@ CDP *b;
 	*b = r;
 }
 
-void dp_to_vect(f,at,b)
-DP f;
-DL *at;
-Q *b;
+void dp_to_vect(DP f,DL *at,Q *b)
 {
 	int i,nv;
 	MP m;
@@ -276,8 +247,7 @@ Q *b;
 	}
 }
 
-NODE dp_dllist(f)
-DP f;
+NODE dp_dllist(DP f)
 {
 	MP m;
 	NODE mp,mp0;
@@ -292,9 +262,7 @@ DP f;
 	return mp0;
 }
 
-NODE mul_dllist(d,f)
-DL d;
-DP f;
+NODE mul_dllist(DL d,DP f)
 {
 	MP m;
 	NODE mp,mp0;
@@ -318,8 +286,7 @@ DP f;
 	return mp0;
 }
 
-void pdl(f)
-NODE f;
+void pdl(NODE f)
 {
 	while ( f ) {
 		printdl(BDY(f)); f = NEXT(f);
@@ -328,12 +295,7 @@ NODE f;
 	printf("\n");
 }
 
-void dp_gr_main(f,v,homo,modular,field,ord,rp)
-LIST f,v;
-Num homo;
-int modular,field;
-struct order_spec *ord;
-LIST *rp;
+void dp_gr_main(LIST f,LIST v,Num homo,int modular,int field,struct order_spec *ord,LIST *rp)
 {
 	int i,mindex,m,nochk;
 	struct order_spec ord1;
@@ -430,15 +392,10 @@ LIST *rp;
 	}
 	print_stat();
 	if ( ShowMag )
-		fprintf(asir_out,"\nMax_mag=%d\n",Max_mag);
+		fprintf(asir_out,"\nMax_mag=%d, Max_coef=%d\n",Max_mag, Max_coef);
 }
 
-void dp_gr_mod_main(f,v,homo,m,ord,rp)
-LIST f,v;
-Num homo;
-int m;
-struct order_spec *ord;
-LIST *rp;
+void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp)
 {
 	struct order_spec ord1;
 	VL fv,vv,vc;
@@ -503,15 +460,11 @@ extern struct oEGT eg_red_mod;
 	MKLIST(*rp,r0);
 }
 
-void dp_f4_main(f,v,ord,rp)
-LIST f,v;
-struct order_spec *ord;
-LIST *rp;
+void dp_f4_main(LIST f,LIST v,struct order_spec *ord,LIST *rp)
 {
-	int i,mindex,m,nochk,homogen;
-	struct order_spec ord1;
+	int homogen;
 	VL fv,vv,vc;
-	NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;
+	NODE fd,fd0,r,r0,t,x,s,xx;
 
 	dp_fcoeffs = 0;
 	get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);
@@ -539,17 +492,12 @@ LIST *rp;
 	MKLIST(*rp,r0);
 }
 
-void dp_f4_mod_main(f,v,m,ord,rp)
-LIST f,v;
-int m;
-struct order_spec *ord;
-LIST *rp;
+void dp_f4_mod_main(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp)
 {
-	int i,homogen;
-	struct order_spec ord1;
+	int homogen;
 	VL fv,vv,vc;
 	DP b,c,c1;
-	NODE fd,fd0,fi,fi0,r,r0,t,subst,x,s,xx;
+	NODE fd,fd0,r,r0,t,x,s,xx;
 
 	dp_fcoeffs = 0;
 	get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&vc);
@@ -586,23 +534,21 @@ LIST *rp;
 	print_stat();
 }
 
-NODE gb_f4(f)
-NODE f;
+NODE gb_f4(NODE f)
 {
-	int i,j,k,nh,row,col,nv;
+	int i,k,nh,row,col,nv;
 	NODE r,g,gall;
 	NODE s,s0;
 	DP_pairs d,dm,dr,t;
-	DP h,nf,nf1,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;
+	DP nf,nf1,f2,sp,sd,tdp;
 	MP mp,mp0;
-	NODE blist,bt,nt;
+	NODE blist,bt;
 	DL *ht,*at;
 	MAT mat,nm;
-	int *colstat;
 	int *rind,*cind;
 	int rank,nred;
 	Q dn;
-	struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim;
+	struct oEGT tmp0,tmp1,eg_split_symb;
 	extern struct oEGT eg_mod,eg_elim,eg_chrem,eg_gschk,eg_intrat,eg_symb;
 
 	init_eg(&eg_mod); init_eg(&eg_elim); init_eg(&eg_chrem);
@@ -708,19 +654,19 @@ NODE f;
 /* initial bases are monic */
 
 unsigned int **psca;
+GeoBucket create_bucket();
+DL remove_head_bucket(GeoBucket,int);
 
-NODE gb_f4_mod(f,m)
-NODE f;
-int m;
+NODE gb_f4_mod(NODE f,int m)
 {
 	int i,j,k,nh,row,col,nv;
 	NODE r,g,gall;
 	NODE s,s0;
 	DP_pairs d,dm,dr,t;
-	DP h,nf,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;
+	DP nf,sp,sd,tdp;
 	MP mp,mp0;
-	NODE blist,bt,nt,bt1,dt,rhtlist;
-	DL *ht,*at,*st;
+	NODE blist,bt,bt1,dt;
+	DL *at,*st;
 	int **spmat;
 	CDP *redmat;
 	int *colstat,*w,*w1;
@@ -728,14 +674,16 @@ int m;
 	int *indred,*isred;
 	CDP ri;
 	int pscalen;
-	struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim1,eg_split_elim2;
-	extern struct oEGT eg_symb,eg_elim1,eg_elim2;
+	GeoBucket bucket;
+	DL head;
+	struct oEGT tmp0,tmp1,eg_split_symb,eg_split_conv,eg_split_elim1,eg_split_elim2;
+	extern struct oEGT eg_symb,eg_conv,eg_elim1,eg_elim2;
 
 	/* initialize coeffcient array list of ps[] */
 	pscalen = pslen;
 	psca = (unsigned int **)MALLOC(pscalen*sizeof(unsigned int *));
 
-	init_eg(&eg_symb); init_eg(&eg_elim1); init_eg(&eg_elim2);
+	init_eg(&eg_symb); init_eg(&eg_conv); init_eg(&eg_elim1); init_eg(&eg_elim2);
 	for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) {
 		i = (int)BDY(r);
 		d = updpairs(d,g,i);
@@ -750,41 +698,57 @@ int m;
 		minsugar(d,&dm,&dr); d = dr;
 		if ( DP_Print )
 			fprintf(asir_out,"sugar=%d\n",dm->sugar);
-		blist = 0; s0 = 0;
+		blist = 0;
+		bucket = create_bucket();
 		/* asph : sum of all head terms of spoly */
 		for ( t = dm; t; t = NEXT(t) ) {
 			_dp_sp_mod(ps[t->dp1],ps[t->dp2],m,&sp);
 /*			fprintf(stderr,"splen=%d-",dp_nt(sp)); */
 			if ( sp ) {
 				MKNODE(bt,sp,blist); blist = bt;
-				s0 = symb_merge(s0,dp_dllist(sp),nv);
+				add_bucket(bucket,dp_dllist(sp),nv);
 /*				fprintf(stderr,"%d-",length(s0)); */
 			}
 		}
+#if 0
 		if ( DP_Print )
 			fprintf(asir_out,"initial spmat : %d x %d ",length(blist),length(s0));
+#endif
 		/* s0 : all the terms appeared in symbolic reduction */
-		for ( s = s0, nred = 0; s; s = NEXT(s) ) {
+		nred = 0;
+		s0 = 0;
+		while ( 1 ) {
+			head = remove_head_bucket(bucket,nv);
+			if ( !head ) break;
+			else {
+				NEXTNODE(s0,s);
+				BDY(s) = (pointer)head;
+			}
 			for ( r = gall;	r; r = NEXT(r) )
-				if ( _dl_redble(BDY(ps[(int)BDY(r)])->dl,BDY(s),nv) )
+				if ( _dl_redble(BDY(ps[(int)BDY(r)])->dl,head,nv) )
 					break;
 			if ( r ) {
-				dltod(BDY(s),nv,&tdp);
+				dltod(head,nv,&tdp);
 				dp_subd(tdp,ps[(int)BDY(r)],&sd);
 				dt = mul_dllist(BDY(sd)->dl,ps[(int)BDY(r)]);
+				add_bucket(bucket,NEXT(dt),nv);
 /*				fprintf(stderr,"[%d]",length(dt)); */
 				/* list of [t,f] */
 				bt1 = mknode(2,BDY(sd)->dl,BDY(r));
 				MKNODE(bt,bt1,blist); blist = bt;
-				symb_merge(s,dt,nv);
-/*				fprintf(stderr,"%d-",length(s)); */
+/*				fprintf(stderr,"%d-",length(s0));  */
 				nred++;
 			}
 		}
+		if ( s0 ) NEXT(s) = 0;
 /*		fprintf(stderr,"\n"); */
+		get_eg(&tmp1); add_eg(&eg_symb,&tmp0,&tmp1);
+		init_eg(&eg_split_symb); add_eg(&eg_split_symb,&tmp0,&tmp1);
+
 		if ( DP_Print )
 			fprintf(asir_out,"number of reducers : %d\n",nred);
 
+		get_eg(&tmp0);
 		/* the first nred polys in blist are reducers */
 		/* row = the number of all the polys */
 		for ( r = blist, row = 0; r; r = NEXT(r), row++ );
@@ -823,8 +787,8 @@ 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); add_eg(&eg_conv,&tmp0,&tmp1);
+		init_eg(&eg_split_conv); add_eg(&eg_split_conv,&tmp0,&tmp1);
 
 		get_eg(&tmp1);
 		/* spoly matrix; stored in reduced form; terms in ht[] are omitted */
@@ -881,6 +845,7 @@ int m;
 		if ( DP_Print ) {
 			fprintf(asir_out,"done rank = %d\n",rank,row,col);
 			print_eg("Symb",&eg_split_symb);
+			print_eg("Conv",&eg_split_conv);
 			print_eg("Elim1",&eg_split_elim1);
 			print_eg("Elim2",&eg_split_elim2);
 			fprintf(asir_out,"\n");
@@ -923,6 +888,7 @@ int m;
 	}
 	if ( DP_Print ) {
 		print_eg("Symb",&eg_symb);
+		print_eg("Conv",&eg_conv);
 		print_eg("Elim1",&eg_elim1);
 		print_eg("Elim2",&eg_elim2);
 		fflush(asir_out);
@@ -930,23 +896,21 @@ int m;
 	return g;
 }
 
-NODE gb_f4_mod_old(f,m)
-NODE f;
-int m;
+NODE gb_f4_mod_old(NODE f,int m)
 {
 	int i,j,k,nh,row,col,nv;
 	NODE r,g,gall;
 	NODE s,s0;
 	DP_pairs d,dm,dr,t;
-	DP h,nf,f1,f2,f21,f21r,sp,sp1,sd,sdm,tdp;
+	DP nf,f2,sp,sd,sdm,tdp;
 	MP mp,mp0;
-	NODE blist,bt,nt;
+	NODE blist,bt;
 	DL *ht,*at,*st;
 	int **spmat,**redmat;
 	int *colstat,*w;
 	int rank,nred,nsp,nonzero,spcol;
 	int *indred,*isred,*ri;
-	struct oEGT tmp0,tmp1,tmp2,eg_split_symb,eg_split_elim1,eg_split_elim2;
+	struct oEGT tmp0,tmp1,eg_split_symb,eg_split_elim1,eg_split_elim2;
 	extern struct oEGT eg_symb,eg_elim1,eg_elim2;
 
 	init_eg(&eg_symb); init_eg(&eg_elim1); init_eg(&eg_elim2);
@@ -1100,8 +1064,7 @@ int m;
 	return g;
 }
 
-int DPPlength(n)
-DP_pairs n;
+int DPPlength(DP_pairs n)
 {
 	int i;
 
@@ -1109,8 +1072,7 @@ DP_pairs n;
 	return i;
 }
 
-void printdl(dl)
-DL dl;
+void printdl(DL dl)
 {
 	int i;
 
@@ -1120,9 +1082,7 @@ DL dl;
 	fprintf(asir_out,"%d>>",dl->d[i]);
 }
 
-void pltovl(l,vl)
-LIST l;
-VL *vl;
+void pltovl(LIST l,VL *vl)
 {
 	NODE n;
 	VL r,r0;
@@ -1135,9 +1095,7 @@ VL *vl;
 	*vl = r0;
 }
 
-void makesubst(v,s)
-VL v;
-NODE *s;
+void makesubst(VL v,NODE *s)
 {
 	NODE r,r0;
 	Q q;
@@ -1156,8 +1114,7 @@ NODE *s;
 	*s = r0;
 }
 
-void printsubst(s)
-NODE s;
+void printsubst(NODE s)
 {
 	fputc('[',asir_out);
 	while ( s ) {
@@ -1171,8 +1128,7 @@ NODE s;
 	fprintf(asir_out,"]\n"); return;
 }
 
-void vlminus(v,w,d)
-VL v,w,*d;
+void vlminus(VL v,VL w,VL *d)
 {
 	int i,j,n,m;
 	V *va,*wa;
@@ -1202,10 +1158,7 @@ VL v,w,*d;
 	*d = r0;
 }
 
-int validhc(a,m,s)
-P a;
-int m;
-NODE s;
+int validhc(P a,int m,NODE s)
 {
 	P c,c1;
 	V v;
@@ -1220,9 +1173,7 @@ NODE s;
 	return c1 ? 1 : 0;
 }
 
-void setup_arrays(f,m,r)
-NODE f,*r;
-int m;
+void setup_arrays(NODE f,int m,NODE *r)
 {
 	int i;
 	NODE s,s0,f0;
@@ -1250,7 +1201,7 @@ int m;
 		STRING fname;
 		LIST input;
 		NODE arg,t,t1;
-		Obj dmy;
+		Obj obj;
 	
 		t = 0;
 		for ( i = psn-1; i >= 0; i-- ) {
@@ -1263,7 +1214,7 @@ int m;
 			STOQ(OXCheck,q);
 			MKSTR(fname,"register_input");
 			arg = mknode(3,q,fname,input);
-			Pox_cmo_rpc(arg,&dmy);
+			Pox_cmo_rpc(arg,&obj);
 		} else if ( OXCheck < 0 ) {
 			MKNODE(AllTraceList,input,0);
 		}
@@ -1275,9 +1226,7 @@ int m;
 	*r = s0;
 }
 
-void prim_part(f,m,r)
-DP f,*r;
-int m;
+void prim_part(DP f,int m,DP *r)
 {
 	P d,t;
 
@@ -1285,11 +1234,9 @@ int m;
 		if ( PCoeffs )
 			dp_prim_mod(f,m,r);
 		else
-			*r = f;
+			_dp_monic(f,m,r);
 	} else {
-		if ( dp_fcoeffs )
-			*r = f;
-		else if ( PCoeffs )
+		if ( dp_fcoeffs || PCoeffs )
 			dp_prim(f,r);
 		else
 			dp_ptozp(f,r);
@@ -1303,10 +1250,7 @@ int m;
 	}
 }
 
-NODE /* of DP */ NODE_sortb_insert( newdp, nd, dec )
-DP newdp;
-NODE /* of DP */ nd;
-int dec;
+NODE /* of DP */ NODE_sortb_insert( DP newdp, NODE /* of DP */ nd, int dec )
 {
 	register NODE last, p;
 	register DL newdl = BDY(newdp)->dl;
@@ -1325,9 +1269,7 @@ int dec;
 	return nd;
 }
 
-NODE NODE_sortb( node, dec )
-NODE node;
-int dec;
+NODE NODE_sortb( NODE node, int dec )
 {
 	register NODE nd, ans;
 
@@ -1336,10 +1278,7 @@ int dec;
 	return ans;
 }
 
-NODE /* of index */ NODE_sortbi_insert( newdpi, nd, dec )
-int newdpi;
-NODE /* of index */ nd;
-int dec;
+NODE /* of index */ NODE_sortbi_insert( int newdpi, NODE /* of index */ nd, int dec )
 {
 	register NODE last, p;
 	register DL newdl = psh[newdpi];
@@ -1358,9 +1297,7 @@ int dec;
 	return nd;
 }
 
-NODE NODE_sortbi( node, dec )
-NODE node;
-int dec;
+NODE NODE_sortbi( NODE node, int dec )
 {
 	register NODE nd, ans;
 
@@ -1369,9 +1306,7 @@ int dec;
 	return ans;
 }
 
-void reduceall(in,h)
-NODE in;
-NODE *h;
+void reduceall(NODE in,NODE *h)
 {
 	NODE r,t,top;
 	int n,i,j;
@@ -1424,10 +1359,7 @@ NODE *h;
 		fprintf(asir_out,"\n");
 }
 
-void reduceall_mod(in,m,h)
-NODE in;
-int m;
-NODE *h;
+void reduceall_mod(NODE in,int m,NODE *h)
 {
 	NODE r,t,top;
 	int n,i,j;
@@ -1472,10 +1404,7 @@ NODE *h;
 		fprintf(asir_out,"\n");
 }
 
-int newps(a,m,subst)
-DP a;
-int m;
-NODE subst;
+int newps(DP a,int m,NODE subst)
 {
 	if ( m && !validhc(!a?0:BDY(a)->c,m,subst) )
 		return -1;
@@ -1507,7 +1436,7 @@ NODE subst;
 		NODE arg;
 		Q q1,q2;
 		STRING fname;
-		Obj dmy;
+		Obj obj;
 	
 		/* reverse the TraceList */
 		tn = TraceList;
@@ -1520,7 +1449,7 @@ NODE subst;
 			MKSTR(fname,"check_trace");
 			STOQ(psn,q2);
 			arg = mknode(5,q1,fname,a,q2,trace);
-			Pox_cmo_rpc(arg,&dmy);
+			Pox_cmo_rpc(arg,&obj);
 		} else if ( OXCheck < 0 ) {
 			STOQ(psn,q1);
 			tn = mknode(2,q1,trace);
@@ -1534,10 +1463,7 @@ NODE subst;
 	return psn++;
 }
 
-int newps_nosave(a,m,subst)
-DP a;
-int m;
-NODE subst;
+int newps_nosave(DP a,int m,NODE subst)
 {
 	if ( m && !validhc(!a?0:BDY(a)->c,m,subst) )
 		return -1;
@@ -1559,9 +1485,7 @@ NODE subst;
 	return psn++;
 }
 
-int newps_mod(a,m)
-DP a;
-int m;
+int newps_mod(DP a,int m)
 {
 	if ( psn == pslen ) {
 		pslen *= 2;
@@ -1576,8 +1500,7 @@ int m;
 	return psn++;
 }
 
-void reducebase_dehomo(f,g)
-NODE f,*g;
+void reducebase_dehomo(NODE f,NODE *g)
 {
 	int n,i,j,k;
 	int *r;
@@ -1623,9 +1546,7 @@ NODE f,*g;
 	*g = top;
 }
 
-NODE append_one(f,n)
-NODE f;
-int n;
+NODE append_one(NODE f,int n)
 {
 	NODE t;
 
@@ -1638,8 +1559,7 @@ int n;
 	}
 }
 
-DP_pairs minp( d, prest )
-DP_pairs d, *prest;
+DP_pairs minp( DP_pairs d, DP_pairs *prest )
 {
 	register DP_pairs m, ml, p, l;
 	register DL lcm;
@@ -1664,9 +1584,7 @@ DP_pairs d, *prest;
 	return m;
 }
 
-void minsugar(d,dm,dr)
-DP_pairs d;
-DP_pairs *dm,*dr;
+void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr)
 {
 	int msugar;
 	DP_pairs t,dm0,dr0,dmt,drt;
@@ -1691,18 +1609,15 @@ DP_pairs *dm,*dr;
 	*dm = dm0; *dr = dr0;
 }
 
-NODE gb(f,m,subst)
-NODE f;
-int m;
-NODE subst;
+NODE gb(NODE f,int m,NODE subst)
 {
-	int i,nh,prev,mag;
+	int i,nh,prev,mag,mag0,magt;
 	NODE r,g,gall;
-	DP_pairs d,d1;
+	DP_pairs d;
 	DP_pairs l;
 	DP h,nf,nfm,dp1,dp2;
 	MP mp;
-	struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tsp0,tsp1,tspm0,tspm1,tnp0,tnp1,tmp0,tmp1;
+	struct oEGT tnf0,tnf1,tnfm0,tnfm1,tpz0,tpz1,tnp0,tnp1;
 	int skip_nf_flag;
 	double t_0;
 	Q q;
@@ -1710,6 +1625,7 @@ NODE subst;
 	static prev_sugar = -1;
 
 	Max_mag = 0;
+	Max_coef = 0;
 	prev = 1;
 	doing_f4 = 0;
 	if ( m ) {
@@ -1741,7 +1657,6 @@ NODE subst;
 			if ( Demand ) {
 				if ( dp_load_t(psn,&nf) ) {
 					skip_nf_flag = 1;
-					tnf1=tsp1;
 					goto skip_nf;
 				} else {
 					skip_nf_flag = 0;
@@ -1762,7 +1677,7 @@ NODE subst;
 				_dp_nf(gall,h,ps,!Top,&nf);
 			else
 				_dp_nf_z(gall,h,ps,!Top,DP_Multiple,&nf);
-			if ( DP_Print )
+			if ( DP_Print && nf )
 				fprintf(asir_out,"(%.3g)",get_rtime()-t_0);
 			get_eg(&tnf1); add_eg(&eg_nf,&tnf0,&tnf1);
 		} else
@@ -1785,8 +1700,12 @@ skip_nf:
 			g = updbase(g,nh);
 			gall = append_one(gall,nh);
 			if ( !dp_fcoeffs && ShowMag ) {
-				for ( mag = 0, mp = BDY(h); mp; mp = NEXT(mp) )
-					mag += p_mag((P)mp->c);
+				for ( mag = 0, mag0 = 0, mp = BDY(h); mp; mp = NEXT(mp) ) {
+					magt = p_mag((P)mp->c);
+					mag0 = MAX(mag0,magt);
+					mag += magt;
+				}
+				Max_coef = MAX(Max_coef,mag0);
 				Max_mag = MAX(Max_mag,mag);
 			}
 			if ( DP_Print ) {
@@ -1798,7 +1717,7 @@ skip_nf:
 					l->dp1,l->dp2,length(g),length(gall),DPPlength(d),
 					pss[nh]);
 				if ( ShowMag )
-					fprintf(asir_out,",mag=%d",mag);
+					fprintf(asir_out,",mag=(%d,%d)",mag,mag0);
 				fprintf(asir_out,"\n"); fflush(asir_out);
 			} else if ( DP_PrintShort ) {
 				fprintf(asir_out,"+"); fflush(asir_out);
@@ -1822,16 +1741,14 @@ skip_nf:
 	return g;
 }
 
-NODE gb_mod(f,m)
-NODE f;
-int m;
+NODE gb_mod(NODE f,int m)
 {
 	int i,nh,prev;
 	NODE r,g,gall;
-	DP_pairs d,d1;
+	DP_pairs d;
 	DP_pairs l;
 	DP h,nf;
-	struct oEGT tnfm0,tnfm1,tspm0,tspm1,tmp0,tmp1,tpz0,tpz1;
+	struct oEGT tnfm0,tnfm1,tpz0,tpz1;
 
 	prev = 1;
 	for ( gall = g = 0, d = 0, r = f; r; r = NEXT(r) ) {
@@ -1886,13 +1803,9 @@ int m;
 	return g;
 }
 
-DP_pairs updpairs( d, g, t)
-DP_pairs d;
-NODE /* of index */ g;
-int t;
+DP_pairs updpairs( DP_pairs d, NODE /* of index */ g, int t)
 {
 	register DP_pairs d1, dd, nd;
-	struct oEGT tup0,tup1;
 	int dl,dl1;
 
 	if ( !g ) return d;
@@ -1927,9 +1840,7 @@ int t;
 	return d;
 }
 
-DP_pairs newpairs( g, t )
-NODE /* of index */ g;
-register int t;
+DP_pairs newpairs( NODE /* of index */ g, int t )
 {
 	register NODE r;
 	register DL tdl = psh[t];
@@ -1947,7 +1858,7 @@ register int t;
 		p->lcm = lcm_of_DL(CNVars, dl = psh[dp], tdl, (DL)0 );
 #if 0
 		if ( do_weyl )
-			p->sugar = dl_weight(p->lcm);
+			p->sugar = dl_weyl_weight(p->lcm);
 		else
 #endif
 			p->sugar = (ts > (s = pss[dp] - dl->td) ? ts : s) + p->lcm->td;
@@ -1955,9 +1866,7 @@ register int t;
 	return last;
 }
 
-DP_pairs criterion_B( d, s )
-register DP_pairs d;
-int s;
+DP_pairs criterion_B( DP_pairs d, int s )
 {
 	register DP_pairs dd, p;
 	register DL tij, t = psh[s], dltmp;
@@ -1980,8 +1889,7 @@ int s;
 	return dd;
 }
 
-DP_pairs criterion_M( d1 )
-DP_pairs d1;
+DP_pairs criterion_M( DP_pairs d1 )
 {
 	register DP_pairs dd, e, d3, d2, p;
 	register DL itdl, jtdl;
@@ -2023,8 +1931,7 @@ DP_pairs d1;
 	return dd;
 }
 
-static DP_pairs collect_pairs_of_hdlcm( d1, prest )
-DP_pairs d1, *prest;
+static DP_pairs collect_pairs_of_hdlcm( DP_pairs d1, DP_pairs *prest )
 {
 	register DP_pairs w, p, r, s;
 	register DL ti;
@@ -2048,8 +1955,7 @@ DP_pairs d1, *prest;
 	return w;
 }
 
-int criterion_2( dp1, dp2 )
-int dp1, dp2;
+int criterion_2( int dp1, int dp2 )
 {
 	register int i, *d1, *d2;
 
@@ -2059,8 +1965,7 @@ int dp1, dp2;
 	return 1;
 }
 
-DP_pairs criterion_F( d1 )
-DP_pairs d1;
+DP_pairs criterion_F( DP_pairs d1 )
 {
 	DP_pairs rest, head;
 	register DP_pairs last, p, r, w;
@@ -2069,7 +1974,7 @@ DP_pairs d1;
 	for ( head = last = 0, p = d1; NEXT(p); ) {
 		s = (r = w = collect_pairs_of_hdlcm( p, &rest ))->sugar;
 		while ( w = NEXT(w) )
-			if ( criterion_2( w->dp1, w->dp2 ) ) {
+			if ( !do_weyl && criterion_2( w->dp1, w->dp2 ) ) {
 				r = w;
 				break;
 			} else if ( w->sugar < s ) s = (r = w)->sugar;
@@ -2083,18 +1988,14 @@ DP_pairs d1;
 	return head;
 }
 
-NODE updbase(g,t)
-NODE g;
-int t;
+NODE updbase(NODE g,int t)
 {
 	g = remove_reducibles(g,t);
 	g = append_one(g,t);
 	return g;
 }
 
-NODE /* of index */ remove_reducibles( nd, newdp )
-NODE /* of index */ nd;
-int newdp;
+NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp )
 {
 	register DL dl, dln;
 	register NODE last, p, head;
@@ -2115,8 +2016,7 @@ int newdp;
 	return head;
 }
 
-int dl_redble( dl1, dl2 )
-DL dl1, dl2;
+int dl_redble(DL dl1,DL dl2)
 {
 	register int n, *d1, *d2;
 
@@ -2125,8 +2025,8 @@ DL dl1, dl2;
 	return 1;
 }
 
-int dl_weight(dl)
-DL dl;
+#if 0
+int dl_weyl_weight(DL dl)
 {
 	int n,w,i;
 
@@ -2135,9 +2035,9 @@ DL dl;
 		w += (-dl->d[i]+dl->d[n+i]);
 	return w;
 }
+#endif
 
-int gbcheck(f)
-NODE f;
+int gbcheck(NODE f)
 {
 	int i;
 	NODE r,g,gall;
@@ -2175,9 +2075,42 @@ NODE f;
 	return 1;
 }
 
-int membercheck(f,x)
-NODE f,x;
+void gbcheck_list(NODE f,int n,VECT *gp,LIST *pp)
 {
+	int i;
+	NODE r,g,gall,u,u0,t;
+	VECT vect;
+	LIST pair;
+	DP_pairs d,l;
+	Q q1,q2;
+
+	/* we need the following settings */
+	NVars = CNVars = n;
+	setup_arrays(f,0,&r);
+	for ( gall = g = 0, d = 0; r; r = NEXT(r) ) {
+		i = (int)BDY(r);
+		d = updpairs(d,g,i);
+		g = updbase(g,i);
+		gall = append_one(gall,i);
+	}
+	NEWVECT(vect); vect->len = psn; vect->body = (pointer)ps;
+	*gp = vect;
+
+	for ( u0 = 0, l = d; l; l = NEXT(l) ) {
+		NEXTNODE(u0,u);
+		STOQ(l->dp1,q1);
+		STOQ(l->dp2,q2);
+		t = mknode(2,q1,q2);
+		MKLIST(pair,t);
+		BDY(u) = (pointer)pair;
+	}
+	if ( u0 )
+		NEXT(u) = 0;
+	MKLIST(*pp,u0);
+}
+
+int membercheck(NODE f,NODE x)
+{
 	DP g;
 	struct oEGT tmp0,tmp1;
 
@@ -2203,11 +2136,11 @@ NODE f,x;
 	return 1;
 }
 
-void dp_set_flag(name,value)
-Obj name,value;
+void dp_set_flag(Obj name,Obj value)
 {
 	char *n;
 	int v;
+	Q ratio;
 
 	if ( OID(name) != O_STR )
 		return;
@@ -2218,6 +2151,16 @@ Obj name,value;
 	if ( !strcmp(n,"Dist") ) {
 		Dist = (LIST)value; return;
 	}
+	if ( !strcmp(n,"Content") ) {
+		ratio = (Q)value;
+		if ( ratio ) {
+			DP_Multiple = BD(NM(ratio))[0];
+			Denominator = INT(ratio) ? 1 : BD(DN(ratio))[0];
+		} else {
+			DP_Multiple = 0;
+			Denominator = 1;
+		}
+	}
 	if ( value && OID(value) != O_N )
 		return;
 	v = QTOS((Q)value);
@@ -2259,15 +2202,22 @@ Obj name,value;
 		OXCheck = v;
 }
 
-void dp_make_flaglist(list)
-LIST *list;
+void dp_make_flaglist(LIST *list)
 {
-	Q v;
+	Q v,nm,dn;
 	STRING name,path;
 	NODE n,n1;
 
+#if 0
 	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;
+#else
+	if ( DP_Multiple ) {
+		STOQ(DP_Multiple,nm); STOQ(Denominator,dn); divq(nm,dn,&v);
+	} else
+		v = 0;
+	MKNODE(n,v,0); MKSTR(name,"Content"); MKNODE(n1,name,n); n = n1;
+#endif
 	MKNODE(n1,Dist,n); n = n1; MKSTR(name,"Dist"); 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;
@@ -2295,10 +2245,7 @@ LIST *list;
 
 #define DELIM '/'
 
-void dp_save(index,p,prefix)
-int index;
-Obj p;
-char *prefix;
+void dp_save(int index,Obj p,char *prefix)
 {
 	FILE *fp;
 	char path[BUFSIZ];
@@ -2312,9 +2259,7 @@ char *prefix;
 	savevl(fp,VC); saveobj(fp,p); fclose(fp);
 }
 
-void dp_load(index,p)
-int index;
-DP *p;
+void dp_load(int index,DP *p)
 {
 	FILE *fp;
 	char path[BUFSIZ];
@@ -2325,13 +2270,15 @@ DP *p;
 		sprintf(path,"%s%c%d",Demand,DELIM,index);
 		if ( !(fp = fopen(path,"rb") ) )
 			error("dp_load : cannot open a file");
-		skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp);
+		if ( PCoeffs )
+			loadvl(fp);
+		else
+			skipvl(fp);
+		loadobj(fp,(Obj *)p); fclose(fp);
 	}
 }
 
-int dp_load_t(index,p)
-int index;
-DP *p;
+int dp_load_t(int index,DP *p)
 {
 	FILE *fp;
 	char path[BUFSIZ];
@@ -2340,7 +2287,11 @@ DP *p;
 	if ( !(fp = fopen(path,"rb") ) )
 		return 0;
 	else {
-		skipvl(fp); loadobj(fp,(Obj *)p); fclose(fp); return 1;
+		if ( PCoeffs )
+			loadvl(fp);
+		else
+			skipvl(fp);
+		loadobj(fp,(Obj *)p); fclose(fp); return 1;
 	}
 }
 
@@ -2371,10 +2322,7 @@ extern int GenTrace;
 extern NODE TraceList;
 extern int mpi_mag;
 
-void dp_mulc_d(p,c,r)
-DP p;
-P c;
-DP *r;
+void dp_mulc_d(DP p,P c,DP *r)
 {
 	if ( Dist && BDY(Dist)
 		&& HMAG(p) > mpi_mag
@@ -2387,12 +2335,7 @@ DP *r;
 	}
 }
 
-void _dp_nf(b,g,ps,full,rp)
-NODE b;
-DP g;
-DP *ps;
-int full;
-DP *rp;
+void _dp_nf(NODE b,DP g,DP *ps,int full,DP *rp)
 {
 	DP u,p,d,s,t,mult;
 	P coef;
@@ -2450,25 +2393,15 @@ DP *rp;
 	*rp = d;
 }
 
-void _dp_nf_z(b,g,ps,full,multiple,r)
-NODE b;
-DP g;
-DP *ps;
-int full,multiple;
-DP *r;
+void _dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *r)
 {
-	DP u,dp,rp,t,t1,t2,red,shift;
+	DP u,dp,rp,t,t1,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;
+	double t_0,tt,t_p,t_m,t_g,t_a;
 	LIST hist;
 	NODE node;
 	Q rcred,mrcred;
@@ -2497,9 +2430,9 @@ DP *r;
 				tt = get_rtime(); t_p += tt-t_0;
 
 				dp_subd(rp,red,&shift);
-				dp_mulc_d(rp,cr,&t);
+				dp_mulc_d(rp,(P)cr,&t);
 				chsgnp((P)cred,(P *)&mcred);
-				dp_mulc_d(red,mcred,&t1);
+				dp_mulc_d(red,(P)mcred,&t1);
 				muld(CO,shift,t1,&t1);
 				addd(CO,t,t1,&u);
 				t_m += get_rtime()-tt;
@@ -2594,10 +2527,7 @@ final:
 
 void imulv();
 
-void dp_imul_d(p,q,rp)
-DP p;
-Q q;
-DP *rp;
+void dp_imul_d(DP p,Q q,DP *rp)
 {
 	int nsep,ndist,i,j,k,l,n;
 	double t0,t1,t2;
@@ -2606,8 +2536,8 @@ DP *rp;
 	VECT c,cs,ri;
 	VECT *r;
 	MP m;
-	NODE tn,dist,n0,n1,n2;
-	Obj dmy;
+	NODE tn,dist,n0;
+	Obj obj;
 	STRING imul;
 	extern LIST Dist;
 
@@ -2628,7 +2558,7 @@ DP *rp;
 	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);
+		Pox_rpc(n0,&obj);
 	}
 	t1 = get_rtime();
 	im_t_s += t1 - t0;
@@ -2636,7 +2566,7 @@ DP *rp;
 	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]);
+		Pox_pop_local(n0,&obj); r[i] = (VECT)obj;
 		if ( OID(r[i]) == O_ERR ) {
 			printexpr(CO,(Obj)r[i]);
 			error("dp_imul_d : aborted");
@@ -2653,10 +2583,7 @@ DP *rp;
 	dp_vtod(s,p,rp);
 }
 
-void imulv(w,c,rp)
-VECT w;
-Q c;
-VECT *rp;
+void imulv(VECT w,Q c,VECT *rp)
 {
 	int n,i;
 	VECT r;
@@ -2667,9 +2594,7 @@ VECT *rp;
 		mulq((Q)BDY(w)[i],(Q)c,(Q *)&BDY(r)[i]);
 }
 
-void dptoca(p,rp)
-DP p;
-unsigned int **rp;
+void dptoca(DP p,unsigned int **rp)
 {
 	int i;
 	MP m;