#include "custom.h"
extern char **spots ;
extern int spotXhash ;
extern int spotYhash ;
extern int numXspots ;
extern int numYspots ;
extern int spotSize  ;
extern int choose ;
extern int bigcell ;
extern int toobig  ;
int flips , flipp , attp ;
int newxx , newyy ;
extern double Tsave ;
extern int rangeLimit ;
extern int count ;

extern int newOrient( CELLBOXPTR cellptr , int range );
extern int usite0( int a , int newaor );
extern int wireestx( int xc , int yy1 , int yy2 , double factor3 );
extern int wireesty( int yc , int xx1 , int xx2 , double factor3 );
extern int uaspect( int a , double newAspect );
extern int usite1( int a , int xb , int yb );
extern int usiteo1( int a , int xb , int yb , int newaor );
extern int usite2( int a , int b , int ax , int ay , int bx , int by );
extern int usiteo2( int a , int b , int ax , int ay , int bx , int by, 
		   int newaor ,int newbor );
extern void selectpin( CELLBOXPTR acellptr );

void forceGrid( int x , int y );
void pickSpot( CELLBOXPTR cellptr , int orient , int ll , int rr , int bb , 
	      int tt , int *x , int *y );
void fixSpot( CELLBOXPTR cellptr , int oldx , int oldy , int oldorient );
void fixSpotAsp(CELLBOXPTR cellptr,int lft,int rte,int bot,int top);

