src/hd/rholo3.c

/* Copyright (c) 1997 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Routines for tracking beam compuatations
 */

#include "rholo.h"


#define abs(x)          ((x) > 0 ? (x) : -(x))
#define sgn(x)          ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)


static PACKHEAD *complist=NULL; /* list of beams to compute */
static int      complen=0;      /* length of complist */
static int      listpos=0;      /* current list position for next_packet */
static int      lastin= -1;     /* last ordered position in list */


int
beamcmp(b0, b1)                 /* comparison for descending compute order */
register PACKHEAD       *b0, *b1;
{
        return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
                b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
}


bundle_set(op, clist, nents)    /* bundle set operation */
int     op;
PACKHEAD        *clist;
int     nents;
{
        BEAM    *b;
        PACKHEAD        *p;
        register int    i, n;

        switch (op) {
        case BS_NEW:                    /* new computation set */
                if (complen)
                        free((char *)complist);
                if (nents <= 0) {
                        complist = NULL;
                        listpos = complen = 0;
                        lastin = -1;
                        return;
                }
                complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
                if (complist == NULL)
                        goto memerr;
                bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
                complen = nents;
                listpos = 0;
                lastin = -1;            /* flag for initial sort */
                break;
        case BS_ADD:                    /* add to computation set */
                if (nents <= 0)
                        return;
                                        /* merge any common members */
                for (i = 0; i < complen; i++)
                        for (n = 0; n < nents; n++)
                                if (clist[n].bi == complist[i].bi &&
                                                clist[n].hd == complist[i].hd) {
                                        complist[i].nr += clist[n].nr;
                                        clist[n].nr = 0;
                                        lastin = -1;    /* flag full sort */
                                        break;
                                }
                                        /* sort updated list */
                sortcomplist();
                                        /* sort new entries */
                qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
                                        /* what can't we satisfy? */
                for (n = 0; n < nents && clist[n].nr >
                                bnrays(hdlist[clist[n].hd],clist[n].bi); n++)
                        ;
                if (n) {                /* allocate space for merged list */
                        PACKHEAD        *newlist;
                        newlist = (PACKHEAD *)malloc(
                                        (complen+n)*sizeof(PACKHEAD) );
                        if (newlist == NULL)
                                goto memerr;
                                                /* merge lists */
                        mergeclists(newlist, clist, n, complist, complen);
                        if (complen)
                                free((char *)complist);
                        complist = newlist;
                        complen += n;
                }
                listpos = 0;
                lastin = complen-1;     /* list is now sorted */
                break;
        case BS_DEL:                    /* delete from computation set */
                if (nents <= 0)
                        return;
                                        /* find each member */
                for (i = 0; i < complen; i++)
                        for (n = 0; n < nents; n++)
                                if (clist[n].bi == complist[i].bi &&
                                                clist[n].hd == complist[i].hd) {
                                        if (clist[n].nr == 0 ||
                                                clist[n].nr >= complist[i].nr)
                                                complist[i].nr = 0;
                                        else
                                                complist[i].nr -= clist[n].nr;
                                        lastin = -1;    /* flag full sort */
                                        break;
                                }
                if (lastin < 0)         /* sort updated list */
                        sortcomplist();
                return;                 /* no display */
        default:
                error(CONSISTENCY, "bundle_set called with unknown operation");
        }
        n = 0;                          /* allocate packet holder */
        for (i = 0; i < nents; i++)
                if (clist[i].nr > n)
                        n = clist[i].nr;
        p = (PACKHEAD *)malloc(packsiz(n));
        if (p == NULL)
                goto memerr;
                                        /* display what we have */
        for (i = 0; i < nents; i++)
                if ((b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
                        bcopy((char *)hdbray(b), (char *)packrays(p),
                                        (p->nr=b->nrm)*sizeof(RAYVAL));
                        disp_packet(p);
                }
        free((char *)p);                /* clean up */
        return;
memerr:
        error(SYSTEM, "out of memory in bundle_set");
}


int
weightf(hp, x0, x1, x2)         /* voxel weighting function */
register HOLO   *hp;
register int    x0, x1, x2;
{
        switch (vlet(OCCUPANCY)) {
        case 'U':               /* uniform weighting */
                return(1);
        case 'C':               /* center weighting (crude) */
                x0 += x0 - hp->grid[0] + 1;
                x0 = abs(x0)*hp->grid[1]*hp->grid[2];
                x1 += x1 - hp->grid[1] + 1;
                x1 = abs(x1)*hp->grid[0]*hp->grid[2];
                x2 += x2 - hp->grid[2] + 1;
                x2 = abs(x2)*hp->grid[0]*hp->grid[1];
                return(hp->grid[0]*hp->grid[1]*hp->grid[2] -
                                (x0+x1+x2)/3);
        default:
                badvalue(OCCUPANCY);
        }
}


/* The following is by Daniel Cohen, taken from Graphics Gems IV, p. 368 */
long
lineweight(hp, x, y, z, dx, dy, dz)     /* compute weights along a line */
HOLO    *hp;
int     x, y, z, dx, dy, dz;
{
        long    wres = 0;
        int     n, sx, sy, sz, exy, exz, ezy, ax, ay, az, bx, by, bz;

        sx = sgn(dx);   sy = sgn(dy);   sz = sgn(dz);
        ax = abs(dx);   ay = abs(dy);   az = abs(dz);
        bx = 2*ax;      by = 2*ay;      bz = 2*az;
        exy = ay-ax;    exz = az-ax;    ezy = ay-az;
        n = ax+ay+az + 1;               /* added increment to visit last */
        while (n--) {
                wres += weightf(hp, x, y, z);
                if (exy < 0) {
                        if (exz < 0) {
                                x += sx;
                                exy += by; exz += bz;
                        } else {
                                z += sz;
                                exz -= bx; ezy += by;
                        }
                } else {
                        if (ezy < 0) {
                                z += sz;
                                exz -= bx; ezy += by;
                        } else {
                                y += sy;
                                exy -= bx; ezy -= bz;
                        }
                }
        }
        return(wres);
}


init_global()                   /* initialize global ray computation */
{
        long    wtotal = 0;
        int     i, j;
        int     lseg[2][3];
        double  frac;
        register int    k;
                                        /* free old list */
        if (complen > 0)
                free((char *)complist);
                                        /* allocate beam list */
        complen = 0;
        for (j = 0; hdlist[j] != NULL; j++)
                complen += nbeams(hdlist[j]);
        complist = (PACKHEAD *)malloc(complen*sizeof(PACKHEAD));
        if (complist == NULL)
                error(SYSTEM, "out of memory in init_global");
                                        /* compute beam weights */
        k = 0;
        for (j = 0; hdlist[j] != NULL; j++)
                for (i = nbeams(hdlist[j]); i > 0; i--) {
                        hdlseg(lseg, hdlist[j], i);
                        complist[k].hd = j;
                        complist[k].bi = i;
                        complist[k].nr = lineweight( hdlist[j],
                                        lseg[0][0], lseg[0][1], lseg[0][2],
                                        lseg[1][0] - lseg[0][0],
                                        lseg[1][1] - lseg[0][1],
                                        lseg[1][2] - lseg[0][2] );
                        wtotal += complist[k++].nr;
                }
                                        /* adjust weights */
        if (vdef(DISKSPACE)) {
                frac = 1024.*1024.*vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
                if (frac < 0.95 | frac > 1.05)
                        while (k--)
                                complist[k].nr = frac * complist[k].nr;
        }
        listpos = 0; lastin = -1;       /* flag initial sort */
}


mergeclists(cdest, cl1, n1, cl2, n2)    /* merge two sorted lists */
PACKHEAD        *cdest;
PACKHEAD        *cl1, *cl2;
int     n1, n2;
{
        int     cmp;

        while (n1 | n2) {
                if (!n1) cmp = 1;
                else if (!n2) cmp = -1;
                else cmp = beamcmp(cl1, cl2);
                if (cmp > 0) {
                        copystruct(cdest, cl2);
                        cl2++; n2--;
                } else {
                        copystruct(cdest, cl1);
                        cl1++; n1--;
                }
                cdest++;
        }
}


sortcomplist()                  /* fix our list order */
{
        PACKHEAD        *list2;
        register int    i;

                                /* empty queue */
        done_packets(flush_queue());
        if (complen <= 0)       /* check to see if there is even a list */
                return;
        if (lastin < 0)         /* flag to sort entire list */
                qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
        else if (listpos) {     /* else sort and merge sublist */
                list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
                if (list2 == NULL)
                        error(SYSTEM, "out of memory in sortcomplist");
                bcopy((char *)complist,(char *)list2,listpos*sizeof(PACKHEAD));
                qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
                mergeclists(complist, list2, listpos,
                                complist+listpos, complen-listpos);
                free((char *)list2);
        }
                                        /* check for all finished */
        if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
                free((char *)complist);
                complist = NULL;
                complen = 0;
        }
                                        /* drop satisfied requests */
        for (i = complen; i-- && complist[i].nr <=
                        bnrays(hdlist[complist[i].hd],complist[i].bi); )
                ;
        if (i < 0) {
                free((char *)complist);
                complist = NULL;
                complen = 0;
        } else if (i < complen-1) {
                list2 = (PACKHEAD *)realloc((char *)complist,
                                (i+1)*sizeof(PACKHEAD));
                if (list2 != NULL) {
                        complist = list2;
                        complen = i+1;
                }
        }
        listpos = 0; lastin = i;
}


