#define EXTERN extern
#include "mpd.h"

void zscanwithlist ( p ) 
halfword p ; 
{/* 30 31 32 */ smallnumber t  ; 
  halfword q  ; 
  halfword cp, pp, dp  ; 
  cp = 1 ; 
  pp = 1 ; 
  dp = 1 ; 
  while ( curcmd == 68 ) {
      
    t = curmod ; 
    getxnext () ; 
    scanexpression () ; 
    if ( curtype != t ) 
    {
      disperr ( 0 , 1012 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 1013 ; 
	helpline [ 0 ] = 1014 ; 
      } 
      if ( t == 10 ) 
      helpline [ 1 ] = 1015 ; 
      else if ( t == 13 ) 
      helpline [ 1 ] = 1016 ; 
      putgetflusherror ( 0 ) ; 
    } 
    else if ( t == 13 ) 
    {
      if ( cp == 1 ) 
      {
	cp = p ; 
	while ( cp != 0 ) {
	    
	  if ( ( mem [ cp ] .hhfield .b0 < 4 ) ) 
	  goto lab30 ; 
	  cp = mem [ cp ] .hhfield .v.RH ; 
	} 
	lab30: ; 
      } 
      if ( cp != 0 ) 
      {
	q = mem [ curexp + 1 ] .cint ; 
	mem [ cp + 2 ] .cint = mem [ q + 1 ] .cint ; 
	mem [ cp + 3 ] .cint = mem [ q + 3 ] .cint ; 
	mem [ cp + 4 ] .cint = mem [ q + 5 ] .cint ; 
	if ( mem [ cp + 2 ] .cint < 0 ) 
	mem [ cp + 2 ] .cint = 0 ; 
	if ( mem [ cp + 3 ] .cint < 0 ) 
	mem [ cp + 3 ] .cint = 0 ; 
	if ( mem [ cp + 4 ] .cint < 0 ) 
	mem [ cp + 4 ] .cint = 0 ; 
	if ( mem [ cp + 2 ] .cint > 65536L ) 
	mem [ cp + 2 ] .cint = 65536L ; 
	if ( mem [ cp + 3 ] .cint > 65536L ) 
	mem [ cp + 3 ] .cint = 65536L ; 
	if ( mem [ cp + 4 ] .cint > 65536L ) 
	mem [ cp + 4 ] .cint = 65536L ; 
      } 
      flushcurexp ( 0 ) ; 
    } 
    else if ( t == 6 ) 
    {
      if ( pp == 1 ) 
      {
	pp = p ; 
	while ( pp != 0 ) {
	    
	  if ( ( mem [ pp ] .hhfield .b0 < 3 ) ) 
	  goto lab31 ; 
	  pp = mem [ pp ] .hhfield .v.RH ; 
	} 
	lab31: ; 
      } 
      if ( pp != 0 ) 
      {
	if ( mem [ pp + 1 ] .hhfield .lhfield != 0 ) 
	tossknotlist ( mem [ pp + 1 ] .hhfield .lhfield ) ; 
	mem [ pp + 1 ] .hhfield .lhfield = curexp ; 
	curtype = 1 ; 
	if ( mem [ pp ] .hhfield .b0 == 2 ) 
	{
	  if ( ( mem [ pp + 1 ] .hhfield .lhfield == mem [ mem [ pp + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
	  mem [ pp + 7 ] .cint = getpenscale ( mem [ pp + 1 ] .hhfield .lhfield ) ; 
	} 
      } 
    } 
    else {
	
      if ( dp == 1 ) 
      {
	dp = p ; 
	while ( dp != 0 ) {
	    
	  if ( mem [ dp ] .hhfield .b0 == 2 ) 
	  goto lab32 ; 
	  dp = mem [ dp ] .hhfield .v.RH ; 
	} 
	lab32: ; 
      } 
      if ( dp != 0 ) 
      {
	if ( mem [ dp + 6 ] .hhfield .v.RH != 0 ) 
	if ( mem [ mem [ dp + 6 ] .hhfield .v.RH ] .hhfield .lhfield == 0 ) 
	tossedges ( mem [ dp + 6 ] .hhfield .v.RH ) ; 
	else decr ( mem [ mem [ dp + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) 
	; 
	mem [ dp + 6 ] .hhfield .v.RH = makedashes ( curexp ) ; 
	curtype = 1 ; 
      } 
    } 
  } 
  if ( cp > 1 ) 
  {
    q = mem [ cp ] .hhfield .v.RH ; 
    while ( q != 0 ) {
	
      if ( ( mem [ q ] .hhfield .b0 < 4 ) ) 
      {
	mem [ q + 2 ] .cint = mem [ cp + 2 ] .cint ; 
	mem [ q + 3 ] .cint = mem [ cp + 3 ] .cint ; 
	mem [ q + 4 ] .cint = mem [ cp + 4 ] .cint ; 
      } 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
  } 
  if ( pp > 1 ) 
  {
    q = mem [ pp ] .hhfield .v.RH ; 
    while ( q != 0 ) {
	
      if ( ( mem [ q ] .hhfield .b0 < 3 ) ) 
      {
	if ( mem [ q + 1 ] .hhfield .lhfield != 0 ) 
	tossknotlist ( mem [ q + 1 ] .hhfield .lhfield ) ; 
	mem [ q + 1 ] .hhfield .lhfield = makepen ( copypath ( mem [ pp + 1 ] .hhfield .lhfield ) , false ) ; 
	if ( mem [ q ] .hhfield .b0 == 2 ) 
	if ( mem [ pp ] .hhfield .b0 == 2 ) 
	mem [ q + 7 ] .cint = mem [ pp + 7 ] .cint ; 
	else {
	    
	  {
	    if ( ( mem [ q + 1 ] .hhfield .lhfield == mem [ mem [ q + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
	    mem [ q + 7 ] .cint = getpenscale ( mem [ q + 1 ] .hhfield .lhfield ) ; 
	  } 
	  pp = q ; 
	} 
      } 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
  } 
  if ( dp > 1 ) 
  {
    q = mem [ dp ] .hhfield .v.RH ; 
    while ( q != 0 ) {
	
      if ( mem [ q ] .hhfield .b0 == 2 ) 
      {
	if ( mem [ q + 6 ] .hhfield .v.RH != 0 ) 
	if ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield == 0 ) 
	tossedges ( mem [ q + 6 ] .hhfield .v.RH ) ; 
	else decr ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) ; 
	mem [ q + 6 ] .hhfield .v.RH = mem [ dp + 6 ] .hhfield .v.RH ; 
	if ( mem [ q + 6 ] .hhfield .v.RH != 0 ) 
	incr ( mem [ mem [ q + 6 ] .hhfield .v.RH ] .hhfield .lhfield ) ; 
      } 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
  } 
} 
halfword zfindedgesvar ( t ) 
halfword t ; 
{register halfword Result; halfword p  ; 
  halfword curedges  ; 
  p = findvariable ( t ) ; 
  curedges = 0 ; 
  if ( p == 0 ) 
  {
    obliterated ( t ) ; 
    putgeterror () ; 
  } 
  else if ( mem [ p ] .hhfield .b0 != 10 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 841 ) ; 
    } 
    showtokenlist ( t , 0 , 1000 , 0 ) ; 
    print ( 1017 ) ; 
    printtype ( mem [ p ] .hhfield .b0 ) ; 
    printchar ( 41 ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 1018 ; 
      helpline [ 0 ] = 1019 ; 
    } 
    putgeterror () ; 
  } 
  else {
      
    mem [ p + 1 ] .cint = privateedges ( mem [ p + 1 ] .cint ) ; 
    curedges = mem [ p + 1 ] .cint ; 
  } 
  flushnodelist ( t ) ; 
  Result = curedges ; 
  return(Result) ; 
} 
halfword zstartdrawcmd ( sep ) 
quarterword sep ; 
{register halfword Result; halfword lhv  ; 
  quarterword addtype  ; 
  lhv = 0 ; 
  getxnext () ; 
  varflag = sep ; 
  scanprimary () ; 
  if ( curtype != 20 ) 
  {
    disperr ( 0 , 1022 ) ; 
    {
      helpptr = 4 ; 
      helpline [ 3 ] = 1023 ; 
      helpline [ 2 ] = 1024 ; 
      helpline [ 1 ] = 1025 ; 
      helpline [ 0 ] = 1019 ; 
    } 
    putgetflusherror ( 0 ) ; 
  } 
  else {
      
    lhv = curexp ; 
    addtype = curmod ; 
    curtype = 1 ; 
    getxnext () ; 
    scanexpression () ; 
  } 
  lastaddtype = addtype ; 
  Result = lhv ; 
  return(Result) ; 
} 
void dobounds ( ) 
{halfword lhv, lhe  ; 
  halfword p  ; 
  integer m  ; 
  m = curmod ; 
  lhv = startdrawcmd ( 71 ) ; 
  if ( lhv != 0 ) 
  {
    lhe = findedgesvar ( lhv ) ; 
    if ( lhe == 0 ) 
    flushcurexp ( 0 ) ; 
    else if ( curtype != 8 ) 
    {
      disperr ( 0 , 1026 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 1027 ; 
	helpline [ 0 ] = 1019 ; 
      } 
      putgetflusherror ( 0 ) ; 
    } 
    else if ( mem [ curexp ] .hhfield .b0 == 0 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 1028 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 1029 ; 
	helpline [ 0 ] = 1019 ; 
      } 
      putgeterror () ; 
    } 
    else {
	
      p = newboundsnode ( curexp , m ) ; 
      mem [ p ] .hhfield .v.RH = mem [ lhe + 7 ] .hhfield .v.RH ; 
      mem [ lhe + 7 ] .hhfield .v.RH = p ; 
      if ( mem [ lhe + 7 ] .hhfield .lhfield == lhe + 7 ) 
      mem [ lhe + 7 ] .hhfield .lhfield = p ; 
      p = getnode ( grobjectsize [ ( m + 2 ) ] ) ; 
      mem [ p ] .hhfield .b0 = ( m + 2 ) ; 
      mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = p ; 
      mem [ lhe + 7 ] .hhfield .lhfield = p ; 
      initbbox ( lhe ) ; 
    } 
  } 
} 
void doaddto ( ) 
{halfword lhv, lhe  ; 
  halfword p  ; 
  halfword e  ; 
  quarterword addtype  ; 
  lhv = startdrawcmd ( 69 ) ; 
  addtype = lastaddtype ; 
  if ( lhv != 0 ) 
  {
    if ( addtype == 2 ) 
    {
      p = 0 ; 
      e = 0 ; 
      if ( curtype != 10 ) 
      {
	disperr ( 0 , 1030 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 1031 ; 
	  helpline [ 0 ] = 1019 ; 
	} 
	putgetflusherror ( 0 ) ; 
      } 
      else {
	  
	e = privateedges ( curexp ) ; 
	curtype = 1 ; 
	p = mem [ e + 7 ] .hhfield .v.RH ; 
      } 
    } 
    else {
	
      e = 0 ; 
      p = 0 ; 
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( curtype != 8 ) 
      {
	disperr ( 0 , 1030 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 1027 ; 
	  helpline [ 0 ] = 1019 ; 
	} 
	putgetflusherror ( 0 ) ; 
      } 
      else if ( addtype == 1 ) 
      if ( mem [ curexp ] .hhfield .b0 == 0 ) 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 1028 ) ; 
	} 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 1029 ; 
	  helpline [ 0 ] = 1019 ; 
	} 
	putgeterror () ; 
      } 
      else {
	  
	p = newfillnode ( curexp ) ; 
	curtype = 1 ; 
      } 
      else {
	  
	p = newstrokednode ( curexp ) ; 
	curtype = 1 ; 
      } 
    } 
    scanwithlist ( p ) ; 
    lhe = findedgesvar ( lhv ) ; 
    if ( lhe == 0 ) 
    {
      if ( ( e == 0 ) && ( p != 0 ) ) 
      e = tossgrobject ( p ) ; 
      if ( e != 0 ) 
      if ( mem [ e ] .hhfield .lhfield == 0 ) 
      tossedges ( e ) ; 
      else decr ( mem [ e ] .hhfield .lhfield ) ; 
    } 
    else if ( addtype == 2 ) 
    if ( e != 0 ) 
    {
      if ( mem [ e + 7 ] .hhfield .v.RH != 0 ) 
      {
	mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = mem [ e + 7 
	] .hhfield .v.RH ; 
	mem [ lhe + 7 ] .hhfield .lhfield = mem [ e + 7 ] .hhfield .lhfield ; 
	mem [ e + 7 ] .hhfield .lhfield = e + 7 ; 
	mem [ e + 7 ] .hhfield .v.RH = 0 ; 
	flushdashlist ( lhe ) ; 
      } 
      tossedges ( e ) ; 
    } 
    else ; 
    else if ( p != 0 ) 
    {
      mem [ mem [ lhe + 7 ] .hhfield .lhfield ] .hhfield .v.RH = p ; 
      mem [ lhe + 7 ] .hhfield .lhfield = p ; 
      if ( addtype == 0 ) 
      {
	if ( mem [ p + 1 ] .hhfield .lhfield == 0 ) 
	mem [ p + 1 ] .hhfield .lhfield = getpencircle ( 0 ) ; 
	{
	  if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
	  mem [ p + 7 ] .cint = getpenscale ( mem [ p + 1 ] .hhfield .lhfield 
	  ) ; 
	} 
      } 
    } 
  } 
} 
scaled ztfmcheck ( m ) 
smallnumber m ; 
{register scaled Result; if ( abs ( internal [ m ] ) >= 134217728L ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 1048 ) ; 
    } 
    print ( intname [ m ] ) ; 
    print ( 1049 ) ; 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 1050 ; 
    } 
    putgeterror () ; 
    if ( internal [ m ] > 0 ) 
    Result = 134217727L ; 
    else Result = -134217727L ; 
  } 
  else Result = internal [ m ] ; 
  return(Result) ; 
} 
void readpsnametable ( ) 
{/* 50 30 */ fontnumber k  ; 
  integer lmax  ; 
  integer j  ; 
  char c  ; 
  strnumber s  ; 
  (void) strncpy(nameoffile+1, pstabname, sizeof pstabname) ; 
  if ( aopenin ( pstabfile , 11 ) ) 
  {
    lmax = 0 ; 
    {register integer for_end; k = lastpsfnum + 1 ; for_end = lastfnum ; if ( 
    k <= for_end) do 
      if ( ( strstart [ nextstr [ fontname [ k ] ] ] - strstart [ fontname [ k 
      ] ] ) > lmax ) 
      lmax = ( strstart [ nextstr [ fontname [ k ] ] ] - strstart [ fontname [ 
      k ] ] ) ; 
    while ( k++ < for_end ) ; } 
    while ( ! eof ( pstabfile ) ) {
	
      {
	if ( poolptr + lmax > maxpoolptr ) 
	if ( poolptr + lmax > poolsize ) 
	docompaction ( lmax ) ; 
	else maxpoolptr = poolptr + lmax ; 
      } 
      j = lmax ; 
      while ( true ) {
	  
	if ( eoln ( pstabfile ) ) 
	fatalerror ( 1113 ) ; 
	read ( pstabfile , c ) ; 
	if ( c == ' ' ) 
	goto lab30 ; 
	decr ( j ) ; 
	if ( j >= 0 ) 
	{
	  strpool [ poolptr ] = xord [ c ] ; 
	  incr ( poolptr ) ; 
	} 
	else {
	    
	  poolptr = strstart [ strptr ] ; 
	  goto lab50 ; 
	} 
      } 
      lab30: s = makestring () ; 
      {register integer for_end; k = lastpsfnum + 1 ; for_end = lastfnum 
      ; if ( k <= for_end) do 
	if ( strvsstr ( s , fontname [ k ] ) == 0 ) 
	{
	  flushstring ( s ) ; 
	  j = 32 ; 
	  {
	    if ( poolptr + j > maxpoolptr ) 
	    if ( poolptr + j > poolsize ) 
	    docompaction ( j ) ; 
	    else maxpoolptr = poolptr + j ; 
	  } 
	  do {
	      if ( eoln ( pstabfile ) ) 
	    fatalerror ( 1113 ) ; 
	    read ( pstabfile , c ) ; 
	  } while ( ! ( c != ' ' ) ) ; 
	  do {
	      decr ( j ) ; 
	    if ( j < 0 ) 
	    fatalerror ( 1113 ) ; 
	    {
	      strpool [ poolptr ] = xord [ c ] ; 
	      incr ( poolptr ) ; 
	    } 
	    if ( eoln ( pstabfile ) ) 
	    c = ' ' ; 
	    else read ( pstabfile , c ) ; 
	  } while ( ! ( c == ' ' ) ) ; 
	  {
	    if ( strref [ fontpsname [ k ] ] < 127 ) 
	    if ( strref [ fontpsname [ k ] ] > 1 ) 
	    decr ( strref [ fontpsname [ k ] ] ) ; 
	    else flushstring ( fontpsname [ k ] ) ; 
	  } 
	  fontpsname [ k ] = makestring () ; 
	  goto lab50 ; 
	} 
      while ( k++ < for_end ) ; } 
      flushstring ( s ) ; 
      lab50: readln ( pstabfile ) ; 
    } 
    lastpsfnum = lastfnum ; 
    aclose ( pstabfile ) ; 
  } 
} 
void openoutputfile ( ) 
{integer c  ; 
  char oldsetting  ; 
  strnumber s  ; 
  if ( jobname == 0 ) 
  openlogfile () ; 
  c = roundunscaled ( internal [ 17 ] ) ; 
  if ( c < 0 ) 
  s = 1114 ; 
  else {
      
    oldsetting = selector ; 
    selector = 10 ; 
    printchar ( 46 ) ; 
    printint ( c ) ; 
    s = makestring () ; 
    selector = oldsetting ; 
  } 
  packjobname ( s ) ; 
  while ( ! aopenout ( psfile ) ) promptfilename ( 1115 , s ) ; 
  {
    if ( strref [ s ] < 127 ) 
    if ( strref [ s ] > 1 ) 
    decr ( strref [ s ] ) ; 
    else flushstring ( s ) ; 
  } 
  if ( ( c < firstoutputcode ) && ( firstoutputcode >= 0 ) ) 
  {
    firstoutputcode = c ; 
    {
      if ( strref [ firstfilename ] < 127 ) 
      if ( strref [ firstfilename ] > 1 ) 
      decr ( strref [ firstfilename ] ) ; 
      else flushstring ( firstfilename ) ; 
    } 
    firstfilename = amakenamestring ( psfile ) ; 
  } 
  if ( c >= lastoutputcode ) 
  {
    lastoutputcode = c ; 
    {
      if ( strref [ lastfilename ] < 127 ) 
      if ( strref [ lastfilename ] > 1 ) 
      decr ( strref [ lastfilename ] ) ; 
      else flushstring ( lastfilename ) ; 
    } 
    lastfilename = amakenamestring ( psfile ) ; 
  } 
  if ( termoffset > maxprintline - 6 ) 
  println () ; 
  else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  printchar ( 32 ) ; 
  printchar ( 91 ) ; 
  if ( c >= 0 ) 
  printint ( c ) ; 
} 
void zpspairout ( x , y ) 
scaled x ; 
scaled y ; 
{if ( psoffset + 26 > maxprintline ) 
  println () ; 
  printscaled ( x ) ; 
  printchar ( 32 ) ; 
  printscaled ( y ) ; 
  printchar ( 32 ) ; 
} 
void zpsprint ( s ) 
strnumber s ; 
{if ( psoffset + ( strstart [ nextstr [ s ] ] - strstart [ s ] ) > 
  maxprintline ) 
  println () ; 
  print ( s ) ; 
} 
void zpspathout ( h ) 
halfword h ; 
{/* 10 */ halfword p, q  ; 
  scaled d  ; 
  boolean curved  ; 
  if ( psoffset + 40 > maxprintline ) 
  println () ; 
  if ( neednewpath ) 
  print ( 1118 ) ; 
  neednewpath = true ; 
  pspairout ( mem [ h + 1 ] .cint , mem [ h + 2 ] .cint ) ; 
  print ( 1119 ) ; 
  p = h ; 
  do {
      if ( mem [ p ] .hhfield .b1 == 0 ) 
    {
      if ( p == h ) 
      psprint ( 1120 ) ; 
      goto lab10 ; 
    } 
    q = mem [ p ] .hhfield .v.RH ; 
    curved = true ; 
    if ( mem [ p + 5 ] .cint == mem [ p + 1 ] .cint ) 
    if ( mem [ p + 6 ] .cint == mem [ p + 2 ] .cint ) 
    if ( mem [ q + 3 ] .cint == mem [ q + 1 ] .cint ) 
    if ( mem [ q + 4 ] .cint == mem [ q + 2 ] .cint ) 
    curved = false ; 
    d = mem [ q + 3 ] .cint - mem [ p + 5 ] .cint ; 
    if ( abs ( mem [ p + 5 ] .cint - mem [ p + 1 ] .cint - d ) <= 131 ) 
    if ( abs ( mem [ q + 1 ] .cint - mem [ q + 3 ] .cint - d ) <= 131 ) 
    {
      d = mem [ q + 4 ] .cint - mem [ p + 6 ] .cint ; 
      if ( abs ( mem [ p + 6 ] .cint - mem [ p + 2 ] .cint - d ) <= 131 ) 
      if ( abs ( mem [ q + 2 ] .cint - mem [ q + 4 ] .cint - d ) <= 131 ) 
      curved = false ; 
    } 
    println () ; 
    if ( curved ) 
    {
      pspairout ( mem [ p + 5 ] .cint , mem [ p + 6 ] .cint ) ; 
      pspairout ( mem [ q + 3 ] .cint , mem [ q + 4 ] .cint ) ; 
      pspairout ( mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ; 
      psprint ( 1122 ) ; 
    } 
    else if ( q != h ) 
    {
      pspairout ( mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ; 
      psprint ( 1123 ) ; 
    } 
    p = q ; 
  } while ( ! ( p == h ) ) ; 
  psprint ( 1121 ) ; 
  lab10: ; 
} 
void zunknowngraphicsstate ( c ) 
scaled c ; 
{gsred = c ; 
  gsgreen = c ; 
  gsblue = c ; 
  gsljoin = 3 ; 
  gslcap = 3 ; 
  gsmiterlim = 0 ; 
  gsdashp = 1 ; 
  gsdashsc = 0 ; 
  gswidth = -1 ; 
} 
boolean zcoordrangeOK ( h , zoff , dz ) 
halfword h ; 
smallnumber zoff ; 
scaled dz ; 
{/* 40 45 10 */ register boolean Result; halfword p  ; 
  scaled zlo, zhi  ; 
  scaled z  ; 
  zlo = mem [ h + zoff ] .cint ; 
  zhi = zlo ; 
  p = h ; 
  while ( mem [ p ] .hhfield .b1 != 0 ) {
      
    z = mem [ p + zoff + 4 ] .cint ; 
    if ( z < zlo ) 
    zlo = z ; 
    else if ( z > zhi ) 
    zhi = z ; 
    if ( zhi - zlo > dz ) 
    goto lab40 ; 
    p = mem [ p ] .hhfield .v.RH ; 
    z = mem [ p + zoff + 2 ] .cint ; 
    if ( z < zlo ) 
    zlo = z ; 
    else if ( z > zhi ) 
    zhi = z ; 
    if ( zhi - zlo > dz ) 
    goto lab40 ; 
    z = mem [ p + zoff ] .cint ; 
    if ( z < zlo ) 
    zlo = z ; 
    else if ( z > zhi ) 
    zhi = z ; 
    if ( zhi - zlo > dz ) 
    goto lab40 ; 
    if ( p == h ) 
    goto lab45 ; 
  } 
  lab45: Result = true ; 
  goto lab10 ; 
  lab40: Result = false ; 
  lab10: ; 
  return(Result) ; 
} 
boolean zsamedashes ( h , hh ) 
halfword h ; 
halfword hh ; 
{/* 30 */ register boolean Result; halfword p, pp  ; 
  if ( h == hh ) 
  Result = true ; 
  else if ( ( h <= 1 ) || ( hh <= 1 ) ) 
  Result = false ; 
  else if ( mem [ h + 1 ] .cint != mem [ hh + 1 ] .cint ) 
  Result = false ; 
  else {
      
    p = mem [ h ] .hhfield .v.RH ; 
    pp = mem [ hh ] .hhfield .v.RH ; 
    while ( ( p != 2 ) && ( pp != 2 ) ) if ( ( mem [ p + 1 ] .cint != mem [ pp 
    + 1 ] .cint ) || ( mem [ p + 2 ] .cint != mem [ pp + 2 ] .cint ) ) 
    goto lab30 ; 
    else {
	
      p = mem [ p ] .hhfield .v.RH ; 
      pp = mem [ pp ] .hhfield .v.RH ; 
    } 
    lab30: Result = p == pp ; 
  } 
  return(Result) ; 
} 
void zfixgraphicsstate ( p ) 
halfword p ; 
{halfword hh, pp  ; 
  scaled wx, wy, ww  ; 
  boolean adjwx  ; 
  integer tx, ty  ; 
  scaled scf  ; 
  if ( ( mem [ p ] .hhfield .b0 < 4 ) ) 
  if ( ( gsred != mem [ p + 2 ] .cint ) || ( gsgreen != mem [ p + 3 ] .cint ) 
  || ( gsblue != mem [ p + 4 ] .cint ) ) 
  {
    gsred = mem [ p + 2 ] .cint ; 
    gsgreen = mem [ p + 3 ] .cint ; 
    gsblue = mem [ p + 4 ] .cint ; 
    if ( ( gsred == gsgreen ) && ( gsgreen == gsblue ) ) 
    {
      if ( psoffset + 16 > maxprintline ) 
      println () ; 
      printchar ( 32 ) ; 
      printscaled ( gsred ) ; 
      print ( 1127 ) ; 
    } 
    else {
	
      if ( psoffset + 36 > maxprintline ) 
      println () ; 
      printchar ( 32 ) ; 
      printscaled ( gsred ) ; 
      printchar ( 32 ) ; 
      printscaled ( gsgreen ) ; 
      printchar ( 32 ) ; 
      printscaled ( gsblue ) ; 
      print ( 1128 ) ; 
    } 
  } 
  if ( ( mem [ p ] .hhfield .b0 == 1 ) || ( mem [ p ] .hhfield .b0 == 2 ) ) 
  if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
  if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
  {
    pp = mem [ p + 1 ] .hhfield .lhfield ; 
    if ( ( mem [ pp + 5 ] .cint == mem [ pp + 1 ] .cint ) && ( mem [ pp + 4 ] .cint == mem [ pp + 2 ] .cint ) ) 
    {
      wx = abs ( mem [ pp + 3 ] .cint - mem [ pp + 1 ] .cint ) ; 
      wy = abs ( mem [ pp + 6 ] .cint - mem [ pp + 2 ] .cint ) ; 
    } 
    else {
	
      wx = pythadd ( mem [ pp + 3 ] .cint - mem [ pp + 1 ] .cint , mem [ pp + 
      5 ] .cint - mem [ pp + 1 ] .cint ) ; 
      wy = pythadd ( mem [ pp + 4 ] .cint - mem [ pp + 2 ] .cint , mem [ pp + 
      6 ] .cint - mem [ pp + 2 ] .cint ) ; 
    } 
    tx = 1 ; 
    ty = 1 ; 
    if ( coordrangeOK ( mem [ p + 1 ] .hhfield .v.RH , 2 , wy ) ) 
    tx = 10 ; 
    else if ( coordrangeOK ( mem [ p + 1 ] .hhfield .v.RH , 1 , wx ) ) 
    ty = 10 ; 
    if ( wy / ty >= wx / tx ) 
    {
      ww = wy ; 
      adjwx = false ; 
    } 
    else {
	
      ww = wx ; 
      adjwx = true ; 
    } 
    if ( ( ww != gswidth ) || ( adjwx != gsadjwx ) ) 
    {
      if ( adjwx ) 
      {
	if ( psoffset + 13 > maxprintline ) 
	println () ; 
	printchar ( 32 ) ; 
	printscaled ( ww ) ; 
	psprint ( 1129 ) ; 
      } 
      else {
	  
	if ( psoffset + 15 > maxprintline ) 
	println () ; 
	print ( 1130 ) ; 
	printscaled ( ww ) ; 
	psprint ( 1131 ) ; 
      } 
      gswidth = ww ; 
      gsadjwx = adjwx ; 
    } 
    if ( mem [ p ] .hhfield .b0 == 1 ) 
    hh = 0 ; 
    else {
	
      hh = mem [ p + 6 ] .hhfield .v.RH ; 
      if ( mem [ p + 7 ] .cint == 0 ) 
      if ( gswidth == 0 ) 
      scf = 65536L ; 
      else hh = 0 ; 
      else scf = makescaled ( gswidth , mem [ p + 7 ] .cint ) ; 
    } 
    if ( hh == 0 ) 
    {
      if ( gsdashp != 0 ) 
      {
	psprint ( 1132 ) ; 
	gsdashp = 0 ; 
      } 
    } 
    else if ( ( gsdashsc != scf ) || ! samedashes ( gsdashp , hh ) ) 
    {
      gsdashp = hh ; 
      gsdashsc = scf ; 
      if ( ( mem [ hh + 1 ] .cint == 0 ) || ( abs ( mem [ hh + 1 ] .cint ) / 
      65536L >= 2147483647L / scf ) ) 
      psprint ( 1132 ) ; 
      else {
	  
	pp = mem [ hh ] .hhfield .v.RH ; 
	mem [ 3 ] .cint = mem [ pp + 1 ] .cint + mem [ hh + 1 ] .cint ; 
	if ( psoffset + 28 > maxprintline ) 
	println () ; 
	print ( 1133 ) ; 
	while ( pp != 2 ) {
	    
	  pspairout ( takescaled ( mem [ pp + 2 ] .cint - mem [ pp + 1 ] .cint 
	  , scf ) , takescaled ( mem [ mem [ pp ] .hhfield .v.RH + 1 ] .cint - 
	  mem [ pp + 2 ] .cint , scf ) ) ; 
	  pp = mem [ pp ] .hhfield .v.RH ; 
	} 
	if ( psoffset + 22 > maxprintline ) 
	println () ; 
	print ( 1134 ) ; 
	printscaled ( takescaled ( dashoffset ( hh ) , scf ) ) ; 
	print ( 1135 ) ; 
      } 
    } 
    if ( mem [ p ] .hhfield .b0 == 2 ) 
    if ( ( mem [ mem [ p + 1 ] .hhfield .v.RH ] .hhfield .b0 == 0 ) || ( mem [ 
    p + 6 ] .hhfield .v.RH != 0 ) ) 
    if ( gslcap != mem [ p + 6 ] .hhfield .b0 ) 
    {
      if ( psoffset + 13 > maxprintline ) 
      println () ; 
      printchar ( 32 ) ; 
      printchar ( 48 + mem [ p + 6 ] .hhfield .b0 ) ; 
      print ( 1124 ) ; 
      gslcap = mem [ p + 6 ] .hhfield .b0 ; 
    } 
    if ( gsljoin != mem [ p ] .hhfield .b1 ) 
    {
      if ( psoffset + 14 > maxprintline ) 
      println () ; 
      printchar ( 32 ) ; 
      printchar ( 48 + mem [ p ] .hhfield .b1 ) ; 
      print ( 1125 ) ; 
      gsljoin = mem [ p ] .hhfield .b1 ; 
    } 
    if ( gsmiterlim != mem [ p + 5 ] .cint ) 
    {
      if ( psoffset + 27 > maxprintline ) 
      println () ; 
      printchar ( 32 ) ; 
      printscaled ( mem [ p + 5 ] .cint ) ; 
      print ( 1126 ) ; 
      gsmiterlim = mem [ p + 5 ] .cint ; 
    } 
  } 
  if ( psoffset > 0 ) 
  println () ; 
} 
void zstrokeellipse ( h , fillalso ) 
halfword h ; 
boolean fillalso ; 
{scaled txx, txy, tyx, tyy  ; 
  halfword p  ; 
  scaled d1, det  ; 
  integer s  ; 
  boolean transforming  ; 
  transforming = false ; 
  p = mem [ h + 1 ] .hhfield .lhfield ; 
  txx = mem [ p + 3 ] .cint ; 
  tyx = mem [ p + 4 ] .cint ; 
  txy = mem [ p + 5 ] .cint ; 
  tyy = mem [ p + 6 ] .cint ; 
  if ( ( mem [ p + 1 ] .cint != 0 ) || ( mem [ p + 2 ] .cint != 0 ) ) 
  {
    printnl ( 1139 ) ; 
    pspairout ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
    psprint ( 1140 ) ; 
    txx = txx - mem [ p + 1 ] .cint ; 
    tyx = tyx - mem [ p + 2 ] .cint ; 
    txy = txy - mem [ p + 1 ] .cint ; 
    tyy = tyy - mem [ p + 2 ] .cint ; 
    transforming = true ; 
  } 
  else printnl ( 285 ) ; 
  if ( gswidth != 65536L ) 
  if ( gswidth == 0 ) 
  {
    txx = 65536L ; 
    tyy = 65536L ; 
  } 
  else {
      
    txx = makescaled ( txx , gswidth ) ; 
    txy = makescaled ( txy , gswidth ) ; 
    tyx = makescaled ( tyx , gswidth ) ; 
    tyy = makescaled ( tyy , gswidth ) ; 
  } 
  if ( ( txy != 0 ) || ( tyx != 0 ) || ( txx != 65536L ) || ( tyy != 65536L ) 
  ) 
  if ( ( ! transforming ) ) 
  {
    psprint ( 1139 ) ; 
    transforming = true ; 
  } 
  det = takescaled ( txx , tyy ) - takescaled ( txy , tyx ) ; 
  d1 = 4 * 10 + 1 ; 
  if ( abs ( det ) < d1 ) 
  {
    if ( det >= 0 ) 
    {
      d1 = d1 - det ; 
      s = 1 ; 
    } 
    else {
	
      d1 = - (integer) d1 - det ; 
      s = -1 ; 
    } 
    d1 = d1 * 65536L ; 
    if ( abs ( txx ) + abs ( tyy ) >= abs ( txy ) + abs ( tyy ) ) 
    if ( abs ( txx ) > abs ( tyy ) ) 
    tyy = tyy + ( d1 + s * abs ( txx ) ) / txx ; 
    else txx = txx + ( d1 + s * abs ( tyy ) ) / tyy ; 
    else if ( abs ( txy ) > abs ( tyx ) ) 
    tyx = tyx + ( d1 + s * abs ( txy ) ) / txy ; 
    else txy = txy + ( d1 + s * abs ( tyx ) ) / tyx ; 
  } 
  pspathout ( mem [ h + 1 ] .hhfield .v.RH ) ; 
  if ( fillalso ) 
  printnl ( 1136 ) ; 
  if ( ( txy != 0 ) || ( tyx != 0 ) ) 
  {
    println () ; 
    printchar ( 91 ) ; 
    pspairout ( txx , tyx ) ; 
    pspairout ( txy , tyy ) ; 
    psprint ( 1141 ) ; 
  } 
  else if ( ( txx != 65536L ) || ( tyy != 65536L ) ) 
  {
    println () ; 
    pspairout ( txx , tyy ) ; 
    print ( 1142 ) ; 
  } 
  psprint ( 1137 ) ; 
  if ( transforming ) 
  psprint ( 1138 ) ; 
  println () ; 
} 
void zpsfillout ( p ) 
halfword p ; 
{pspathout ( p ) ; 
  psprint ( 1143 ) ; 
  println () ; 
} 
void zdoouterenvelope ( p , h ) 
halfword p ; 
halfword h ; 
{p = makeenvelope ( p , mem [ h + 1 ] .hhfield .lhfield , mem [ h ] .hhfield .b1 , 0 , mem [ h + 5 ] .cint ) ; 
  psfillout ( p ) ; 
  tossknotlist ( p ) ; 
} 
scaled zchoosescale ( p ) 
halfword p ; 
{register scaled Result; scaled a, b, c, d, ad, bc  ; 
  a = mem [ p + 10 ] .cint ; 
  b = mem [ p + 11 ] .cint ; 
  c = mem [ p + 12 ] .cint ; 
  d = mem [ p + 13 ] .cint ; 
  if ( ( a < 0 ) ) 
  a = - (integer) a ; 
  if ( ( b < 0 ) ) 
  b = - (integer) b ; 
  if ( ( c < 0 ) ) 
  c = - (integer) c ; 
  if ( ( d < 0 ) ) 
  d = - (integer) d ; 
  ad = ( a - d ) / 2 ; 
  bc = ( b - c ) / 2 ; 
  Result = pythadd ( pythadd ( d + ad , ad ) , pythadd ( c + bc , bc ) ) ; 
  return(Result) ; 
} 
void zpsstringout ( s ) 
strnumber s ; 
{poolpointer i  ; 
  ASCIIcode k  ; 
  print ( 40 ) ; 
  i = strstart [ s ] ; 
  while ( i < strstart [ nextstr [ s ] ] ) {
      
    if ( psoffset + 5 > maxprintline ) 
    {
      printchar ( 92 ) ; 
      println () ; 
    } 
    k = strpool [ i ] ; 
    if ( ( ( k < 32 ) || ( k > 126 ) ) ) 
    {
      printchar ( 92 ) ; 
      printchar ( 48 + ( k / 64 ) ) ; 
      printchar ( 48 + ( ( k / 8 ) % 8 ) ) ; 
      printchar ( 48 + ( k % 8 ) ) ; 
    } 
    else {
	
      if ( ( k == 40 ) || ( k == 41 ) || ( k == 92 ) ) 
      printchar ( 92 ) ; 
      printchar ( k ) ; 
    } 
    incr ( i ) ; 
  } 
  print ( 41 ) ; 
} 
boolean zispsname ( s ) 
strnumber s ; 
{/* 45 10 */ register boolean Result; poolpointer i  ; 
  ASCIIcode k  ; 
  i = strstart [ s ] ; 
  while ( i < strstart [ nextstr [ s ] ] ) {
      
    k = strpool [ i ] ; 
    if ( ( k <= 32 ) || ( k > 126 ) ) 
    goto lab45 ; 
    if ( ( k == 40 ) || ( k == 41 ) || ( k == 60 ) || ( k == 62 ) || ( k == 
    123 ) || ( k == 125 ) || ( k == 47 ) || ( k == 37 ) ) 
    goto lab45 ; 
    incr ( i ) ; 
  } 
  Result = true ; 
  goto lab10 ; 
  lab45: Result = false ; 
  lab10: ; 
  return(Result) ; 
} 
void zpsnameout ( s , lit ) 
strnumber s ; 
boolean lit ; 
{if ( psoffset + ( strstart [ nextstr [ s ] ] - strstart [ s ] ) + 2 > 
  maxprintline ) 
  println () ; 
  printchar ( 32 ) ; 
  if ( ispsname ( s ) ) 
  {
    if ( lit ) 
    printchar ( 47 ) ; 
    print ( s ) ; 
  } 
  else {
      
    psstringout ( s ) ; 
    if ( ! lit ) 
    psprint ( 1144 ) ; 
    psprint ( 1145 ) ; 
  } 
} 
void zunmarkfont ( f ) 
fontnumber f ; 
{integer k  ; 
  {register integer for_end; k = charbase [ f ] + fontbc [ f ] ; for_end = 
  charbase [ f ] + fontec [ f ] ; if ( k <= for_end) do 
    fontinfo [ k ] .qqqq .b3 = 0 ; 
  while ( k++ < for_end ) ; } 
} 
void zmarkstringchars ( f , s ) 
fontnumber f ; 
strnumber s ; 
{integer b  ; 
  poolASCIIcode bc, ec  ; 
  poolpointer k  ; 
  b = charbase [ f ] ; 
  bc = fontbc [ f ] ; 
  ec = fontec [ f ] ; 
  k = strstart [ nextstr [ s ] ] ; 
  while ( k > strstart [ s ] ) {
      
    decr ( k ) ; 
    if ( ( strpool [ k ] >= bc ) && ( strpool [ k ] <= ec ) ) 
    fontinfo [ b + strpool [ k ] ] .qqqq .b3 = 1 ; 
  } 
} 
void zhexdigitout ( d ) 
smallnumber d ; 
{if ( d < 10 ) 
  printchar ( d + 48 ) ; 
  else printchar ( d + 87 ) ; 
} 
halfword zpsmarksout ( f , c ) 
fontnumber f ; 
eightbits c ; 
{register halfword Result; eightbits bc, ec  ; 
  integer lim  ; 
  integer p  ; 
  char d, b  ; 
  lim = 4 * ( emergencylinelength - psoffset - 4 ) ; 
  bc = fontbc [ f ] ; 
  ec = fontec [ f ] ; 
  if ( c > bc ) 
  bc = c ; 
  p = charbase [ f ] + bc ; 
  while ( ( fontinfo [ p ] .qqqq .b3 == 0 ) && ( bc < ec ) ) {
      
    incr ( p ) ; 
    incr ( bc ) ; 
  } 
  if ( ec >= bc + lim ) 
  ec = bc + lim - 1 ; 
  p = charbase [ f ] + ec ; 
  while ( ( fontinfo [ p ] .qqqq .b3 == 0 ) && ( bc < ec ) ) {
      
    decr ( p ) ; 
    decr ( ec ) ; 
  } 
  printchar ( 32 ) ; 
  hexdigitout ( bc / 16 ) ; 
  hexdigitout ( bc % 16 ) ; 
  printchar ( 58 ) ; 
  b = 8 ; 
  d = 0 ; 
  {register integer for_end; p = charbase [ f ] + bc ; for_end = charbase [ f 
  ] + ec ; if ( p <= for_end) do 
    {
      if ( b == 0 ) 
      {
	hexdigitout ( d ) ; 
	d = 0 ; 
	b = 8 ; 
      } 
      if ( fontinfo [ p ] .qqqq .b3 != 0 ) 
      d = d + b ; 
      b = halfp ( b ) ; 
    } 
  while ( p++ < for_end ) ; } 
  hexdigitout ( d ) ; 
  while ( ( ec < fontec [ f ] ) && ( fontinfo [ p ] .qqqq .b3 == 0 ) ) {
      
    incr ( p ) ; 
    incr ( ec ) ; 
  } 
  Result = ec + 1 ; 
  return(Result) ; 
} 
boolean zcheckpsmarks ( f , c ) 
fontnumber f ; 
integer c ; 
{/* 10 */ register boolean Result; integer p  ; 
  {register integer for_end; p = charbase [ f ] + c ; for_end = charbase [ f 
  ] + fontec [ f ] ; if ( p <= for_end) do 
    if ( fontinfo [ p ] .qqqq .b3 == 1 ) 
    {
      Result = true ; 
      goto lab10 ; 
    } 
  while ( p++ < for_end ) ; } 
  Result = false ; 
  lab10: ; 
  return(Result) ; 
} 
quarterword zsizeindex ( f , s ) 
fontnumber f ; 
scaled s ; 
{/* 40 */ register quarterword Result; halfword p, q  ; 
  quarterword i  ; 
  q = fontsizes [ f ] ; 
  i = 0 ; 
  while ( q != 0 ) {
      
    if ( abs ( s - mem [ q + 1 ] .cint ) <= 65 ) 
    goto lab40 ; 
    else {
	
      p = q ; 
      q = mem [ q ] .hhfield .v.RH ; 
      incr ( i ) ; 
    } 
    if ( i == 255 ) 
    overflow ( 1146 , 255 ) ; 
  } 
  q = getnode ( 2 ) ; 
  mem [ q + 1 ] .cint = s ; 
  if ( i == 0 ) 
  fontsizes [ f ] = q ; 
  else mem [ p ] .hhfield .v.RH = q ; 
  lab40: Result = i ; 
  return(Result) ; 
} 
scaled zindexedsize ( f , j ) 
fontnumber f ; 
quarterword j ; 
{register scaled Result; halfword p  ; 
  quarterword i  ; 
  p = fontsizes [ f ] ; 
  i = 0 ; 
  if ( p == 0 ) 
  confusion ( 1147 ) ; 
  while ( ( i != j ) ) {
      
    incr ( i ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
    if ( p == 0 ) 
    confusion ( 1147 ) ; 
  } 
  Result = mem [ p + 1 ] .cint ; 
  return(Result) ; 
} 
void clearsizes ( ) 
{fontnumber f  ; 
  halfword p  ; 
  {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= for_end) 
  do 
    while ( fontsizes [ f ] != 0 ) {
	
      p = fontsizes [ f ] ; 
      fontsizes [ f ] = mem [ p ] .hhfield .v.RH ; 
      freenode ( p , 2 ) ; 
    } 
  while ( f++ < for_end ) ; } 
} 
void zshipout ( h ) 
halfword h ; 
{/* 30 40 */ halfword p  ; 
  halfword q  ; 
  integer t  ; 
  fontnumber f, ff  ; 
  fontnumber ldf  ; 
  boolean donefonts  ; 
  quarterword nextsize  ; 
  halfword curfsize[fontmax + 1]  ; 
  scaled ds, scf  ; 
  boolean transformed  ; 
  openoutputfile () ; 
  if ( ( internal [ 32 ] > 0 ) && ( lastpsfnum < lastfnum ) ) 
  readpsnametable () ; 
  nonpssetting = selector ; 
  selector = 8 ; 
  print ( 1156 ) ; 
  if ( internal [ 32 ] > 0 ) 
  print ( 1157 ) ; 
  printnl ( 1158 ) ; 
  setbbox ( h , true ) ; 
  if ( mem [ h + 2 ] .cint > mem [ h + 4 ] .cint ) 
  print ( 1159 ) ; 
  else {
      
    pspairout ( floorscaled ( mem [ h + 2 ] .cint ) , floorscaled ( mem [ h + 
    3 ] .cint ) ) ; 
    pspairout ( - (integer) floorscaled ( - (integer) mem [ h + 4 ] .cint ) ,    - (integer) floorscaled ( - (integer) mem [ h + 5 ] .cint ) ) ; 
  } 
  printnl ( 1160 ) ; 
  printnl ( 1161 ) ; 
  printint ( roundunscaled ( internal [ 13 ] ) ) ; 
  printchar ( 46 ) ; 
  printdd ( roundunscaled ( internal [ 14 ] ) ) ; 
  printchar ( 46 ) ; 
  printdd ( roundunscaled ( internal [ 15 ] ) ) ; 
  printchar ( 58 ) ; 
  t = roundunscaled ( internal [ 16 ] ) ; 
  printdd ( t / 60 ) ; 
  printdd ( t % 60 ) ; 
  printnl ( 1162 ) ; 
  {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= for_end) 
  do 
    fontsizes [ f ] = 0 ; 
  while ( f++ < for_end ) ; } 
  p = mem [ h + 7 ] .hhfield .v.RH ; 
  while ( p != 0 ) {
      
    if ( mem [ p ] .hhfield .b0 == 3 ) 
    if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
    {
      f = mem [ p + 1 ] .hhfield .lhfield ; 
      if ( internal [ 32 ] > 0 ) 
      fontsizes [ f ] = 1 ; 
      else {
	  
	if ( fontsizes [ f ] == 0 ) 
	unmarkfont ( f ) ; 
	mem [ p ] .hhfield .b1 = sizeindex ( f , choosescale ( p ) ) ; 
	if ( mem [ p ] .hhfield .b1 == 0 ) 
	markstringchars ( f , mem [ p + 1 ] .hhfield .v.RH ) ; 
      } 
    } 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  if ( internal [ 32 ] > 0 ) 
  {
    ldf = 0 ; 
    {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= 
    for_end) do 
      if ( fontsizes [ f ] != 0 ) 
      {
	if ( ldf == 0 ) 
	printnl ( 1163 ) ; 
	{register integer for_end; ff = ldf ; for_end = 0 ; if ( ff >= 
	for_end) do 
	  if ( fontsizes [ ff ] != 0 ) 
	  if ( strvsstr ( fontpsname [ f ] , fontpsname [ ff ] ) == 0 ) 
	  goto lab40 ; 
	while ( ff-- > for_end ) ; } 
	if ( psoffset + 1 + ( strstart [ nextstr [ fontpsname [ f ] ] ] - 
	strstart [ fontpsname [ f ] ] ) > maxprintline ) 
	printnl ( 1164 ) ; 
	printchar ( 32 ) ; 
	print ( fontpsname [ f ] ) ; 
	ldf = f ; 
	lab40: ; 
      } 
    while ( f++ < for_end ) ; } 
  } 
  else {
      
    nextsize = 0 ; 
    {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= 
    for_end) do 
      curfsize [ f ] = fontsizes [ f ] ; 
    while ( f++ < for_end ) ; } 
    do {
	donefonts = true ; 
      {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= 
      for_end) do 
	{
	  if ( curfsize [ f ] != 0 ) 
	  {
	    t = 0 ; 
	    while ( checkpsmarks ( f , t ) ) {
		
	      printnl ( 1165 ) ; 
	      if ( psoffset + ( strstart [ nextstr [ fontname [ f ] ] ] - 
	      strstart [ fontname [ f ] ] ) + 12 > emergencylinelength ) 
	      goto lab30 ; 
	      print ( fontname [ f ] ) ; 
	      printchar ( 32 ) ; 
	      ds = ( fontdsize [ f ] + 8 ) / 16 ; 
	      printscaled ( takescaled ( ds , mem [ curfsize [ f ] + 1 ] .cint 
	      ) ) ; 
	      if ( psoffset + 12 > emergencylinelength ) 
	      goto lab30 ; 
	      printchar ( 32 ) ; 
	      printscaled ( ds ) ; 
	      if ( psoffset + 5 > emergencylinelength ) 
	      goto lab30 ; 
	      t = psmarksout ( f , t ) ; 
	    } 
	    lab30: curfsize [ f ] = mem [ curfsize [ f ] ] .hhfield .v.RH ; 
	  } 
	  if ( curfsize [ f ] != 0 ) 
	  {
	    unmarkfont ( f ) ; 
	    donefonts = false ; 
	  } 
	} 
      while ( f++ < for_end ) ; } 
      if ( ! donefonts ) 
      {
	incr ( nextsize ) ; 
	p = mem [ h + 7 ] .hhfield .v.RH ; 
	while ( p != 0 ) {
	    
	  if ( mem [ p ] .hhfield .b0 == 3 ) 
	  if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
	  if ( mem [ p ] .hhfield .b1 == nextsize ) 
	  markstringchars ( mem [ p + 1 ] .hhfield .lhfield , mem [ p + 1 ] .hhfield .v.RH ) ; 
	  p = mem [ p ] .hhfield .v.RH ; 
	} 
      } 
    } while ( ! ( donefonts ) ) ; 
  } 
  println () ; 
  if ( internal [ 32 ] > 0 ) 
  {
    if ( ldf != 0 ) 
    {
      {register integer for_end; f = 1 ; for_end = lastfnum ; if ( f <= 
      for_end) do 
	if ( fontsizes [ f ] != 0 ) 
	{
	  psnameout ( fontname [ f ] , true ) ; 
	  psnameout ( fontpsname [ f ] , true ) ; 
	  psprint ( 1166 ) ; 
	  println () ; 
	} 
      while ( f++ < for_end ) ; } 
      print ( 1167 ) ; 
      println () ; 
    } 
  } 
  print ( 1151 ) ; 
  printnl ( 1152 ) ; 
  println () ; 
  t = mem [ memtop - 3 ] .hhfield .v.RH ; 
  while ( t != 0 ) {
      
    if ( ( strstart [ nextstr [ mem [ t + 1 ] .cint ] ] - strstart [ mem [ t + 
    1 ] .cint ] ) <= emergencylinelength ) 
    print ( mem [ t + 1 ] .cint ) ; 
    else overflow ( 1150 , emergencylinelength ) ; 
    println () ; 
    t = mem [ t ] .hhfield .v.RH ; 
  } 
  flushtokenlist ( mem [ memtop - 3 ] .hhfield .v.RH ) ; 
  mem [ memtop - 3 ] .hhfield .v.RH = 0 ; 
  lastpending = memtop - 3 ; 
  unknowngraphicsstate ( 0 ) ; 
  neednewpath = true ; 
  p = mem [ h + 7 ] .hhfield .v.RH ; 
  while ( p != 0 ) {
      
    fixgraphicsstate ( p ) ; 
    switch ( mem [ p ] .hhfield .b0 ) 
    {case 4 : 
      {
	printnl ( 1139 ) ; 
	pspathout ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	psprint ( 1168 ) ; 
	println () ; 
      } 
      break ; 
    case 6 : 
      {
	printnl ( 1169 ) ; 
	println () ; 
	unknowngraphicsstate ( -1 ) ; 
      } 
      break ; 
    case 1 : 
      if ( mem [ p + 1 ] .hhfield .lhfield == 0 ) 
      psfillout ( mem [ p + 1 ] .hhfield .v.RH ) ; 
      else if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
      strokeellipse ( p , true ) ; 
      else {
	  
	doouterenvelope ( copypath ( mem [ p + 1 ] .hhfield .v.RH ) , p ) ; 
	doouterenvelope ( htapypoc ( mem [ p + 1 ] .hhfield .v.RH ) , p ) ; 
      } 
      break ; 
    case 2 : 
      if ( ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ) 
      strokeellipse ( p , false ) ; 
      else {
	  
	q = copypath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	t = mem [ p + 6 ] .hhfield .b0 ; 
	if ( mem [ q ] .hhfield .b0 != 0 ) 
	{
	  mem [ insertknot ( q , mem [ q + 1 ] .cint , mem [ q + 2 ] .cint ) ] .hhfield .b0 = 0 ; 
	  mem [ q ] .hhfield .b1 = 0 ; 
	  q = mem [ q ] .hhfield .v.RH ; 
	  t = 1 ; 
	} 
	q = makeenvelope ( q , mem [ p + 1 ] .hhfield .lhfield , mem [ p ] .hhfield .b1 , t , mem [ p + 5 ] .cint ) ; 
	psfillout ( q ) ; 
	tossknotlist ( q ) ; 
      } 
      break ; 
    case 3 : 
      if ( ( mem [ p + 1 ] .hhfield .lhfield != 0 ) && ( ( strstart [ nextstr 
      [ mem [ p + 1 ] .hhfield .v.RH ] ] - strstart [ mem [ p + 1 ] .hhfield .v.RH ] ) > 0 ) ) 
      {
	if ( internal [ 32 ] > 0 ) 
	scf = choosescale ( p ) ; 
	else scf = indexedsize ( mem [ p + 1 ] .hhfield .lhfield , mem [ p ] .hhfield .b1 ) ; 
	transformed = ( mem [ p + 10 ] .cint != scf ) || ( mem [ p + 13 ] .cint != scf ) || ( mem [ p + 11 ] .cint != 0 ) || ( mem [ p + 12 ] .cint != 0 ) ; 
	if ( transformed ) 
	{
	  print ( 1171 ) ; 
	  pspairout ( makescaled ( mem [ p + 10 ] .cint , scf ) , makescaled ( 
	  mem [ p + 12 ] .cint , scf ) ) ; 
	  pspairout ( makescaled ( mem [ p + 11 ] .cint , scf ) , makescaled ( 
	  mem [ p + 13 ] .cint , scf ) ) ; 
	  pspairout ( mem [ p + 8 ] .cint , mem [ p + 9 ] .cint ) ; 
	  psprint ( 1172 ) ; 
	} 
	else {
	    
	  pspairout ( mem [ p + 8 ] .cint , mem [ p + 9 ] .cint ) ; 
	  psprint ( 1119 ) ; 
	} 
	println () ; 
	psstringout ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	psnameout ( fontname [ mem [ p + 1 ] .hhfield .lhfield ] , false ) ; 
	if ( psoffset + 18 > maxprintline ) 
	println () ; 
	printchar ( 32 ) ; 
	ds = ( fontdsize [ mem [ p + 1 ] .hhfield .lhfield ] + 8 ) / 16 ; 
	printscaled ( takescaled ( ds , scf ) ) ; 
	print ( 1170 ) ; 
	if ( transformed ) 
	psprint ( 1138 ) ; 
	println () ; 
      } 
      break ; 
    case 5 : 
    case 7 : 
      ; 
      break ; 
    } 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  print ( 1153 ) ; 
  println () ; 
  print ( 1154 ) ; 
  println () ; 
  aclose ( psfile ) ; 
  selector = nonpssetting ; 
  if ( internal [ 32 ] <= 0 ) 
  clearsizes () ; 
  printchar ( 93 ) ; 
  flush ( termout ) ; 
  incr ( totalshipped ) ; 
  if ( internal [ 9 ] > 0 ) 
  printedges ( h , 1155 , true ) ; 
} 
void doshipout ( ) 
{integer c  ; 
  getxnext () ; 
  scanexpression () ; 
  if ( curtype != 10 ) 
  {
    disperr ( 0 , 1032 ) ; 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 1033 ; 
    } 
    putgetflusherror ( 0 ) ; 
  } 
  else {
      
    c = roundunscaled ( internal [ 17 ] ) % 256 ; 
    if ( c < 0 ) 
    c = c + 256 ; 
    if ( c < bc ) 
    bc = c ; 
    if ( c > ec ) 
    ec = c ; 
    charexists [ c ] = true ; 
    tfmwidth [ c ] = tfmcheck ( 19 ) ; 
    tfmheight [ c ] = tfmcheck ( 20 ) ; 
    tfmdepth [ c ] = tfmcheck ( 21 ) ; 
    tfmitalcorr [ c ] = tfmcheck ( 22 ) ; 
    shipout ( curexp ) ; 
    flushcurexp ( 0 ) ; 
  } 
} 
void znostringerr ( s ) 
strnumber s ; 
{disperr ( 0 , 741 ) ; 
  {
    helpptr = 1 ; 
    helpline [ 0 ] = s ; 
  } 
  putgeterror () ; 
} 
void domessage ( ) 
{char m  ; 
  m = curmod ; 
  getxnext () ; 
  scanexpression () ; 
  if ( curtype != 4 ) 
  nostringerr ( 1037 ) ; 
  else switch ( m ) 
  {case 0 : 
    {
      printnl ( 285 ) ; 
      slowprint ( curexp ) ; 
    } 
    break ; 
  case 1 : 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 285 ) ; 
      } 
      slowprint ( curexp ) ; 
      if ( errhelp != 0 ) 
      useerrhelp = true ; 
      else if ( longhelpseen ) 
      {
	helpptr = 1 ; 
	helpline [ 0 ] = 1038 ; 
      } 
      else {
	  
	if ( interaction < 3 ) 
	longhelpseen = true ; 
	{
	  helpptr = 4 ; 
	  helpline [ 3 ] = 1039 ; 
	  helpline [ 2 ] = 1040 ; 
	  helpline [ 1 ] = 1041 ; 
	  helpline [ 0 ] = 1042 ; 
	} 
      } 
      putgeterror () ; 
      useerrhelp = false ; 
    } 
    break ; 
  case 2 : 
    {
      if ( errhelp != 0 ) 
      {
	if ( strref [ errhelp ] < 127 ) 
	if ( strref [ errhelp ] > 1 ) 
	decr ( strref [ errhelp ] ) ; 
	else flushstring ( errhelp ) ; 
      } 
      if ( ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] ) == 0 ) 
      errhelp = 0 ; 
      else {
	  
	errhelp = curexp ; 
	{
	  if ( strref [ errhelp ] < 127 ) 
	  incr ( strref [ errhelp ] ) ; 
	} 
      } 
    } 
    break ; 
  } 
  flushcurexp ( 0 ) ; 
} 
void dowrite ( ) 
{/* 22 */ strnumber t  ; 
  writeindex n, n0  ; 
  char oldsetting  ; 
  getxnext () ; 
  scanexpression () ; 
  if ( curtype != 4 ) 
  nostringerr ( 1043 ) ; 
  else if ( curcmd != 71 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 1044 ) ; 
    } 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 1045 ; 
    } 
    putgeterror () ; 
  } 
  else {
      
    t = curexp ; 
    curtype = 1 ; 
    getxnext () ; 
    scanexpression () ; 
    if ( curtype != 4 ) 
    nostringerr ( 1046 ) ; 
    else {
	
      n = writefiles ; 
      n0 = writefiles ; 
      do {
	  lab22: if ( n == 0 ) 
	{
	  if ( n0 == writefiles ) 
	  if ( writefiles < 4 ) 
	  incr ( writefiles ) ; 
	  else overflow ( 1047 , 4 ) ; 
	  n = n0 ; 
	  openwritefile ( curexp , n ) ; 
	} 
	else {
	    
	  decr ( n ) ; 
	  if ( wrfname [ n ] == 0 ) 
	  {
	    n0 = n ; 
	    goto lab22 ; 
	  } 
	} 
      } while ( ! ( strvsstr ( curexp , wrfname [ n ] ) == 0 ) ) ; 
      if ( eofline == 0 ) 
      {
	{
	  strpool [ poolptr ] = 0 ; 
	  incr ( poolptr ) ; 
	} 
	eofline = makestring () ; 
	strref [ eofline ] = 127 ; 
      } 
      if ( strvsstr ( t , eofline ) == 0 ) 
      {
	aclose ( wrfile [ n ] ) ; 
	{
	  if ( strref [ wrfname [ n ] ] < 127 ) 
	  if ( strref [ wrfname [ n ] ] > 1 ) 
	  decr ( strref [ wrfname [ n ] ] ) ; 
	  else flushstring ( wrfname [ n ] ) ; 
	} 
	wrfname [ n ] = 0 ; 
	if ( n == writefiles - 1 ) 
	writefiles = n ; 
      } 
      else {
	  
	oldsetting = selector ; 
	selector = n ; 
	slowprint ( t ) ; 
	println () ; 
	selector = oldsetting ; 
      } 
    } 
    {
      if ( strref [ t ] < 127 ) 
      if ( strref [ t ] > 1 ) 
      decr ( strref [ t ] ) ; 
      else flushstring ( t ) ; 
    } 
  } 
  flushcurexp ( 0 ) ; 
} 
eightbits getcode ( ) 
{/* 40 */ register eightbits Result; integer c  ; 
  getxnext () ; 
  scanexpression () ; 
  if ( curtype == 16 ) 
  {
    c = roundunscaled ( curexp ) ; 
    if ( c >= 0 ) 
    if ( c < 256 ) 
    goto lab40 ; 
  } 
  else if ( curtype == 4 ) 
  if ( ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] ) == 1 ) 
  {
    c = strpool [ strstart [ curexp ] ] ; 
    goto lab40 ; 
  } 
  disperr ( 0 , 1056 ) ; 
  {
    helpptr = 2 ; 
    helpline [ 1 ] = 1057 ; 
    helpline [ 0 ] = 1058 ; 
  } 
  putgetflusherror ( 0 ) ; 
  c = 0 ; 
  lab40: Result = c ; 
  return(Result) ; 
} 
void zsettag ( c , t , r ) 
halfword c ; 
smallnumber t ; 
halfword r ; 
{if ( chartag [ c ] == 0 ) 
  {
    chartag [ c ] = t ; 
    charremainder [ c ] = r ; 
    if ( t == 1 ) 
    {
      incr ( labelptr ) ; 
      labelloc [ labelptr ] = r ; 
      labelchar [ labelptr ] = c ; 
    } 
  } 
  else {
      
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 1059 ) ; 
    } 
    if ( ( c > 32 ) && ( c < 127 ) ) 
    print ( c ) ; 
    else if ( c == 256 ) 
    print ( 1060 ) ; 
    else {
	
      print ( 1061 ) ; 
      printint ( c ) ; 
    } 
    print ( 1062 ) ; 
    switch ( chartag [ c ] ) 
    {case 1 : 
      print ( 1063 ) ; 
      break ; 
    case 2 : 
      print ( 1064 ) ; 
      break ; 
    case 3 : 
      print ( 1053 ) ; 
      break ; 
    } 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 1065 ; 
      helpline [ 0 ] = 1019 ; 
    } 
    putgeterror () ; 
  } 
} 
void dotfmcommand ( ) 
{/* 22 30 */ short c, cc  ; 
  integer k  ; 
  integer j  ; 
  switch ( curmod ) 
  {case 0 : 
    {
      c = getcode () ; 
      while ( curcmd == 80 ) {
	  
	cc = getcode () ; 
	settag ( c , 2 , cc ) ; 
	c = cc ; 
      } 
    } 
    break ; 
  case 1 : 
    {
      lkstarted = false ; 
      lab22: getxnext () ; 
      if ( ( curcmd == 77 ) && lkstarted ) 
      {
	c = getcode () ; 
	if ( nl - skiptable [ c ] > 128 ) 
	{
	  {
	    {
	      if ( interaction == 3 ) 
	      ; 
	      printnl ( 263 ) ; 
	      print ( 1082 ) ; 
	    } 
	    {
	      helpptr = 1 ; 
	      helpline [ 0 ] = 1083 ; 
	    } 
	    error () ; 
	    ll = skiptable [ c ] ; 
	    do {
		lll = ligkern [ ll ] .b0 ; 
	      ligkern [ ll ] .b0 = 128 ; 
	      ll = ll - lll ; 
	    } while ( ! ( lll == 0 ) ) ; 
	  } 
	  skiptable [ c ] = ligtablesize ; 
	} 
	if ( skiptable [ c ] == ligtablesize ) 
	ligkern [ nl - 1 ] .b0 = 0 ; 
	else ligkern [ nl - 1 ] .b0 = nl - skiptable [ c ] - 1 ; 
	skiptable [ c ] = nl - 1 ; 
	goto lab30 ; 
      } 
      if ( curcmd == 78 ) 
      {
	c = 256 ; 
	curcmd = 80 ; 
      } 
      else {
	  
	backinput () ; 
	c = getcode () ; 
      } 
      if ( ( curcmd == 80 ) || ( curcmd == 79 ) ) 
      {
	if ( curcmd == 80 ) 
	if ( c == 256 ) 
	bchlabel = nl ; 
	else settag ( c , 1 , nl ) ; 
	else if ( skiptable [ c ] < ligtablesize ) 
	{
	  ll = skiptable [ c ] ; 
	  skiptable [ c ] = ligtablesize ; 
	  do {
	      lll = ligkern [ ll ] .b0 ; 
	    if ( nl - ll > 128 ) 
	    {
	      {
		{
		  if ( interaction == 3 ) 
		  ; 
		  printnl ( 263 ) ; 
		  print ( 1082 ) ; 
		} 
		{
		  helpptr = 1 ; 
		  helpline [ 0 ] = 1083 ; 
		} 
		error () ; 
		ll = ll ; 
		do {
		    lll = ligkern [ ll ] .b0 ; 
		  ligkern [ ll ] .b0 = 128 ; 
		  ll = ll - lll ; 
		} while ( ! ( lll == 0 ) ) ; 
	      } 
	      goto lab22 ; 
	    } 
	    ligkern [ ll ] .b0 = nl - ll - 1 ; 
	    ll = ll - lll ; 
	  } while ( ! ( lll == 0 ) ) ; 
	} 
	goto lab22 ; 
      } 
      if ( curcmd == 75 ) 
      {
	ligkern [ nl ] .b1 = c ; 
	ligkern [ nl ] .b0 = 0 ; 
	if ( curmod < 128 ) 
	{
	  ligkern [ nl ] .b2 = curmod ; 
	  ligkern [ nl ] .b3 = getcode () ; 
	} 
	else {
	    
	  getxnext () ; 
	  scanexpression () ; 
	  if ( curtype != 16 ) 
	  {
	    disperr ( 0 , 1084 ) ; 
	    {
	      helpptr = 2 ; 
	      helpline [ 1 ] = 1085 ; 
	      helpline [ 0 ] = 309 ; 
	    } 
	    putgetflusherror ( 0 ) ; 
	  } 
	  kern [ nk ] = curexp ; 
	  k = 0 ; 
	  while ( kern [ k ] != curexp ) incr ( k ) ; 
	  if ( k == nk ) 
	  {
	    if ( nk == maxkerns ) 
	    overflow ( 1081 , maxkerns ) ; 
	    incr ( nk ) ; 
	  } 
	  ligkern [ nl ] .b2 = 128 + ( k / 256 ) ; 
	  ligkern [ nl ] .b3 = ( k % 256 ) ; 
	} 
	lkstarted = true ; 
      } 
      else {
	  
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 1070 ) ; 
	} 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 1071 ; 
	} 
	backerror () ; 
	ligkern [ nl ] .b1 = 0 ; 
	ligkern [ nl ] .b2 = 0 ; 
	ligkern [ nl ] .b3 = 0 ; 
	ligkern [ nl ] .b0 = 129 ; 
      } 
      if ( nl == ligtablesize ) 
      overflow ( 1072 , ligtablesize ) ; 
      incr ( nl ) ; 
      if ( curcmd == 81 ) 
      goto lab22 ; 
      if ( ligkern [ nl - 1 ] .b0 < 128 ) 
      ligkern [ nl - 1 ] .b0 = 128 ; 
      lab30: ; 
    } 
    break ; 
  case 2 : 
    {
      if ( ne == 256 ) 
      overflow ( 1053 , 256 ) ; 
      c = getcode () ; 
      settag ( c , 3 , ne ) ; 
      if ( curcmd != 80 ) 
      {
	missingerr ( 58 ) ; 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 1086 ; 
	} 
	backerror () ; 
      } 
      exten [ ne ] .b0 = getcode () ; 
      if ( curcmd != 81 ) 
      {
	missingerr ( 44 ) ; 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 1086 ; 
	} 
	backerror () ; 
      } 
      exten [ ne ] .b1 = getcode () ; 
      if ( curcmd != 81 ) 
      {
	missingerr ( 44 ) ; 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 1086 ; 
	} 
	backerror () ; 
      } 
      exten [ ne ] .b2 = getcode () ; 
      if ( curcmd != 81 ) 
      {
	missingerr ( 44 ) ; 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 1086 ; 
	} 
	backerror () ; 
      } 
      exten [ ne ] .b3 = getcode () ; 
      incr ( ne ) ; 
    } 
    break ; 
  case 3 : 
  case 4 : 
    {
      c = curmod ; 
      getxnext () ; 
      scanexpression () ; 
      if ( ( curtype != 16 ) || ( curexp < 32768L ) ) 
      {
	disperr ( 0 , 1066 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 1067 ; 
	  helpline [ 0 ] = 1068 ; 
	} 
	putgeterror () ; 
      } 
      else {
	  
	j = roundunscaled ( curexp ) ; 
	if ( curcmd != 80 ) 
	{
	  missingerr ( 58 ) ; 
	  {
	    helpptr = 1 ; 
	    helpline [ 0 ] = 1069 ; 
	  } 
	  backerror () ; 
	} 
	if ( c == 3 ) 
	do {
	    if ( j > headersize ) 
	  overflow ( 1054 , headersize ) ; 
	  headerbyte [ j ] = getcode () ; 
	  incr ( j ) ; 
	} while ( ! ( curcmd != 81 ) ) ; 
	else do {
	    if ( j > maxfontdimen ) 
	  overflow ( 1055 , maxfontdimen ) ; 
	  while ( j > np ) {
	      
	    incr ( np ) ; 
	    param [ np ] = 0 ; 
	  } 
	  getxnext () ; 
	  scanexpression () ; 
	  if ( curtype != 16 ) 
	  {
	    disperr ( 0 , 1087 ) ; 
	    {
	      helpptr = 1 ; 
	      helpline [ 0 ] = 309 ; 
	    } 
	    putgetflusherror ( 0 ) ; 
	  } 
	  param [ j ] = curexp ; 
	  incr ( j ) ; 
	} while ( ! ( curcmd != 81 ) ) ; 
      } 
    } 
    break ; 
  } 
}