void uloop(void)
{

CELLBOXPTR acellptr , bcellptr ;
TILEBOXPTR tileptr ;
TERMBOXPTR termptr , btermptr ;
double range , newAspect;
int a , b , numberx , numbery ;
int attempts , i ;
int xb , yb , axcenter , aycenter ;
int bxcenter , bycenter ;
int aorient , borient , newaor , newbor ;
int flip0, flipo, flip2, flipo2, flipa, flip1 ;
int att0, atto, att2, atto2, atta, att1 ;
int ll , rr , bb , tt , ax , ay , bx , by ;
int reject ;
int al , ar , ab , at ;
int bl , br , bt , min , minstep ;
int delt1 , delt2 ;
int lft, rte, bot, top, xcenter, ycenter ;

flips    = 0 ;
attempts = 0 ;
flip0    = 0 ;
att0     = 0 ;
flipo    = 0 ;
atto     = 0 ;
flip2    = 0 ;
att2     = 0 ;
flipo2   = 0 ;
atto2    = 0 ;
flipa    = 0 ;
atta     = 0 ;
flip1    = 0 ;
att1     = 0 ;
flipp    = 0 ;
attp     = 0 ;


numberx = rangeLimit ;
numbery = rangeLimit ;
if( count < 1 ) {
    fprintf(fpo,"range limiter:%d units either way in x",numberx);
    fprintf(fpo,"   compared to bdxlength:%d\n",bdxlength);
    fprintf(fpo,"range limiter:%d units either way in y",numbery);
    fprintf(fpo,"   compared to bdylength:%d\n",bdylength);
}

while( attempts < attmax ) {
    do {
	a = (int) ( (double) choose * ( (double) RAND / 
				    (double) 0x7fffffff ) ) + 1 ;
    } while( a == choose + 1 ) ;

    do {
	b = (int) ( (double) bigcell * ( (double) RAND / 
				    (double) 0x7fffffff ) ) + 1 ;
    } while( b == toobig ) ;

    if( a == b ) {
	continue ;
    }

    acellptr = cellarray[ a ]   ;
    aorient  = acellptr->orient ;

    if( a > numcells && b <= numcells ) {
	newaor = newOrient( acellptr , 8 ) ;
	if( newaor >= 0 ) {
	    if( usite0( a , newaor ) ) {
		flips++ ;
		flip0++ ;
	    }
	    att0++  ;
	}
    } else if( a <= numcells && b > numcells ) {
	if( acellptr->class != 0 ) {
	    continue ;
	}
	axcenter = acellptr->xcenter ;
	aycenter = acellptr->ycenter ;

	ll = (axcenter-numberx < blockl) ? blockl :
	     (axcenter - numberx > blockr ? blockr : axcenter - numberx);
	rr = (axcenter+numberx > blockr) ? blockr :
	     (axcenter + numberx < blockl ? blockl : axcenter + numberx);
	bb = (aycenter-numbery < blockb) ? blockb :
	     (aycenter - numbery > blockt ? blockt : aycenter - numbery);
	tt = (aycenter+numbery > blockt) ? blockt :
	     (aycenter + numbery < blockb ? blockb : aycenter + numbery);

	pickSpot( acellptr , aorient , ll , rr , bb , tt , &xb , &yb ) ;

	if( gridGiven ) {
	    termptr  = acellptr->config[aorient]->termptr ;
	    forceGrid( xb + termptr->xpos , yb + termptr->ypos ) ;
	    xb = newxx - termptr->xpos ;
	    yb = newyy - termptr->ypos ;
	}

        if( usite1( a , xb , yb ) ) {
	    flips++ ;
	    flip1++ ;
	    att1++ ;
	    attempts++ ;

	    fixSpot( acellptr , axcenter , aycenter , aorient ) ;

	} else {
	    attempts++ ;
	    att1++ ;
	    newaor = newOrient( acellptr , 4 ) ;
	    reject = 1 ;
	    if( newaor >= 0 ) {
		if( usiteo1( a , xb , yb , newaor ) ) {
		    flips++ ;
		    flipo++ ;
		    atto++  ;
		    reject = 0 ;

		    fixSpot( acellptr , axcenter , aycenter , aorient ) ;

		} else {
		    atto++  ;
		}
	    }
	    if( reject ) {
		newaor = newOrient( acellptr , 8 ) ;
		reject = 1 ;
		if( newaor >= 0 ) {
		    if( usite0( a , newaor ) ) {
			flips++ ;
			flip0++ ;
			att0++  ;
			reject = 0 ;

			fixSpot( acellptr, axcenter, aycenter, aorient);

		    } else {
			att0++  ;
		    }
		}
	    }
	}
	if( acellptr->numUnComTerms != 0 ){
	    for( i = 1 ; i <= acellptr->numgroups ; i++ ) {
		selectpin( acellptr ) ;
	    }
	}
	/*
	 *   The goal here is to generate a new
	 *   aspect ratio for the cell if such
	 *   a thing is permitted.  First test
	 *   for permission.
	 */
	if( acellptr->softflag != 0 &&
		(acellptr->aspUB > 0.01 + acellptr->aspLB)){
	    /*
	     *   We have clearance for an aspect
	     *   ratio change
	     */
	    range = acellptr->aspUB - acellptr->aspLB;
	    newAspect = range * ((double)RAND / 
		    (double) 0x7fffffff) + acellptr->aspLB ;

	    xcenter = acellptr->xcenter ;
	    ycenter = acellptr->ycenter ;
	    lft = xcenter + acellptr->config[acellptr->orient]->left   ;
	    rte = xcenter + acellptr->config[acellptr->orient]->right  ;
	    bot = ycenter + acellptr->config[acellptr->orient]->bottom ;
	    top = ycenter + acellptr->config[acellptr->orient]->top    ;

	    if( uaspect( a , newAspect ) ) {
		flips++ ;
		flipa++ ;

		fixSpotAsp(acellptr,lft,rte,bot,top) ;
	    } 
	    atta++ ;
	}
    } else { /*  a & b <= numcells or a & b > numcells  */
	bcellptr = cellarray[b] ;
	borient = bcellptr->orient ;
	if( acellptr->class == -1 || bcellptr->class == -1 ||
			    acellptr->class != bcellptr->class ) {
	    continue ;
	}
	if( gridGiven ) {
	    /*
	     *   Force pin 1 to lie on the underlying grid, specified
	     *   by:  n * (grid) + offset , in each direction.
	     */
	    btermptr = bcellptr->config[bcellptr->orient]->termptr ;
	    termptr = acellptr->config[aorient]->termptr ;
	    forceGrid( bcellptr->xcenter + termptr->xpos , 
		       bcellptr->ycenter + termptr->ypos ) ;
	    ax = newxx - termptr->xpos ;
	    ay = newyy - termptr->ypos ;
	    forceGrid( acellptr->xcenter + btermptr->xpos , 
		       acellptr->ycenter + btermptr->ypos ) ;
	    bx = newxx - btermptr->xpos ;
	    by = newyy - btermptr->ypos ;
	} else {
	    ax = bcellptr->xcenter ;
	    ay = bcellptr->ycenter ;
	    bx = acellptr->xcenter ;
	    by = acellptr->ycenter ;
	}
	axcenter = bx ;
	aycenter = by ;
	bxcenter = ax ;
	bycenter = ay ;
	/* ****************************************************** */
	/*  SOMETHING NEW  */
	tileptr = acellptr->config[ aorient ]  ;
	al = ax + tileptr->left    ;
	ar = ax + tileptr->right   ;
	ab = ay + tileptr->bottom  ;
	at = ay + tileptr->top     ;
	if( a <= numcells ) {
	    al -= wireestx(al,ab,at,tileptr->lweight ) ;
	    ar += wireestx(ar,ab,at,tileptr->rweight ) ;
	    ab -= wireesty(ab,al,ar,tileptr->bweight ) ;
	    at += wireesty(at,al,ar,tileptr->tweight ) ;
	}
	tileptr = bcellptr->config[ bcellptr->orient ]  ;
	bl = bx + tileptr->left    ;
	br = bx + tileptr->right   ;
	bb = by + tileptr->bottom  ;
	bt = by + tileptr->top     ;
	if( b <= numcells ) {
	    bl -= wireestx(bl,bb,bt,tileptr->lweight ) ;
	    br += wireestx(br,bb,bt,tileptr->rweight ) ;
	    bb -= wireesty(bb,bl,br,tileptr->bweight ) ;
	    bt += wireesty(bt,bl,br,tileptr->tweight ) ;
	}
	min = 1000000 ;
	minstep = 0 ;
	if( bl >= ar || al >= br || bb >= at || ab >= bt ) {
	    if( bl < ar ) {
		if( ar - bl < min ) { 
		    minstep = 1 ;
		    min = ar - bl ;
		}
	    }
	    if( al < br ) {
		if( br - al < min ) { 
		    minstep = 2 ;
		    min = br - al ;
		}
	    }
	    if( bb < at ) {
		if( at - bb < min ) { 
		    minstep = 3 ;
		    min = at - bb ;
		}
	    }
	    if( ab < bt ) {
		if( bt - ab < min ) { 
		    minstep = 4 ;
		    min = bt - ab ;
		}
	    }
	}
	if( minstep != 0 ) {
	    delt1 = min / 2 ;
	    delt2 = min - min / 2 ;
	    if( minstep == 1 ) {
		bx += delt1 ;
		ax -= delt2 ;
		if( br + delt1 > blockr ) {
		    bx -= br + delt1 - blockr ;
		    ax -= br + delt1 - blockr ;
		} else if( al - delt2 < blockl ) {
		    bx += blockl - (al - delt2) ;
		    ax += blockl - (al - delt2) ;
		}
	    } else if( minstep == 2 ) {
		ax += delt1 ;
		bx -= delt2 ;
		if( ar + delt1 > blockr ) {
		    bx -= ar + delt1 - blockr ;
		    ax -= ar + delt1 - blockr ;
		} else if( bl - delt2 < blockl ) {
		    bx += blockl - (bl - delt2) ;
		    ax += blockl - (bl - delt2) ;
		}
	    } else if( minstep == 3 ) {
		by += delt1 ;
		ay -= delt2 ;
		if( bt + delt1 > blockt ) {
		    by -= bt + delt1 - blockt ;
		    ay -= bt + delt1 - blockt ;
		} else if( ab - delt2 < blockb ) {
		    by += blockb - (ab - delt2) ;
		    ay += blockb - (ab - delt2) ;
		}
	    } else {
		ay += delt1 ;
		by -= delt2 ;
		if( at + delt1 > blockt ) {
		    by -= at + delt1 - blockt ;
		    ay -= at + delt1 - blockt ;
		} else if( bb - delt2 < blockb ) {
		    by += blockb - (bb - delt2) ;
		    ay += blockb - (bb - delt2) ;
		}
	    }
	}
	/* ****************************************************** */
	if( usite2( a , b , ax , ay , bx , by )  ) {
	    flips++ ;
	    flip2++ ;
	    att2++  ;
	    attempts++ ;

	    fixSpot( acellptr , axcenter , aycenter , aorient ) ;
	    fixSpot( bcellptr , bxcenter , bycenter , borient ) ;

	} else {
	    att2++  ;
	    attempts++ ;
	    /*
		try again with opposite orientation types
	    */
	    newaor = newOrient( acellptr , 4 ) ;
	    newbor = newOrient( bcellptr , 4 ) ;
	    if( newaor >= 0 || newbor >= 0 ) {
		if( newaor < 0 ) {
		    newaor = aorient ;
		} else if( newbor < 0 ) {
		    newbor = borient ;
		}
		if( gridGiven ) {
		    btermptr = bcellptr->config[newbor]-> termptr ;
		    termptr = acellptr->config[newaor]->termptr ;
		    forceGrid( bcellptr->xcenter + termptr->xpos , 
			       bcellptr->ycenter + termptr->ypos ) ;
		    ax = newxx - termptr->xpos ;
		    ay = newyy - termptr->ypos ;
		    forceGrid( acellptr->xcenter + btermptr->xpos , 
			       acellptr->ycenter + btermptr->ypos ) ;
		    bx = newxx - btermptr->xpos ;
		    by = newyy - btermptr->ypos ;
		} else {
		    ax = bcellptr->xcenter ;
		    ay = bcellptr->ycenter ;
		    bx = acellptr->xcenter ;
		    by = acellptr->ycenter ;
		}
		/* ************************************************** */
		/*  SOMETHING NEW  */
		tileptr = acellptr->config[ newaor ]  ;
		al = ax + tileptr->left    ;
		ar = ax + tileptr->right   ;
		ab = ay + tileptr->bottom  ;
		at = ay + tileptr->top     ;
		if( a <= numcells ) {
		    al -= wireestx(al,ab,at,tileptr->lweight ) ;
		    ar += wireestx(ar,ab,at,tileptr->rweight ) ;
		    ab -= wireesty(ab,al,ar,tileptr->bweight ) ;
		    at += wireesty(at,al,ar,tileptr->tweight ) ;
		}
		tileptr = bcellptr->config[ newbor ]  ;
		bl = bx + tileptr->left    ;
		br = bx + tileptr->right   ;
		bb = by + tileptr->bottom  ;
		bt = by + tileptr->top     ;
		if( b <= numcells ) {
		    bl -= wireestx(bl,bb,bt,tileptr->lweight ) ;
		    br += wireestx(br,bb,bt,tileptr->rweight ) ;
		    bb -= wireesty(bb,bl,br,tileptr->bweight ) ;
		    bt += wireesty(bt,bl,br,tileptr->tweight ) ;
		}
		min = 1000000 ;
		minstep = 0 ;
		if( bl >= ar || al >= br || bb >= at || ab >= bt ) {
		    if( bl < ar ) {
			if( ar - bl < min ) { 
			    minstep = 1 ;
			    min = ar - bl ;
			}
		    }
		    if( al < br ) {
			if( br - al < min ) { 
			    minstep = 2 ;
			    min = br - al ;
			}
		    }
		    if( bb < at ) {
			if( at - bb < min ) { 
			    minstep = 3 ;
			    min = at - bb ;
			}
		    }
		    if( ab < bt ) {
			if( bt - ab < min ) { 
			    minstep = 4 ;
			    min = bt - ab ;
			}
		    }
		}
		if( minstep != 0 ) {
		    delt1 = min / 2 ;
		    delt2 = min - min / 2 ;
		    if( minstep == 1 ) {
			bx += delt1 ;
			ax -= delt2 ;
			if( br + delt1 > blockr ) {
			    bx -= br + delt1 - blockr ;
			    ax -= br + delt1 - blockr ;
			} else if( al - delt2 < blockl ) {
			    bx += blockl - (al - delt2) ;
			    ax += blockl - (al - delt2) ;
			}
		    } else if( minstep == 2 ) {
			ax += delt1 ;
			bx -= delt2 ;
			if( ar + delt1 > blockr ) {
			    bx -= ar + delt1 - blockr ;
			    ax -= ar + delt1 - blockr ;
			} else if( bl - delt2 < blockl ) {
			    bx += blockl - (bl - delt2) ;
			    ax += blockl - (bl - delt2) ;
			}
		    } else if( minstep == 3 ) {
			by += delt1 ;
			ay -= delt2 ;
			if( bt + delt1 > blockt ) {
			    by -= bt + delt1 - blockt ;
			    ay -= bt + delt1 - blockt ;
			} else if( ab - delt2 < blockb ) {
			    by += blockb - (ab - delt2) ;
			    ay += blockb - (ab - delt2) ;
			}
		    } else {
			ay += delt1 ;
			by -= delt2 ;
			if( at + delt1 > blockt ) {
			    by -= at + delt1 - blockt ;
			    ay -= at + delt1 - blockt ;
			} else if( bb - delt2 < blockb ) {
			    by += blockb - (bb - delt2) ;
			    ay += blockb - (bb - delt2) ;
			}
		    }
		}
		/* ************************************************** */

		if( usiteo2( a, b, ax, ay, bx, by, newaor, newbor) ) {
		    flips++  ;
		    flipo2++ ;
		    atto2++  ;
		    attempts++ ;

		    fixSpot( acellptr , axcenter , aycenter , aorient ) ;
		    fixSpot( bcellptr , bxcenter , bycenter , borient ) ;

		} else {
		    atto2++  ;
		    attempts++ ;
		}
	    }
	}
    }
}
fprintf(fpo,"acceptance breakdown:\n"); 
fprintf(fpo,"              single cell: %d / %d\n", flip1 , att1) ;
fprintf(fpo,"     single w/ orient chg: %d / %d\n", flipo , atto) ;
fprintf(fpo,"               orient chg: %d / %d\n", flip0 , att0) ;
fprintf(fpo,"                pin moves: %d / %d\n", flipp , attp) ;
fprintf(fpo,"        aspect ratio chgs: %d / %d\n", flipa , atta) ;
fprintf(fpo,"        cell interchanges: %d / %d\n", flip2 , att2) ;
fprintf(fpo,"      interchgs w/ orient: %d / %d\n", flipo2 ,atto2);
fprintf(fpo,"\tno. of accepted flips: %d\n", flips ) ;
/*
doublecheck() ;
fprintf(fpo,"TimberWolf Wire Cost: %d   Penalty: %d\n\n",funccost,
							    penalty);
*/
return ;
}


