#define EXTERN extern
#include "mpd.h"

fraction zcrossingpoint ( a , b , c ) 
integer a ; 
integer b ; 
integer c ; 
{/* 10 */ register fraction Result; integer d  ; 
  integer x, xx, x0, x1, x2  ; 
  if ( a < 0 ) 
  {
    Result = 0 ; 
    goto lab10 ; 
  } 
  if ( c >= 0 ) 
  {
    if ( b >= 0 ) 
    if ( c > 0 ) 
    {
      Result = 268435457L ; 
      goto lab10 ; 
    } 
    else if ( ( a == 0 ) && ( b == 0 ) ) 
    {
      Result = 268435457L ; 
      goto lab10 ; 
    } 
    else {
	
      Result = 268435456L ; 
      goto lab10 ; 
    } 
    if ( a == 0 ) 
    {
      Result = 0 ; 
      goto lab10 ; 
    } 
  } 
  else if ( a == 0 ) 
  if ( b <= 0 ) 
  {
    Result = 0 ; 
    goto lab10 ; 
  } 
  d = 1 ; 
  x0 = a ; 
  x1 = a - b ; 
  x2 = b - c ; 
  do {
      x = ( x1 + x2 ) / 2 ; 
    if ( x1 - x0 > x0 ) 
    {
      x2 = x ; 
      x0 = x0 + x0 ; 
      d = d + d ; 
    } 
    else {
	
      xx = x1 + x - x0 ; 
      if ( xx > x0 ) 
      {
	x2 = x ; 
	x0 = x0 + x0 ; 
	d = d + d ; 
      } 
      else {
	  
	x0 = x0 - xx ; 
	if ( x <= x0 ) 
	if ( x + x2 <= x0 ) 
	{
	  Result = 268435457L ; 
	  goto lab10 ; 
	} 
	x1 = x ; 
	d = d + d + 1 ; 
      } 
    } 
  } while ( ! ( d >= 268435456L ) ) ; 
  Result = d - 268435456L ; 
  lab10: ; 
  return(Result) ; 
} 
scaled zevalcubic ( p , q , t ) 
halfword p ; 
halfword q ; 
fraction t ; 
{register scaled Result; scaled x1, x2, x3  ; 
  x1 = mem [ p ] .cint - takefraction ( mem [ p ] .cint - mem [ p + 4 ] .cint 
  , t ) ; 
  x2 = mem [ p + 4 ] .cint - takefraction ( mem [ p + 4 ] .cint - mem [ q + 2 
  ] .cint , t ) ; 
  x3 = mem [ q + 2 ] .cint - takefraction ( mem [ q + 2 ] .cint - mem [ q ] .cint , t ) ; 
  x1 = x1 - takefraction ( x1 - x2 , t ) ; 
  x2 = x2 - takefraction ( x2 - x3 , t ) ; 
  Result = x1 - takefraction ( x1 - x2 , t ) ; 
  return(Result) ; 
} 
void zboundcubic ( p , q , c ) 
halfword p ; 
halfword q ; 
smallnumber c ; 
{boolean wavy  ; 
  scaled del1, del2, del3, del, dmax  ; 
  fraction t, tt  ; 
  scaled x  ; 
  x = mem [ q ] .cint ; 
  if ( x < bbmin [ c ] ) 
  bbmin [ c ] = x ; 
  if ( x > bbmax [ c ] ) 
  bbmax [ c ] = x ; 
  wavy = true ; 
  if ( bbmin [ c ] <= mem [ p + 4 ] .cint ) 
  if ( mem [ p + 4 ] .cint <= bbmax [ c ] ) 
  if ( bbmin [ c ] <= mem [ q + 2 ] .cint ) 
  if ( mem [ q + 2 ] .cint <= bbmax [ c ] ) 
  wavy = false ; 
  if ( wavy ) 
  {
    del1 = mem [ p + 4 ] .cint - mem [ p ] .cint ; 
    del2 = mem [ q + 2 ] .cint - mem [ p + 4 ] .cint ; 
    del3 = mem [ q ] .cint - mem [ q + 2 ] .cint ; 
    if ( del1 != 0 ) 
    del = del1 ; 
    else if ( del2 != 0 ) 
    del = del2 ; 
    else del = del3 ; 
    if ( del != 0 ) 
    {
      dmax = abs ( del1 ) ; 
      if ( abs ( del2 ) > dmax ) 
      dmax = abs ( del2 ) ; 
      if ( abs ( del3 ) > dmax ) 
      dmax = abs ( del3 ) ; 
      while ( dmax < 134217728L ) {
	  
	dmax = dmax + dmax ; 
	del1 = del1 + del1 ; 
	del2 = del2 + del2 ; 
	del3 = del3 + del3 ; 
      } 
    } 
    if ( del < 0 ) 
    {
      del1 = - (integer) del1 ; 
      del2 = - (integer) del2 ; 
      del3 = - (integer) del3 ; 
    } 
    t = crossingpoint ( del1 , del2 , del3 ) ; 
    if ( t < 268435456L ) 
    {
      x = evalcubic ( p , q , t ) ; 
      if ( x < bbmin [ c ] ) 
      bbmin [ c ] = x ; 
      if ( x > bbmax [ c ] ) 
      bbmax [ c ] = x ; 
      del2 = del2 - takefraction ( del2 - del3 , t ) ; 
      if ( del2 > 0 ) 
      del2 = 0 ; 
      tt = crossingpoint ( 0 , - (integer) del2 , - (integer) del3 ) ; 
      if ( tt < 268435456L ) 
      {
	x = evalcubic ( p , q , tt - takefraction ( tt - 268435456L , t ) ) ; 
	if ( x < bbmin [ c ] ) 
	bbmin [ c ] = x ; 
	if ( x > bbmax [ c ] ) 
	bbmax [ c ] = x ; 
      } 
    } 
  } 
} 
void zpathbbox ( h ) 
halfword h ; 
{/* 10 */ halfword p, q  ; 
  bbmin [ 0 ] = mem [ h + 1 ] .cint ; 
  bbmin [ 1 ] = mem [ h + 2 ] .cint ; 
  bbmax [ 0 ] = bbmin [ 0 ] ; 
  bbmax [ 1 ] = bbmin [ 1 ] ; 
  p = h ; 
  do {
      if ( mem [ p ] .hhfield .b1 == 0 ) 
    goto lab10 ; 
    q = mem [ p ] .hhfield .v.RH ; 
    boundcubic ( p + 1 , q + 1 , 0 ) ; 
    boundcubic ( p + 2 , q + 2 , 1 ) ; 
    p = q ; 
  } while ( ! ( p == h ) ) ; 
  lab10: ; 
} 
scaled zsolverisingcubic ( a , b , c , x ) 
scaled a ; 
scaled b ; 
scaled c ; 
scaled x ; 
{register scaled Result; scaled ab, bc, ac  ; 
  integer t  ; 
  integer xx  ; 
  if ( ( a < 0 ) || ( c < 0 ) ) 
  confusion ( 547 ) ; 
  if ( x <= 0 ) 
  Result = 0 ; 
  else if ( x >= a + b + c ) 
  Result = 65536L ; 
  else {
      
    t = 1 ; 
    while ( ( a > 715827882L ) || ( b > 715827882L ) || ( c > 715827882L ) ) {
	
      a = halfp ( a ) ; 
      b = ( b ) / 2 ; 
      c = halfp ( c ) ; 
      x = halfp ( x ) ; 
    } 
    do {
	t = t + t ; 
      ab = ( a + b ) / 2 ; 
      bc = ( b + c ) / 2 ; 
      ac = ( ab + bc ) / 2 ; 
      xx = x - a - ab - ac ; 
      if ( xx < - (integer) x ) 
      {
	x = x + x ; 
	b = ab ; 
	c = ac ; 
      } 
      else {
	  
	x = x + xx ; 
	a = ac ; 
	b = bc ; 
	t = t + 1 ; 
      } 
    } while ( ! ( t >= 65536L ) ) ; 
    Result = t - 65536L ; 
  } 
  return(Result) ; 
} 
scaled zarctest ( dx0 , dy0 , dx1 , dy1 , dx2 , dy2 , v0 , v02 , v2 , agoal ,tol ) 
scaled dx0 ; 
scaled dy0 ; 
scaled dx1 ; 
scaled dy1 ; 
scaled dx2 ; 
scaled dy2 ; 
scaled v0 ; 
scaled v02 ; 
scaled v2 ; 
scaled agoal ; 
scaled tol ; 
{/* 10 */ register scaled Result; boolean simple  ; 
  scaled dx01, dy01, dx12, dy12, dx02, dy02  ; 
  scaled v002, v022  ; 
  scaled arc  ; 
  scaled a, b  ; 
  scaled anew, aaux  ; 
  scaled tmp, tmp2  ; 
  scaled arc1  ; 
  dx01 = ( dx0 + dx1 ) / 2 ; 
  dx12 = ( dx1 + dx2 ) / 2 ; 
  dx02 = ( dx01 + dx12 ) / 2 ; 
  dy01 = ( dy0 + dy1 ) / 2 ; 
  dy12 = ( dy1 + dy2 ) / 2 ; 
  dy02 = ( dy01 + dy12 ) / 2 ; 
  v002 = pythadd ( dx01 + ( dx0 + dx02 ) / 2 , dy01 + ( dy0 + dy02 ) / 2 ) ; 
  v022 = pythadd ( dx12 + ( dx02 + dx2 ) / 2 , dy12 + ( dy02 + dy2 ) / 2 ) ; 
  tmp = halfp ( v02 + 2 ) ; 
  arc1 = v002 + ( halfp ( v0 + tmp ) - v002 ) / 2 ; 
  arc = v022 + ( halfp ( v2 + tmp ) - v022 ) / 2 ; 
  if ( ( arc < 2147483647L - arc1 ) ) 
  arc = arc + arc1 ; 
  else {
      
    aritherror = true ; 
    if ( agoal == 2147483647L ) 
    Result = 2147483647L ; 
    else Result = -131072L ; 
    goto lab10 ; 
  } 
  simple = ( dx0 >= 0 ) && ( dx1 >= 0 ) && ( dx2 >= 0 ) || ( dx0 <= 0 ) && ( 
  dx1 <= 0 ) && ( dx2 <= 0 ) ; 
  if ( simple ) 
  simple = ( dy0 >= 0 ) && ( dy1 >= 0 ) && ( dy2 >= 0 ) || ( dy0 <= 0 ) && ( 
  dy1 <= 0 ) && ( dy2 <= 0 ) ; 
  if ( ! simple ) 
  {
    simple = ( dx0 >= dy0 ) && ( dx1 >= dy1 ) && ( dx2 >= dy2 ) || ( dx0 <= 
    dy0 ) && ( dx1 <= dy1 ) && ( dx2 <= dy2 ) ; 
    if ( simple ) 
    simple = ( - (integer) dx0 >= dy0 ) && ( - (integer) dx1 >= dy1 ) && ( 
    - (integer) dx2 >= dy2 ) || ( - (integer) dx0 <= dy0 ) && ( - (integer) 
    dx1 <= dy1 ) && ( - (integer) dx2 <= dy2 ) ; 
  } 
  if ( simple && ( abs ( arc - v02 - halfp ( v0 + v2 ) ) <= tol ) ) 
  if ( arc < agoal ) 
  Result = arc ; 
  else {
      
    tmp = ( v02 + 2 ) / 4 ; 
    if ( agoal <= arc1 ) 
    {
      tmp2 = halfp ( v0 ) ; 
      Result = halfp ( solverisingcubic ( tmp2 , arc1 - tmp2 - tmp , tmp ,      agoal ) ) - 131072L ; 
    } 
    else {
	
      tmp2 = halfp ( v2 ) ; 
      Result = ( -98304L ) + halfp ( solverisingcubic ( tmp , arc - arc1 - tmp 
      - tmp2 , tmp2 , agoal - arc1 ) ) ; 
    } 
  } 
  else {
      
    aaux = 2147483647L - agoal ; 
    if ( agoal > aaux ) 
    {
      aaux = agoal - aaux ; 
      anew = 2147483647L ; 
    } 
    else {
	
      anew = agoal + agoal ; 
      aaux = 0 ; 
    } 
    tol = tol + halfp ( tol ) ; 
    a = arctest ( dx0 , dy0 , dx01 , dy01 , dx02 , dy02 , v0 , v002 , halfp ( 
    v02 ) , anew , tol ) ; 
    if ( a < 0 ) 
    Result = - (integer) halfp ( 131072L - a ) ; 
    else {
	
      if ( a > aaux ) 
      {
	aaux = aaux - a ; 
	anew = anew + aaux ; 
      } 
      b = arctest ( dx02 , dy02 , dx12 , dy12 , dx2 , dy2 , halfp ( v02 ) ,      v022 , v2 , anew , tol ) ; 
      if ( b < 0 ) 
      Result = - (integer) halfp ( - (integer) b ) - 32768L ; 
      else Result = a + ( b - a ) / 2 ; 
    } 
  } 
  lab10: ; 
  return(Result) ; 
} 
scaled zdoarctest ( dx0 , dy0 , dx1 , dy1 , dx2 , dy2 , agoal ) 
scaled dx0 ; 
scaled dy0 ; 
scaled dx1 ; 
scaled dy1 ; 
scaled dx2 ; 
scaled dy2 ; 
scaled agoal ; 
{register scaled Result; scaled v0, v1, v2  ; 
  scaled v02  ; 
  v0 = pythadd ( dx0 , dy0 ) ; 
  v1 = pythadd ( dx1 , dy1 ) ; 
  v2 = pythadd ( dx2 , dy2 ) ; 
  if ( ( v0 >= 1073741824L ) || ( v1 >= 1073741824L ) || ( v2 >= 1073741824L ) 
  ) 
  {
    aritherror = true ; 
    if ( agoal == 2147483647L ) 
    Result = 2147483647L ; 
    else Result = -131072L ; 
  } 
  else {
      
    v02 = pythadd ( dx1 + ( dx0 + dx2 ) / 2 , dy1 + ( dy0 + dy2 ) / 2 ) ; 
    Result = arctest ( dx0 , dy0 , dx1 , dy1 , dx2 , dy2 , v0 , v02 , v2 ,    agoal , 16 ) ; 
  } 
  return(Result) ; 
} 
scaled zgetarclength ( h ) 
halfword h ; 
{/* 30 */ register scaled Result; halfword p, q  ; 
  scaled a, atot  ; 
  atot = 0 ; 
  p = h ; 
  while ( mem [ p ] .hhfield .b1 != 0 ) {
      
    q = mem [ p ] .hhfield .v.RH ; 
    a = doarctest ( mem [ p + 5 ] .cint - mem [ p + 1 ] .cint , mem [ p + 6 ] .cint - mem [ p + 2 ] .cint , mem [ q + 3 ] .cint - mem [ p + 5 ] .cint ,    mem [ q + 4 ] .cint - mem [ p + 6 ] .cint , mem [ q + 1 ] .cint - mem [ q 
    + 3 ] .cint , mem [ q + 2 ] .cint - mem [ q + 4 ] .cint , 2147483647L ) ; 
    atot = slowadd ( a , atot ) ; 
    if ( q == h ) 
    goto lab30 ; 
    else p = q ; 
  } 
  lab30: {
      
    if ( aritherror ) 
    cleararith () ; 
  } 
  Result = atot ; 
  return(Result) ; 
} 
scaled zgetarctime ( h , arc0 ) 
halfword h ; 
scaled arc0 ; 
{/* 30 */ register scaled Result; halfword p, q  ; 
  scaled ttot  ; 
  scaled t  ; 
  scaled arc  ; 
  integer n  ; 
  if ( arc0 < 0 ) 
  {
    if ( mem [ h ] .hhfield .b0 == 0 ) 
    ttot = 0 ; 
    else {
	
      p = htapypoc ( h ) ; 
      ttot = - (integer) getarctime ( p , - (integer) arc0 ) ; 
      tossknotlist ( p ) ; 
    } 
    goto lab30 ; 
  } 
  if ( arc0 == 2147483647L ) 
  decr ( arc0 ) ; 
  ttot = 0 ; 
  arc = arc0 ; 
  p = h ; 
  while ( ( mem [ p ] .hhfield .b1 != 0 ) && ( arc > 0 ) ) {
      
    q = mem [ p ] .hhfield .v.RH ; 
    t = doarctest ( mem [ p + 5 ] .cint - mem [ p + 1 ] .cint , mem [ p + 6 ] .cint - mem [ p + 2 ] .cint , mem [ q + 3 ] .cint - mem [ p + 5 ] .cint ,    mem [ q + 4 ] .cint - mem [ p + 6 ] .cint , mem [ q + 1 ] .cint - mem [ q 
    + 3 ] .cint , mem [ q + 2 ] .cint - mem [ q + 4 ] .cint , arc ) ; 
    if ( t < 0 ) 
    {
      ttot = ttot + t + 131072L ; 
      arc = 0 ; 
    } 
    else {
	
      ttot = ttot + 65536L ; 
      arc = arc - t ; 
    } 
    if ( q == h ) 
    if ( arc > 0 ) 
    {
      n = arc / ( arc0 - arc ) ; 
      arc = arc - n * ( arc0 - arc ) ; 
      if ( ttot > 2147483647L / ( n + 1 ) ) 
      {
	aritherror = true ; 
	ttot = 2147483647L ; 
	goto lab30 ; 
      } 
      ttot = ( n + 1 ) * ttot ; 
    } 
    p = q ; 
  } 
  lab30: {
      
    if ( aritherror ) 
    cleararith () ; 
  } 
  Result = ttot ; 
  return(Result) ; 
} 
void zmoveknot ( p , q ) 
halfword p ; 
halfword q ; 
{mem [ mem [ p ] .hhfield .lhfield ] .hhfield .v.RH = mem [ p ] .hhfield .v.RH ; 
  mem [ mem [ p ] .hhfield .v.RH ] .hhfield .lhfield = mem [ p ] .hhfield .lhfield ; 
  mem [ p ] .hhfield .lhfield = q ; 
  mem [ p ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
  mem [ q ] .hhfield .v.RH = p ; 
  mem [ mem [ p ] .hhfield .v.RH ] .hhfield .lhfield = p ; 
} 
halfword zconvexhull ( h ) 
halfword h ; 
{/* 31 32 33 */ register halfword Result; halfword l, r  ; 
  halfword p, q  ; 
  halfword s  ; 
  scaled dx, dy  ; 
  if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
  Result = h ; 
  else {
      
    l = h ; 
    p = mem [ h ] .hhfield .v.RH ; 
    while ( p != h ) {
	
      if ( mem [ p + 1 ] .cint <= mem [ l + 1 ] .cint ) 
      if ( ( mem [ p + 1 ] .cint < mem [ l + 1 ] .cint ) || ( mem [ p + 2 ] .cint < mem [ l + 2 ] .cint ) ) 
      l = p ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
    r = h ; 
    p = mem [ h ] .hhfield .v.RH ; 
    while ( p != h ) {
	
      if ( mem [ p + 1 ] .cint >= mem [ r + 1 ] .cint ) 
      if ( ( mem [ p + 1 ] .cint > mem [ r + 1 ] .cint ) || ( mem [ p + 2 ] .cint > mem [ r + 2 ] .cint ) ) 
      r = p ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
    if ( l != r ) 
    {
      s = mem [ r ] .hhfield .v.RH ; 
      dx = mem [ r + 1 ] .cint - mem [ l + 1 ] .cint ; 
      dy = mem [ r + 2 ] .cint - mem [ l + 2 ] .cint ; 
      p = mem [ l ] .hhfield .v.RH ; 
      while ( p != r ) {
	  
	q = mem [ p ] .hhfield .v.RH ; 
	if ( abvscd ( dx , mem [ p + 2 ] .cint - mem [ l + 2 ] .cint , dy ,	mem [ p + 1 ] .cint - mem [ l + 1 ] .cint ) > 0 ) 
	moveknot ( p , r ) ; 
	p = q ; 
      } 
      p = s ; 
      while ( p != l ) {
	  
	q = mem [ p ] .hhfield .v.RH ; 
	if ( abvscd ( dx , mem [ p + 2 ] .cint - mem [ l + 2 ] .cint , dy ,	mem [ p + 1 ] .cint - mem [ l + 1 ] .cint ) < 0 ) 
	moveknot ( p , l ) ; 
	p = q ; 
      } 
      p = mem [ l ] .hhfield .v.RH ; 
      while ( p != r ) {
	  
	q = mem [ p ] .hhfield .lhfield ; 
	while ( mem [ q + 1 ] .cint > mem [ p + 1 ] .cint ) q = mem [ q ] .hhfield .lhfield ; 
	while ( mem [ q + 1 ] .cint == mem [ p + 1 ] .cint ) if ( mem [ q + 2 
	] .cint > mem [ p + 2 ] .cint ) 
	q = mem [ q ] .hhfield .lhfield ; 
	else goto lab31 ; 
	lab31: if ( q == mem [ p ] .hhfield .lhfield ) 
	p = mem [ p ] .hhfield .v.RH ; 
	else {
	    
	  p = mem [ p ] .hhfield .v.RH ; 
	  moveknot ( mem [ p ] .hhfield .lhfield , q ) ; 
	} 
      } 
      p = mem [ r ] .hhfield .v.RH ; 
      while ( p != l ) {
	  
	q = mem [ p ] .hhfield .lhfield ; 
	while ( mem [ q + 1 ] .cint < mem [ p + 1 ] .cint ) q = mem [ q ] .hhfield .lhfield ; 
	while ( mem [ q + 1 ] .cint == mem [ p + 1 ] .cint ) if ( mem [ q + 2 
	] .cint < mem [ p + 2 ] .cint ) 
	q = mem [ q ] .hhfield .lhfield ; 
	else goto lab32 ; 
	lab32: if ( q == mem [ p ] .hhfield .lhfield ) 
	p = mem [ p ] .hhfield .v.RH ; 
	else {
	    
	  p = mem [ p ] .hhfield .v.RH ; 
	  moveknot ( mem [ p ] .hhfield .lhfield , q ) ; 
	} 
      } 
    } 
    if ( l != mem [ l ] .hhfield .v.RH ) 
    {
      p = l ; 
      q = mem [ l ] .hhfield .v.RH ; 
      while ( true ) {
	  
	dx = mem [ q + 1 ] .cint - mem [ p + 1 ] .cint ; 
	dy = mem [ q + 2 ] .cint - mem [ p + 2 ] .cint ; 
	p = q ; 
	q = mem [ q ] .hhfield .v.RH ; 
	if ( p == l ) 
	goto lab33 ; 
	if ( p != r ) 
	if ( abvscd ( dx , mem [ q + 2 ] .cint - mem [ p + 2 ] .cint , dy ,	mem [ q + 1 ] .cint - mem [ p + 1 ] .cint ) <= 0 ) 
	{
	  s = mem [ p ] .hhfield .lhfield ; 
	  freenode ( p , 7 ) ; 
	  mem [ s ] .hhfield .v.RH = q ; 
	  mem [ q ] .hhfield .lhfield = s ; 
	  if ( s == l ) 
	  p = s ; 
	  else {
	      
	    p = mem [ s ] .hhfield .lhfield ; 
	    q = s ; 
	  } 
	} 
      } 
      lab33: ; 
    } 
    Result = l ; 
  } 
  return(Result) ; 
} 
halfword zmakepen ( h , needhull ) 
halfword h ; 
boolean needhull ; 
{register halfword Result; halfword p, q  ; 
  q = h ; 
  do {
      p = q ; 
    q = mem [ q ] .hhfield .v.RH ; 
    mem [ q ] .hhfield .lhfield = p ; 
  } while ( ! ( q == h ) ) ; 
  if ( needhull ) 
  {
    h = convexhull ( h ) ; 
    if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
    {
      mem [ h + 3 ] .cint = mem [ h + 1 ] .cint ; 
      mem [ h + 4 ] .cint = mem [ h + 2 ] .cint ; 
      mem [ h + 5 ] .cint = mem [ h + 1 ] .cint ; 
      mem [ h + 6 ] .cint = mem [ h + 2 ] .cint ; 
    } 
  } 
  Result = h ; 
  return(Result) ; 
} 
halfword zgetpencircle ( diam ) 
scaled diam ; 
{register halfword Result; halfword h  ; 
  h = getnode ( 7 ) ; 
  mem [ h ] .hhfield .v.RH = h ; 
  mem [ h ] .hhfield .lhfield = h ; 
  mem [ h + 1 ] .cint = 0 ; 
  mem [ h + 2 ] .cint = 0 ; 
  mem [ h + 3 ] .cint = diam ; 
  mem [ h + 4 ] .cint = 0 ; 
  mem [ h + 5 ] .cint = 0 ; 
  mem [ h + 6 ] .cint = diam ; 
  Result = h ; 
  return(Result) ; 
} 
void zmakepath ( h ) 
halfword h ; 
{halfword p  ; 
  smallnumber k  ; 
  scaled centerx, centery  ; 
  scaled widthx, widthy  ; 
  scaled heightx, heighty  ; 
  scaled dx, dy  ; 
  integer kk  ; 
  if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
  {
    centerx = mem [ h + 1 ] .cint ; 
    centery = mem [ h + 2 ] .cint ; 
    widthx = mem [ h + 3 ] .cint - centerx ; 
    widthy = mem [ h + 4 ] .cint - centery ; 
    heightx = mem [ h + 5 ] .cint - centerx ; 
    heighty = mem [ h + 6 ] .cint - centery ; 
    p = h ; 
    {register integer for_end; k = 0 ; for_end = 7 ; if ( k <= for_end) do 
      {
	kk = ( k + 6 ) % 8 ; 
	mem [ p + 1 ] .cint = centerx + takefraction ( halfcos [ k ] , widthx 
	) + takefraction ( halfcos [ kk ] , heightx ) ; 
	mem [ p + 2 ] .cint = centery + takefraction ( halfcos [ k ] , widthy 
	) + takefraction ( halfcos [ kk ] , heighty ) ; 
	dx = - (integer) takefraction ( dcos [ kk ] , widthx ) + takefraction 
	( dcos [ k ] , heightx ) ; 
	dy = - (integer) takefraction ( dcos [ kk ] , widthy ) + takefraction 
	( dcos [ k ] , heighty ) ; 
	mem [ p + 5 ] .cint = mem [ p + 1 ] .cint + dx ; 
	mem [ p + 6 ] .cint = mem [ p + 2 ] .cint + dy ; 
	mem [ p + 3 ] .cint = mem [ p + 1 ] .cint - dx ; 
	mem [ p + 4 ] .cint = mem [ p + 2 ] .cint - dy ; 
	mem [ p ] .hhfield .b0 = 1 ; 
	mem [ p ] .hhfield .b1 = 1 ; 
	if ( k == 7 ) 
	mem [ p ] .hhfield .v.RH = h ; 
	else mem [ p ] .hhfield .v.RH = getnode ( 7 ) ; 
	p = mem [ p ] .hhfield .v.RH ; 
      } 
    while ( k++ < for_end ) ; } 
  } 
  else {
      
    p = h ; 
    do {
	mem [ p ] .hhfield .b0 = 1 ; 
      mem [ p ] .hhfield .b1 = 1 ; 
      mem [ p + 3 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ p + 4 ] .cint = mem [ p + 2 ] .cint ; 
      mem [ p + 5 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ p + 6 ] .cint = mem [ p + 2 ] .cint ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } while ( ! ( p == h ) ) ; 
  } 
} 
void zfindoffset ( x , y , h ) 
scaled x ; 
scaled y ; 
halfword h ; 
{halfword p, q  ; 
  scaled wx, wy, hx, hy  ; 
  fraction xx, yy  ; 
  fraction d  ; 
  if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
  if ( ( x == 0 ) && ( y == 0 ) ) 
  {
    curx = mem [ h + 1 ] .cint ; 
    cury = mem [ h + 2 ] .cint ; 
  } 
  else {
      
    wx = mem [ h + 3 ] .cint - mem [ h + 1 ] .cint ; 
    wy = mem [ h + 4 ] .cint - mem [ h + 2 ] .cint ; 
    hx = mem [ h + 5 ] .cint - mem [ h + 1 ] .cint ; 
    hy = mem [ h + 6 ] .cint - mem [ h + 2 ] .cint ; 
    while ( ( abs ( x ) < 134217728L ) && ( abs ( y ) < 134217728L ) ) {
	
      x = x + x ; 
      y = y + y ; 
    } 
    yy = - (integer) ( takefraction ( x , hy ) + takefraction ( y ,    - (integer) hx ) ) ; 
    xx = takefraction ( x , - (integer) wy ) + takefraction ( y , wx ) ; 
    d = pythadd ( xx , yy ) ; 
    if ( d > 0 ) 
    {
      xx = ( makefraction ( xx , d ) ) / 2 ; 
      yy = ( makefraction ( yy , d ) ) / 2 ; 
    } 
    curx = mem [ h + 1 ] .cint + takefraction ( xx , wx ) + takefraction ( yy 
    , hx ) ; 
    cury = mem [ h + 2 ] .cint + takefraction ( xx , wy ) + takefraction ( yy 
    , hy ) ; 
  } 
  else {
      
    q = h ; 
    do {
	p = q ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } while ( ! ( abvscd ( mem [ q + 1 ] .cint - mem [ p + 1 ] .cint , y , mem 
    [ q + 2 ] .cint - mem [ p + 2 ] .cint , x ) >= 0 ) ) ; 
    do {
	p = q ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } while ( ! ( abvscd ( mem [ q + 1 ] .cint - mem [ p + 1 ] .cint , y , mem 
    [ q + 2 ] .cint - mem [ p + 2 ] .cint , x ) <= 0 ) ) ; 
    curx = mem [ p + 1 ] .cint ; 
    cury = mem [ p + 2 ] .cint ; 
  } 
} 
void zpenbbox ( h ) 
halfword h ; 
{halfword p  ; 
  if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
  {
    findoffset ( 0 , 268435456L , h ) ; 
    bbmax [ 0 ] = curx ; 
    bbmin [ 0 ] = 2 * mem [ h + 1 ] .cint - curx ; 
    findoffset ( -268435456L , 0 , h ) ; 
    bbmax [ 1 ] = cury ; 
    bbmin [ 1 ] = 2 * mem [ h + 2 ] .cint - cury ; 
  } 
  else {
      
    bbmin [ 0 ] = mem [ h + 1 ] .cint ; 
    bbmax [ 0 ] = bbmin [ 0 ] ; 
    bbmin [ 1 ] = mem [ h + 2 ] .cint ; 
    bbmax [ 1 ] = bbmin [ 1 ] ; 
    p = mem [ h ] .hhfield .v.RH ; 
    while ( p != h ) {
	
      if ( mem [ p + 1 ] .cint < bbmin [ 0 ] ) 
      bbmin [ 0 ] = mem [ p + 1 ] .cint ; 
      if ( mem [ p + 2 ] .cint < bbmin [ 1 ] ) 
      bbmin [ 1 ] = mem [ p + 2 ] .cint ; 
      if ( mem [ p + 1 ] .cint > bbmax [ 0 ] ) 
      bbmax [ 0 ] = mem [ p + 1 ] .cint ; 
      if ( mem [ p + 2 ] .cint > bbmax [ 1 ] ) 
      bbmax [ 1 ] = mem [ p + 2 ] .cint ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
  } 
} 
halfword znewfillnode ( p ) 
halfword p ; 
{register halfword Result; halfword t  ; 
  t = getnode ( 6 ) ; 
  mem [ t ] .hhfield .b0 = 1 ; 
  mem [ t + 1 ] .hhfield .v.RH = p ; 
  mem [ t + 1 ] .hhfield .lhfield = 0 ; 
  mem [ t + 2 ] .cint = 0 ; 
  mem [ t + 3 ] .cint = 0 ; 
  mem [ t + 4 ] .cint = 0 ; 
  if ( internal [ 27 ] > 65536L ) 
  mem [ t ] .hhfield .b1 = 2 ; 
  else if ( internal [ 27 ] > 0 ) 
  mem [ t ] .hhfield .b1 = 1 ; 
  else mem [ t ] .hhfield .b1 = 0 ; 
  if ( internal [ 29 ] < 65536L ) 
  mem [ t + 5 ] .cint = 65536L ; 
  else mem [ t + 5 ] .cint = internal [ 29 ] ; 
  Result = t ; 
  return(Result) ; 
} 
halfword znewstrokednode ( p ) 
halfword p ; 
{register halfword Result; halfword t  ; 
  t = getnode ( 8 ) ; 
  mem [ t ] .hhfield .b0 = 2 ; 
  mem [ t + 1 ] .hhfield .v.RH = p ; 
  mem [ t + 1 ] .hhfield .lhfield = 0 ; 
  mem [ t + 6 ] .hhfield .v.RH = 0 ; 
  mem [ t + 7 ] .cint = 65536L ; 
  mem [ t + 2 ] .cint = 0 ; 
  mem [ t + 3 ] .cint = 0 ; 
  mem [ t + 4 ] .cint = 0 ; 
  if ( internal [ 27 ] > 65536L ) 
  mem [ t ] .hhfield .b1 = 2 ; 
  else if ( internal [ 27 ] > 0 ) 
  mem [ t ] .hhfield .b1 = 1 ; 
  else mem [ t ] .hhfield .b1 = 0 ; 
  if ( internal [ 29 ] < 65536L ) 
  mem [ t + 5 ] .cint = 65536L ; 
  else mem [ t + 5 ] .cint = internal [ 29 ] ; 
  if ( internal [ 28 ] > 65536L ) 
  mem [ t + 6 ] .hhfield .b0 = 2 ; 
  else if ( internal [ 28 ] > 0 ) 
  mem [ t + 6 ] .hhfield .b0 = 1 ; 
  else mem [ t + 6 ] .hhfield .b0 = 0 ; 
  Result = t ; 
  return(Result) ; 
} 
void beginname ( ) 
{{
    
    if ( strref [ curname ] < 127 ) 
    if ( strref [ curname ] > 1 ) 
    decr ( strref [ curname ] ) ; 
    else flushstring ( curname ) ; 
  } 
  {
    if ( strref [ curarea ] < 127 ) 
    if ( strref [ curarea ] > 1 ) 
    decr ( strref [ curarea ] ) ; 
    else flushstring ( curarea ) ; 
  } 
  {
    if ( strref [ curext ] < 127 ) 
    if ( strref [ curext ] > 1 ) 
    decr ( strref [ curext ] ) ; 
    else flushstring ( curext ) ; 
  } 
  areadelimiter = -1 ; 
  extdelimiter = -1 ; 
} 
boolean zmorename ( c ) 
ASCIIcode c ; 
{register boolean Result; if ( ( c == 32 ) || ( c == 9 ) ) 
  Result = false ; 
  else {
      
    if ( ( c == 47 || c == 92 ) ) 
    {
      areadelimiter = poolptr - strstart [ strptr ] ; 
      extdelimiter = -1 ; 
    } 
    else if ( ( c == 46 ) && ( extdelimiter < 0 ) ) 
    extdelimiter = poolptr - strstart [ strptr ] ; 
    {
      if ( poolptr + 1 > maxpoolptr ) 
      if ( poolptr + 1 > poolsize ) 
      docompaction ( 1 ) ; 
      else maxpoolptr = poolptr + 1 ; 
    } 
    {
      strpool [ poolptr ] = c ; 
      incr ( poolptr ) ; 
    } 
    Result = true ; 
  } 
  return(Result) ; 
} 
void endname ( ) 
{strnumber s  ; 
  s = strptr ; 
  if ( areadelimiter < 0 ) 
  curarea = 285 ; 
  else {
      
    curarea = makestring () ; 
    choplaststring ( strstart [ s ] + areadelimiter + 1 ) ; 
  } 
  if ( extdelimiter < 0 ) 
  {
    curext = 285 ; 
    curname = makestring () ; 
  } 
  else {
      
    curname = makestring () ; 
    choplaststring ( strstart [ s ] + extdelimiter ) ; 
    curext = makestring () ; 
  } 
} 
void zpackfilename ( n , a , e ) 
strnumber n ; 
strnumber a ; 
strnumber e ; 
{integer k  ; 
  ASCIIcode c  ; 
  poolpointer j  ; 
  k = 0 ; 
  {register integer for_end; j = strstart [ a ] ; for_end = strstart [ 
  nextstr [ a ] ] - 1 ; if ( j <= for_end) do 
    {
      c = strpool [ j ] ; 
      incr ( k ) ; 
      if ( k <= filenamesize ) 
      nameoffile [ k ] = xchr [ c ] ; 
    } 
  while ( j++ < for_end ) ; } 
  {register integer for_end; j = strstart [ n ] ; for_end = strstart [ 
  nextstr [ n ] ] - 1 ; if ( j <= for_end) do 
    {
      c = strpool [ j ] ; 
      incr ( k ) ; 
      if ( k <= filenamesize ) 
      nameoffile [ k ] = xchr [ c ] ; 
    } 
  while ( j++ < for_end ) ; } 
  {register integer for_end; j = strstart [ e ] ; for_end = strstart [ 
  nextstr [ e ] ] - 1 ; if ( j <= for_end) do 
    {
      c = strpool [ j ] ; 
      incr ( k ) ; 
      if ( k <= filenamesize ) 
      nameoffile [ k ] = xchr [ c ] ; 
    } 
  while ( j++ < for_end ) ; } 
  if ( k <= filenamesize ) 
  namelength = k ; 
  else namelength = filenamesize ; 
  {register integer for_end; k = namelength + 1 ; for_end = filenamesize 
  ; if ( k <= for_end) do 
    nameoffile [ k ] = ' ' ; 
  while ( k++ < for_end ) ; } 
} 
void zstrscanfile ( s ) 
strnumber s ; 
{/* 30 */ poolpointer p, q  ; 
  beginname () ; 
  p = strstart [ s ] ; 
  q = strstart [ nextstr [ s ] ] ; 
  while ( p < q ) {
      
    if ( ! morename ( strpool [ p ] ) ) 
    goto lab30 ; 
    incr ( p ) ; 
  } 
  lab30: endname () ; 
} 
fontnumber zreadfontinfo ( fname ) 
strnumber fname ; 
{/* 11 30 */ register fontnumber Result; boolean fileopened  ; 
  fontnumber n  ; 
  halfword lf, lh, bc, ec, nw, nh, nd  ; 
  integer whdsize  ; 
  integer i, ii  ; 
  integer jj  ; 
  scaled z  ; 
  fraction d  ; 
  eightbits handd  ; 
  n = 0 ; 
  fileopened = false ; 
  strscanfile ( fname ) ; 
  if ( curext == 285 ) 
  curext = 1092 ; 
  packfilename ( curname , curarea , curext ) ; 
  if ( ! bopenin ( tfminfile ) ) 
  goto lab11 ; 
  tfmtemp = getc ( tfminfile ) ; 
  fileopened = true ; 
  {
    lf = tfmtemp ; 
    if ( lf > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    lf = lf * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    lh = tfmtemp ; 
    if ( lh > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    lh = lh * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    bc = tfmtemp ; 
    if ( bc > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    bc = bc * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    ec = tfmtemp ; 
    if ( ec > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    ec = ec * 256 + tfmtemp ; 
  } 
  if ( ( bc > 1 + ec ) || ( ec > 255 ) ) 
  goto lab11 ; 
  tfmtemp = getc ( tfminfile ) ; 
  {
    nw = tfmtemp ; 
    if ( nw > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    nw = nw * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    nh = tfmtemp ; 
    if ( nh > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    nh = nh * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    nd = tfmtemp ; 
    if ( nd > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    nd = nd * 256 + tfmtemp ; 
  } 
  whdsize = ( ec + 1 - bc ) + nw + nh + nd ; 
  if ( lf < 6 + lh + whdsize ) 
  goto lab11 ; 
  {register integer for_end; jj = 10 ; for_end = 1 ; if ( jj >= for_end) do 
    tfmtemp = getc ( tfminfile ) ; 
  while ( jj-- > for_end ) ; } 
  if ( ( lastfnum == fontmax ) || ( nextfmem + whdsize >= fontmemsize ) ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 1100 ) ; 
    } 
    print ( fname ) ; 
    print ( 1107 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 1108 ; 
      helpline [ 1 ] = 1109 ; 
      helpline [ 0 ] = 1110 ; 
    } 
    error () ; 
    goto lab30 ; 
  } 
  incr ( lastfnum ) ; 
  n = lastfnum ; 
  fontbc [ n ] = bc ; 
  fontec [ n ] = ec ; 
  charbase [ n ] = nextfmem - bc + 0 ; 
  widthbase [ n ] = nextfmem + ec - bc + 1 ; 
  heightbase [ n ] = widthbase [ n ] + 0 + nw ; 
  depthbase [ n ] = heightbase [ n ] + nh ; 
  nextfmem = nextfmem + whdsize ; 
  if ( lh < 2 ) 
  goto lab11 ; 
  {register integer for_end; jj = 4 ; for_end = 1 ; if ( jj >= for_end) do 
    tfmtemp = getc ( tfminfile ) ; 
  while ( jj-- > for_end ) ; } 
  tfmtemp = getc ( tfminfile ) ; 
  {
    z = tfmtemp ; 
    if ( z > 127 ) 
    goto lab11 ; 
    tfmtemp = getc ( tfminfile ) ; 
    z = z * 256 + tfmtemp ; 
  } 
  tfmtemp = getc ( tfminfile ) ; 
  z = z * 256 + tfmtemp ; 
  tfmtemp = getc ( tfminfile ) ; 
  z = z * 256 + tfmtemp ; 
  fontdsize [ n ] = takefraction ( z , 267432584L ) ; 
  {register integer for_end; jj = 4 * ( lh - 2 ) ; for_end = 1 ; if ( jj >= 
  for_end) do 
    tfmtemp = getc ( tfminfile ) ; 
  while ( jj-- > for_end ) ; } 
  ii = widthbase [ n ] + 0 ; 
  i = charbase [ n ] + 0 + bc ; 
  while ( i < ii ) {
      
    tfmtemp = getc ( tfminfile ) ; 
    fontinfo [ i ] .qqqq .b0 = tfmtemp ; 
    tfmtemp = getc ( tfminfile ) ; 
    handd = tfmtemp ; 
    fontinfo [ i ] .qqqq .b1 = handd / 16 ; 
    fontinfo [ i ] .qqqq .b2 = handd % 16 ; 
    tfmtemp = getc ( tfminfile ) ; 
    tfmtemp = getc ( tfminfile ) ; 
    incr ( i ) ; 
  } 
  while ( i < nextfmem ) {
      
    tfmtemp = getc ( tfminfile ) ; 
    d = tfmtemp ; 
    if ( d >= 128 ) 
    d = d - 256 ; 
    tfmtemp = getc ( tfminfile ) ; 
    d = d * 256 + tfmtemp ; 
    tfmtemp = getc ( tfminfile ) ; 
    d = d * 256 + tfmtemp ; 
    tfmtemp = getc ( tfminfile ) ; 
    d = d * 256 + tfmtemp ; 
    fontinfo [ i ] .cint = takefraction ( d * 16 , fontdsize [ n ] ) ; 
    incr ( i ) ; 
  } 
  if ( eof ( tfminfile ) ) 
  goto lab11 ; 
  goto lab30 ; 
  lab11: {
      
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 1100 ) ; 
  } 
  print ( fname ) ; 
  if ( fileopened ) 
  print ( 1101 ) ; 
  else print ( 1102 ) ; 
  {
    helpptr = 3 ; 
    helpline [ 2 ] = 1103 ; 
    helpline [ 1 ] = 1104 ; 
    helpline [ 0 ] = 1105 ; 
  } 
  if ( fileopened ) 
  helpline [ 0 ] = 1106 ; 
  error () ; 
  lab30: if ( fileopened ) 
  bclose ( tfminfile ) ; 
  if ( n != 0 ) 
  {
    fontpsname [ n ] = fname ; 
    fontname [ n ] = fname ; 
    strref [ fname ] = 127 ; 
  } 
  Result = n ; 
  return(Result) ; 
} 
fontnumber zfindfont ( f ) 
strnumber f ; 
{/* 10 40 */ register fontnumber Result; fontnumber n  ; 
  {register integer for_end; n = 0 ; for_end = lastfnum ; if ( n <= for_end) 
  do 
    if ( strvsstr ( f , fontname [ n ] ) == 0 ) 
    goto lab40 ; 
  while ( n++ < for_end ) ; } 
  Result = readfontinfo ( f ) ; 
  goto lab10 ; 
  lab40: Result = n ; 
  lab10: ; 
  return(Result) ; 
} 
void zlostwarning ( f , k ) 
fontnumber f ; 
poolpointer k ; 
{if ( internal [ 11 ] > 0 ) 
  {
    begindiagnostic () ; 
    printnl ( 1111 ) ; 
    print ( strpool [ k ] ) ; 
    print ( 1112 ) ; 
    print ( fontname [ f ] ) ; 
    printchar ( 33 ) ; 
    enddiagnostic ( false ) ; 
  } 
} 
void zsettextbox ( p ) 
halfword p ; 
{fontnumber f  ; 
  poolASCIIcode bc, ec  ; 
  poolpointer k, kk  ; 
  fourquarters cc  ; 
  scaled h, d  ; 
  mem [ p + 5 ] .cint = 0 ; 
  mem [ p + 6 ] .cint = -2147483647L ; 
  mem [ p + 7 ] .cint = -2147483647L ; 
  f = mem [ p + 1 ] .hhfield .lhfield ; 
  bc = fontbc [ f ] ; 
  ec = fontec [ f ] ; 
  kk = strstart [ nextstr [ mem [ p + 1 ] .hhfield .v.RH ] ] ; 
  k = strstart [ mem [ p + 1 ] .hhfield .v.RH ] ; 
  while ( k < kk ) {
      
    if ( ( strpool [ k ] < bc ) || ( strpool [ k ] > ec ) ) 
    lostwarning ( f , k ) ; 
    else {
	
      cc = fontinfo [ charbase [ f ] + strpool [ k ] ] .qqqq ; 
      if ( ! ( cc .b0 > 0 ) ) 
      lostwarning ( f , k ) ; 
      else {
	  
	mem [ p + 5 ] .cint = mem [ p + 5 ] .cint + fontinfo [ widthbase [ f ] 
	+ cc .b0 ] .cint ; 
	h = fontinfo [ heightbase [ f ] + cc .b1 ] .cint ; 
	d = fontinfo [ depthbase [ f ] + cc .b2 ] .cint ; 
	if ( h > mem [ p + 6 ] .cint ) 
	mem [ p + 6 ] .cint = h ; 
	if ( d > mem [ p + 7 ] .cint ) 
	mem [ p + 7 ] .cint = d ; 
      } 
    } 
    incr ( k ) ; 
  } 
  if ( mem [ p + 6 ] .cint < - (integer) mem [ p + 7 ] .cint ) 
  {
    mem [ p + 6 ] .cint = 0 ; 
    mem [ p + 7 ] .cint = 0 ; 
  } 
} 
halfword znewtextnode ( f , s ) 
strnumber f ; 
strnumber s ; 
{register halfword Result; halfword t  ; 
  t = getnode ( 14 ) ; 
  mem [ t ] .hhfield .b0 = 3 ; 
  mem [ t + 1 ] .hhfield .v.RH = s ; 
  mem [ t + 1 ] .hhfield .lhfield = findfont ( f ) ; 
  mem [ t + 2 ] .cint = 0 ; 
  mem [ t + 3 ] .cint = 0 ; 
  mem [ t + 4 ] .cint = 0 ; 
  mem [ t + 8 ] .cint = 0 ; 
  mem [ t + 9 ] .cint = 0 ; 
  mem [ t + 10 ] .cint = 65536L ; 
  mem [ t + 11 ] .cint = 0 ; 
  mem [ t + 12 ] .cint = 0 ; 
  mem [ t + 13 ] .cint = 65536L ; 
  settextbox ( t ) ; 
  Result = t ; 
  return(Result) ; 
} 
halfword znewboundsnode ( p , c ) 
halfword p ; 
smallnumber c ; 
{register halfword Result; halfword t  ; 
  t = getnode ( grobjectsize [ c ] ) ; 
  mem [ t ] .hhfield .b0 = c ; 
  mem [ t + 1 ] .hhfield .v.RH = p ; 
  Result = t ; 
  return(Result) ; 
} 
void zinitbbox ( h ) 
halfword h ; 
{mem [ h + 6 ] .hhfield .v.RH = h + 7 ; 
  mem [ h + 6 ] .hhfield .lhfield = 0 ; 
  mem [ h + 2 ] .cint = 2147483647L ; 
  mem [ h + 3 ] .cint = 2147483647L ; 
  mem [ h + 4 ] .cint = -2147483647L ; 
  mem [ h + 5 ] .cint = -2147483647L ; 
} 
void zinitedges ( h ) 
halfword h ; 
{mem [ h ] .hhfield .v.RH = 2 ; 
  mem [ h + 7 ] .hhfield .lhfield = h + 7 ; 
  mem [ h + 7 ] .hhfield .v.RH = 0 ; 
  mem [ h ] .hhfield .lhfield = 0 ; 
  initbbox ( h ) ; 
} 
halfword zcopyobjects ( p , q ) 
halfword p ; 
halfword q ; 
{register halfword Result; halfword hh  ; 
  halfword pp  ; 
  smallnumber k  ; 
  hh = getnode ( 8 ) ; 
  mem [ hh ] .hhfield .v.RH = 2 ; 
  mem [ hh ] .hhfield .lhfield = 0 ; 
  pp = hh + 7 ; 
  while ( ( p != q ) ) {
      
    k = grobjectsize [ mem [ p ] .hhfield .b0 ] ; 
    mem [ pp ] .hhfield .v.RH = getnode ( k ) ; 
    pp = mem [ pp ] .hhfield .v.RH ; 
    while ( ( k > 0 ) ) {
	
      decr ( k ) ; 
      mem [ pp + k ] = mem [ p + k ] ; 
    } 
    switch ( mem [ p ] .hhfield .b0 ) 
    {case 4 : 
    case 5 : 
      mem [ pp + 1 ] .hhfield .v.RH = copypath ( mem [ p + 1 ] .hhfield .v.RH 
      ) ; 
      break ; 
    case 1 : 
      {
	mem [ pp + 1 ] .hhfield .v.RH = copypath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
	mem [ pp + 1 ] .hhfield .lhfield = makepen ( copypath ( mem [ p + 1 ] .hhfield .lhfield ) , false ) ; 
      } 
      break ; 
    case 2 : 
      {
	mem [ pp + 1 ] .hhfield .v.RH = copypath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	mem [ pp + 1 ] .hhfield .lhfield = makepen ( copypath ( mem [ p + 1 ] .hhfield .lhfield ) , false ) ; 
	if ( mem [ p + 6 ] .hhfield .v.RH != 0 ) 
	incr ( mem [ mem [ pp + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) ; 
      } 
      break ; 
    case 3 : 
      {
	if ( strref [ mem [ pp + 1 ] .hhfield .v.RH ] < 127 ) 
	incr ( strref [ mem [ pp + 1 ] .hhfield .v.RH ] ) ; 
      } 
      break ; 
    case 6 : 
    case 7 : 
      ; 
      break ; 
    } 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  mem [ hh + 7 ] .hhfield .lhfield = pp ; 
  mem [ pp ] .hhfield .v.RH = 0 ; 
  Result = hh ; 
  return(Result) ; 
} 
halfword zprivateedges ( h ) 
halfword h ; 
{register halfword Result; halfword hh  ; 
  halfword p, pp  ; 
  if ( mem [ h ] .hhfield .lhfield == 0 ) 
  Result = h ; 
  else {
      
    decr ( mem [ h ] .hhfield .lhfield ) ; 
    hh = copyobjects ( mem [ h + 7 ] .hhfield .v.RH , 0 ) ; 
    pp = hh ; 
    p = mem [ h ] .hhfield .v.RH ; 
    while ( ( p != 2 ) ) {
	
      mem [ pp ] .hhfield .v.RH = getnode ( 3 ) ; 
      pp = mem [ pp ] .hhfield .v.RH ; 
      mem [ pp + 1 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ pp + 2 ] .cint = mem [ p + 2 ] .cint ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
    mem [ pp ] .hhfield .v.RH = 2 ; 
    mem [ hh + 1 ] .cint = mem [ h + 1 ] .cint ; 
    mem [ hh + 2 ] .cint = mem [ h + 2 ] .cint ; 
    mem [ hh + 3 ] .cint = mem [ h + 3 ] .cint ; 
    mem [ hh + 4 ] .cint = mem [ h + 4 ] .cint ; 
    mem [ hh + 5 ] .cint = mem [ h + 5 ] .cint ; 
    mem [ hh + 6 ] .hhfield .lhfield = mem [ h + 6 ] .hhfield .lhfield ; 
    p = h + 7 ; 
    pp = hh + 7 ; 
    while ( ( p != mem [ h + 6 ] .hhfield .v.RH ) ) {
	
      if ( p == 0 ) 
      confusion ( 551 ) ; 
      p = mem [ p ] .hhfield .v.RH ; 
      pp = mem [ pp ] .hhfield .v.RH ; 
    } 
    mem [ hh + 6 ] .hhfield .v.RH = pp ; 
    Result = hh ; 
  } 
  return(Result) ; 
} 
halfword zskip1component ( p ) 
halfword p ; 
{register halfword Result; integer lev  ; 
  lev = 0 ; 
  do {
      if ( ( mem [ p ] .hhfield .b0 >= 4 ) ) 
    if ( ( mem [ p ] .hhfield .b0 >= 6 ) ) 
    decr ( lev ) ; 
    else incr ( lev ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } while ( ! ( lev == 0 ) ) ; 
  Result = p ; 
  return(Result) ; 
} 
void xretraceerror ( ) 
{{
    
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 580 ) ; 
  } 
  {
    helpptr = 3 ; 
    helpline [ 2 ] = 584 ; 
    helpline [ 1 ] = 585 ; 
    helpline [ 0 ] = 583 ; 
  } 
  putgeterror () ; 
} 
halfword zmakedashes ( h ) 
halfword h ; 
{/* 10 40 45 */ register halfword Result; halfword p  ; 
  scaled y0  ; 
  halfword p0  ; 
  halfword pp, qq, rr  ; 
  halfword d, dd  ; 
  scaled x0, x1, x2, x3  ; 
  halfword dln  ; 
  halfword hh  ; 
  scaled xoff  ; 
  if ( mem [ h ] .hhfield .v.RH != 2 ) 
  goto lab40 ; 
  p0 = 0 ; 
  p = mem [ h + 7 ] .hhfield .v.RH ; 
  while ( p != 0 ) {
      
    if ( mem [ p ] .hhfield .b0 != 2 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 580 ) ; 
      } 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 581 ; 
	helpline [ 1 ] = 582 ; 
	helpline [ 0 ] = 583 ; 
      } 
      putgeterror () ; 
      goto lab45 ; 
    } 
    pp = mem [ p + 1 ] .hhfield .v.RH ; 
    if ( p0 == 0 ) 
    {
      p0 = p ; 
      y0 = mem [ pp + 2 ] .cint ; 
    } 
    if ( ( mem [ p + 2 ] .cint != mem [ p0 + 2 ] .cint ) || ( mem [ p + 3 ] .cint != mem [ p0 + 3 ] .cint ) || ( mem [ p + 4 ] .cint != mem [ p0 + 4 ] .cint ) ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 580 ) ; 
      } 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 586 ; 
	helpline [ 1 ] = 587 ; 
	helpline [ 0 ] = 583 ; 
      } 
      putgeterror () ; 
      goto lab45 ; 
    } 
    rr = pp ; 
    if ( mem [ pp ] .hhfield .v.RH != pp ) 
    do {
	qq = rr ; 
      rr = mem [ rr ] .hhfield .v.RH ; 
      x0 = mem [ qq + 1 ] .cint ; 
      x1 = mem [ qq + 5 ] .cint ; 
      x2 = mem [ rr + 3 ] .cint ; 
      x3 = mem [ rr + 1 ] .cint ; 
      if ( ( x0 > x1 ) || ( x1 > x2 ) || ( x2 > x3 ) ) 
      if ( ( x0 < x1 ) || ( x1 < x2 ) || ( x2 < x3 ) ) 
      if ( abvscd ( x2 - x1 , x2 - x1 , x1 - x0 , x3 - x2 ) > 0 ) 
      {
	xretraceerror () ; 
	goto lab45 ; 
      } 
      if ( ( mem [ pp + 1 ] .cint > x0 ) || ( x0 > x3 ) ) 
      if ( ( mem [ pp + 1 ] .cint < x0 ) || ( x0 < x3 ) ) 
      {
	xretraceerror () ; 
	goto lab45 ; 
      } 
    } while ( ! ( mem [ rr ] .hhfield .b1 == 0 ) ) ; 
    d = getnode ( 3 ) ; 
    mem [ d ] .hhfield .lhfield = mem [ p + 6 ] .hhfield .v.RH ; 
    if ( mem [ pp + 1 ] .cint < mem [ rr + 1 ] .cint ) 
    {
      mem [ d + 1 ] .cint = mem [ pp + 1 ] .cint ; 
      mem [ d + 2 ] .cint = mem [ rr + 1 ] .cint ; 
    } 
    else {
	
      mem [ d + 1 ] .cint = mem [ rr + 1 ] .cint ; 
      mem [ d + 2 ] .cint = mem [ pp + 1 ] .cint ; 
    } 
    mem [ 3 ] .cint = mem [ d + 2 ] .cint ; 
    dd = h ; 
    while ( mem [ mem [ dd ] .hhfield .v.RH + 1 ] .cint < mem [ d + 2 ] .cint 
    ) dd = mem [ dd ] .hhfield .v.RH ; 
    if ( dd != h ) 
    if ( ( mem [ dd + 2 ] .cint > mem [ d + 1 ] .cint ) ) 
    {
      xretraceerror () ; 
      goto lab45 ; 
    } 
    mem [ d ] .hhfield .v.RH = mem [ dd ] .hhfield .v.RH ; 
    mem [ dd ] .hhfield .v.RH = d ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  if ( mem [ h ] .hhfield .v.RH == 2 ) 
  goto lab45 ; 
  d = h ; 
  while ( mem [ d ] .hhfield .v.RH != 2 ) {
      
    hh = mem [ mem [ d ] .hhfield .v.RH ] .hhfield .lhfield ; 
    if ( hh == 0 ) 
    d = mem [ d ] .hhfield .v.RH ; 
    else if ( mem [ hh + 1 ] .cint == 0 ) 
    d = mem [ d ] .hhfield .v.RH ; 
    else {
	
      if ( mem [ hh ] .hhfield .v.RH == 0 ) 
      confusion ( 588 ) ; 
      dln = mem [ d ] .hhfield .v.RH ; 
      dd = mem [ hh ] .hhfield .v.RH ; 
      xoff = mem [ dln + 1 ] .cint - mem [ dd + 1 ] .cint - dashoffset ( hh ) 
      ; 
      mem [ 3 ] .cint = mem [ dd + 1 ] .cint + mem [ hh + 1 ] .cint ; 
      mem [ 4 ] .cint = mem [ 3 ] .cint ; 
      while ( xoff + mem [ dd + 2 ] .cint < mem [ dln + 1 ] .cint ) dd = mem [ 
      dd ] .hhfield .v.RH ; 
      while ( mem [ dln + 1 ] .cint <= mem [ dln + 2 ] .cint ) {
	  
	if ( dd == 2 ) 
	{
	  dd = mem [ hh ] .hhfield .v.RH ; 
	  xoff = xoff + mem [ hh + 1 ] .cint ; 
	} 
	if ( xoff + mem [ dd + 1 ] .cint <= mem [ dln + 2 ] .cint ) 
	{
	  mem [ d ] .hhfield .v.RH = getnode ( 3 ) ; 
	  d = mem [ d ] .hhfield .v.RH ; 
	  mem [ d ] .hhfield .v.RH = dln ; 
	  if ( mem [ dln + 1 ] .cint > xoff + mem [ dd + 1 ] .cint ) 
	  mem [ d + 1 ] .cint = mem [ dln + 1 ] .cint ; 
	  else mem [ d + 1 ] .cint = xoff + mem [ dd + 1 ] .cint ; 
	  if ( mem [ dln + 2 ] .cint < xoff + mem [ dd + 2 ] .cint ) 
	  mem [ d + 2 ] .cint = mem [ dln + 2 ] .cint ; 
	  else mem [ d + 2 ] .cint = xoff + mem [ dd + 2 ] .cint ; 
	} 
	dd = mem [ dd ] .hhfield .v.RH ; 
	mem [ dln + 1 ] .cint = xoff + mem [ dd + 1 ] .cint ; 
      } 
      mem [ d ] .hhfield .v.RH = mem [ dln ] .hhfield .v.RH ; 
      freenode ( dln , 3 ) ; 
    } 
  } 
  d = mem [ h ] .hhfield .v.RH ; 
  while ( ( mem [ d ] .hhfield .v.RH != 2 ) ) d = mem [ d ] .hhfield .v.RH ; 
  dd = mem [ h ] .hhfield .v.RH ; 
  mem [ h + 1 ] .cint = mem [ d + 2 ] .cint - mem [ dd + 1 ] .cint ; 
  if ( abs ( y0 ) > mem [ h + 1 ] .cint ) 
  mem [ h + 1 ] .cint = abs ( y0 ) ; 
  else if ( d != dd ) 
  {
    mem [ h ] .hhfield .v.RH = mem [ dd ] .hhfield .v.RH ; 
    mem [ d + 2 ] .cint = mem [ dd + 2 ] .cint + mem [ h + 1 ] .cint ; 
    freenode ( dd , 3 ) ; 
  } 
  lab40: Result = h ; 
  goto lab10 ; 
  lab45: flushdashlist ( h ) ; 
  if ( mem [ h ] .hhfield .lhfield == 0 ) 
  tossedges ( h ) ; 
  else decr ( mem [ h ] .hhfield .lhfield ) ; 
  Result = 0 ; 
  lab10: ; 
  return(Result) ; 
} 
void zadjustbbox ( h ) 
halfword h ; 
{if ( bbmin [ 0 ] < mem [ h + 2 ] .cint ) 
  mem [ h + 2 ] .cint = bbmin [ 0 ] ; 
  if ( bbmin [ 1 ] < mem [ h + 3 ] .cint ) 
  mem [ h + 3 ] .cint = bbmin [ 1 ] ; 
  if ( bbmax [ 0 ] > mem [ h + 4 ] .cint ) 
  mem [ h + 4 ] .cint = bbmax [ 0 ] ; 
  if ( bbmax [ 1 ] > mem [ h + 5 ] .cint ) 
  mem [ h + 5 ] .cint = bbmax [ 1 ] ; 
} 
void zboxends ( p , pp , h ) 
halfword p ; 
halfword pp ; 
halfword h ; 
{/* 10 */ halfword q  ; 
  fraction dx, dy  ; 
  scaled d  ; 
  scaled z  ; 
  scaled xx, yy  ; 
  integer i  ; 
  if ( mem [ p ] .hhfield .b1 != 0 ) 
  {
    q = mem [ p ] .hhfield .v.RH ; 
    while ( true ) {
	
      if ( q == mem [ p ] .hhfield .v.RH ) 
      {
	dx = mem [ p + 1 ] .cint - mem [ p + 5 ] .cint ; 
	dy = mem [ p + 2 ] .cint - mem [ p + 6 ] .cint ; 
	if ( ( dx == 0 ) && ( dy == 0 ) ) 
	{
	  dx = mem [ p + 1 ] .cint - mem [ q + 3 ] .cint ; 
	  dy = mem [ p + 2 ] .cint - mem [ q + 4 ] .cint ; 
	} 
      } 
      else {
	  
	dx = mem [ p + 1 ] .cint - mem [ p + 3 ] .cint ; 
	dy = mem [ p + 2 ] .cint - mem [ p + 4 ] .cint ; 
	if ( ( dx == 0 ) && ( dy == 0 ) ) 
	{
	  dx = mem [ p + 1 ] .cint - mem [ q + 5 ] .cint ; 
	  dy = mem [ p + 2 ] .cint - mem [ q + 6 ] .cint ; 
	} 
      } 
      dx = mem [ p + 1 ] .cint - mem [ q + 1 ] .cint ; 
      dy = mem [ p + 2 ] .cint - mem [ q + 2 ] .cint ; 
      d = pythadd ( dx , dy ) ; 
      if ( d > 0 ) 
      {
	dx = makefraction ( dx , d ) ; 
	dy = makefraction ( dy , d ) ; 
	findoffset ( - (integer) dy , dx , pp ) ; 
	xx = curx ; 
	yy = cury ; 
	{register integer for_end; i = 1 ; for_end = 2 ; if ( i <= for_end) 
	do 
	  {
	    findoffset ( dx , dy , pp ) ; 
	    d = takefraction ( xx - curx , dx ) + takefraction ( yy - cury ,	    dy ) ; 
	    if ( ( d < 0 ) && ( i == 1 ) || ( d > 0 ) && ( i == 2 ) ) 
	    confusion ( 589 ) ; 
	    z = mem [ p + 1 ] .cint + curx + takefraction ( d , dx ) ; 
	    if ( z < mem [ h + 2 ] .cint ) 
	    mem [ h + 2 ] .cint = z ; 
	    if ( z > mem [ h + 4 ] .cint ) 
	    mem [ h + 4 ] .cint = z ; 
	    z = mem [ p + 2 ] .cint + cury + takefraction ( d , dy ) ; 
	    if ( z < mem [ h + 3 ] .cint ) 
	    mem [ h + 3 ] .cint = z ; 
	    if ( z > mem [ h + 5 ] .cint ) 
	    mem [ h + 5 ] .cint = z ; 
	    dx = - (integer) dx ; 
	    dy = - (integer) dy ; 
	  } 
	while ( i++ < for_end ) ; } 
      } 
      if ( mem [ p ] .hhfield .b1 == 0 ) 
      goto lab10 ; 
      else do {
	  q = p ; 
	p = mem [ p ] .hhfield .v.RH ; 
      } while ( ! ( mem [ p ] .hhfield .b1 == 0 ) ) ; 
    } 
  } 
  lab10: ; 
} 
void zsetbbox ( h , toplevel ) 
halfword h ; 
boolean toplevel ; 
{/* 10 */ halfword p  ; 
  scaled sminx, sminy, smaxx, smaxy  ; 
  scaled x0, x1, y0, y1  ; 
  integer lev  ; 
  switch ( mem [ h + 6 ] .hhfield .lhfield ) 
  {case 0 : 
    ; 
    break ; 
  case 1 : 
    if ( internal [ 33 ] > 0 ) 
    initbbox ( h ) ; 
    break ; 
  case 2 : 
    if ( internal [ 33 ] <= 0 ) 
    initbbox ( h ) ; 
    break ; 
  } 
  while ( mem [ mem [ h + 6 ] .hhfield .v.RH ] .hhfield .v.RH != 0 ) {
      
    p = mem [ mem [ h + 6 ] .hhfield .v.RH ] .hhfield .v.RH ; 
    mem [ h + 6 ] .hhfield .v.RH = p ; 
    switch ( mem [ p ] .hhfield .b0 ) 
    {case 6 : 
      if ( toplevel ) 
      confusion ( 590 ) ; 
      else goto lab10 ; 
      break ; 
    case 1 : 
      {
	pathbbox ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	adjustbbox ( h ) ; 
      } 
      break ; 
    case 5 : 
      if ( internal [ 33 ] > 0 ) 
      mem [ h + 6 ] .hhfield .lhfield = 2 ; 
      else {
	  
	mem [ h + 6 ] .hhfield .lhfield = 1 ; 
	pathbbox ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	adjustbbox ( h ) ; 
	lev = 1 ; 
	while ( lev != 0 ) {
	    
	  if ( mem [ p ] .hhfield .v.RH == 0 ) 
	  confusion ( 591 ) ; 
	  p = mem [ p ] .hhfield .v.RH ; 
	  if ( mem [ p ] .hhfield .b0 == 5 ) 
	  incr ( lev ) ; 
	  else if ( mem [ p ] .hhfield .b0 == 7 ) 
	  decr ( lev ) ; 
	} 
	mem [ h + 6 ] .hhfield .v.RH = p ; 
      } 
      break ; 
    case 7 : 
      if ( internal [ 33 ] <= 0 ) 
      confusion ( 591 ) ; 
      break ; 
    case 2 : 
      {
	pathbbox ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	x0 = bbmin [ 0 ] ; 
	y0 = bbmin [ 1 ] ; 
	x1 = bbmax [ 0 ] ; 
	y1 = bbmax [ 1 ] ; 
	penbbox ( mem [ p + 1 ] .hhfield .lhfield ) ; 
	bbmin [ 0 ] = bbmin [ 0 ] + x0 ; 
	bbmin [ 1 ] = bbmin [ 1 ] + y0 ; 
	bbmax [ 0 ] = bbmax [ 0 ] + x1 ; 
	bbmax [ 1 ] = bbmax [ 1 ] + y1 ; 
	adjustbbox ( h ) ; 
	if ( ( mem [ mem [ p + 1 ] .hhfield .v.RH ] .hhfield .b0 == 0 ) && ( 
	mem [ p + 6 ] .hhfield .b0 == 2 ) ) 
	boxends ( mem [ p + 1 ] .hhfield .v.RH , mem [ p + 1 ] .hhfield .lhfield , h ) ; 
      } 
      break ; 
    case 3 : 
      {
	x1 = takescaled ( mem [ p + 10 ] .cint , mem [ p + 5 ] .cint ) ; 
	y0 = takescaled ( mem [ p + 11 ] .cint , - (integer) mem [ p + 7 ] .cint ) ; 
	y1 = takescaled ( mem [ p + 11 ] .cint , mem [ p + 6 ] .cint ) ; 
	bbmin [ 0 ] = mem [ p + 8 ] .cint ; 
	bbmax [ 0 ] = bbmin [ 0 ] ; 
	if ( y0 < y1 ) 
	{
	  bbmin [ 0 ] = bbmin [ 0 ] + y0 ; 
	  bbmax [ 0 ] = bbmax [ 0 ] + y1 ; 
	} 
	else {
	    
	  bbmin [ 0 ] = bbmin [ 0 ] + y1 ; 
	  bbmax [ 0 ] = bbmax [ 0 ] + y0 ; 
	} 
	if ( x1 < 0 ) 
	bbmin [ 0 ] = bbmin [ 0 ] + x1 ; 
	else bbmax [ 0 ] = bbmax [ 0 ] + x1 ; 
	x1 = takescaled ( mem [ p + 12 ] .cint , mem [ p + 5 ] .cint ) ; 
	y0 = takescaled ( mem [ p + 13 ] .cint , - (integer) mem [ p + 7 ] .cint ) ; 
	y1 = takescaled ( mem [ p + 13 ] .cint , mem [ p + 6 ] .cint ) ; 
	bbmin [ 1 ] = mem [ p + 9 ] .cint ; 
	bbmax [ 1 ] = bbmin [ 1 ] ; 
	if ( y0 < y1 ) 
	{
	  bbmin [ 1 ] = bbmin [ 1 ] + y0 ; 
	  bbmax [ 1 ] = bbmax [ 1 ] + y1 ; 
	} 
	else {
	    
	  bbmin [ 1 ] = bbmin [ 1 ] + y1 ; 
	  bbmax [ 1 ] = bbmax [ 1 ] + y0 ; 
	} 
	if ( x1 < 0 ) 
	bbmin [ 1 ] = bbmin [ 1 ] + x1 ; 
	else bbmax [ 1 ] = bbmax [ 1 ] + x1 ; 
	adjustbbox ( h ) ; 
      } 
      break ; 
    case 4 : 
      {
	pathbbox ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	x0 = bbmin [ 0 ] ; 
	y0 = bbmin [ 1 ] ; 
	x1 = bbmax [ 0 ] ; 
	y1 = bbmax [ 1 ] ; 
	sminx = mem [ h + 2 ] .cint ; 
	sminy = mem [ h + 3 ] .cint ; 
	smaxx = mem [ h + 4 ] .cint ; 
	smaxy = mem [ h + 5 ] .cint ; 
	mem [ h + 2 ] .cint = 2147483647L ; 
	mem [ h + 3 ] .cint = 2147483647L ; 
	mem [ h + 4 ] .cint = -2147483647L ; 
	mem [ h + 5 ] .cint = -2147483647L ; 
	setbbox ( h , false ) ; 
	if ( mem [ h + 2 ] .cint < x0 ) 
	mem [ h + 2 ] .cint = x0 ; 
	if ( mem [ h + 3 ] .cint < y0 ) 
	mem [ h + 3 ] .cint = y0 ; 
	if ( mem [ h + 4 ] .cint > x1 ) 
	mem [ h + 4 ] .cint = x1 ; 
	if ( mem [ h + 5 ] .cint > y1 ) 
	mem [ h + 5 ] .cint = y1 ; 
	bbmin [ 0 ] = sminx ; 
	bbmin [ 1 ] = sminy ; 
	bbmax [ 0 ] = smaxx ; 
	bbmax [ 1 ] = smaxy ; 
	adjustbbox ( h ) ; 
      } 
      break ; 
    } 
  } 
  if ( ! toplevel ) 
  confusion ( 590 ) ; 
  lab10: ; 
} 
void zsplitcubic ( p , t ) 
halfword p ; 
fraction t ; 
{scaled v  ; 
  halfword q, r  ; 
  q = mem [ p ] .hhfield .v.RH ; 
  r = getnode ( 7 ) ; 
  mem [ p ] .hhfield .v.RH = r ; 
  mem [ r ] .hhfield .v.RH = q ; 
  mem [ r ] .hhfield .b0 = 1 ; 
  mem [ r ] .hhfield .b1 = 1 ; 
  v = mem [ p + 5 ] .cint - takefraction ( mem [ p + 5 ] .cint - mem [ q + 3 ] .cint , t ) ; 
  mem [ p + 5 ] .cint = mem [ p + 1 ] .cint - takefraction ( mem [ p + 1 ] .cint - mem [ p + 5 ] .cint , t ) ; 
  mem [ q + 3 ] .cint = mem [ q + 3 ] .cint - takefraction ( mem [ q + 3 ] .cint - mem [ q + 1 ] .cint , t ) ; 
  mem [ r + 3 ] .cint = mem [ p + 5 ] .cint - takefraction ( mem [ p + 5 ] .cint - v , t ) ; 
  mem [ r + 5 ] .cint = v - takefraction ( v - mem [ q + 3 ] .cint , t ) ; 
  mem [ r + 1 ] .cint = mem [ r + 3 ] .cint - takefraction ( mem [ r + 3 ] .cint - mem [ r + 5 ] .cint , t ) ; 
  v = mem [ p + 6 ] .cint - takefraction ( mem [ p + 6 ] .cint - mem [ q + 4 ] .cint , t ) ; 
  mem [ p + 6 ] .cint = mem [ p + 2 ] .cint - takefraction ( mem [ p + 2 ] .cint - mem [ p + 6 ] .cint , t ) ; 
  mem [ q + 4 ] .cint = mem [ q + 4 ] .cint - takefraction ( mem [ q + 4 ] .cint - mem [ q + 2 ] .cint , t ) ; 
  mem [ r + 4 ] .cint = mem [ p + 6 ] .cint - takefraction ( mem [ p + 6 ] .cint - v , t ) ; 
  mem [ r + 6 ] .cint = v - takefraction ( v - mem [ q + 4 ] .cint , t ) ; 
  mem [ r + 2 ] .cint = mem [ r + 4 ] .cint - takefraction ( mem [ r + 4 ] .cint - mem [ r + 6 ] .cint , t ) ; 
} 
void zremovecubic ( p ) 
halfword p ; 
{halfword q  ; 
  q = mem [ p ] .hhfield .v.RH ; 
  mem [ p ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
  mem [ p + 5 ] .cint = mem [ q + 5 ] .cint ; 
  mem [ p + 6 ] .cint = mem [ q + 6 ] .cint ; 
  freenode ( q , 7 ) ; 
} 
halfword zpenwalk ( w , k ) 
halfword w ; 
integer k ; 
{register halfword Result; while ( k > 0 ) {
    
    w = mem [ w ] .hhfield .v.RH ; 
    decr ( k ) ; 
  } 
  while ( k < 0 ) {
      
    w = mem [ w ] .hhfield .lhfield ; 
    incr ( k ) ; 
  } 
  Result = w ; 
  return(Result) ; 
} 
void zfinoffsetprep ( p , w , x0 , x1 , x2 , y0 , y1 , y2 , rise , turnamt ) 
halfword p ; 
halfword w ; 
integer x0 ; 
integer x1 ; 
integer x2 ; 
integer y0 ; 
integer y1 ; 
integer y2 ; 
integer rise ; 
integer turnamt ; 
{/* 10 */ halfword ww  ; 
  scaled du, dv  ; 
  integer t0, t1, t2  ; 
  fraction t  ; 
  fraction s  ; 
  integer v  ; 
  halfword q  ; 
  q = mem [ p ] .hhfield .v.RH ; 
  while ( true ) {
      
    if ( rise > 0 ) 
    ww = mem [ w ] .hhfield .v.RH ; 
    else ww = mem [ w ] .hhfield .lhfield ; 
    du = mem [ ww + 1 ] .cint - mem [ w + 1 ] .cint ; 
    dv = mem [ ww + 2 ] .cint - mem [ w + 2 ] .cint ; 
    if ( abs ( du ) >= abs ( dv ) ) 
    {
      s = makefraction ( dv , du ) ; 
      t0 = takefraction ( x0 , s ) - y0 ; 
      t1 = takefraction ( x1 , s ) - y1 ; 
      t2 = takefraction ( x2 , s ) - y2 ; 
      if ( du < 0 ) 
      {
	t0 = - (integer) t0 ; 
	t1 = - (integer) t1 ; 
	t2 = - (integer) t2 ; 
      } 
    } 
    else {
	
      s = makefraction ( du , dv ) ; 
      t0 = x0 - takefraction ( y0 , s ) ; 
      t1 = x1 - takefraction ( y1 , s ) ; 
      t2 = x2 - takefraction ( y2 , s ) ; 
      if ( dv < 0 ) 
      {
	t0 = - (integer) t0 ; 
	t1 = - (integer) t1 ; 
	t2 = - (integer) t2 ; 
      } 
    } 
    if ( t0 < 0 ) 
    t0 = 0 ; 
    t = crossingpoint ( t0 , t1 , t2 ) ; 
    if ( t >= 268435456L ) 
    if ( turnamt > 0 ) 
    t = 268435456L ; 
    else goto lab10 ; 
    {
      splitcubic ( p , t ) ; 
      p = mem [ p ] .hhfield .v.RH ; 
      mem [ p ] .hhfield .lhfield = 16384 + rise ; 
      decr ( turnamt ) ; 
      v = x0 - takefraction ( x0 - x1 , t ) ; 
      x1 = x1 - takefraction ( x1 - x2 , t ) ; 
      x0 = v - takefraction ( v - x1 , t ) ; 
      v = y0 - takefraction ( y0 - y1 , t ) ; 
      y1 = y1 - takefraction ( y1 - y2 , t ) ; 
      y0 = v - takefraction ( v - y1 , t ) ; 
      if ( turnamt < 0 ) 
      {
	t1 = t1 - takefraction ( t1 - t2 , t ) ; 
	if ( t1 > 0 ) 
	t1 = 0 ; 
	t = crossingpoint ( 0 , - (integer) t1 , - (integer) t2 ) ; 
	if ( t > 268435456L ) 
	t = 268435456L ; 
	incr ( turnamt ) ; 
	if ( ( t == 268435456L ) && ( mem [ p ] .hhfield .v.RH != q ) ) 
	mem [ mem [ p ] .hhfield .v.RH ] .hhfield .lhfield = mem [ mem [ p ] .hhfield .v.RH ] .hhfield .lhfield - rise ; 
	else {
	    
	  splitcubic ( p , t ) ; 
	  mem [ mem [ p ] .hhfield .v.RH ] .hhfield .lhfield = 16384 - rise ; 
	  v = x1 - takefraction ( x1 - x2 , t ) ; 
	  x1 = x0 - takefraction ( x0 - x1 , t ) ; 
	  x2 = x1 - takefraction ( x1 - v , t ) ; 
	  v = y1 - takefraction ( y1 - y2 , t ) ; 
	  y1 = y0 - takefraction ( y0 - y1 , t ) ; 
	  y2 = y1 - takefraction ( y1 - v , t ) ; 
	} 
      } 
    } 
    w = ww ; 
  } 
  lab10: ; 
} 
integer zgetturnamt ( w , dx , dy , ccw ) 
halfword w ; 
scaled dx ; 
scaled dy ; 
boolean ccw ; 
{/* 30 */ register integer Result; halfword ww  ; 
  integer s  ; 
  integer t  ; 
  s = 0 ; 
  if ( ccw ) 
  {
    ww = mem [ w ] .hhfield .v.RH ; 
    do {
	t = abvscd ( dy , mem [ ww + 1 ] .cint - mem [ w + 1 ] .cint , dx ,      mem [ ww + 2 ] .cint - mem [ w + 2 ] .cint ) ; 
      if ( t < 0 ) 
      goto lab30 ; 
      incr ( s ) ; 
      w = ww ; 
      ww = mem [ ww ] .hhfield .v.RH ; 
    } while ( ! ( t <= 0 ) ) ; 
    lab30: ; 
  } 
  else {
      
    ww = mem [ w ] .hhfield .lhfield ; 
    while ( abvscd ( dy , mem [ w + 1 ] .cint - mem [ ww + 1 ] .cint , dx ,    mem [ w + 2 ] .cint - mem [ ww + 2 ] .cint ) < 0 ) {
	
      decr ( s ) ; 
      w = ww ; 
      ww = mem [ ww ] .hhfield .lhfield ; 
    } 
  } 
  Result = s ; 
  return(Result) ; 
} 
halfword zoffsetprep ( c , h ) 
halfword c ; 
halfword h ; 
{/* 45 */ register halfword Result; halfword n  ; 
  halfword p, q, r, w, ww  ; 
  integer kneeded  ; 
  halfword w0  ; 
  scaled dxin, dyin  ; 
  integer turnamt  ; 
  integer x0, x1, x2, y0, y1, y2  ; 
  integer t0, t1, t2  ; 
  integer du, dv, dx, dy  ; 
  integer dx0, dy0  ; 
  integer lmaxcoef  ; 
  integer x0a, x1a, x2a, y0a, y1a, y2a  ; 
  fraction t  ; 
  fraction s  ; 
  integer u0, u1, v0, v1  ; 
  integer ss  ; 
  schar dsign  ; 
  n = 0 ; 
  p = h ; 
  do {
      incr ( n ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } while ( ! ( p == h ) ) ; 
  dxin = mem [ mem [ h ] .hhfield .v.RH + 1 ] .cint - mem [ mem [ h ] .hhfield .lhfield + 1 ] .cint ; 
  dyin = mem [ mem [ h ] .hhfield .v.RH + 2 ] .cint - mem [ mem [ h ] .hhfield .lhfield + 2 ] .cint ; 
  if ( ( dxin == 0 ) && ( dyin == 0 ) ) 
  {
    dxin = mem [ mem [ h ] .hhfield .lhfield + 2 ] .cint - mem [ h + 2 ] .cint 
    ; 
    dyin = mem [ h + 1 ] .cint - mem [ mem [ h ] .hhfield .lhfield + 1 ] .cint 
    ; 
  } 
  w0 = h ; 
  p = c ; 
  kneeded = 0 ; 
  do {
      q = mem [ p ] .hhfield .v.RH ; 
    mem [ p ] .hhfield .lhfield = 16384 + kneeded ; 
    kneeded = 0 ; 
    x0 = mem [ p + 5 ] .cint - mem [ p + 1 ] .cint ; 
    x2 = mem [ q + 1 ] .cint - mem [ q + 3 ] .cint ; 
    x1 = mem [ q + 3 ] .cint - mem [ p + 5 ] .cint ; 
    y0 = mem [ p + 6 ] .cint - mem [ p + 2 ] .cint ; 
    y2 = mem [ q + 2 ] .cint - mem [ q + 4 ] .cint ; 
    y1 = mem [ q + 4 ] .cint - mem [ p + 6 ] .cint ; 
    lmaxcoef = abs ( x0 ) ; 
    if ( abs ( x1 ) > lmaxcoef ) 
    lmaxcoef = abs ( x1 ) ; 
    if ( abs ( x2 ) > lmaxcoef ) 
    lmaxcoef = abs ( x2 ) ; 
    if ( abs ( y0 ) > lmaxcoef ) 
    lmaxcoef = abs ( y0 ) ; 
    if ( abs ( y1 ) > lmaxcoef ) 
    lmaxcoef = abs ( y1 ) ; 
    if ( abs ( y2 ) > lmaxcoef ) 
    lmaxcoef = abs ( y2 ) ; 
    if ( lmaxcoef == 0 ) 
    goto lab45 ; 
    while ( lmaxcoef < 134217728L ) {
	
      lmaxcoef = lmaxcoef + lmaxcoef ; 
      x0 = x0 + x0 ; 
      x1 = x1 + x1 ; 
      x2 = x2 + x2 ; 
      y0 = y0 + y0 ; 
      y1 = y1 + y1 ; 
      y2 = y2 + y2 ; 
    } 
    dx = x0 ; 
    dy = y0 ; 
    if ( dx == 0 ) 
    if ( dy == 0 ) 
    {
      dx = x1 ; 
      dy = y1 ; 
      if ( dx == 0 ) 
      if ( dy == 0 ) 
      {
	dx = x2 ; 
	dy = y2 ; 
      } 
    } 
    if ( p == c ) 
    {
      dx0 = dx ; 
      dy0 = dy ; 
    } 
    turnamt = getturnamt ( w0 , dx , dy , abvscd ( dy , dxin , dx , dyin ) >= 
    0 ) ; 
    w = penwalk ( w0 , turnamt ) ; 
    w0 = w ; 
    mem [ p ] .hhfield .lhfield = mem [ p ] .hhfield .lhfield + turnamt ; 
    dxin = x2 ; 
    dyin = y2 ; 
    if ( dxin == 0 ) 
    if ( dyin == 0 ) 
    {
      dxin = x1 ; 
      dyin = y1 ; 
      if ( dxin == 0 ) 
      if ( dyin == 0 ) 
      {
	dxin = x0 ; 
	dyin = y0 ; 
      } 
    } 
    dsign = abvscd ( dx , dyin , dxin , dy ) ; 
    if ( dsign == 0 ) 
    if ( dx == 0 ) 
    if ( dy > 0 ) 
    dsign = 1 ; 
    else dsign = -1 ; 
    else if ( dx > 0 ) 
    dsign = 1 ; 
    else dsign = -1 ; 
    t0 = ( takefraction ( x0 , y2 ) ) / 2 - ( takefraction ( x2 , y0 ) ) / 2 ; 
    t1 = ( takefraction ( x1 , y0 + y2 ) ) / 2 - ( takefraction ( y1 , x0 + x2 
    ) ) / 2 ; 
    if ( t0 == 0 ) 
    t0 = dsign ; 
    if ( t0 > 0 ) 
    {
      t = crossingpoint ( t0 , t1 , - (integer) t0 ) ; 
      u0 = x0 - takefraction ( x0 - x1 , t ) ; 
      u1 = x1 - takefraction ( x1 - x2 , t ) ; 
      v0 = y0 - takefraction ( y0 - y1 , t ) ; 
      v1 = y1 - takefraction ( y1 - y2 , t ) ; 
    } 
    else {
	
      t = crossingpoint ( - (integer) t0 , t1 , t0 ) ; 
      u0 = x2 - takefraction ( x2 - x1 , t ) ; 
      u1 = x1 - takefraction ( x1 - x0 , t ) ; 
      v0 = y2 - takefraction ( y2 - y1 , t ) ; 
      v1 = y1 - takefraction ( y1 - y0 , t ) ; 
    } 
    ss = takefraction ( x0 + x2 , u0 - takefraction ( u0 - u1 , t ) ) + 
    takefraction ( y0 + y2 , v0 - takefraction ( v0 - v1 , t ) ) ; 
    turnamt = getturnamt ( w , dxin , dyin , dsign > 0 ) ; 
    if ( ss < 0 ) 
    turnamt = turnamt - dsign * n ; 
    ww = mem [ w ] .hhfield .lhfield ; 
    du = mem [ ww + 1 ] .cint - mem [ w + 1 ] .cint ; 
    dv = mem [ ww + 2 ] .cint - mem [ w + 2 ] .cint ; 
    if ( abs ( du ) >= abs ( dv ) ) 
    {
      s = makefraction ( dv , du ) ; 
      t0 = takefraction ( x0 , s ) - y0 ; 
      t1 = takefraction ( x1 , s ) - y1 ; 
      t2 = takefraction ( x2 , s ) - y2 ; 
      if ( du < 0 ) 
      {
	t0 = - (integer) t0 ; 
	t1 = - (integer) t1 ; 
	t2 = - (integer) t2 ; 
      } 
    } 
    else {
	
      s = makefraction ( du , dv ) ; 
      t0 = x0 - takefraction ( y0 , s ) ; 
      t1 = x1 - takefraction ( y1 , s ) ; 
      t2 = x2 - takefraction ( y2 , s ) ; 
      if ( dv < 0 ) 
      {
	t0 = - (integer) t0 ; 
	t1 = - (integer) t1 ; 
	t2 = - (integer) t2 ; 
      } 
    } 
    if ( t0 < 0 ) 
    t0 = 0 ; 
    t = crossingpoint ( t0 , t1 , t2 ) ; 
    if ( turnamt >= 0 ) 
    if ( t2 < 0 ) 
    t = 268435457L ; 
    else {
	
      u0 = x0 - takefraction ( x0 - x1 , t ) ; 
      u1 = x1 - takefraction ( x1 - x2 , t ) ; 
      ss = takefraction ( - (integer) du , u0 - takefraction ( u0 - u1 , t ) ) 
      ; 
      v0 = y0 - takefraction ( y0 - y1 , t ) ; 
      v1 = y1 - takefraction ( y1 - y2 , t ) ; 
      ss = ss + takefraction ( - (integer) dv , v0 - takefraction ( v0 - v1 ,      t ) ) ; 
      if ( ss < 0 ) 
      t = 268435457L ; 
    } 
    else if ( t > 268435456L ) 
    t = 268435456L ; 
    if ( t > 268435456L ) 
    finoffsetprep ( p , w , x0 , x1 , x2 , y0 , y1 , y2 , 1 , turnamt ) ; 
    else {
	
      splitcubic ( p , t ) ; 
      r = mem [ p ] .hhfield .v.RH ; 
      x1a = x0 - takefraction ( x0 - x1 , t ) ; 
      x1 = x1 - takefraction ( x1 - x2 , t ) ; 
      x2a = x1a - takefraction ( x1a - x1 , t ) ; 
      y1a = y0 - takefraction ( y0 - y1 , t ) ; 
      y1 = y1 - takefraction ( y1 - y2 , t ) ; 
      y2a = y1a - takefraction ( y1a - y1 , t ) ; 
      finoffsetprep ( p , w , x0 , x1a , x2a , y0 , y1a , y2a , 1 , 0 ) ; 
      x0 = x2a ; 
      y0 = y2a ; 
      mem [ r ] .hhfield .lhfield = 16383 ; 
      if ( turnamt >= 0 ) 
      {
	t1 = t1 - takefraction ( t1 - t2 , t ) ; 
	if ( t1 > 0 ) 
	t1 = 0 ; 
	t = crossingpoint ( 0 , - (integer) t1 , - (integer) t2 ) ; 
	if ( t > 268435456L ) 
	t = 268435456L ; 
	splitcubic ( r , t ) ; 
	mem [ mem [ r ] .hhfield .v.RH ] .hhfield .lhfield = 16385 ; 
	x1a = x1 - takefraction ( x1 - x2 , t ) ; 
	x1 = x0 - takefraction ( x0 - x1 , t ) ; 
	x0a = x1 - takefraction ( x1 - x1a , t ) ; 
	y1a = y1 - takefraction ( y1 - y2 , t ) ; 
	y1 = y0 - takefraction ( y0 - y1 , t ) ; 
	y0a = y1 - takefraction ( y1 - y1a , t ) ; 
	finoffsetprep ( mem [ r ] .hhfield .v.RH , w , x0a , x1a , x2 , y0a ,	y1a , y2 , 1 , turnamt ) ; 
	x2 = x0a ; 
	y2 = y0a ; 
	finoffsetprep ( r , ww , x0 , x1 , x2 , y0 , y1 , y2 , -1 , 0 ) ; 
      } 
      else finoffsetprep ( r , ww , x0 , x1 , x2 , y0 , y1 , y2 , -1 , -1 - 
      turnamt ) ; 
    } 
    w0 = penwalk ( w0 , turnamt ) ; 
    lab45: ; 
    do {
	r = mem [ p ] .hhfield .v.RH ; 
      if ( mem [ p + 1 ] .cint == mem [ p + 5 ] .cint ) 
      if ( mem [ p + 2 ] .cint == mem [ p + 6 ] .cint ) 
      if ( mem [ p + 1 ] .cint == mem [ r + 3 ] .cint ) 
      if ( mem [ p + 2 ] .cint == mem [ r + 4 ] .cint ) 
      if ( mem [ p + 1 ] .cint == mem [ r + 1 ] .cint ) 
      if ( mem [ p + 2 ] .cint == mem [ r + 2 ] .cint ) 
      if ( r != p ) 
      {
	kneeded = mem [ p ] .hhfield .lhfield - 16384 ; 
	if ( r == q ) 
	q = p ; 
	else {
	    
	  mem [ p ] .hhfield .lhfield = kneeded + mem [ r ] .hhfield .lhfield 
	  ; 
	  kneeded = 0 ; 
	} 
	if ( r == c ) 
	{
	  mem [ p ] .hhfield .lhfield = mem [ c ] .hhfield .lhfield ; 
	  c = p ; 
	} 
	if ( r == specp1 ) 
	specp1 = p ; 
	if ( r == specp2 ) 
	specp2 = p ; 
	r = p ; 
	removecubic ( p ) ; 
      } 
      p = r ; 
    } while ( ! ( p == q ) ) ; 
  } while ( ! ( q == c ) ) ; 
  specoffset = mem [ c ] .hhfield .lhfield - 16384 ; 
  if ( mem [ c ] .hhfield .v.RH == c ) 
  mem [ c ] .hhfield .lhfield = 16384 + n ; 
  else {
      
    mem [ c ] .hhfield .lhfield = mem [ c ] .hhfield .lhfield + kneeded ; 
    while ( w0 != h ) {
	
      mem [ c ] .hhfield .lhfield = mem [ c ] .hhfield .lhfield + 1 ; 
      w0 = mem [ w0 ] .hhfield .v.RH ; 
    } 
    while ( mem [ c ] .hhfield .lhfield <= 16384 - n ) mem [ c ] .hhfield .lhfield = mem [ c ] .hhfield .lhfield + n ; 
    while ( mem [ c ] .hhfield .lhfield > 16384 ) mem [ c ] .hhfield .lhfield 
    = mem [ c ] .hhfield .lhfield - n ; 
    if ( ( mem [ c ] .hhfield .lhfield != 16384 ) && ( abvscd ( dy0 , dxin ,    dx0 , dyin ) >= 0 ) ) 
    mem [ c ] .hhfield .lhfield = mem [ c ] .hhfield .lhfield + n ; 
  } 
  Result = c ; 
  return(Result) ; 
}