#include "custom.h"
int HorV ;
int nPinLocs ;
UNCOMBOX *UCptr ;
typedef struct flogbox {
    int pin ;
    int placed ;
    int finalx ;
    int finaly ;
}
FBOX ,
*FBOXPTR ;
FBOXPTR lArray ;

extern int findLoc( int pin );

void finalpin(void)
{

CELLBOXPTR ptr ;
CONTENTBOX *SCptr ;
LOCBOX *SLptr ;
double aspFactor ;
int cell , i , j , k , site , span , trueSpan , pin1 , overlapping ;
int xprev , yprev , totalPin , loc , xnext , ynext , sum ;
int firstLoc , lastLoc , val , isoNum , loFill , hiFill , hit ;
int totLeft , first , second , secLoc , prefer , lastPin ;
int endSeqs[101] , begSeqs[101] , conSeqs[11][101] , isolated[201] ;
int nextS , nextUp ;


for( cell = 1 ; cell <= numcells ; cell++ ) {
    ptr = cellarray[ cell ] ;
    if( ptr->numUnComTerms == 0 ) {
	continue ;
    }
    SCptr = ptr->siteContent ;
    SLptr = ptr->config[ ptr->orient ]->siteLocArray ;
    UCptr = ptr->unComTerms ;
    for( i = 1 ; i <= ptr->numUnComTerms ; i++ ) {
	UCptr[i].finalx = -100000000 ;
	UCptr[i].finaly = -100000000 ;
    }
    for( site = 1 ; site <= ptr->numsites ; site++ ) {
	if( SCptr[ site ].contents <= 0 ) {
	    continue ;
	}
	/* 
	 *  Now we have a site with nonzero contents.
	 */
	span = SCptr[ site ].span ;
	HorV = SCptr[ site ].HorV ;
	if( ptr->orient <= 3 ) {
	    aspFactor = sqrt( ptr->aspect / ptr->aspectO ) ;
	} else {
	    aspFactor = sqrt( ptr->aspectO / ptr->aspect ) ;
	    if( HorV == 1 ) {
		HorV = 0 ;
	    } else {
		HorV = 1 ;
	    }
	}
	if( HorV ) {
	    trueSpan = (int) ( (double) span * aspFactor ) ;
	    if( (double) span - (double) trueSpan / aspFactor >
		(double) (trueSpan + 1) / aspFactor -
						(double) span ) {
		trueSpan++ ;
	    }
	} else {
	    trueSpan = (int) ( (double) span / aspFactor ) ;
	    if( (double) span - (double) trueSpan * aspFactor >
		(double) (trueSpan + 1) * aspFactor -
						(double) span ) {
		trueSpan++ ;
	    }
	}
	nPinLocs = trueSpan / pinSpacing ;
	if( trueSpan - nPinLocs * pinSpacing > (nPinLocs + 1) *
				    pinSpacing - trueSpan ) {
	    nPinLocs++ ;
	}
	/*  
	 *   prepare the location array for the pins  
	 */
	lArray = (FBOXPTR) malloc( (nPinLocs + 1) * sizeof( FBOX ));
	for( i = 1 ; i <= nPinLocs ; i++ ) {
	    lArray[ i ].placed = 0 ;
	    lArray[ i ].pin = 0 ;
	    lArray[ i ].finalx = 0 ;
	    lArray[ i ].finaly = 0 ;
	}
	/*
	 *  center of trueSpan is at:
	 *  SLptr[ site ].xpos  and  SLptr[ site ].ypos
	 */
	if( HorV ) {      /*  a vertical trueSpan  */
	    if( site == ptr->numsites ) {
		nextS = 1 ;
	    } else {
		nextS = site + 1 ;
	    }
	    if( SLptr[nextS].ypos > SLptr[site].ypos ) {
		nextUp = 1 ;
	    } else {
		nextUp = 0 ;
	    }
	    for( i = 1 ; i <= nPinLocs ; i++ ) {
		lArray[ i ].finalx = SLptr[ site ].xpos ;
		if( nextUp == 0 ) {
		    lArray[ i ].finaly = SLptr[ site ].ypos - 
			trueSpan / 2 + (i - 1) * pinSpacing ;
		} else {
		    lArray[ i ].finaly = SLptr[ site ].ypos - 
			(trueSpan + 1) / 2 + i * pinSpacing ;
		}
	    }
	} else {       /* a horizontal trueSpan  */
	    if( site == ptr->numsites ) {
		nextS = 1 ;
	    } else {
		nextS = site + 1 ;
	    }
	    if( SLptr[nextS].xpos > SLptr[site].xpos ) {
		nextUp = 1 ;
	    } else {
		nextUp = 0 ;
	    }
	    for( i = 1 ; i <= nPinLocs ; i++ ) {
		lArray[ i ].finaly = SLptr[ site ].ypos ;
		if( nextUp == 0 ) {
		    lArray[ i ].finalx = SLptr[ site ].xpos - 
			    trueSpan / 2 + (i - 1) * pinSpacing ;
		} else {
		    lArray[ i ].finalx = SLptr[ site ].xpos - 
			(trueSpan + 1) / 2 + i * pinSpacing ;
		}
	    }
	}

	/*  initialize the storage arrays  */
	for( j = 0 ; j <= 100 ; j++ ) {
	    endSeqs[ j ] = 0 ;
	    begSeqs[ j ] = 0 ;
	    for( i = 0 ; i <= 10 ; i++ ) {
		conSeqs[ i ][ j ] = 0 ;
	    }
	}
	for( j = 0 ; j <= 200 ; j++ ) {
	    isolated[ j ] = 0 ;
	}

	/*  Now let's look at the pins belonging to this site */

	for( pin1 = 1 ; pin1 <= ptr->numUnComTerms ; pin1++ ) {
	    if( UCptr[ pin1 ].site == site ) {
		/*
		 *  We have found a pin in this site
		 */
		if( UCptr[ pin1 ].sequence == 0 ) {
		    /*
		     *  This pin is the continuation of a
		     *  sequence started in a previous site.
		     *  Look at the previous pin to see
		     *  what its site is.
		     */
		    if( endSeqs[0] == 0 ) {
			xprev = SLptr[ UCptr[pin1 - 1].site ].xpos ;
			yprev = SLptr[ UCptr[pin1 - 1].site ].ypos ;
			if( ABS( lArray[ 1 ].finalx - xprev ) +
			    ABS( lArray[ 1 ].finaly - yprev )  <
			    ABS( lArray[nPinLocs].finalx - xprev ) +
			    ABS( lArray[nPinLocs].finaly - yprev )){
			    /*
			     *  Then the previous site is nearer
			     *  pin location number 1. So place this
			     *  pin in location number 1.
			     */
			    endSeqs[0] = 1 ;
			    endSeqs[1] = 1 ;
			    endSeqs[2] = pin1 ;
			} else {
			    endSeqs[0] = 1 ;
			    endSeqs[1] = nPinLocs ;
			    endSeqs[2] = pin1 ;
			}
			for(++pin1; pin1 <= ptr->numUnComTerms; 
						    pin1++){
			    if( UCptr[ pin1 ].sequence != 0 ||
				UCptr[ pin1 ].site != site ) {
				break ;
			    }
			    endSeqs[ ++endSeqs[0] + 1 ] = pin1 ;
			}
		    } else {
			fprintf(fpo,"OOPs: a endSeqs ");
			fprintf(fpo,"cannot fit in the");
			fprintf(fpo," site:%d\n", site );
			fprintf(fpo,"TimberWolf has ");
			fprintf(fpo,"to leave it out\n");
			fprintf(fpo,"Current cell: %d\n", cell ) ;

			for(++pin1; pin1 <= ptr->numUnComTerms; 
							pin1++){
			    if( UCptr[ pin1 ].sequence != 0 ||
				UCptr[ pin1 ].site != site ) {
				break ;
			    }
			}
		    }
		    pin1-- ;
		} else if( UCptr[ pin1 ].sequence > 1 ) {
		    conSeqs[ ++conSeqs[0][0] ][0] = 1 ;
		    conSeqs[ conSeqs[0][0] ][2] = pin1 ;
		    for(++pin1; pin1 <= ptr->numUnComTerms; pin1++){
			if( UCptr[ pin1 ].sequence != 0 ||
				      UCptr[ pin1 ].site != site ) {
			    if( UCptr[ pin1 ].sequence == 0 ) {
				/*
				 *  Lo and behold, a begSeqs here.
				 *  Transfer this entry in conSeqs
				 *  to begSeqs and zero out the
				 *  latest conSeqs entry.
				 */
				i = conSeqs[ conSeqs[0][0] ][0] + 1;
				if( begSeqs[0] == 0 ) {
				    for( ; i >= 0 ; i-- ) {
					begSeqs[ i ] = conSeqs[
					      conSeqs[0][0] ][ i ] ;
					conSeqs[ conSeqs[0][0] ][i] 
							       = 0 ;
				    }
				} else {
				    fprintf(fpo,"OOPs: a begSeqs ");
				    fprintf(fpo,"cannot fit in ");
				    fprintf(fpo," site:%d\n", site);
				    fprintf(fpo,"TimberWolf has t");
				    fprintf(fpo,"o leave it out\n");
				    fprintf(fpo,"Current cell:%d\n",
							    cell ) ;
				    for( ; i >= 0 ; i-- ) {
					conSeqs[ conSeqs[0][0] ][i] 
							       = 0 ;
				    }
				}
				conSeqs[0][0]-- ;
			    }
			    break ;
			}
			conSeqs[ conSeqs[0][0] ]
			       [ ++conSeqs[ conSeqs[0][0] ][0] + 1 ]
			       = pin1 ;
		    }
		    pin1-- ;
		} else {  /* sequence # was numero uno  */
		    isolated[ 2 * ++isolated[0] ] = pin1 ;
		}
	    }
	}
	/*
	 *   At this point, all the pins for a given site
	 *   are in the "arrays" endSeqs, begSeqs, conSeqs,
	 *   and isolated.  The next thing to do is to sort
	 *   all this info out.
	 */
	/*
	 *   First of all, do the ending sequences --- since we
	 *   already know which end of the site they are
	 *   coming from.  Of course, if we have any such.
	 */
	totalPin = endSeqs[0] ;
	if( totalPin > nPinLocs ) {
	    fprintf(fpo,"OOPs: an endSeqs cannot fit in site:%d\n",
							  site ) ;
	    fprintf(fpo,"TimberWolf will have to leave it out\n") ;
	    fprintf(fpo,"Current cell: %d\n", cell ) ;
	}
	if( endSeqs[0] > 0 && totalPin <= nPinLocs ) {
	    if( endSeqs[1] == 1 ) {
		lArray[1].pin = endSeqs[2] ;
		lArray[1].placed = 1 ;
		loc = 1 ;
		for( i = 2 ; i <= endSeqs[0] ; i++ ) {
		    lArray[ ++loc ].pin = endSeqs[ i + 1 ] ;
		    lArray[ loc ].placed = 1 ;
		}
	    } else {
		lArray[ nPinLocs ].pin = endSeqs[2] ;
		lArray[ nPinLocs ].placed = 1 ;
		loc = nPinLocs ;
		for( i = 2 ; i <= endSeqs[0] ; i++ ) {
		    lArray[ --loc ].pin = endSeqs[ i + 1 ] ;
		    lArray[ loc ].placed = 1 ;
		}
	    }
	}
	/*
	 *  Now we have to deal with beginning sequences
	 *  which begin in this site and carry on to the
	 *  next site.
	 */
	if( begSeqs[0] > 0 && totalPin + begSeqs[0] <= nPinLocs ) {
	    totalPin += begSeqs[0] ;
	    lastPin = begSeqs[ begSeqs[0] + 1 ] ;
	    /*
	     *
	     *  Look at the next pin to see
	     *  what its site is.
	     */
	    xnext = SLptr[ UCptr[ lastPin + 1 ].site ].xpos ;
	    ynext = SLptr[ UCptr[ lastPin + 1 ].site ].ypos ;
	    if( ABS( lArray[ 1 ].finalx - xnext ) +
		ABS( lArray[ 1 ].finaly - ynext )  <
		ABS( lArray[ nPinLocs ].finalx - xnext ) +
		ABS( lArray[ nPinLocs ].finaly - ynext )) {
		/*
		 *  Then the next site is nearer
		 *  pin location number 1.  So place this
		 *  pin in location number 1.
		 */
		lArray[1].pin = begSeqs[ begSeqs[0] + 1 ] ;
		lArray[1].placed = 1 ;
		loc = 1 ;
		for( i = begSeqs[0] - 1 ; i >= 1 ; i-- ) {
		    lArray[ ++loc ].pin = begSeqs[ i + 1 ] ;
		    lArray[ loc ].placed = 1 ;
		}
	    } else {
		lArray[ nPinLocs ].pin = begSeqs[ begSeqs[0] + 1 ] ;
		lArray[ nPinLocs ].placed = 1 ;
		loc = nPinLocs ;
		for( i = begSeqs[0] - 1 ; i >= 1 ; i-- ) {
		    lArray[ --loc ].pin = begSeqs[ i + 1 ] ;
		    lArray[ loc ].placed = 1 ;
		}
	    }
	} else if( totalPin + begSeqs[0] > nPinLocs ) {
	    fprintf(fpo,"OOPs: a begSeqs cannot fit in site:%d\n",
							  site ) ;
	    fprintf(fpo,"TimberWolf will have to leave it out\n") ;
	    fprintf(fpo,"Current cell: %d\n", cell ) ;
	} 
	/*
	 *   Now we have a bit more work to do.  We have
	 *   to examine the contained sequences and the
	 *   isolated pins.  For each pin, we have to find
	 *   its most desirable position in the site
	 *   from location 1 thru nPinLocs.
	 */
	for( i = 1 ; i <= conSeqs[0][0] ; i++ ) {
	    if( totalPin + conSeqs[ i ][0] > nPinLocs ) {
		fprintf(fpo,"OOPs: TimberWolf has to ignore a \n");
		fprintf(fpo,"contained sequence in site:%d\n",site);
		fprintf(fpo,"Current cell: %d\n", cell ) ;
		continue ;
	    } else {
		totalPin += conSeqs[ i ][0] ;
	    }
	    sum = 0 ;
	    for( j = 1 ; j <= conSeqs[ i ][0] ; j++ ) {
		if( j == 1 ) {
		    firstLoc = findLoc( conSeqs[ i ][ j + 1 ] ) ;
		    sum += firstLoc ;
		} else if( j == conSeqs[ i ][0] ) {
		    lastLoc = findLoc( conSeqs[ i ][ j + 1 ] ) ;
		    sum += lastLoc ;
		} else {
		    sum += findLoc( conSeqs[ i ][ j + 1 ] ) ;
		}
	    }
	    /*
	     *  The average best place to go for this sequence
	     *  is sum divided by conSeqs[ i ][0].
	     */
	    val = sum / conSeqs[ i ][0] - conSeqs[ i ][0] / 2 ; 
	    if( val < 1 ) {
		val = 1 ;
	    } else if( val > nPinLocs - conSeqs[ i ][0] + 1 ) {
		val = nPinLocs - conSeqs[ i ][0] + 1 ;
	    }
	    if( firstLoc > lastLoc ) {
		conSeqs[ i ][1] = -val ;
	    } else {
		conSeqs[ i ][1] = val ;
	    }
	}
	/*
	 *   And now its finally time to deal with the isolated
	 *   pins.  First, let's see if we can deal with all
	 *   of them.
	 */
       
	if( totalPin + isolated[0] > nPinLocs ) {
	    isoNum = nPinLocs - totalPin ;
	    fprintf(fpo,"OOPs: isolated pin(s) cannot fit in ");
	    fprintf(fpo,"the site: %d\n", site ) ;
	    fprintf(fpo,"TimberWolf will have to ignore this ");
	    fprintf(fpo,"number of pins: %d\n", 
				totalPin + isolated[0] - nPinLocs );
	    fprintf(fpo,"Current cell: %d\n", cell ) ;
	} else {
	    isoNum = isolated[0] ;
	}
	/*
	 *   Here we go
	 */
	for( i = 1 ; i <= isoNum ; i++ ) {
	    isolated[ 2 * i - 1 ] = findLoc( isolated[ 2 * i ] ) ;
	}

	/*
	 *   And ... Now ... Here's ...... the Pin Placer
	 */
	
	/*
	 *   One would surmise that since the beginning and
	 *   ending sequences are already placed , then the
	 *   next thing to do is to place the contained 
	 *   sequences.  Finally, of course, the isolated pins.
	 */
	/*
	 *   The basic method will be to establish two
	 *   endpoints ( say, "left" and "right", if HorV is 0 )
	 *   such that all locs to the left of "left" are
	 *   filled and all locs to the right of "right" are
	 *   also filled.  Then, any conSeqs wanting to start
	 *   to the left of "left" will be packed tight to
	 *   "left" and "left" will be updated accordingly.
	 *   Similarly, all conSeqs wanting to extend beyond
	 *   right will be packed tight to "right" and "right"
	 *   will be updated.
	 */
	loFill = 0 ;
	for( i = 1 ; i <= nPinLocs ; i++ ) {
	    if( lArray[ i ].placed == 1 ) {
		loFill = i ;
	    } else {
		break ;
	    }
	}
	hiFill = nPinLocs + 1 ;
	for( i = nPinLocs ; i >= 1 ; i-- ) {
	    if( lArray[ i ].placed == 1 ) {
		hiFill = i ;
	    } else {
		break ;
	    }
	}

	hit = 1 ;
	while( hit == 1 ) {
	    hit = 0 ;
	    for( i = 1 ; i <= conSeqs[0][0] ; i++ ) {
		if( conSeqs[i][1] == 0 ) {
		    continue ;
		}
		if( ABS( conSeqs[i][1] ) <= loFill + 1 ) {
		    /*
		     *  Place sequence i starting from loFill + 1
		     */
		    if( conSeqs[i][1] > 0 ) {
			for( j = 1 ; j <= conSeqs[i][0] ; j++ ) {
			    lArray[ loFill + j ].pin = 
						  conSeqs[i][j+1] ;
			    lArray[ loFill + j ].placed = 1 ;
			}
		    } else {
			for( j = 1 , k = conSeqs[i][0] ; 
				   j <= conSeqs[i][0] ; j++ , k--) {
			    lArray[ loFill + j ].pin = 
						  conSeqs[i][k+1] ;
			    lArray[ loFill + j ].placed = 1 ;
			}
		    }
		    loFill += conSeqs[i][0] ;
		    conSeqs[i][1] = 0 ;
		    hit = 1 ;
		} else if( ABS( conSeqs[i][1] ) + 
				    conSeqs[i][0] >= hiFill ) {
		    /*
		     *  Place sequence i starting from 
		     *  hiFill - conSeqs[i][0]
		     */
		    if( conSeqs[i][1] > 0 ) {
			for( j = hiFill - conSeqs[i][0] , k = 1 ; 
				    j < hiFill ; j++ , k++ ) {
			    lArray[ j ].pin = conSeqs[i][k+1] ;
			    lArray[ j ].placed = 1 ;
			}
		    } else {
			for( j = hiFill - conSeqs[i][0] , 
				    k = conSeqs[i][0] ; 
				    j < hiFill ; j++ , k-- ) {
			    lArray[ j ].pin = conSeqs[i][k+1] ;
			    lArray[ j ].placed = 1 ;
			}
		    }
		    hiFill -= conSeqs[i][0] ;
		    conSeqs[i][1] = 0 ;
		    hit = 1 ;
		}
	    }
	}
	/*
	 *   Ok, that was the easy placement.  Now we have to
	 *   deal with any other conSeqs that may be left
	 *   which apparently want to sit in the middle of
	 *   the site.
	 */
	/*
	 *   Now select the lowest-most remaining sequence.
	 *   Put it in its bestPos if the other remaining
	 *   sequences can fit in the remaining space above.
	 *   Otherwise, back it off as necessary.
	 */
	totLeft = 0 ;
	for( i = 1 ; i <= conSeqs[0][0] ; i++ ) {
	    if( conSeqs[i][1] == 0 ) {
		continue ;
	    }
	    totLeft += conSeqs[i][0] ;
	}

	while( totLeft > 0 ) {
	    first = 0 ;
	    second = 0 ;
	    firstLoc = nPinLocs + 1 ;
	    secLoc = nPinLocs + 1 ;
	    for( i = 1 ; i <= conSeqs[0][0] ; i++ ) {
		if( conSeqs[i][1] == 0 ) {
		    continue ;
		}
		if( ABS( conSeqs[i][1] ) < firstLoc ) {
		    if( first != 0 ) {
			second = first ;
			secLoc = firstLoc ;
		    }
		    firstLoc = ABS( conSeqs[i][1] ) ;
		    first = i ;
		} else if( ABS( conSeqs[i][1] ) < secLoc ) {
		    secLoc = ABS( conSeqs[i][1] ) ;
		    second = i ;
		}
	    }
	    while( firstLoc + totLeft > hiFill ) {
		    /*
		     *   Insufficient room if we start at firstLoc
		     */
		firstLoc-- ;
	    }
		/*
		 *   If secLoc intersects firstLoc to firstLoc +
		 *   ( length of firstseq - 1 ) then back off
		 *   firstLoc ( if possible ) by an amount
		 *   equal to 1/2 of the amount of overlapping
		 */
	    if( secLoc < firstLoc + conSeqs[ first ][0] - 1 ) {
		overlapping = firstLoc + conSeqs[ first ][0] - 1 -
							secLoc ;
		while( (firstLoc + 
				conSeqs[ first ][0] - 1 - secLoc) > 
						    overlapping / 2 ) {
		    if( firstLoc - 1 > loFill ) {
			firstLoc-- ;
		    } else {
			break ;
		    }
		}
		    /*
		     *  We want to place both of these sequences
		     */
		if( conSeqs[ first ][1] > 0 ) {
		    for( j = 1 ; j <= conSeqs[ first ][0] ; j++ ) {
			lArray[ firstLoc - 1 + j ].pin = 
					     conSeqs[ first ][j+1] ;
			lArray[ firstLoc - 1 + j ].placed = 1 ;
		    }
		} else {
		    for( j = 1 , k = conSeqs[ first ][0] ; 
			   j <= conSeqs[ first ][0] ; j++ , k--) {
			lArray[ firstLoc - 1 + j ].pin = 
					     conSeqs[ first ][k+1] ;
			lArray[ firstLoc - 1 + j ].placed = 1 ;
		    }
		}
		loFill = firstLoc + conSeqs[ first ][0] - 1 ;
		conSeqs[ first ][1] = 0 ;
		totLeft -= conSeqs[ first ][0] ;

		if( conSeqs[ second ][1] > 0 ) {
		    for( j = 1 ; j <= conSeqs[ second ][0] ; j++ ) {
			lArray[ loFill + j ].pin = 
				     conSeqs[ second ][j+1] ;
			lArray[ loFill + j ].placed = 1 ;
		    }
		} else {
		    for( j = 1 , k = conSeqs[ second ][0] ; 
			   j <= conSeqs[ second ][0] ; j++ , k--) {
			lArray[ loFill + j ].pin = 
				     conSeqs[ second ][k+1] ;
			lArray[ loFill + j ].placed = 1 ;
		    }
		}
		loFill = loFill + conSeqs[ second ][0] ;
		conSeqs[ second ][1] = 0 ;
		totLeft -= conSeqs[ second ][0] ;
	    } else {  /*  place only the "first" sequence  */
		if( conSeqs[ first ][1] > 0 ) {
		    for( j = 1 ; j <= conSeqs[ first ][0] ; j++ ) {
			lArray[ firstLoc - 1 + j ].pin = 
					     conSeqs[ first ][j+1] ;
			lArray[ firstLoc - 1 + j ].placed = 1 ;
		    }
		} else {
		    for( j = 1 , k = conSeqs[ first ][0] ; 
			   j <= conSeqs[ first ][0] ; j++ , k--) {
			lArray[ firstLoc - 1 + j ].pin = 
					     conSeqs[ first ][k+1] ;
			lArray[ firstLoc - 1 + j ].placed = 1 ;
		    }
		}
		loFill = firstLoc + conSeqs[ first ][0] - 1 ;
		conSeqs[ first ][1] = 0 ;
		totLeft -= conSeqs[ first ][0] ;
	    }
	}

	/*
	 *   Whew!!!!  Finally to the isolated pins!
	 */
	/*
	 *  For the first pass, any pins which can be
	 *  placed exactly in their most desirable places
	 *  are so placed.
	 */
	for( i = 1 ; i <= isoNum ; i++ ) {
	    if( lArray[ isolated[ 2 * i - 1 ] ].placed == 0 ) {
		lArray[ isolated[ 2 * i - 1 ] ].placed = 1 ;
		lArray[ isolated[ 2 * i - 1 ] ].pin =
						 isolated[ 2 * i ] ;
		isolated[ 2 * i - 1 ] = 0 ;
	    }
	}
	/*
	 *  Now comes the trickier stuff for those pins which
	 *  cannot go exactly where they would like to go
	 */
	for( i = 1 ; i <= isoNum ; i++ ) {
	    prefer = isolated[ 2 * i - 1 ] ;
	    if( prefer == 0 ) {
		continue ;
	    }
	    for( k = 1 ; k < nPinLocs ; k++ ) {
		if( prefer + k <= nPinLocs ) {
		    if( lArray[ prefer + k ].placed == 0 ) {
			lArray[ prefer + k ].placed = 1 ;
			lArray[ prefer + k ].pin =
						 isolated[ 2 * i ] ;
			isolated[ 2 * i - 1 ] = 0 ;
			break ;
		    }
		}
		if( prefer - k >= 1 ) {
		    if( lArray[ prefer - k ].placed == 0 ) {
			lArray[ prefer - k ].placed = 1 ;
			lArray[ prefer - k ].pin =
						 isolated[ 2 * i ] ;
			isolated[ 2 * i - 1 ] = 0 ;
			break ;
		    }
		}
	    }
	}
	/*
	 *  Believe it or not, all the pins for this site
	 *  have been placed.  Now all we have to do is
	 *  put the placement information into the array
	 *  pointed to by UCptr.
	 */
	for( i = 1 ; i <= nPinLocs ; i++ ) {
	    if( lArray[ i ].placed == 1 ) {
	       UCptr[ lArray[ i ].pin ].finalx = lArray[ i ].finalx;
	       UCptr[ lArray[ i ].pin ].finaly = lArray[ i ].finaly;
	    }
	}
	/*
	 *   And that's it folks, for this particular site.
	 *   Prep for the next one.
	 */
	free( lArray ) ;
    }
    for( i = 1 ; i <= ptr->numUnComTerms ; i++ ) {
	if( UCptr[i].finalx == -100000000  && 
				UCptr[i].finaly == -100000000 ) {
	    /* 
	     *  If at first you don't succeed, take a wild guess
	     */
	    UCptr[i].finalx = SLptr[ UCptr[i].site ].xpos ;
	    UCptr[i].finaly = SLptr[ UCptr[i].site ].ypos ;
	}
    }
}
return ;
}