void forceGrid( int x , int y )
{

newxx = ( (x - gOffsetX) / gridX ) * gridX + gOffsetX ;
if( ABS(newxx + gridX - x) < ABS(newxx - x) ) {
    newxx += gridX ;
}
newyy = ( (y - gOffsetY) / gridY ) * gridY + gOffsetY ;
if( ABS(newyy + gridY - y) < ABS(newyy - y) ) {
    newyy += gridY ;
}
return ;
}


void pickSpot( CELLBOXPTR cellptr , int orient , int ll , int rr , int bb , 
               int tt , int *x , int *y )
{

TILEBOXPTR tileptr ;
int lspot , rspot , bspot , tspot ;
int l , r , b , t ;
int llspot , rrspot , bbspot , ttspot ;
int xrange , yrange ;
int xspot , yspot ;
int xc , yc ;

llspot = (ll - spotXhash) / spotSize ;
rrspot = (rr - spotXhash) / spotSize ;
bbspot = (bb - spotYhash) / spotSize ;
ttspot = (tt - spotYhash) / spotSize ;
xrange = rrspot - llspot + 1 ;
yrange = ttspot - bbspot + 1 ;

tileptr = cellptr->config[orient] ;
xc = cellptr->xcenter    ;
yc = cellptr->ycenter    ;
l = xc + tileptr->left   ;
r = xc + tileptr->right  ;
b = yc + tileptr->bottom ;
t = yc + tileptr->top    ;

l -= wireestx(l,b,t,tileptr->lweight ) ;
r += wireestx(r,b,t,tileptr->rweight ) ;
b -= wireesty(b,l,r,tileptr->bweight ) ;
t += wireesty(t,l,r,tileptr->tweight ) ;

lspot = (l - spotXhash) / spotSize ;
rspot = (r - spotXhash) / spotSize ;
bspot = (b - spotYhash) / spotSize ;
tspot = (t - spotYhash) / spotSize ;

xspot = (cellptr->xcenter - spotXhash) / spotSize ;
yspot = (cellptr->ycenter - spotYhash) / spotSize ;


for( ; ; ) {
    *x = (int) ( (double) xrange * ( (double) RAND / 
				(double) 0x7fffffff ) ) + llspot ;
    *y = (int) ( (double) yrange * ( (double) RAND / 
				(double) 0x7fffffff ) ) + bbspot ;
    if( spots[*x][*y] == 0 ) {
	break ;
    }
    if( *x >= lspot && *x <= rspot && *y >= bspot && *y <= tspot 
		&& ((ABS(*x - xspot) > 1) || (ABS(*y - yspot) > 1)) ) {
	break ;
    }
}
/*
 *   Randomly select (*x,*y) location within spot [*x,*y]
 */
*x = *x * spotSize + spotXhash ;
*y = *y * spotSize + spotYhash ;

*x += (int)((double) spotSize * ((double) RAND / (double) 0x7fffffff));
*y += (int)((double) spotSize * ((double) RAND / (double) 0x7fffffff));

return ;
}