/*
 * The following routine works on the assumption that the bundle weights are
 * more or less evenly distributed, such that computing a packet causes
 * a given bundle to move way down in the computation order.  We keep
 * track of where the computed bundle with the highest priority would end
 * up, and if we get further in our compute list than this, we resort the
 * list and start again from the beginning.  We have to flush the queue
 * each time we sort, to ensure that we are not disturbing the order.
 *      If our major assumption is violated, and we have a very steep
 * descent in our weights, then we will end up resorting much more often
 * than necessary, resulting in frequent flushing of the queue.  Since
 * a merge sort is used, the sorting costs will be minimal.
 */
next_packet(p)                  /* prepare packet for computation */
register PACKET *p;
{
        int     ncomp;
        register int    i;

        if (complen <= 0)
                return(0);
        if (listpos > lastin)           /* time to sort the list */
                sortcomplist();
        p->hd = complist[listpos].hd;
        p->bi = complist[listpos].bi;
        ncomp = bnrays(hdlist[p->hd],p->bi);
        p->nr = complist[listpos].nr - ncomp;
        if (p->nr <= 0)
                return(0);
        if (p->nr > RPACKSIZ)
                p->nr = RPACKSIZ;
        ncomp += p->nr;                 /* find where this one would go */
        while (lastin > listpos && complist[listpos].nr *
                (bnrays(hdlist[complist[lastin].hd],complist[lastin].bi)+1)
                        > complist[lastin].nr * (ncomp+1))
                lastin--;
        listpos++;
        return(1);
}
Revision:	3.5
Committed:	Thu Nov 6 16:11:49 1997 UTC (27 years, 11 months ago) by gregl
Content type:	text/plain
Branch:	MAIN
Changes since 3.4:	+3 -3 lines
Log Message:	changed disp_packet to take PACKHEAD* r.t. PACKET*
#	User	Rev	Content
1	gregl	3.1	/* Copyright (c) 1997 Silicon Graphics, Inc. */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ SGI";
5			#endif
6
7			/*
8			* Routines for tracking beam compuatations
9			*/
10
11			#include "rholo.h"
12
13
14			#define abs(x) ((x) > 0 ? (x) : -(x))
15			#define sgn(x) ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)
16
17
18	gregl	3.4	static PACKHEAD complist=NULL; / list of beams to compute */
19			static int complen=0; /* length of complist */
20			static int listpos=0; /* current list position for next_packet */
21			static int lastin= -1; /* last ordered position in list */
22	gregl	3.1
23
24			int
25	gregl	3.2	beamcmp(b0, b1) /* comparison for descending compute order */
26			register PACKHEAD b0, b1;
27			{
28			return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
29			b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
30			}
31
32
33			bundle_set(op, clist, nents) /* bundle set operation */
34			int op;
35			PACKHEAD *clist;
36			int nents;
37			{
38			BEAM *b;
39			PACKHEAD *p;
40			register int i, n;
41
42			switch (op) {
43			case BS_NEW: /* new computation set */
44			if (complen)
45			free((char *)complist);
46			if (nents <= 0) {
47			complist = NULL;
48			listpos = complen = 0;
49			lastin = -1;
50			return;
51			}
52			complist = (PACKHEAD )malloc(nentssizeof(PACKHEAD));
53			if (complist == NULL)
54			goto memerr;
55			bcopy((char )clist, (char )complist, nents*sizeof(PACKHEAD));
56			complen = nents;
57			listpos = 0;
58			lastin = -1; /* flag for initial sort */
59			break;
60			case BS_ADD: /* add to computation set */
61			if (nents <= 0)
62			return;
63			/* merge any common members */
64			for (i = 0; i < complen; i++)
65			for (n = 0; n < nents; n++)
66			if (clist[n].bi == complist[i].bi &&
67			clist[n].hd == complist[i].hd) {
68			complist[i].nr += clist[n].nr;
69			clist[n].nr = 0;
70			lastin = -1; /* flag full sort */
71			break;
72			}
73			/* sort updated list */
74			sortcomplist();
75			/* sort new entries */
76			qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
77			/* what can't we satisfy? */
78			for (n = 0; n < nents && clist[n].nr >
79			bnrays(hdlist[clist[n].hd],clist[n].bi); n++)
80			;
81			if (n) { /* allocate space for merged list */
82			PACKHEAD *newlist;
83			newlist = (PACKHEAD *)malloc(
84			(complen+n)*sizeof(PACKHEAD) );
85			if (newlist == NULL)
86			goto memerr;
87			/* merge lists */
88			mergeclists(newlist, clist, n, complist, complen);
89			if (complen)
90			free((char *)complist);
91			complist = newlist;
92			complen += n;
93			}
94			listpos = 0;
95			lastin = complen-1; /* list is now sorted */
96			break;
97			case BS_DEL: /* delete from computation set */
98			if (nents <= 0)
99			return;
100			/* find each member */
101			for (i = 0; i < complen; i++)
102			for (n = 0; n < nents; n++)
103			if (clist[n].bi == complist[i].bi &&
104			clist[n].hd == complist[i].hd) {
105			if (clist[n].nr == 0 \|\|
106			clist[n].nr >= complist[i].nr)
107			complist[i].nr = 0;
108			else
109			complist[i].nr -= clist[n].nr;
110			lastin = -1; /* flag full sort */
111			break;
112			}
113	gregl	3.3	if (lastin < 0) /* sort updated list */
114			sortcomplist();
115	gregl	3.2	return; /* no display */
116			default:
117			error(CONSISTENCY, "bundle_set called with unknown operation");
118			}
119			n = 0; /* allocate packet holder */
120			for (i = 0; i < nents; i++)
121			if (clist[i].nr > n)
122			n = clist[i].nr;
123	gregl	3.5	p = (PACKHEAD *)malloc(packsiz(n));
124	gregl	3.3	if (p == NULL)
125			goto memerr;
126			/* display what we have */
127	gregl	3.2	for (i = 0; i < nents; i++)
128	gregl	3.3	if ((b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
129	gregl	3.5	bcopy((char )hdbray(b), (char )packrays(p),
130	gregl	3.2	(p->nr=b->nrm)*sizeof(RAYVAL));
131	gregl	3.5	disp_packet(p);
132	gregl	3.2	}
133			free((char )p); / clean up */
134			return;
135			memerr:
136			error(SYSTEM, "out of memory in bundle_set");
137			}
138
139
140			int
141	gregl	3.1	weightf(hp, x0, x1, x2) /* voxel weighting function */
142			register HOLO *hp;
143			register int x0, x1, x2;
144			{
145			switch (vlet(OCCUPANCY)) {
146			case 'U': /* uniform weighting */
147			return(1);
148			case 'C': /* center weighting (crude) */
149			x0 += x0 - hp->grid[0] + 1;
150			x0 = abs(x0)hp->grid[1]hp->grid[2];
151			x1 += x1 - hp->grid[1] + 1;
152			x1 = abs(x1)hp->grid[0]hp->grid[2];
153			x2 += x2 - hp->grid[2] + 1;
154			x2 = abs(x2)hp->grid[0]hp->grid[1];
155			return(hp->grid[0]hp->grid[1]hp->grid[2] -
156			(x0+x1+x2)/3);
157			default:
158			badvalue(OCCUPANCY);
159			}
160			}
161
162
163			/* The following is by Daniel Cohen, taken from Graphics Gems IV, p. 368 */
164			long
165			lineweight(hp, x, y, z, dx, dy, dz) /* compute weights along a line */
166			HOLO *hp;
167			int x, y, z, dx, dy, dz;
168			{
169			long wres = 0;
170			int n, sx, sy, sz, exy, exz, ezy, ax, ay, az, bx, by, bz;
171
172			sx = sgn(dx); sy = sgn(dy); sz = sgn(dz);
173			ax = abs(dx); ay = abs(dy); az = abs(dz);
174			bx = 2ax; by = 2ay; bz = 2*az;
175			exy = ay-ax; exz = az-ax; ezy = ay-az;
176			n = ax+ay+az + 1; /* added increment to visit last */
177			while (n--) {
178			wres += weightf(hp, x, y, z);
179			if (exy < 0) {
180			if (exz < 0) {
181			x += sx;
182			exy += by; exz += bz;
183			} else {
184			z += sz;
185			exz -= bx; ezy += by;
186			}
187			} else {
188			if (ezy < 0) {
189			z += sz;
190			exz -= bx; ezy += by;
191			} else {
192			y += sy;
193			exy -= bx; ezy -= bz;
194			}
195			}
196			}
197			return(wres);
198			}
199
200
201			init_global() /* initialize global ray computation */
202			{
203			long wtotal = 0;
204			int i, j;
205			int lseg[2][3];
206			double frac;
207			register int k;
208	gregl	3.3	/* free old list */
209			if (complen > 0)
210			free((char *)complist);
211	gregl	3.1	/* allocate beam list */
212			complen = 0;
213			for (j = 0; hdlist[j] != NULL; j++)
214			complen += nbeams(hdlist[j]);
215			complist = (PACKHEAD )malloc(complensizeof(PACKHEAD));
216			if (complist == NULL)
217			error(SYSTEM, "out of memory in init_global");
218			/* compute beam weights */
219			k = 0;
220			for (j = 0; hdlist[j] != NULL; j++)
221			for (i = nbeams(hdlist[j]); i > 0; i--) {
222			hdlseg(lseg, hdlist[j], i);
223			complist[k].hd = j;
224			complist[k].bi = i;
225			complist[k].nr = lineweight( hdlist[j],
226			lseg[0][0], lseg[0][1], lseg[0][2],
227			lseg[1][0] - lseg[0][0],
228			lseg[1][1] - lseg[0][1],
229			lseg[1][2] - lseg[0][2] );
230			wtotal += complist[k++].nr;
231			}
232			/* adjust weights */
233			if (vdef(DISKSPACE)) {
234			frac = 1024.1024.vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
235			if (frac < 0.95 \| frac > 1.05)
236			while (k--)
237			complist[k].nr = frac * complist[k].nr;
238			}
239	gregl	3.4	listpos = 0; lastin = -1; /* flag initial sort */
240	gregl	3.1	}
241
242
243			mergeclists(cdest, cl1, n1, cl2, n2) /* merge two sorted lists */
244			PACKHEAD *cdest;
245			PACKHEAD cl1, cl2;
246			int n1, n2;
247			{
248			int cmp;
249
250			while (n1 \| n2) {
251			if (!n1) cmp = 1;
252			else if (!n2) cmp = -1;
253			else cmp = beamcmp(cl1, cl2);
254			if (cmp > 0) {
255			copystruct(cdest, cl2);
256			cl2++; n2--;
257			} else {
258			copystruct(cdest, cl1);
259			cl1++; n1--;
260			}
261			cdest++;
262			}
263			}
264
265
266			sortcomplist() /* fix our list order */
267			{
268			PACKHEAD *list2;
269	gregl	3.2	register int i;
270
271	gregl	3.1	/* empty queue */
272			done_packets(flush_queue());
273	gregl	3.3	if (complen <= 0) /* check to see if there is even a list */
274	gregl	3.2	return;
275	gregl	3.1	if (lastin < 0) /* flag to sort entire list */
276			qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
277			else if (listpos) { /* else sort and merge sublist */
278			list2 = (PACKHEAD )malloc(listpossizeof(PACKHEAD));
279			if (list2 == NULL)
280			error(SYSTEM, "out of memory in sortcomplist");
281			bcopy((char )complist,(char )list2,listpos*sizeof(PACKHEAD));
282			qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
283			mergeclists(complist, list2, listpos,
284			complist+listpos, complen-listpos);
285			free((char *)list2);
286			}
287	gregl	3.2	/* check for all finished */
288			if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
289			free((char *)complist);
290			complist = NULL;
291			complen = 0;
292			}
293			/* drop satisfied requests */
294			for (i = complen; i-- && complist[i].nr <=
295			bnrays(hdlist[complist[i].hd],complist[i].bi); )
296			;
297	gregl	3.4	if (i < 0) {
298			free((char *)complist);
299			complist = NULL;
300			complen = 0;
301			} else if (i < complen-1) {
302	gregl	3.2	list2 = (PACKHEAD )realloc((char )complist,
303			(i+1)*sizeof(PACKHEAD));
304			if (list2 != NULL) {
305			complist = list2;
306			complen = i+1;
307			}
308			}
309			listpos = 0; lastin = i;
310	gregl	3.1	}
311
312
313			/*
314			* The following routine works on the assumption that the bundle weights are
315			* more or less evenly distributed, such that computing a packet causes
316			* a given bundle to move way down in the computation order. We keep
317			* track of where the computed bundle with the highest priority would end
318			* up, and if we get further in our compute list than this, we resort the
319			* list and start again from the beginning. We have to flush the queue
320			* each time we sort, to ensure that we are not disturbing the order.
321			* If our major assumption is violated, and we have a very steep
322			* descent in our weights, then we will end up resorting much more often
323			* than necessary, resulting in frequent flushing of the queue. Since
324			* a merge sort is used, the sorting costs will be minimal.
325			*/
326			next_packet(p) /* prepare packet for computation */
327			register PACKET *p;
328			{
329			int ncomp;
330			register int i;
331
332			if (complen <= 0)
333			return(0);
334			if (listpos > lastin) /* time to sort the list */
335			sortcomplist();
336			p->hd = complist[listpos].hd;
337			p->bi = complist[listpos].bi;
338			ncomp = bnrays(hdlist[p->hd],p->bi);
339			p->nr = complist[listpos].nr - ncomp;
340			if (p->nr <= 0)
341			return(0);
342			if (p->nr > RPACKSIZ)
343			p->nr = RPACKSIZ;
344			ncomp += p->nr; /* find where this one would go */
345			while (lastin > listpos && complist[listpos].nr *
346			(bnrays(hdlist[complist[lastin].hd],complist[lastin].bi)+1)
347			> complist[lastin].nr * (ncomp+1))
348			lastin--;
349			listpos++;
350			return(1);
351			}