#define EXTERN extern
#include "mpd.h"

void zdepdiv ( p , v ) 
halfword p ; 
scaled v ; 
{/* 10 */ halfword q  ; 
  smallnumber s, t  ; 
  if ( p == 0 ) 
  q = curexp ; 
  else if ( mem [ p ] .hhfield .b0 != 16 ) 
  q = p ; 
  else {
      
    mem [ p + 1 ] .cint = makescaled ( mem [ p + 1 ] .cint , v ) ; 
    goto lab10 ; 
  } 
  t = mem [ q ] .hhfield .b0 ; 
  q = mem [ q + 1 ] .hhfield .v.RH ; 
  s = t ; 
  if ( t == 17 ) 
  if ( abvscd ( maxcoef ( q ) , 65536L , 626349396L , abs ( v ) ) >= 0 ) 
  t = 18 ; 
  q = poverv ( q , v , s , t ) ; 
  depfinish ( q , p , t ) ; 
  lab10: ; 
} 
void zsetuptrans ( c ) 
quarterword c ; 
{/* 30 10 */ halfword p, q, r  ; 
  if ( ( c != 107 ) || ( curtype != 12 ) ) 
  {
    p = stashcurexp () ; 
    curexp = idtransform () ; 
    curtype = 12 ; 
    q = mem [ curexp + 1 ] .cint ; 
    switch ( c ) 
    {case 103 : 
      if ( mem [ p ] .hhfield .b0 == 16 ) 
      {
	nsincos ( ( mem [ p + 1 ] .cint % 23592960L ) * 16 ) ; 
	mem [ q + 5 ] .cint = roundfraction ( ncos ) ; 
	mem [ q + 9 ] .cint = roundfraction ( nsin ) ; 
	mem [ q + 7 ] .cint = - (integer) mem [ q + 9 ] .cint ; 
	mem [ q + 11 ] .cint = mem [ q + 5 ] .cint ; 
	goto lab30 ; 
      } 
      break ; 
    case 104 : 
      if ( mem [ p ] .hhfield .b0 > 14 ) 
      {
	install ( q + 6 , p ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 105 : 
      if ( mem [ p ] .hhfield .b0 > 14 ) 
      {
	install ( q + 4 , p ) ; 
	install ( q + 10 , p ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 106 : 
      if ( mem [ p ] .hhfield .b0 == 14 ) 
      {
	r = mem [ p + 1 ] .cint ; 
	install ( q , r ) ; 
	install ( q + 2 , r + 2 ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 108 : 
      if ( mem [ p ] .hhfield .b0 > 14 ) 
      {
	install ( q + 4 , p ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 109 : 
      if ( mem [ p ] .hhfield .b0 > 14 ) 
      {
	install ( q + 10 , p ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 110 : 
      if ( mem [ p ] .hhfield .b0 == 14 ) 
      {
	r = mem [ p + 1 ] .cint ; 
	install ( q + 4 , r ) ; 
	install ( q + 10 , r ) ; 
	install ( q + 8 , r + 2 ) ; 
	if ( mem [ r + 2 ] .hhfield .b0 == 16 ) 
	mem [ r + 3 ] .cint = - (integer) mem [ r + 3 ] .cint ; 
	else negatedeplist ( mem [ r + 3 ] .hhfield .v.RH ) ; 
	install ( q + 6 , r + 2 ) ; 
	goto lab30 ; 
      } 
      break ; 
    case 107 : 
      ; 
      break ; 
    } 
    disperr ( p , 910 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 911 ; 
      helpline [ 1 ] = 912 ; 
      helpline [ 0 ] = 913 ; 
    } 
    putgeterror () ; 
    lab30: recyclevalue ( p ) ; 
    freenode ( p , 2 ) ; 
  } 
  q = mem [ curexp + 1 ] .cint ; 
  r = q + 12 ; 
  do {
      r = r - 2 ; 
    if ( mem [ r ] .hhfield .b0 != 16 ) 
    goto lab10 ; 
  } while ( ! ( r == q ) ) ; 
  txx = mem [ q + 5 ] .cint ; 
  txy = mem [ q + 7 ] .cint ; 
  tyx = mem [ q + 9 ] .cint ; 
  tyy = mem [ q + 11 ] .cint ; 
  tx = mem [ q + 1 ] .cint ; 
  ty = mem [ q + 3 ] .cint ; 
  flushcurexp ( 0 ) ; 
  lab10: ; 
} 
void zsetupknowntrans ( c ) 
quarterword c ; 
{setuptrans ( c ) ; 
  if ( curtype != 16 ) 
  {
    disperr ( 0 , 914 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 915 ; 
      helpline [ 1 ] = 916 ; 
      helpline [ 0 ] = 913 ; 
    } 
    putgetflusherror ( 0 ) ; 
    txx = 65536L ; 
    txy = 0 ; 
    tyx = 0 ; 
    tyy = 65536L ; 
    tx = 0 ; 
    ty = 0 ; 
  } 
} 
void ztrans ( p , q ) 
halfword p ; 
halfword q ; 
{scaled v  ; 
  v = takescaled ( mem [ p ] .cint , txx ) + takescaled ( mem [ q ] .cint ,  txy ) + tx ; 
  mem [ q ] .cint = takescaled ( mem [ p ] .cint , tyx ) + takescaled ( mem [ 
  q ] .cint , tyy ) + ty ; 
  mem [ p ] .cint = v ; 
} 
void zdopathtrans ( p ) 
halfword p ; 
{/* 10 */ halfword q  ; 
  q = p ; 
  do {
      if ( mem [ q ] .hhfield .b0 != 0 ) 
    trans ( q + 3 , q + 4 ) ; 
    trans ( q + 1 , q + 2 ) ; 
    if ( mem [ q ] .hhfield .b1 != 0 ) 
    trans ( q + 5 , q + 6 ) ; 
    q = mem [ q ] .hhfield .v.RH ; 
  } while ( ! ( q == p ) ) ; 
  lab10: ; 
} 
void zdopentrans ( p ) 
halfword p ; 
{/* 10 */ halfword q  ; 
  if ( ( p == mem [ p ] .hhfield .v.RH ) ) 
  {
    trans ( p + 3 , p + 4 ) ; 
    trans ( p + 5 , p + 6 ) ; 
  } 
  q = p ; 
  do {
      trans ( q + 1 , q + 2 ) ; 
    q = mem [ q ] .hhfield .v.RH ; 
  } while ( ! ( q == p ) ) ; 
  lab10: ; 
} 
void zedgestrans ( p , c ) 
halfword p ; 
quarterword c ; 
{/* 31 */ halfword h  ; 
  halfword q  ; 
  halfword r, s  ; 
  scaled sx, sy  ; 
  scaled v  ; 
  setupknowntrans ( c ) ; 
  h = privateedges ( mem [ p + 1 ] .cint ) ; 
  mem [ p + 1 ] .cint = h ; 
  if ( mem [ h ] .hhfield .v.RH != 2 ) 
  if ( ( txy != 0 ) || ( tyx != 0 ) || ( ty != 0 ) || ( abs ( txx ) != abs ( 
  tyy ) ) ) 
  flushdashlist ( h ) ; 
  else {
      
    if ( txx < 0 ) 
    {
      r = mem [ h ] .hhfield .v.RH ; 
      mem [ h ] .hhfield .v.RH = 2 ; 
      while ( r != 2 ) {
	  
	s = r ; 
	r = mem [ r ] .hhfield .v.RH ; 
	v = mem [ s + 1 ] .cint ; 
	mem [ s + 1 ] .cint = mem [ s + 2 ] .cint ; 
	mem [ s + 2 ] .cint = v ; 
	mem [ s ] .hhfield .v.RH = mem [ h ] .hhfield .v.RH ; 
	mem [ h ] .hhfield .v.RH = s ; 
      } 
    } 
    r = mem [ h ] .hhfield .v.RH ; 
    while ( r != 2 ) {
	
      mem [ r + 1 ] .cint = takescaled ( mem [ r + 1 ] .cint , txx ) + tx ; 
      mem [ r + 2 ] .cint = takescaled ( mem [ r + 2 ] .cint , txx ) + tx ; 
      r = mem [ r ] .hhfield .v.RH ; 
    } 
    mem [ h + 1 ] .cint = takescaled ( mem [ h + 1 ] .cint , abs ( tyy ) ) ; 
  } 
  if ( ( txx == 0 ) && ( tyy == 0 ) ) 
  {
    v = mem [ h + 2 ] .cint ; 
    mem [ h + 2 ] .cint = mem [ h + 3 ] .cint ; 
    mem [ h + 3 ] .cint = v ; 
    v = mem [ h + 4 ] .cint ; 
    mem [ h + 4 ] .cint = mem [ h + 5 ] .cint ; 
    mem [ h + 5 ] .cint = v ; 
  } 
  else if ( ( txy != 0 ) || ( tyx != 0 ) ) 
  {
    initbbox ( h ) ; 
    goto lab31 ; 
  } 
  if ( mem [ h + 2 ] .cint <= mem [ h + 4 ] .cint ) 
  {
    mem [ h + 2 ] .cint = takescaled ( mem [ h + 2 ] .cint , txx + txy ) + tx 
    ; 
    mem [ h + 4 ] .cint = takescaled ( mem [ h + 4 ] .cint , txx + txy ) + tx 
    ; 
    mem [ h + 3 ] .cint = takescaled ( mem [ h + 3 ] .cint , tyx + tyy ) + ty 
    ; 
    mem [ h + 5 ] .cint = takescaled ( mem [ h + 5 ] .cint , tyx + tyy ) + ty 
    ; 
    if ( txx + txy < 0 ) 
    {
      v = mem [ h + 2 ] .cint ; 
      mem [ h + 2 ] .cint = mem [ h + 4 ] .cint ; 
      mem [ h + 4 ] .cint = v ; 
    } 
    if ( tyx + tyy < 0 ) 
    {
      v = mem [ h + 3 ] .cint ; 
      mem [ h + 3 ] .cint = mem [ h + 5 ] .cint ; 
      mem [ h + 5 ] .cint = v ; 
    } 
  } 
  lab31: ; 
  q = mem [ h + 7 ] .hhfield .v.RH ; 
  while ( q != 0 ) {
      
    switch ( mem [ q ] .hhfield .b0 ) 
    {case 1 : 
    case 2 : 
      {
	dopathtrans ( mem [ q + 1 ] .hhfield .v.RH ) ; 
	if ( mem [ q + 1 ] .hhfield .lhfield != 0 ) 
	{
	  sx = tx ; 
	  sy = ty ; 
	  tx = 0 ; 
	  ty = 0 ; 
	  dopentrans ( mem [ q + 1 ] .hhfield .lhfield ) ; 
	  tx = sx ; 
	  ty = sy ; 
	} 
      } 
      break ; 
    case 4 : 
    case 5 : 
      dopathtrans ( mem [ q + 1 ] .hhfield .v.RH ) ; 
      break ; 
    case 3 : 
      {
	r = q + 8 ; 
	trans ( r , r + 1 ) ; 
	sx = tx ; 
	sy = ty ; 
	tx = 0 ; 
	ty = 0 ; 
	trans ( r + 2 , r + 4 ) ; 
	trans ( r + 3 , r + 5 ) ; 
	tx = sx ; 
	ty = sy ; 
      } 
      break ; 
    case 6 : 
    case 7 : 
      ; 
      break ; 
    } 
    q = mem [ q ] .hhfield .v.RH ; 
  } 
  unstashcurexp ( p ) ; 
} 
void zbilin1 ( p , t , q , u , delta ) 
halfword p ; 
scaled t ; 
halfword q ; 
scaled u ; 
scaled delta ; 
{halfword r  ; 
  if ( t != 65536L ) 
  depmult ( p , t , true ) ; 
  if ( u != 0 ) 
  if ( mem [ q ] .hhfield .b0 == 16 ) 
  delta = delta + takescaled ( mem [ q + 1 ] .cint , u ) ; 
  else {
      
    if ( mem [ p ] .hhfield .b0 != 18 ) 
    {
      if ( mem [ p ] .hhfield .b0 == 16 ) 
      newdep ( p , constdependency ( mem [ p + 1 ] .cint ) ) ; 
      else mem [ p + 1 ] .hhfield .v.RH = ptimesv ( mem [ p + 1 ] .hhfield .v.RH , 65536L , 17 , 18 , true ) ; 
      mem [ p ] .hhfield .b0 = 18 ; 
    } 
    mem [ p + 1 ] .hhfield .v.RH = pplusfq ( mem [ p + 1 ] .hhfield .v.RH , u 
    , mem [ q + 1 ] .hhfield .v.RH , 18 , mem [ q ] .hhfield .b0 ) ; 
  } 
  if ( mem [ p ] .hhfield .b0 == 16 ) 
  mem [ p + 1 ] .cint = mem [ p + 1 ] .cint + delta ; 
  else {
      
    r = mem [ p + 1 ] .hhfield .v.RH ; 
    while ( mem [ r ] .hhfield .lhfield != 0 ) r = mem [ r ] .hhfield .v.RH ; 
    delta = mem [ r + 1 ] .cint + delta ; 
    if ( r != mem [ p + 1 ] .hhfield .v.RH ) 
    mem [ r + 1 ] .cint = delta ; 
    else {
	
      recyclevalue ( p ) ; 
      mem [ p ] .hhfield .b0 = 16 ; 
      mem [ p + 1 ] .cint = delta ; 
    } 
  } 
  if ( fixneeded ) 
  fixdependencies () ; 
} 
void zaddmultdep ( p , v , r ) 
halfword p ; 
scaled v ; 
halfword r ; 
{if ( mem [ r ] .hhfield .b0 == 16 ) 
  mem [ depfinal + 1 ] .cint = mem [ depfinal + 1 ] .cint + takescaled ( mem [ 
  r + 1 ] .cint , v ) ; 
  else {
      
    mem [ p + 1 ] .hhfield .v.RH = pplusfq ( mem [ p + 1 ] .hhfield .v.RH , v 
    , mem [ r + 1 ] .hhfield .v.RH , 18 , mem [ r ] .hhfield .b0 ) ; 
    if ( fixneeded ) 
    fixdependencies () ; 
  } 
} 
void zbilin2 ( p , t , v , u , q ) 
halfword p ; 
halfword t ; 
scaled v ; 
halfword u ; 
halfword q ; 
{scaled vv  ; 
  vv = mem [ p + 1 ] .cint ; 
  mem [ p ] .hhfield .b0 = 18 ; 
  newdep ( p , constdependency ( 0 ) ) ; 
  if ( vv != 0 ) 
  addmultdep ( p , vv , t ) ; 
  if ( v != 0 ) 
  addmultdep ( p , v , u ) ; 
  if ( q != 0 ) 
  addmultdep ( p , 65536L , q ) ; 
  if ( mem [ p + 1 ] .hhfield .v.RH == depfinal ) 
  {
    vv = mem [ depfinal + 1 ] .cint ; 
    recyclevalue ( p ) ; 
    mem [ p ] .hhfield .b0 = 16 ; 
    mem [ p + 1 ] .cint = vv ; 
  } 
} 
void zbilin3 ( p , t , v , u , delta ) 
halfword p ; 
scaled t ; 
scaled v ; 
scaled u ; 
scaled delta ; 
{if ( t != 65536L ) 
  delta = delta + takescaled ( mem [ p + 1 ] .cint , t ) ; 
  else delta = delta + mem [ p + 1 ] .cint ; 
  if ( u != 0 ) 
  mem [ p + 1 ] .cint = delta + takescaled ( v , u ) ; 
  else mem [ p + 1 ] .cint = delta ; 
} 
void zbigtrans ( p , c ) 
halfword p ; 
quarterword c ; 
{/* 10 */ halfword q, r, pp, qq  ; 
  smallnumber s  ; 
  s = bignodesize [ mem [ p ] .hhfield .b0 ] ; 
  q = mem [ p + 1 ] .cint ; 
  r = q + s ; 
  do {
      r = r - 2 ; 
    if ( mem [ r ] .hhfield .b0 != 16 ) 
    {
      setupknowntrans ( c ) ; 
      makeexpcopy ( p ) ; 
      r = mem [ curexp + 1 ] .cint ; 
      if ( curtype == 12 ) 
      {
	bilin1 ( r + 10 , tyy , q + 6 , tyx , 0 ) ; 
	bilin1 ( r + 8 , tyy , q + 4 , tyx , 0 ) ; 
	bilin1 ( r + 6 , txx , q + 10 , txy , 0 ) ; 
	bilin1 ( r + 4 , txx , q + 8 , txy , 0 ) ; 
      } 
      bilin1 ( r + 2 , tyy , q , tyx , ty ) ; 
      bilin1 ( r , txx , q + 2 , txy , tx ) ; 
      goto lab10 ; 
    } 
  } while ( ! ( r == q ) ) ; 
  setuptrans ( c ) ; 
  if ( curtype == 16 ) 
  {
    makeexpcopy ( p ) ; 
    r = mem [ curexp + 1 ] .cint ; 
    if ( curtype == 12 ) 
    {
      bilin3 ( r + 10 , tyy , mem [ q + 7 ] .cint , tyx , 0 ) ; 
      bilin3 ( r + 8 , tyy , mem [ q + 5 ] .cint , tyx , 0 ) ; 
      bilin3 ( r + 6 , txx , mem [ q + 11 ] .cint , txy , 0 ) ; 
      bilin3 ( r + 4 , txx , mem [ q + 9 ] .cint , txy , 0 ) ; 
    } 
    bilin3 ( r + 2 , tyy , mem [ q + 1 ] .cint , tyx , ty ) ; 
    bilin3 ( r , txx , mem [ q + 3 ] .cint , txy , tx ) ; 
  } 
  else {
      
    pp = stashcurexp () ; 
    qq = mem [ pp + 1 ] .cint ; 
    makeexpcopy ( p ) ; 
    r = mem [ curexp + 1 ] .cint ; 
    if ( curtype == 12 ) 
    {
      bilin2 ( r + 10 , qq + 10 , mem [ q + 7 ] .cint , qq + 8 , 0 ) ; 
      bilin2 ( r + 8 , qq + 10 , mem [ q + 5 ] .cint , qq + 8 , 0 ) ; 
      bilin2 ( r + 6 , qq + 4 , mem [ q + 11 ] .cint , qq + 6 , 0 ) ; 
      bilin2 ( r + 4 , qq + 4 , mem [ q + 9 ] .cint , qq + 6 , 0 ) ; 
    } 
    bilin2 ( r + 2 , qq + 10 , mem [ q + 1 ] .cint , qq + 8 , qq + 2 ) ; 
    bilin2 ( r , qq + 4 , mem [ q + 3 ] .cint , qq + 6 , qq ) ; 
    recyclevalue ( pp ) ; 
    freenode ( pp , 2 ) ; 
  } 
  lab10: ; 
} 
void zcat ( p ) 
halfword p ; 
{strnumber a, b  ; 
  poolpointer k  ; 
  a = mem [ p + 1 ] .cint ; 
  b = curexp ; 
  {
    if ( poolptr + ( strstart [ nextstr [ a ] ] - strstart [ a ] ) + ( 
    strstart [ nextstr [ b ] ] - strstart [ b ] ) > maxpoolptr ) 
    if ( poolptr + ( strstart [ nextstr [ a ] ] - strstart [ a ] ) + ( 
    strstart [ nextstr [ b ] ] - strstart [ b ] ) > poolsize ) 
    docompaction ( ( strstart [ nextstr [ a ] ] - strstart [ a ] ) + ( 
    strstart [ nextstr [ b ] ] - strstart [ b ] ) ) ; 
    else maxpoolptr = poolptr + ( strstart [ nextstr [ a ] ] - strstart [ a ] 
    ) + ( strstart [ nextstr [ b ] ] - strstart [ b ] ) ; 
  } 
  {register integer for_end; k = strstart [ a ] ; for_end = strstart [ 
  nextstr [ a ] ] - 1 ; if ( k <= for_end) do 
    {
      strpool [ poolptr ] = strpool [ k ] ; 
      incr ( poolptr ) ; 
    } 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = strstart [ b ] ; for_end = strstart [ 
  nextstr [ b ] ] - 1 ; if ( k <= for_end) do 
    {
      strpool [ poolptr ] = strpool [ k ] ; 
      incr ( poolptr ) ; 
    } 
  while ( k++ < for_end ) ; } 
  curexp = makestring () ; 
  {
    if ( strref [ b ] < 127 ) 
    if ( strref [ b ] > 1 ) 
    decr ( strref [ b ] ) ; 
    else flushstring ( b ) ; 
  } 
} 
void zchopstring ( p ) 
halfword p ; 
{integer a, b  ; 
  integer l  ; 
  integer k  ; 
  strnumber s  ; 
  boolean reversed  ; 
  a = roundunscaled ( mem [ p + 1 ] .cint ) ; 
  b = roundunscaled ( mem [ p + 3 ] .cint ) ; 
  if ( a <= b ) 
  reversed = false ; 
  else {
      
    reversed = true ; 
    k = a ; 
    a = b ; 
    b = k ; 
  } 
  s = curexp ; 
  l = ( strstart [ nextstr [ s ] ] - strstart [ s ] ) ; 
  if ( a < 0 ) 
  {
    a = 0 ; 
    if ( b < 0 ) 
    b = 0 ; 
  } 
  if ( b > l ) 
  {
    b = l ; 
    if ( a > l ) 
    a = l ; 
  } 
  {
    if ( poolptr + b - a > maxpoolptr ) 
    if ( poolptr + b - a > poolsize ) 
    docompaction ( b - a ) ; 
    else maxpoolptr = poolptr + b - a ; 
  } 
  if ( reversed ) 
  {register integer for_end; k = strstart [ s ] + b - 1 ; for_end = strstart 
  [ s ] + a ; if ( k >= for_end) do 
    {
      strpool [ poolptr ] = strpool [ k ] ; 
      incr ( poolptr ) ; 
    } 
  while ( k-- > for_end ) ; } 
  else {
      register integer for_end; k = strstart [ s ] + a ; for_end = strstart 
  [ s ] + b - 1 ; if ( k <= for_end) do 
    {
      strpool [ poolptr ] = strpool [ k ] ; 
      incr ( poolptr ) ; 
    } 
  while ( k++ < for_end ) ; } 
  curexp = makestring () ; 
  {
    if ( strref [ s ] < 127 ) 
    if ( strref [ s ] > 1 ) 
    decr ( strref [ s ] ) ; 
    else flushstring ( s ) ; 
  } 
} 
void zchoppath ( p ) 
halfword p ; 
{halfword q  ; 
  halfword pp, qq, rr, ss  ; 
  scaled a, b, k, l  ; 
  boolean reversed  ; 
  l = pathlength () ; 
  a = mem [ p + 1 ] .cint ; 
  b = mem [ p + 3 ] .cint ; 
  if ( a <= b ) 
  reversed = false ; 
  else {
      
    reversed = true ; 
    k = a ; 
    a = b ; 
    b = k ; 
  } 
  if ( a < 0 ) 
  if ( mem [ curexp ] .hhfield .b0 == 0 ) 
  {
    a = 0 ; 
    if ( b < 0 ) 
    b = 0 ; 
  } 
  else do {
      a = a + l ; 
    b = b + l ; 
  } while ( ! ( a >= 0 ) ) ; 
  if ( b > l ) 
  if ( mem [ curexp ] .hhfield .b0 == 0 ) 
  {
    b = l ; 
    if ( a > l ) 
    a = l ; 
  } 
  else while ( a >= l ) {
      
    a = a - l ; 
    b = b - l ; 
  } 
  q = curexp ; 
  while ( a >= 65536L ) {
      
    q = mem [ q ] .hhfield .v.RH ; 
    a = a - 65536L ; 
    b = b - 65536L ; 
  } 
  if ( b == a ) 
  {
    if ( a > 0 ) 
    {
      splitcubic ( q , a * 4096 ) ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
    pp = copyknot ( q ) ; 
    qq = pp ; 
  } 
  else {
      
    pp = copyknot ( q ) ; 
    qq = pp ; 
    do {
	q = mem [ q ] .hhfield .v.RH ; 
      rr = qq ; 
      qq = copyknot ( q ) ; 
      mem [ rr ] .hhfield .v.RH = qq ; 
      b = b - 65536L ; 
    } while ( ! ( b <= 0 ) ) ; 
    if ( a > 0 ) 
    {
      ss = pp ; 
      pp = mem [ pp ] .hhfield .v.RH ; 
      splitcubic ( ss , a * 4096 ) ; 
      pp = mem [ ss ] .hhfield .v.RH ; 
      freenode ( ss , 7 ) ; 
      if ( rr == ss ) 
      {
	b = makescaled ( b , 65536L - a ) ; 
	rr = pp ; 
      } 
    } 
    if ( b < 0 ) 
    {
      splitcubic ( rr , ( b + 65536L ) * 4096 ) ; 
      freenode ( qq , 7 ) ; 
      qq = mem [ rr ] .hhfield .v.RH ; 
    } 
  } 
  mem [ pp ] .hhfield .b0 = 0 ; 
  mem [ qq ] .hhfield .b1 = 0 ; 
  mem [ qq ] .hhfield .v.RH = pp ; 
  tossknotlist ( curexp ) ; 
  if ( reversed ) 
  {
    curexp = mem [ htapypoc ( pp ) ] .hhfield .v.RH ; 
    tossknotlist ( pp ) ; 
  } 
  else curexp = pp ; 
} 
void zsetupoffset ( p ) 
halfword p ; 
{findoffset ( mem [ p + 1 ] .cint , mem [ p + 3 ] .cint , curexp ) ; 
  pairvalue ( curx , cury ) ; 
} 
void zsetupdirectiontime ( p ) 
halfword p ; 
{flushcurexp ( finddirectiontime ( mem [ p + 1 ] .cint , mem [ p + 3 ] .cint 
  , curexp ) ) ; 
} 
void zfindpoint ( v , c ) 
scaled v ; 
quarterword c ; 
{halfword p  ; 
  scaled n  ; 
  p = curexp ; 
  if ( mem [ p ] .hhfield .b0 == 0 ) 
  n = -65536L ; 
  else n = 0 ; 
  do {
      p = mem [ p ] .hhfield .v.RH ; 
    n = n + 65536L ; 
  } while ( ! ( p == curexp ) ) ; 
  if ( n == 0 ) 
  v = 0 ; 
  else if ( v < 0 ) 
  if ( mem [ p ] .hhfield .b0 == 0 ) 
  v = 0 ; 
  else v = n - 1 - ( ( - (integer) v - 1 ) % n ) ; 
  else if ( v > n ) 
  if ( mem [ p ] .hhfield .b0 == 0 ) 
  v = n ; 
  else v = v % n ; 
  p = curexp ; 
  while ( v >= 65536L ) {
      
    p = mem [ p ] .hhfield .v.RH ; 
    v = v - 65536L ; 
  } 
  if ( v != 0 ) 
  {
    splitcubic ( p , v * 4096 ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  switch ( c ) 
  {case 117 : 
    pairvalue ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
    break ; 
  case 118 : 
    if ( mem [ p ] .hhfield .b0 == 0 ) 
    pairvalue ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
    else pairvalue ( mem [ p + 3 ] .cint , mem [ p + 4 ] .cint ) ; 
    break ; 
  case 119 : 
    if ( mem [ p ] .hhfield .b1 == 0 ) 
    pairvalue ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
    else pairvalue ( mem [ p + 5 ] .cint , mem [ p + 6 ] .cint ) ; 
    break ; 
  } 
} 
void zdoinfont ( p ) 
halfword p ; 
{halfword q  ; 
  q = getnode ( 8 ) ; 
  initedges ( q ) ; 
  mem [ mem [ q + 7 ] .hhfield .lhfield ] .hhfield .v.RH = newtextnode ( 
  curexp , mem [ p + 1 ] .cint ) ; 
  mem [ q + 7 ] .hhfield .lhfield = mem [ mem [ q + 7 ] .hhfield .lhfield ] .hhfield .v.RH ; 
  freenode ( p , 2 ) ; 
  flushcurexp ( q ) ; 
  curtype = 10 ; 
} 
void zdobinary ( p , c ) 
halfword p ; 
quarterword c ; 
{/* 30 31 10 */ halfword q, r, rr  ; 
  halfword oldp, oldexp  ; 
  integer v  ; 
  {
    if ( aritherror ) 
    cleararith () ; 
  } 
  if ( internal [ 6 ] > 131072L ) 
  {
    begindiagnostic () ; 
    printnl ( 902 ) ; 
    printexp ( p , 0 ) ; 
    printchar ( 41 ) ; 
    printop ( c ) ; 
    printchar ( 40 ) ; 
    printexp ( 0 , 0 ) ; 
    print ( 891 ) ; 
    enddiagnostic ( false ) ; 
  } 
  switch ( mem [ p ] .hhfield .b0 ) 
  {case 12 : 
  case 13 : 
  case 14 : 
    oldp = tarnished ( p ) ; 
    break ; 
  case 19 : 
    oldp = 1 ; 
    break ; 
    default: 
    oldp = 0 ; 
    break ; 
  } 
  if ( oldp != 0 ) 
  {
    q = stashcurexp () ; 
    oldp = p ; 
    makeexpcopy ( oldp ) ; 
    p = stashcurexp () ; 
    unstashcurexp ( q ) ; 
  } 
  switch ( curtype ) 
  {case 12 : 
  case 13 : 
  case 14 : 
    oldexp = tarnished ( curexp ) ; 
    break ; 
  case 19 : 
    oldexp = 1 ; 
    break ; 
    default: 
    oldexp = 0 ; 
    break ; 
  } 
  if ( oldexp != 0 ) 
  {
    oldexp = curexp ; 
    makeexpcopy ( oldexp ) ; 
  } 
  switch ( c ) 
  {case 88 : 
  case 89 : 
    if ( ( curtype < 13 ) || ( mem [ p ] .hhfield .b0 < 13 ) ) 
    badbinary ( p , c ) ; 
    else if ( ( curtype > 14 ) && ( mem [ p ] .hhfield .b0 > 14 ) ) 
    addorsubtract ( p , 0 , c ) ; 
    else if ( curtype != mem [ p ] .hhfield .b0 ) 
    badbinary ( p , c ) ; 
    else {
	
      q = mem [ p + 1 ] .cint ; 
      r = mem [ curexp + 1 ] .cint ; 
      rr = r + bignodesize [ curtype ] ; 
      while ( r < rr ) {
	  
	addorsubtract ( q , r , c ) ; 
	q = q + 2 ; 
	r = r + 2 ; 
      } 
    } 
    break ; 
  case 96 : 
  case 97 : 
  case 98 : 
  case 99 : 
  case 100 : 
  case 101 : 
    {
      if ( ( curtype > 14 ) && ( mem [ p ] .hhfield .b0 > 14 ) ) 
      addorsubtract ( p , 0 , 89 ) ; 
      else if ( curtype != mem [ p ] .hhfield .b0 ) 
      {
	badbinary ( p , c ) ; 
	goto lab30 ; 
      } 
      else if ( curtype == 4 ) 
      flushcurexp ( strvsstr ( mem [ p + 1 ] .cint , curexp ) ) ; 
      else if ( ( curtype == 5 ) || ( curtype == 3 ) ) 
      {
	q = mem [ curexp + 1 ] .cint ; 
	while ( ( q != curexp ) && ( q != p ) ) q = mem [ q + 1 ] .cint ; 
	if ( q == p ) 
	flushcurexp ( 0 ) ; 
      } 
      else if ( ( curtype <= 14 ) && ( curtype >= 12 ) ) 
      {
	q = mem [ p + 1 ] .cint ; 
	r = mem [ curexp + 1 ] .cint ; 
	rr = r + bignodesize [ curtype ] - 2 ; 
	while ( true ) {
	    
	  addorsubtract ( q , r , 89 ) ; 
	  if ( mem [ r ] .hhfield .b0 != 16 ) 
	  goto lab31 ; 
	  if ( mem [ r + 1 ] .cint != 0 ) 
	  goto lab31 ; 
	  if ( r == rr ) 
	  goto lab31 ; 
	  q = q + 2 ; 
	  r = r + 2 ; 
	} 
	lab31: takepart ( mem [ r ] .hhfield .b1 + 48 ) ; 
      } 
      else if ( curtype == 2 ) 
      flushcurexp ( curexp - mem [ p + 1 ] .cint ) ; 
      else {
	  
	badbinary ( p , c ) ; 
	goto lab30 ; 
      } 
      if ( curtype != 16 ) 
      {
	if ( curtype < 16 ) 
	{
	  disperr ( p , 285 ) ; 
	  {
	    helpptr = 1 ; 
	    helpline [ 0 ] = 903 ; 
	  } 
	} 
	else {
	    
	  helpptr = 2 ; 
	  helpline [ 1 ] = 904 ; 
	  helpline [ 0 ] = 905 ; 
	} 
	disperr ( 0 , 906 ) ; 
	putgetflusherror ( 31 ) ; 
      } 
      else switch ( c ) 
      {case 96 : 
	if ( curexp < 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      case 97 : 
	if ( curexp <= 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      case 98 : 
	if ( curexp > 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      case 99 : 
	if ( curexp >= 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      case 100 : 
	if ( curexp == 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      case 101 : 
	if ( curexp != 0 ) 
	curexp = 30 ; 
	else curexp = 31 ; 
	break ; 
      } 
      curtype = 2 ; 
      lab30: ; 
    } 
    break ; 
  case 95 : 
  case 94 : 
    if ( ( mem [ p ] .hhfield .b0 != 2 ) || ( curtype != 2 ) ) 
    badbinary ( p , c ) ; 
    else if ( mem [ p + 1 ] .cint == c - 64 ) 
    curexp = mem [ p + 1 ] .cint ; 
    break ; 
  case 90 : 
    if ( ( curtype < 13 ) || ( mem [ p ] .hhfield .b0 < 13 ) ) 
    badbinary ( p , 90 ) ; 
    else if ( ( curtype == 16 ) || ( mem [ p ] .hhfield .b0 == 16 ) ) 
    {
      if ( mem [ p ] .hhfield .b0 == 16 ) 
      {
	v = mem [ p + 1 ] .cint ; 
	freenode ( p , 2 ) ; 
      } 
      else {
	  
	v = curexp ; 
	unstashcurexp ( p ) ; 
      } 
      if ( curtype == 16 ) 
      curexp = takescaled ( curexp , v ) ; 
      else if ( ( curtype == 14 ) || ( curtype == 13 ) ) 
      {
	p = mem [ curexp + 1 ] .cint + bignodesize [ curtype ] ; 
	do {
	    p = p - 2 ; 
	  depmult ( p , v , true ) ; 
	} while ( ! ( p == mem [ curexp + 1 ] .cint ) ) ; 
      } 
      else depmult ( 0 , v , true ) ; 
      goto lab10 ; 
    } 
    else if ( ( nicecolororpair ( p , mem [ p ] .hhfield .b0 ) && ( curtype > 
    14 ) ) || ( nicecolororpair ( curexp , curtype ) && ( mem [ p ] .hhfield .b0 > 14 ) ) ) 
    {
      hardtimes ( p ) ; 
      goto lab10 ; 
    } 
    else badbinary ( p , 90 ) ; 
    break ; 
  case 91 : 
    if ( ( curtype != 16 ) || ( mem [ p ] .hhfield .b0 < 13 ) ) 
    badbinary ( p , 91 ) ; 
    else {
	
      v = curexp ; 
      unstashcurexp ( p ) ; 
      if ( v == 0 ) 
      {
	disperr ( 0 , 835 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 908 ; 
	  helpline [ 0 ] = 909 ; 
	} 
	putgeterror () ; 
      } 
      else {
	  
	if ( curtype == 16 ) 
	curexp = makescaled ( curexp , v ) ; 
	else if ( curtype <= 14 ) 
	{
	  p = mem [ curexp + 1 ] .cint + bignodesize [ curtype ] ; 
	  do {
	      p = p - 2 ; 
	    depdiv ( p , v ) ; 
	  } while ( ! ( p == mem [ curexp + 1 ] .cint ) ) ; 
	} 
	else depdiv ( 0 , v ) ; 
      } 
      goto lab10 ; 
    } 
    break ; 
  case 92 : 
  case 93 : 
    if ( ( curtype == 16 ) && ( mem [ p ] .hhfield .b0 == 16 ) ) 
    if ( c == 92 ) 
    curexp = pythadd ( mem [ p + 1 ] .cint , curexp ) ; 
    else curexp = pythsub ( mem [ p + 1 ] .cint , curexp ) ; 
    else badbinary ( p , c ) ; 
    break ; 
  case 103 : 
  case 104 : 
  case 105 : 
  case 106 : 
  case 107 : 
  case 108 : 
  case 109 : 
  case 110 : 
    if ( mem [ p ] .hhfield .b0 == 8 ) 
    {
      {
	setupknowntrans ( c ) ; 
	unstashcurexp ( p ) ; 
	dopathtrans ( curexp ) ; 
      } 
      goto lab10 ; 
    } 
    else if ( mem [ p ] .hhfield .b0 == 6 ) 
    {
      {
	setupknowntrans ( c ) ; 
	unstashcurexp ( p ) ; 
	dopentrans ( curexp ) ; 
      } 
      curexp = convexhull ( curexp ) ; 
      goto lab10 ; 
    } 
    else if ( ( mem [ p ] .hhfield .b0 == 14 ) || ( mem [ p ] .hhfield .b0 == 
    12 ) ) 
    bigtrans ( p , c ) ; 
    else if ( mem [ p ] .hhfield .b0 == 10 ) 
    {
      edgestrans ( p , c ) ; 
      goto lab10 ; 
    } 
    else badbinary ( p , c ) ; 
    break ; 
  case 102 : 
    if ( ( curtype == 4 ) && ( mem [ p ] .hhfield .b0 == 4 ) ) 
    cat ( p ) ; 
    else badbinary ( p , 102 ) ; 
    break ; 
  case 114 : 
    if ( nicepair ( p , mem [ p ] .hhfield .b0 ) && ( curtype == 4 ) ) 
    chopstring ( mem [ p + 1 ] .cint ) ; 
    else badbinary ( p , 114 ) ; 
    break ; 
  case 115 : 
    {
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( nicepair ( p , mem [ p ] .hhfield .b0 ) && ( curtype == 8 ) ) 
      choppath ( mem [ p + 1 ] .cint ) ; 
      else badbinary ( p , 115 ) ; 
    } 
    break ; 
  case 117 : 
  case 118 : 
  case 119 : 
    {
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( ( curtype == 8 ) && ( mem [ p ] .hhfield .b0 == 16 ) ) 
      findpoint ( mem [ p + 1 ] .cint , c ) ; 
      else badbinary ( p , c ) ; 
    } 
    break ; 
  case 120 : 
    if ( ( curtype == 6 ) && nicepair ( p , mem [ p ] .hhfield .b0 ) ) 
    setupoffset ( mem [ p + 1 ] .cint ) ; 
    else badbinary ( p , 120 ) ; 
    break ; 
  case 116 : 
    {
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( ( curtype == 8 ) && nicepair ( p , mem [ p ] .hhfield .b0 ) ) 
      setupdirectiontime ( mem [ p + 1 ] .cint ) ; 
      else badbinary ( p , 116 ) ; 
    } 
    break ; 
  case 121 : 
    {
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( ( curtype == 8 ) && ( mem [ p ] .hhfield .b0 == 16 ) ) 
      flushcurexp ( getarctime ( curexp , mem [ p + 1 ] .cint ) ) ; 
      else badbinary ( p , c ) ; 
    } 
    break ; 
  case 112 : 
    {
      if ( mem [ p ] .hhfield .b0 == 14 ) 
      {
	q = stashcurexp () ; 
	unstashcurexp ( p ) ; 
	pairtopath () ; 
	p = stashcurexp () ; 
	unstashcurexp ( q ) ; 
      } 
      if ( curtype == 14 ) 
      pairtopath () ; 
      if ( ( curtype == 8 ) && ( mem [ p ] .hhfield .b0 == 8 ) ) 
      {
	pathintersection ( mem [ p + 1 ] .cint , curexp ) ; 
	pairvalue ( curt , curtt ) ; 
      } 
      else badbinary ( p , 112 ) ; 
    } 
    break ; 
  case 111 : 
    if ( ( curtype != 4 ) || ( mem [ p ] .hhfield .b0 != 4 ) ) 
    badbinary ( p , 111 ) ; 
    else {
	
      doinfont ( p ) ; 
      goto lab10 ; 
    } 
    break ; 
  } 
  recyclevalue ( p ) ; 
  freenode ( p , 2 ) ; 
  lab10: {
      
    if ( aritherror ) 
    cleararith () ; 
  } 
  if ( oldp != 0 ) 
  {
    recyclevalue ( oldp ) ; 
    freenode ( oldp , 2 ) ; 
  } 
  if ( oldexp != 0 ) 
  {
    recyclevalue ( oldexp ) ; 
    freenode ( oldexp , 2 ) ; 
  } 
} 
void zfracmult ( n , d ) 
scaled n ; 
scaled d ; 
{halfword p  ; 
  halfword oldexp  ; 
  fraction v  ; 
  if ( internal [ 6 ] > 131072L ) 
  {
    begindiagnostic () ; 
    printnl ( 902 ) ; 
    printscaled ( n ) ; 
    printchar ( 47 ) ; 
    printscaled ( d ) ; 
    print ( 907 ) ; 
    printexp ( 0 , 0 ) ; 
    print ( 891 ) ; 
    enddiagnostic ( false ) ; 
  } 
  switch ( curtype ) 
  {case 12 : 
  case 13 : 
  case 14 : 
    oldexp = tarnished ( curexp ) ; 
    break ; 
  case 19 : 
    oldexp = 1 ; 
    break ; 
    default: 
    oldexp = 0 ; 
    break ; 
  } 
  if ( oldexp != 0 ) 
  {
    oldexp = curexp ; 
    makeexpcopy ( oldexp ) ; 
  } 
  v = makefraction ( n , d ) ; 
  if ( curtype == 16 ) 
  curexp = takefraction ( curexp , v ) ; 
  else if ( curtype <= 14 ) 
  {
    p = mem [ curexp + 1 ] .cint + bignodesize [ curtype ] ; 
    do {
	p = p - 2 ; 
      depmult ( p , v , false ) ; 
    } while ( ! ( p == mem [ curexp + 1 ] .cint ) ) ; 
  } 
  else depmult ( 0 , v , false ) ; 
  if ( oldexp != 0 ) 
  {
    recyclevalue ( oldexp ) ; 
    freenode ( oldexp , 2 ) ; 
  } 
} 
void ztryeq ( l , r ) 
halfword l ; 
halfword r ; 
{/* 30 31 */ halfword p  ; 
  char t  ; 
  halfword q  ; 
  halfword pp  ; 
  char tt  ; 
  boolean copied  ; 
  t = mem [ l ] .hhfield .b0 ; 
  if ( t == 16 ) 
  {
    t = 17 ; 
    p = constdependency ( - (integer) mem [ l + 1 ] .cint ) ; 
    q = p ; 
  } 
  else if ( t == 19 ) 
  {
    t = 17 ; 
    p = singledependency ( l ) ; 
    mem [ p + 1 ] .cint = - (integer) mem [ p + 1 ] .cint ; 
    q = depfinal ; 
  } 
  else {
      
    p = mem [ l + 1 ] .hhfield .v.RH ; 
    q = p ; 
    while ( true ) {
	
      mem [ q + 1 ] .cint = - (integer) mem [ q + 1 ] .cint ; 
      if ( mem [ q ] .hhfield .lhfield == 0 ) 
      goto lab30 ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
    lab30: mem [ mem [ l + 1 ] .hhfield .lhfield ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
    mem [ mem [ q ] .hhfield .v.RH + 1 ] .hhfield .lhfield = mem [ l + 1 ] .hhfield .lhfield ; 
    mem [ l ] .hhfield .b0 = 16 ; 
  } 
  if ( r == 0 ) 
  if ( curtype == 16 ) 
  {
    mem [ q + 1 ] .cint = mem [ q + 1 ] .cint + curexp ; 
    goto lab31 ; 
  } 
  else {
      
    tt = curtype ; 
    if ( tt == 19 ) 
    pp = singledependency ( curexp ) ; 
    else pp = mem [ curexp + 1 ] .hhfield .v.RH ; 
  } 
  else if ( mem [ r ] .hhfield .b0 == 16 ) 
  {
    mem [ q + 1 ] .cint = mem [ q + 1 ] .cint + mem [ r + 1 ] .cint ; 
    goto lab31 ; 
  } 
  else {
      
    tt = mem [ r ] .hhfield .b0 ; 
    if ( tt == 19 ) 
    pp = singledependency ( r ) ; 
    else pp = mem [ r + 1 ] .hhfield .v.RH ; 
  } 
  if ( tt != 19 ) 
  copied = false ; 
  else {
      
    copied = true ; 
    tt = 17 ; 
  } 
  watchcoefs = false ; 
  if ( t == tt ) 
  p = pplusq ( p , pp , t ) ; 
  else if ( t == 18 ) 
  p = pplusfq ( p , 65536L , pp , 18 , 17 ) ; 
  else {
      
    q = p ; 
    while ( mem [ q ] .hhfield .lhfield != 0 ) {
	
      mem [ q + 1 ] .cint = roundfraction ( mem [ q + 1 ] .cint ) ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
    t = 18 ; 
    p = pplusq ( p , pp , t ) ; 
  } 
  watchcoefs = true ; 
  if ( copied ) 
  flushnodelist ( pp ) ; 
  lab31: ; 
  if ( mem [ p ] .hhfield .lhfield == 0 ) 
  {
    if ( abs ( mem [ p + 1 ] .cint ) > 64 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 945 ) ; 
      } 
      print ( 947 ) ; 
      printscaled ( mem [ p + 1 ] .cint ) ; 
      printchar ( 41 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 946 ; 
	helpline [ 0 ] = 944 ; 
      } 
      putgeterror () ; 
    } 
    else if ( r == 0 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 611 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 612 ; 
	helpline [ 0 ] = 613 ; 
      } 
      putgeterror () ; 
    } 
    freenode ( p , 2 ) ; 
  } 
  else {
      
    lineareq ( p , t ) ; 
    if ( r == 0 ) 
    if ( curtype != 16 ) 
    if ( mem [ curexp ] .hhfield .b0 == 16 ) 
    {
      pp = curexp ; 
      curexp = mem [ curexp + 1 ] .cint ; 
      curtype = 16 ; 
      freenode ( pp , 2 ) ; 
    } 
  } 
} 
void zmakeeq ( lhs ) 
halfword lhs ; 
{/* 20 30 45 */ smallnumber t  ; 
  integer v  ; 
  halfword p, q  ; 
  lab20: t = mem [ lhs ] .hhfield .b0 ; 
  if ( t <= 14 ) 
  v = mem [ lhs + 1 ] .cint ; 
  switch ( t ) 
  {case 2 : 
  case 4 : 
  case 6 : 
  case 8 : 
  case 10 : 
    if ( curtype == t + 1 ) 
    {
      nonlineareq ( v , curexp , false ) ; 
      goto lab30 ; 
    } 
    else if ( curtype == t ) 
    {
      if ( curtype <= 4 ) 
      {
	if ( curtype == 4 ) 
	{
	  if ( strvsstr ( v , curexp ) != 0 ) 
	  goto lab45 ; 
	} 
	else if ( v != curexp ) 
	goto lab45 ; 
	{
	  {
	    if ( interaction == 3 ) 
	    ; 
	    printnl ( 263 ) ; 
	    print ( 611 ) ; 
	  } 
	  {
	    helpptr = 2 ; 
	    helpline [ 1 ] = 612 ; 
	    helpline [ 0 ] = 613 ; 
	  } 
	  putgeterror () ; 
	} 
	goto lab30 ; 
      } 
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 942 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 943 ; 
	helpline [ 0 ] = 944 ; 
      } 
      putgeterror () ; 
      goto lab30 ; 
      lab45: {
	  
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 945 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 946 ; 
	helpline [ 0 ] = 944 ; 
      } 
      putgeterror () ; 
      goto lab30 ; 
    } 
    break ; 
  case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
    if ( curtype == t - 1 ) 
    {
      nonlineareq ( curexp , lhs , true ) ; 
      goto lab30 ; 
    } 
    else if ( curtype == t ) 
    {
      ringmerge ( lhs , curexp ) ; 
      goto lab30 ; 
    } 
    else if ( curtype == 14 ) 
    if ( t == 9 ) 
    {
      pairtopath () ; 
      goto lab20 ; 
    } 
    break ; 
  case 12 : 
  case 13 : 
  case 14 : 
    if ( curtype == t ) 
    {
      p = v + bignodesize [ t ] ; 
      q = mem [ curexp + 1 ] .cint + bignodesize [ t ] ; 
      do {
	  p = p - 2 ; 
	q = q - 2 ; 
	tryeq ( p , q ) ; 
      } while ( ! ( p == v ) ) ; 
      goto lab30 ; 
    } 
    break ; 
  case 16 : 
  case 17 : 
  case 18 : 
  case 19 : 
    if ( curtype >= 16 ) 
    {
      tryeq ( lhs , 0 ) ; 
      goto lab30 ; 
    } 
    break ; 
  case 1 : 
    ; 
    break ; 
  } 
  disperr ( lhs , 285 ) ; 
  disperr ( 0 , 939 ) ; 
  if ( mem [ lhs ] .hhfield .b0 <= 14 ) 
  printtype ( mem [ lhs ] .hhfield .b0 ) ; 
  else print ( 341 ) ; 
  printchar ( 61 ) ; 
  if ( curtype <= 14 ) 
  printtype ( curtype ) ; 
  else print ( 341 ) ; 
  printchar ( 41 ) ; 
  {
    helpptr = 2 ; 
    helpline [ 1 ] = 940 ; 
    helpline [ 0 ] = 941 ; 
  } 
  putgeterror () ; 
  lab30: {
      
    if ( aritherror ) 
    cleararith () ; 
  } 
  recyclevalue ( lhs ) ; 
  freenode ( lhs , 2 ) ; 
} 
void doequation ( ) 
{halfword lhs  ; 
  halfword p  ; 
  lhs = stashcurexp () ; 
  getxnext () ; 
  varflag = 76 ; 
  scanexpression () ; 
  if ( curcmd == 53 ) 
  doequation () ; 
  else if ( curcmd == 76 ) 
  doassignment () ; 
  if ( internal [ 6 ] > 131072L ) 
  {
    begindiagnostic () ; 
    printnl ( 902 ) ; 
    printexp ( lhs , 0 ) ; 
    print ( 934 ) ; 
    printexp ( 0 , 0 ) ; 
    print ( 891 ) ; 
    enddiagnostic ( false ) ; 
  } 
  if ( curtype == 9 ) 
  if ( mem [ lhs ] .hhfield .b0 == 14 ) 
  {
    p = stashcurexp () ; 
    unstashcurexp ( lhs ) ; 
    lhs = p ; 
  } 
  makeeq ( lhs ) ; 
} 
void doassignment ( ) 
{halfword lhs  ; 
  halfword p  ; 
  halfword q  ; 
  if ( curtype != 20 ) 
  {
    disperr ( 0 , 931 ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 932 ; 
      helpline [ 0 ] = 933 ; 
    } 
    error () ; 
    doequation () ; 
  } 
  else {
      
    lhs = curexp ; 
    curtype = 1 ; 
    getxnext () ; 
    varflag = 76 ; 
    scanexpression () ; 
    if ( curcmd == 53 ) 
    doequation () ; 
    else if ( curcmd == 76 ) 
    doassignment () ; 
    if ( internal [ 6 ] > 131072L ) 
    {
      begindiagnostic () ; 
      printnl ( 123 ) ; 
      if ( mem [ lhs ] .hhfield .lhfield > 2371 ) 
      print ( intname [ mem [ lhs ] .hhfield .lhfield - ( 2371 ) ] ) ; 
      else showtokenlist ( lhs , 0 , 1000 , 0 ) ; 
      print ( 476 ) ; 
      printexp ( 0 , 0 ) ; 
      printchar ( 125 ) ; 
      enddiagnostic ( false ) ; 
    } 
    if ( mem [ lhs ] .hhfield .lhfield > 2371 ) 
    if ( curtype == 16 ) 
    internal [ mem [ lhs ] .hhfield .lhfield - ( 2371 ) ] = curexp ; 
    else {
	
      disperr ( 0 , 935 ) ; 
      print ( intname [ mem [ lhs ] .hhfield .lhfield - ( 2371 ) ] ) ; 
      print ( 936 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 937 ; 
	helpline [ 0 ] = 938 ; 
      } 
      putgeterror () ; 
    } 
    else {
	
      p = findvariable ( lhs ) ; 
      if ( p != 0 ) 
      {
	q = stashcurexp () ; 
	curtype = undtype ( p ) ; 
	recyclevalue ( p ) ; 
	mem [ p ] .hhfield .b0 = curtype ; 
	mem [ p + 1 ] .cint = 0 ; 
	makeexpcopy ( p ) ; 
	p = stashcurexp () ; 
	unstashcurexp ( q ) ; 
	makeeq ( p ) ; 
      } 
      else {
	  
	obliterated ( lhs ) ; 
	putgeterror () ; 
      } 
    } 
    flushnodelist ( lhs ) ; 
  } 
} 
void dotypedeclaration ( ) 
{smallnumber t  ; 
  halfword p  ; 
  halfword q  ; 
  if ( curmod >= 12 ) 
  t = curmod ; 
  else t = curmod + 1 ; 
  do {
      p = scandeclaredvariable () ; 
    flushvariable ( eqtb [ mem [ p ] .hhfield .lhfield ] .v.RH , mem [ p ] .hhfield .v.RH , false ) ; 
    q = findvariable ( p ) ; 
    if ( q != 0 ) 
    {
      mem [ q ] .hhfield .b0 = t ; 
      mem [ q + 1 ] .cint = 0 ; 
    } 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 948 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 949 ; 
	helpline [ 0 ] = 950 ; 
      } 
      putgeterror () ; 
    } 
    flushlist ( p ) ; 
    if ( curcmd < 81 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 951 ) ; 
      } 
      {
	helpptr = 5 ; 
	helpline [ 4 ] = 952 ; 
	helpline [ 3 ] = 953 ; 
	helpline [ 2 ] = 954 ; 
	helpline [ 1 ] = 955 ; 
	helpline [ 0 ] = 956 ; 
      } 
      if ( curcmd == 44 ) 
      helpline [ 2 ] = 957 ; 
      putgeterror () ; 
      scannerstatus = 2 ; 
      do {
	  { 
	  getnext () ; 
	  if ( curcmd <= 3 ) 
	  tnext () ; 
	} 
	if ( curcmd == 41 ) 
	{
	  if ( strref [ curmod ] < 127 ) 
	  if ( strref [ curmod ] > 1 ) 
	  decr ( strref [ curmod ] ) ; 
	  else flushstring ( curmod ) ; 
	} 
      } while ( ! ( curcmd >= 81 ) ) ; 
      scannerstatus = 0 ; 
    } 
  } while ( ! ( curcmd > 81 ) ) ; 
} 
void dorandomseed ( ) 
{getxnext () ; 
  if ( curcmd != 76 ) 
  {
    missingerr ( 476 ) ; 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 962 ; 
    } 
    backerror () ; 
  } 
  getxnext () ; 
  scanexpression () ; 
  if ( curtype != 16 ) 
  {
    disperr ( 0 , 963 ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 964 ; 
      helpline [ 0 ] = 965 ; 
    } 
    putgetflusherror ( 0 ) ; 
  } 
  else {
      
    initrandoms ( curexp ) ; 
    if ( selector >= 6 ) 
    {
      oldsetting = selector ; 
      selector = 6 ; 
      printnl ( 966 ) ; 
      printscaled ( curexp ) ; 
      printchar ( 125 ) ; 
      printnl ( 285 ) ; 
      selector = oldsetting ; 
    } 
  } 
} 
void doprotection ( ) 
{char m  ; 
  halfword t  ; 
  m = curmod ; 
  do {
      getsymbol () ; 
    t = eqtb [ cursym ] .lhfield ; 
    if ( m == 0 ) 
    {
      if ( t >= 85 ) 
      eqtb [ cursym ] .lhfield = t - 85 ; 
    } 
    else if ( t < 85 ) 
    eqtb [ cursym ] .lhfield = t + 85 ; 
    getxnext () ; 
  } while ( ! ( curcmd != 81 ) ) ; 
} 
void defdelims ( ) 
{halfword ldelim, rdelim  ; 
  getclearsymbol () ; 
  ldelim = cursym ; 
  getclearsymbol () ; 
  rdelim = cursym ; 
  eqtb [ ldelim ] .lhfield = 33 ; 
  eqtb [ ldelim ] .v.RH = rdelim ; 
  eqtb [ rdelim ] .lhfield = 64 ; 
  eqtb [ rdelim ] .v.RH = ldelim ; 
  getxnext () ; 
} 
void dointerim ( ) 
{getxnext () ; 
  if ( curcmd != 42 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 972 ) ; 
    } 
    if ( cursym == 0 ) 
    print ( 977 ) ; 
    else print ( hash [ cursym ] .v.RH ) ; 
    print ( 978 ) ; 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 979 ; 
    } 
    backerror () ; 
  } 
  else {
      
    saveinternal ( curmod ) ; 
    backinput () ; 
  } 
  dostatement () ; 
} 
void dolet ( ) 
{halfword l  ; 
  getsymbol () ; 
  l = cursym ; 
  getxnext () ; 
  if ( curcmd != 53 ) 
  if ( curcmd != 76 ) 
  {
    missingerr ( 61 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 980 ; 
      helpline [ 1 ] = 714 ; 
      helpline [ 0 ] = 981 ; 
    } 
    backerror () ; 
  } 
  getsymbol () ; 
  switch ( curcmd ) 
  {case 13 : 
  case 55 : 
  case 46 : 
  case 51 : 
    incr ( mem [ curmod ] .hhfield .lhfield ) ; 
    break ; 
    default: 
    ; 
    break ; 
  } 
  clearsymbol ( l , false ) ; 
  eqtb [ l ] .lhfield = curcmd ; 
  if ( curcmd == 43 ) 
  eqtb [ l ] .v.RH = 0 ; 
  else eqtb [ l ] .v.RH = curmod ; 
  getxnext () ; 
} 
void donewinternal ( ) 
{do {
    if ( intptr == maxinternal ) 
    overflow ( 982 , maxinternal ) ; 
    getclearsymbol () ; 
    incr ( intptr ) ; 
    eqtb [ cursym ] .lhfield = 42 ; 
    eqtb [ cursym ] .v.RH = intptr ; 
    intname [ intptr ] = hash [ cursym ] .v.RH ; 
    internal [ intptr ] = 0 ; 
    getxnext () ; 
  } while ( ! ( curcmd != 81 ) ) ; 
} 
void doshow ( ) 
{do {
    getxnext () ; 
    scanexpression () ; 
    printnl ( 805 ) ; 
    printexp ( 0 , 2 ) ; 
    flushcurexp ( 0 ) ; 
  } while ( ! ( curcmd != 81 ) ) ; 
} 
void disptoken ( ) 
{printnl ( 988 ) ; 
  if ( cursym == 0 ) 
  {
    if ( curcmd == 44 ) 
    printscaled ( curmod ) ; 
    else if ( curcmd == 40 ) 
    {
      gpointer = curmod ; 
      printcapsule () ; 
    } 
    else {
	
      printchar ( 34 ) ; 
      print ( curmod ) ; 
      printchar ( 34 ) ; 
      {
	if ( strref [ curmod ] < 127 ) 
	if ( strref [ curmod ] > 1 ) 
	decr ( strref [ curmod ] ) ; 
	else flushstring ( curmod ) ; 
      } 
    } 
  } 
  else {
      
    print ( hash [ cursym ] .v.RH ) ; 
    printchar ( 61 ) ; 
    if ( eqtb [ cursym ] .lhfield >= 85 ) 
    print ( 989 ) ; 
    printcmdmod ( curcmd , curmod ) ; 
    if ( curcmd == 13 ) 
    {
      println () ; 
      showmacro ( curmod , 0 , 100000L ) ; 
    } 
  } 
} 
void doshowtoken ( ) 
{do {
    { 
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    disptoken () ; 
    getxnext () ; 
  } while ( ! ( curcmd != 81 ) ) ; 
} 
void doshowstats ( ) 
{printnl ( 998 ) ; 
	;
#ifdef STAT
  printint ( varused ) ; 
  printchar ( 38 ) ; 
  printint ( dynused ) ; 
  if ( false ) 
#endif /* STAT */
  print ( 359 ) ; 
  print ( 999 ) ; 
  printint ( himemmin - lomemmax - 1 ) ; 
  print ( 1000 ) ; 
  println () ; 
  printnl ( 1001 ) ; 
	;
#ifdef STAT
  printint ( strsinuse - initstruse ) ; 
  printchar ( 38 ) ; 
  printint ( poolinuse - initpoolptr ) ; 
  if ( false ) 
#endif /* STAT */
  print ( 359 ) ; 
  print ( 999 ) ; 
  printint ( maxstrings - 1 - strsusedup ) ; 
  printchar ( 38 ) ; 
  printint ( poolsize - poolptr ) ; 
  print ( 1002 ) ; 
  println () ; 
  getxnext () ; 
} 
void zdispvar ( p ) 
halfword p ; 
{halfword q  ; 
  integer n  ; 
  if ( mem [ p ] .hhfield .b0 == 21 ) 
  {
    q = mem [ p + 1 ] .hhfield .lhfield ; 
    do {
	dispvar ( q ) ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } while ( ! ( q == 9 ) ) ; 
    q = mem [ p + 1 ] .hhfield .v.RH ; 
    while ( mem [ q ] .hhfield .b1 == 3 ) {
	
      dispvar ( q ) ; 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
  } 
  else if ( mem [ p ] .hhfield .b0 >= 22 ) 
  {
    printnl ( 285 ) ; 
    printvariablename ( p ) ; 
    if ( mem [ p ] .hhfield .b0 > 22 ) 
    print ( 706 ) ; 
    print ( 1003 ) ; 
    if ( fileoffset >= maxprintline - 20 ) 
    n = 5 ; 
    else n = maxprintline - fileoffset - 15 ; 
    showmacro ( mem [ p + 1 ] .cint , 0 , n ) ; 
  } 
  else if ( mem [ p ] .hhfield .b0 != 0 ) 
  {
    printnl ( 285 ) ; 
    printvariablename ( p ) ; 
    printchar ( 61 ) ; 
    printexp ( p , 0 ) ; 
  } 
} 
void doshowvar ( ) 
{/* 30 */ do {
    { 
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( cursym > 0 ) 
    if ( cursym <= 2371 ) 
    if ( curcmd == 43 ) 
    if ( curmod != 0 ) 
    {
      dispvar ( curmod ) ; 
      goto lab30 ; 
    } 
    disptoken () ; 
    lab30: getxnext () ; 
  } while ( ! ( curcmd != 81 ) ) ; 
} 
void doshowdependencies ( ) 
{halfword p  ; 
  p = mem [ 5 ] .hhfield .v.RH ; 
  while ( p != 5 ) {
      
    if ( interesting ( p ) ) 
    {
      printnl ( 285 ) ; 
      printvariablename ( p ) ; 
      if ( mem [ p ] .hhfield .b0 == 17 ) 
      printchar ( 61 ) ; 
      else print ( 817 ) ; 
      printdependency ( mem [ p + 1 ] .hhfield .v.RH , mem [ p ] .hhfield .b0 
      ) ; 
    } 
    p = mem [ p + 1 ] .hhfield .v.RH ; 
    while ( mem [ p ] .hhfield .lhfield != 0 ) p = mem [ p ] .hhfield .v.RH ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  getxnext () ; 
} 
void doshowwhatever ( ) 
{if ( interaction == 3 ) 
  ; 
  switch ( curmod ) 
  {case 0 : 
    doshowtoken () ; 
    break ; 
  case 1 : 
    doshowstats () ; 
    break ; 
  case 2 : 
    doshow () ; 
    break ; 
  case 3 : 
    doshowvar () ; 
    break ; 
  case 4 : 
    doshowdependencies () ; 
    break ; 
  } 
  if ( internal [ 25 ] > 0 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 1004 ) ; 
    } 
    if ( interaction < 3 ) 
    {
      helpptr = 0 ; 
      decr ( errorcount ) ; 
    } 
    else {
	
      helpptr = 1 ; 
      helpline [ 0 ] = 1005 ; 
    } 
    if ( curcmd == 82 ) 
    error () ; 
    else putgeterror () ; 
  } 
}