void fixSpot( CELLBOXPTR cellptr , int oldx , int oldy , int oldorient )
{

TILEBOXPTR tileptr ;
int lspot , rspot , bspot , tspot ;
int xc , yc , x , y ;
int l , r , b , t ;
register char *sarray ;

tileptr = cellptr->config[oldorient] ;
l = oldx + tileptr->left   ;
r = oldx + tileptr->right  ;
b = oldy + tileptr->bottom ;
t = oldy + tileptr->top    ;

l -= wireestx(l,b,t,tileptr->lweight ) ;
r += wireestx(r,b,t,tileptr->rweight ) ;
b -= wireesty(b,l,r,tileptr->bweight ) ;
t += wireesty(t,l,r,tileptr->tweight ) ;

lspot = (l - spotXhash) / spotSize ;
rspot = (r - spotXhash) / spotSize ;
bspot = (b - spotYhash) / spotSize ;
tspot = (t - spotYhash) / spotSize ;
for( x = lspot + 1 ; x < rspot ; x++ ) {
    sarray = spots[x] + bspot ;
    for( y = bspot + 1 ; y < tspot ; y++ ) {
	(*(++sarray))-- ;
    }
}

tileptr = cellptr->config[cellptr->orient] ;
xc = cellptr->xcenter    ;
yc = cellptr->ycenter    ;
l = xc + tileptr->left   ;
r = xc + tileptr->right  ;
b = yc + tileptr->bottom ;
t = yc + tileptr->top    ;

l -= wireestx(l,b,t,tileptr->lweight ) ;
r += wireestx(r,b,t,tileptr->rweight ) ;
b -= wireesty(b,l,r,tileptr->bweight ) ;
t += wireesty(t,l,r,tileptr->tweight ) ;

lspot = (l - spotXhash) / spotSize ;
rspot = (r - spotXhash) / spotSize ;
bspot = (b - spotYhash) / spotSize ;
tspot = (t - spotYhash) / spotSize ;

for( x = lspot + 1 ; x < rspot ; x++ ) {
    sarray = spots[x] + bspot ;
    for( y = bspot + 1 ; y < tspot ; y++ ) {
	(*(++sarray))++ ;
    }
}

return ;
}


void fixSpotAsp(CELLBOXPTR cellptr,int lft,int rte,int bot,int top)
{

TILEBOXPTR tileptr ;
int lspot , rspot , bspot , tspot ;
int xc , yc , x , y ;
int l , r , b , t ;
register char *sarray ;


/* XXX what the HELL is going on here, haven't you ever heard of lint! */
/* tileptr has not value at this point in time! */
l = lft - wireestx(lft,bot,top,tileptr->lweight ) ;
r = rte + wireestx(rte,bot,top,tileptr->rweight ) ;
b = bot - wireesty(bot,lft,rte,tileptr->bweight ) ;
t = top - wireesty(top,lft,rte,tileptr->tweight ) ;

lspot = (l - spotXhash) / spotSize ;
rspot = (r - spotXhash) / spotSize ;
bspot = (b - spotYhash) / spotSize ;
tspot = (t - spotYhash) / spotSize ;

for( x = lspot + 1 ; x < rspot ; x++ ) {
    sarray = spots[x] + bspot ;
    for( y = bspot + 1 ; y < tspot ; y++ ) {
	(*(++sarray))-- ;
    }
}

tileptr = cellptr->config[cellptr->orient] ;
xc = cellptr->xcenter    ;
yc = cellptr->ycenter    ;
l = xc + tileptr->left   ;
r = xc + tileptr->right  ;
b = yc + tileptr->bottom ;
t = yc + tileptr->top    ;

l -= wireestx(l,b,t,tileptr->lweight ) ;
r += wireestx(r,b,t,tileptr->rweight ) ;
b -= wireesty(b,l,r,tileptr->bweight ) ;
t += wireesty(t,l,r,tileptr->tweight ) ;

lspot = (l - spotXhash) / spotSize ;
rspot = (r - spotXhash) / spotSize ;
bspot = (b - spotYhash) / spotSize ;
tspot = (t - spotYhash) / spotSize ;

for( x = lspot + 1 ; x < rspot ; x++ ) {
    sarray = spots[x] + bspot ;
    for( y = bspot + 1 ; y < tspot ; y++ ) {
	(*(++sarray))++ ;
    }
}

return ;
}