#define EXTERN extern
#include "mpd.h"

void zprpath ( h ) 
halfword h ; 
{/* 30 31 */ halfword p, q  ; 
  p = h ; 
  do {
      q = mem [ p ] .hhfield .v.RH ; 
    if ( ( p == 0 ) || ( q == 0 ) ) 
    {
      printnl ( 261 ) ; 
      goto lab30 ; 
    } 
    printtwo ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
    switch ( mem [ p ] .hhfield .b1 ) 
    {case 0 : 
      {
	if ( mem [ p ] .hhfield .b0 == 4 ) 
	print ( 532 ) ; 
	if ( ( mem [ q ] .hhfield .b0 != 0 ) || ( q != h ) ) 
	q = 0 ; 
	goto lab31 ; 
      } 
      break ; 
    case 1 : 
      {
	print ( 538 ) ; 
	printtwo ( mem [ p + 5 ] .cint , mem [ p + 6 ] .cint ) ; 
	print ( 537 ) ; 
	if ( mem [ q ] .hhfield .b0 != 1 ) 
	print ( 539 ) ; 
	else printtwo ( mem [ q + 3 ] .cint , mem [ q + 4 ] .cint ) ; 
	goto lab31 ; 
      } 
      break ; 
    case 4 : 
      if ( ( mem [ p ] .hhfield .b0 != 1 ) && ( mem [ p ] .hhfield .b0 != 4 ) 
      ) 
      print ( 532 ) ; 
      break ; 
    case 3 : 
    case 2 : 
      {
	if ( mem [ p ] .hhfield .b0 == 4 ) 
	print ( 539 ) ; 
	if ( mem [ p ] .hhfield .b1 == 3 ) 
	{
	  print ( 535 ) ; 
	  printscaled ( mem [ p + 5 ] .cint ) ; 
	} 
	else {
	    
	  nsincos ( mem [ p + 5 ] .cint ) ; 
	  printchar ( 123 ) ; 
	  printscaled ( ncos ) ; 
	  printchar ( 44 ) ; 
	  printscaled ( nsin ) ; 
	} 
	printchar ( 125 ) ; 
      } 
      break ; 
      default: 
      print ( 261 ) ; 
      break ; 
    } 
    if ( mem [ q ] .hhfield .b0 <= 1 ) 
    print ( 533 ) ; 
    else if ( ( mem [ p + 6 ] .cint != 65536L ) || ( mem [ q + 4 ] .cint != 
    65536L ) ) 
    {
      print ( 536 ) ; 
      if ( mem [ p + 6 ] .cint < 0 ) 
      print ( 478 ) ; 
      printscaled ( abs ( mem [ p + 6 ] .cint ) ) ; 
      if ( mem [ p + 6 ] .cint != mem [ q + 4 ] .cint ) 
      {
	print ( 537 ) ; 
	if ( mem [ q + 4 ] .cint < 0 ) 
	print ( 478 ) ; 
	printscaled ( abs ( mem [ q + 4 ] .cint ) ) ; 
      } 
    } 
    lab31: ; 
    p = q ; 
    if ( ( p != h ) || ( mem [ h ] .hhfield .b0 != 0 ) ) 
    {
      printnl ( 534 ) ; 
      if ( mem [ p ] .hhfield .b0 == 2 ) 
      {
	nsincos ( mem [ p + 3 ] .cint ) ; 
	printchar ( 123 ) ; 
	printscaled ( ncos ) ; 
	printchar ( 44 ) ; 
	printscaled ( nsin ) ; 
	printchar ( 125 ) ; 
      } 
      else if ( mem [ p ] .hhfield .b0 == 3 ) 
      {
	print ( 535 ) ; 
	printscaled ( mem [ p + 3 ] .cint ) ; 
	printchar ( 125 ) ; 
      } 
    } 
  } while ( ! ( p == h ) ) ; 
  if ( mem [ h ] .hhfield .b0 != 0 ) 
  print ( 400 ) ; 
  lab30: ; 
} 
void zprintpath ( h , s , nuline ) 
halfword h ; 
strnumber s ; 
boolean nuline ; 
{printdiagnostic ( 540 , s , nuline ) ; 
  println () ; 
  prpath ( h ) ; 
  enddiagnostic ( true ) ; 
} 
void zprpen ( h ) 
halfword h ; 
{/* 30 */ halfword p, q  ; 
  if ( ( h == mem [ h ] .hhfield .v.RH ) ) 
  {
    print ( 549 ) ; 
    printscaled ( mem [ h + 1 ] .cint ) ; 
    printchar ( 44 ) ; 
    printscaled ( mem [ h + 2 ] .cint ) ; 
    printchar ( 44 ) ; 
    printscaled ( mem [ h + 3 ] .cint - mem [ h + 1 ] .cint ) ; 
    printchar ( 44 ) ; 
    printscaled ( mem [ h + 5 ] .cint - mem [ h + 1 ] .cint ) ; 
    printchar ( 44 ) ; 
    printscaled ( mem [ h + 4 ] .cint - mem [ h + 2 ] .cint ) ; 
    printchar ( 44 ) ; 
    printscaled ( mem [ h + 6 ] .cint - mem [ h + 2 ] .cint ) ; 
    printchar ( 41 ) ; 
  } 
  else {
      
    p = h ; 
    do {
	printtwo ( mem [ p + 1 ] .cint , mem [ p + 2 ] .cint ) ; 
      printnl ( 548 ) ; 
      q = mem [ p ] .hhfield .v.RH ; 
      if ( ( q == 0 ) || ( mem [ q ] .hhfield .lhfield != p ) ) 
      {
	printnl ( 261 ) ; 
	goto lab30 ; 
      } 
      p = q ; 
    } while ( ! ( p == h ) ) ; 
    print ( 400 ) ; 
  } 
  lab30: ; 
} 
void zprintpen ( h , s , nuline ) 
halfword h ; 
strnumber s ; 
boolean nuline ; 
{printdiagnostic ( 550 , s , nuline ) ; 
  println () ; 
  prpen ( h ) ; 
  enddiagnostic ( true ) ; 
} 
scaled zgetpenscale ( p ) 
halfword p ; 
{register scaled Result; scaled a, b, c, d  ; 
  scaled maxabs  ; 
  integer s  ; 
  a = mem [ p + 3 ] .cint - mem [ p + 1 ] .cint ; 
  b = mem [ p + 5 ] .cint - mem [ p + 1 ] .cint ; 
  c = mem [ p + 4 ] .cint - mem [ p + 2 ] .cint ; 
  d = mem [ p + 6 ] .cint - mem [ p + 2 ] .cint ; 
  maxabs = abs ( a ) ; 
  if ( abs ( b ) > maxabs ) 
  maxabs = abs ( b ) ; 
  if ( abs ( c ) > maxabs ) 
  maxabs = abs ( c ) ; 
  if ( abs ( d ) > maxabs ) 
  maxabs = abs ( d ) ; 
  s = 64 ; 
  while ( ( maxabs < 268435456L ) && ( s > 1 ) ) {
      
    a = a + a ; 
    b = b + b ; 
    c = c + c ; 
    d = d + d ; 
    maxabs = maxabs + maxabs ; 
    s = halfp ( s ) ; 
  } 
  Result = s * squarert ( abs ( takefraction ( a , d ) - takefraction ( b , c 
  ) ) ) ; 
  return(Result) ; 
} 
void zprintcompactnode ( p , k ) 
halfword p ; 
smallnumber k ; 
{halfword q  ; 
  q = p + k - 1 ; 
  printchar ( 40 ) ; 
  while ( p <= q ) {
      
    printscaled ( mem [ p ] .cint ) ; 
    if ( p < q ) 
    printchar ( 44 ) ; 
    incr ( p ) ; 
  } 
  printchar ( 41 ) ; 
} 
void zprintobjcolor ( p ) 
halfword p ; 
{if ( ( mem [ p + 2 ] .cint > 0 ) || ( mem [ p + 3 ] .cint > 0 ) || ( mem [ p 
  + 4 ] .cint > 0 ) ) 
  {
    print ( 565 ) ; 
    printcompactnode ( p + 2 , 3 ) ; 
  } 
} 
scaled zdashoffset ( h ) 
halfword h ; 
{register scaled Result; scaled x  ; 
  if ( ( mem [ h ] .hhfield .v.RH == 2 ) || ( mem [ h + 1 ] .cint < 0 ) ) 
  confusion ( 573 ) ; 
  if ( mem [ h + 1 ] .cint == 0 ) 
  x = 0 ; 
  else {
      
    x = - (integer) ( mem [ mem [ h ] .hhfield .v.RH + 1 ] .cint % mem [ h + 1 
    ] .cint ) ; 
    if ( x < 0 ) 
    x = x + mem [ h + 1 ] .cint ; 
  } 
  Result = x ; 
  return(Result) ; 
} 
void zprintedges ( h , s , nuline ) 
halfword h ; 
strnumber s ; 
boolean nuline ; 
{halfword p  ; 
  halfword hh, pp  ; 
  scaled scf  ; 
  boolean oktodash  ; 
  printdiagnostic ( 552 , s , nuline ) ; 
  p = h + 7 ; 
  while ( mem [ p ] .hhfield .v.RH != 0 ) {
      
    p = mem [ p ] .hhfield .v.RH ; 
    println () ; 
    switch ( mem [ p ] .hhfield .b0 ) 
    {case 1 : 
      {
	print ( 555 ) ; 
	printobjcolor ( p ) ; 
	printchar ( 58 ) ; 
	println () ; 
	prpath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	println () ; 
	if ( ( mem [ p + 1 ] .hhfield .lhfield != 0 ) ) 
	{
	  switch ( mem [ p ] .hhfield .b1 ) 
	  {case 0 : 
	    {
	      print ( 557 ) ; 
	      printscaled ( mem [ p + 5 ] .cint ) ; 
	    } 
	    break ; 
	  case 1 : 
	    print ( 558 ) ; 
	    break ; 
	  case 2 : 
	    print ( 559 ) ; 
	    break ; 
	    default: 
	    print ( 560 ) ; 
	    break ; 
	  } 
	  print ( 556 ) ; 
	  println () ; 
	  prpen ( mem [ p + 1 ] .hhfield .lhfield ) ; 
	} 
      } 
      break ; 
    case 2 : 
      {
	print ( 566 ) ; 
	printobjcolor ( p ) ; 
	printchar ( 58 ) ; 
	println () ; 
	prpath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	if ( mem [ p + 6 ] .hhfield .v.RH != 0 ) 
	{
	  printnl ( 567 ) ; 
	  oktodash = ( mem [ p + 1 ] .hhfield .lhfield == mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ) ; 
	  if ( ( mem [ p + 7 ] .cint == 0 ) || ! oktodash ) 
	  scf = 65536L ; 
	  else scf = makescaled ( getpenscale ( mem [ p + 1 ] .hhfield .lhfield ) , mem [ p + 7 ] .cint ) ; 
	  hh = mem [ p + 6 ] .hhfield .v.RH ; 
	  pp = mem [ hh ] .hhfield .v.RH ; 
	  if ( ( pp == 2 ) || ( mem [ hh + 1 ] .cint < 0 ) ) 
	  print ( 568 ) ; 
	  else {
	      
	    mem [ 3 ] .cint = mem [ pp + 1 ] .cint + mem [ hh + 1 ] .cint ; 
	    while ( pp != 2 ) {
		
	      print ( 569 ) ; 
	      printscaled ( takescaled ( mem [ pp + 2 ] .cint - mem [ pp + 1 ] .cint , scf ) ) ; 
	      print ( 570 ) ; 
	      printscaled ( takescaled ( mem [ mem [ pp ] .hhfield .v.RH + 1 ] .cint - mem [ pp + 2 ] .cint , scf ) ) ; 
	      pp = mem [ pp ] .hhfield .v.RH ; 
	      if ( pp != 2 ) 
	      printchar ( 32 ) ; 
	    } 
	    print ( 571 ) ; 
	    printscaled ( - (integer) takescaled ( dashoffset ( hh ) , scf ) ) 
	    ; 
	    if ( ! oktodash || ( mem [ hh + 1 ] .cint == 0 ) ) 
	    print ( 572 ) ; 
	  } 
	} 
	println () ; 
	switch ( mem [ p + 6 ] .hhfield .b0 ) 
	{case 0 : 
	  print ( 561 ) ; 
	  break ; 
	case 1 : 
	  print ( 562 ) ; 
	  break ; 
	case 2 : 
	  print ( 563 ) ; 
	  break ; 
	  default: 
	  print ( 539 ) ; 
	  break ; 
	} 
	print ( 564 ) ; 
	switch ( mem [ p ] .hhfield .b1 ) 
	{case 0 : 
	  {
	    print ( 557 ) ; 
	    printscaled ( mem [ p + 5 ] .cint ) ; 
	  } 
	  break ; 
	case 1 : 
	  print ( 558 ) ; 
	  break ; 
	case 2 : 
	  print ( 559 ) ; 
	  break ; 
	  default: 
	  print ( 560 ) ; 
	  break ; 
	} 
	print ( 556 ) ; 
	println () ; 
	if ( mem [ p + 1 ] .hhfield .lhfield == 0 ) 
	print ( 261 ) ; 
	else prpen ( mem [ p + 1 ] .hhfield .lhfield ) ; 
      } 
      break ; 
    case 3 : 
      {
	printchar ( 34 ) ; 
	slowprint ( mem [ p + 1 ] .hhfield .v.RH ) ; 
	print ( 574 ) ; 
	slowprint ( fontname [ mem [ p + 1 ] .hhfield .lhfield ] ) ; 
	printchar ( 34 ) ; 
	println () ; 
	printobjcolor ( p ) ; 
	print ( 575 ) ; 
	printcompactnode ( p + 8 , 6 ) ; 
      } 
      break ; 
    case 4 : 
      {
	print ( 576 ) ; 
	println () ; 
	prpath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
      } 
      break ; 
    case 6 : 
      print ( 577 ) ; 
      break ; 
    case 5 : 
      {
	print ( 578 ) ; 
	println () ; 
	prpath ( mem [ p + 1 ] .hhfield .v.RH ) ; 
      } 
      break ; 
    case 7 : 
      print ( 579 ) ; 
      break ; 
      default: 
      {
	print ( 553 ) ; 
      } 
      break ; 
    } 
  } 
  printnl ( 554 ) ; 
  if ( p != mem [ h + 7 ] .hhfield .lhfield ) 
  print ( 63 ) ; 
  enddiagnostic ( true ) ; 
} 
void zprintdependency ( p , t ) 
halfword p ; 
smallnumber t ; 
{/* 10 */ integer v  ; 
  halfword pp, q  ; 
  pp = p ; 
  while ( true ) {
      
    v = abs ( mem [ p + 1 ] .cint ) ; 
    q = mem [ p ] .hhfield .lhfield ; 
    if ( q == 0 ) 
    {
      if ( ( v != 0 ) || ( p == pp ) ) 
      {
	if ( mem [ p + 1 ] .cint > 0 ) 
	if ( p != pp ) 
	printchar ( 43 ) ; 
	printscaled ( mem [ p + 1 ] .cint ) ; 
      } 
      goto lab10 ; 
    } 
    if ( mem [ p + 1 ] .cint < 0 ) 
    printchar ( 45 ) ; 
    else if ( p != pp ) 
    printchar ( 43 ) ; 
    if ( t == 17 ) 
    v = roundfraction ( v ) ; 
    if ( v != 65536L ) 
    printscaled ( v ) ; 
    if ( mem [ q ] .hhfield .b0 != 19 ) 
    confusion ( 600 ) ; 
    printvariablename ( q ) ; 
    v = mem [ q + 1 ] .cint % 64 ; 
    while ( v > 0 ) {
	
      print ( 601 ) ; 
      v = v - 2 ; 
    } 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  lab10: ; 
} 
void zprintdp ( t , p , verbosity ) 
smallnumber t ; 
halfword p ; 
smallnumber verbosity ; 
{halfword q  ; 
  q = mem [ p ] .hhfield .v.RH ; 
  if ( ( mem [ q ] .hhfield .lhfield == 0 ) || ( verbosity > 0 ) ) 
  printdependency ( p , t ) ; 
  else print ( 814 ) ; 
} 
halfword stashcurexp ( ) 
{register halfword Result; halfword p  ; 
  switch ( curtype ) 
  {case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
  case 12 : 
  case 13 : 
  case 14 : 
  case 17 : 
  case 18 : 
  case 19 : 
    p = curexp ; 
    break ; 
    default: 
    {
      p = getnode ( 2 ) ; 
      mem [ p ] .hhfield .b1 = 14 ; 
      mem [ p ] .hhfield .b0 = curtype ; 
      mem [ p + 1 ] .cint = curexp ; 
    } 
    break ; 
  } 
  curtype = 1 ; 
  mem [ p ] .hhfield .v.RH = 1 ; 
  Result = p ; 
  return(Result) ; 
} 
void zunstashcurexp ( p ) 
halfword p ; 
{curtype = mem [ p ] .hhfield .b0 ; 
  switch ( curtype ) 
  {case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
  case 12 : 
  case 13 : 
  case 14 : 
  case 17 : 
  case 18 : 
  case 19 : 
    curexp = p ; 
    break ; 
    default: 
    {
      curexp = mem [ p + 1 ] .cint ; 
      freenode ( p , 2 ) ; 
    } 
    break ; 
  } 
} 
void zprintexp ( p , verbosity ) 
halfword p ; 
smallnumber verbosity ; 
{boolean restorecurexp  ; 
  smallnumber t  ; 
  integer v  ; 
  halfword q  ; 
  if ( p != 0 ) 
  restorecurexp = false ; 
  else {
      
    p = stashcurexp () ; 
    restorecurexp = true ; 
  } 
  t = mem [ p ] .hhfield .b0 ; 
  if ( t < 17 ) 
  v = mem [ p + 1 ] .cint ; 
  else if ( t < 19 ) 
  v = mem [ p + 1 ] .hhfield .v.RH ; 
  switch ( t ) 
  {case 1 : 
    print ( 325 ) ; 
    break ; 
  case 2 : 
    if ( v == 30 ) 
    print ( 348 ) ; 
    else print ( 349 ) ; 
    break ; 
  case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
  case 15 : 
    {
      printtype ( t ) ; 
      if ( v != 0 ) 
      {
	printchar ( 32 ) ; 
	while ( ( mem [ v ] .hhfield .b1 == 14 ) && ( v != p ) ) v = mem [ v + 
	1 ] .cint ; 
	printvariablename ( v ) ; 
      } 
    } 
    break ; 
  case 4 : 
    {
      printchar ( 34 ) ; 
      slowprint ( v ) ; 
      printchar ( 34 ) ; 
    } 
    break ; 
  case 6 : 
  case 8 : 
  case 10 : 
    if ( verbosity <= 1 ) 
    printtype ( t ) ; 
    else {
	
      if ( selector == 7 ) 
      if ( internal [ 12 ] <= 0 ) 
      {
	selector = 5 ; 
	printtype ( t ) ; 
	print ( 813 ) ; 
	selector = 7 ; 
      } 
      switch ( t ) 
      {case 6 : 
	printpen ( v , 285 , false ) ; 
	break ; 
      case 8 : 
	printpath ( v , 285 , false ) ; 
	break ; 
      case 10 : 
	printedges ( v , 285 , false ) ; 
	break ; 
      } 
    } 
    break ; 
  case 12 : 
  case 13 : 
  case 14 : 
    if ( v == 0 ) 
    printtype ( t ) ; 
    else {
	
      printchar ( 40 ) ; 
      q = v + bignodesize [ t ] ; 
      do {
	  if ( mem [ v ] .hhfield .b0 == 16 ) 
	printscaled ( mem [ v + 1 ] .cint ) ; 
	else if ( mem [ v ] .hhfield .b0 == 19 ) 
	printvariablename ( v ) ; 
	else printdp ( mem [ v ] .hhfield .b0 , mem [ v + 1 ] .hhfield .v.RH ,	verbosity ) ; 
	v = v + 2 ; 
	if ( v != q ) 
	printchar ( 44 ) ; 
      } while ( ! ( v == q ) ) ; 
      printchar ( 41 ) ; 
    } 
    break ; 
  case 16 : 
    printscaled ( v ) ; 
    break ; 
  case 17 : 
  case 18 : 
    printdp ( t , v , verbosity ) ; 
    break ; 
  case 19 : 
    printvariablename ( p ) ; 
    break ; 
    default: 
    confusion ( 812 ) ; 
    break ; 
  } 
  if ( restorecurexp ) 
  unstashcurexp ( p ) ; 
} 
void zdisperr ( p , s ) 
halfword p ; 
strnumber s ; 
{if ( interaction == 3 ) 
  ; 
  printnl ( 805 ) ; 
  printexp ( p , 1 ) ; 
  if ( s != 285 ) 
  {
    printnl ( 263 ) ; 
    print ( s ) ; 
  } 
} 
halfword zpplusfq ( p , f , q , t , tt ) 
halfword p ; 
integer f ; 
halfword q ; 
smallnumber t ; 
smallnumber tt ; 
{/* 30 */ register halfword Result; halfword pp, qq  ; 
  halfword r, s  ; 
  integer threshold  ; 
  integer v  ; 
  if ( t == 17 ) 
  threshold = 2685 ; 
  else threshold = 8 ; 
  r = memtop - 1 ; 
  pp = mem [ p ] .hhfield .lhfield ; 
  qq = mem [ q ] .hhfield .lhfield ; 
  while ( true ) if ( pp == qq ) 
  if ( pp == 0 ) 
  goto lab30 ; 
  else {
      
    if ( tt == 17 ) 
    v = mem [ p + 1 ] .cint + takefraction ( f , mem [ q + 1 ] .cint ) ; 
    else v = mem [ p + 1 ] .cint + takescaled ( f , mem [ q + 1 ] .cint ) ; 
    mem [ p + 1 ] .cint = v ; 
    s = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    if ( abs ( v ) < threshold ) 
    freenode ( s , 2 ) ; 
    else {
	
      if ( abs ( v ) >= 626349397L ) 
      if ( watchcoefs ) 
      {
	mem [ qq ] .hhfield .b0 = 0 ; 
	fixneeded = true ; 
      } 
      mem [ r ] .hhfield .v.RH = s ; 
      r = s ; 
    } 
    pp = mem [ p ] .hhfield .lhfield ; 
    q = mem [ q ] .hhfield .v.RH ; 
    qq = mem [ q ] .hhfield .lhfield ; 
  } 
  else if ( mem [ pp + 1 ] .cint < mem [ qq + 1 ] .cint ) 
  {
    if ( tt == 17 ) 
    v = takefraction ( f , mem [ q + 1 ] .cint ) ; 
    else v = takescaled ( f , mem [ q + 1 ] .cint ) ; 
    if ( abs ( v ) > halfp ( threshold ) ) 
    {
      s = getnode ( 2 ) ; 
      mem [ s ] .hhfield .lhfield = qq ; 
      mem [ s + 1 ] .cint = v ; 
      if ( abs ( v ) >= 626349397L ) 
      if ( watchcoefs ) 
      {
	mem [ qq ] .hhfield .b0 = 0 ; 
	fixneeded = true ; 
      } 
      mem [ r ] .hhfield .v.RH = s ; 
      r = s ; 
    } 
    q = mem [ q ] .hhfield .v.RH ; 
    qq = mem [ q ] .hhfield .lhfield ; 
  } 
  else {
      
    mem [ r ] .hhfield .v.RH = p ; 
    r = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    pp = mem [ p ] .hhfield .lhfield ; 
  } 
  lab30: if ( t == 17 ) 
  mem [ p + 1 ] .cint = slowadd ( mem [ p + 1 ] .cint , takefraction ( mem [ q 
  + 1 ] .cint , f ) ) ; 
  else mem [ p + 1 ] .cint = slowadd ( mem [ p + 1 ] .cint , takescaled ( mem 
  [ q + 1 ] .cint , f ) ) ; 
  mem [ r ] .hhfield .v.RH = p ; 
  depfinal = p ; 
  Result = mem [ memtop - 1 ] .hhfield .v.RH ; 
  return(Result) ; 
} 
halfword zpoverv ( p , v , t0 , t1 ) 
halfword p ; 
scaled v ; 
smallnumber t0 ; 
smallnumber t1 ; 
{register halfword Result; halfword r, s  ; 
  integer w  ; 
  integer threshold  ; 
  boolean scalingdown  ; 
  if ( t0 != t1 ) 
  scalingdown = true ; 
  else scalingdown = false ; 
  if ( t1 == 17 ) 
  threshold = 1342 ; 
  else threshold = 4 ; 
  r = memtop - 1 ; 
  while ( mem [ p ] .hhfield .lhfield != 0 ) {
      
    if ( scalingdown ) 
    if ( abs ( v ) < 524288L ) 
    w = makescaled ( mem [ p + 1 ] .cint , v * 4096 ) ; 
    else w = makescaled ( roundfraction ( mem [ p + 1 ] .cint ) , v ) ; 
    else w = makescaled ( mem [ p + 1 ] .cint , v ) ; 
    if ( abs ( w ) <= threshold ) 
    {
      s = mem [ p ] .hhfield .v.RH ; 
      freenode ( p , 2 ) ; 
      p = s ; 
    } 
    else {
	
      if ( abs ( w ) >= 626349397L ) 
      {
	fixneeded = true ; 
	mem [ mem [ p ] .hhfield .lhfield ] .hhfield .b0 = 0 ; 
      } 
      mem [ r ] .hhfield .v.RH = p ; 
      r = p ; 
      mem [ p + 1 ] .cint = w ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
  } 
  mem [ r ] .hhfield .v.RH = p ; 
  mem [ p + 1 ] .cint = makescaled ( mem [ p + 1 ] .cint , v ) ; 
  Result = mem [ memtop - 1 ] .hhfield .v.RH ; 
  return(Result) ; 
} 
void zvaltoobig ( x ) 
scaled x ; 
{if ( internal [ 30 ] > 0 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 602 ) ; 
    } 
    printscaled ( x ) ; 
    printchar ( 41 ) ; 
    {
      helpptr = 4 ; 
      helpline [ 3 ] = 603 ; 
      helpline [ 2 ] = 604 ; 
      helpline [ 1 ] = 605 ; 
      helpline [ 0 ] = 606 ; 
    } 
    error () ; 
  } 
} 
void zmakeknown ( p , q ) 
halfword p ; 
halfword q ; 
{char t  ; 
  mem [ mem [ q ] .hhfield .v.RH + 1 ] .hhfield .lhfield = mem [ p + 1 ] .hhfield .lhfield ; 
  mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
  t = mem [ p ] .hhfield .b0 ; 
  mem [ p ] .hhfield .b0 = 16 ; 
  mem [ p + 1 ] .cint = mem [ q + 1 ] .cint ; 
  freenode ( q , 2 ) ; 
  if ( abs ( mem [ p + 1 ] .cint ) >= 268435456L ) 
  valtoobig ( mem [ p + 1 ] .cint ) ; 
  if ( internal [ 2 ] > 0 ) 
  if ( interesting ( p ) ) 
  {
    begindiagnostic () ; 
    printnl ( 607 ) ; 
    printvariablename ( p ) ; 
    printchar ( 61 ) ; 
    printscaled ( mem [ p + 1 ] .cint ) ; 
    enddiagnostic ( false ) ; 
  } 
  if ( curexp == p ) 
  if ( curtype == t ) 
  {
    curtype = 16 ; 
    curexp = mem [ p + 1 ] .cint ; 
    freenode ( p , 2 ) ; 
  } 
} 
void fixdependencies ( ) 
{/* 30 */ halfword p, q, r, s, t  ; 
  halfword x  ; 
  r = mem [ 5 ] .hhfield .v.RH ; 
  s = 0 ; 
  while ( r != 5 ) {
      
    t = r ; 
    r = t + 1 ; 
    while ( true ) {
	
      q = mem [ r ] .hhfield .v.RH ; 
      x = mem [ q ] .hhfield .lhfield ; 
      if ( x == 0 ) 
      goto lab30 ; 
      if ( mem [ x ] .hhfield .b0 <= 1 ) 
      {
	if ( mem [ x ] .hhfield .b0 < 1 ) 
	{
	  p = getavail () ; 
	  mem [ p ] .hhfield .v.RH = s ; 
	  s = p ; 
	  mem [ s ] .hhfield .lhfield = x ; 
	  mem [ x ] .hhfield .b0 = 1 ; 
	} 
	mem [ q + 1 ] .cint = mem [ q + 1 ] .cint / 4 ; 
	if ( mem [ q + 1 ] .cint == 0 ) 
	{
	  mem [ r ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
	  freenode ( q , 2 ) ; 
	  q = r ; 
	} 
      } 
      r = q ; 
    } 
    lab30: ; 
    r = mem [ q ] .hhfield .v.RH ; 
    if ( q == mem [ t + 1 ] .hhfield .v.RH ) 
    makeknown ( t , q ) ; 
  } 
  while ( s != 0 ) {
      
    p = mem [ s ] .hhfield .v.RH ; 
    x = mem [ s ] .hhfield .lhfield ; 
    {
      mem [ s ] .hhfield .v.RH = avail ; 
      avail = s ; 
	;
#ifdef STAT
      decr ( dynused ) ; 
#endif /* STAT */
    } 
    s = p ; 
    mem [ x ] .hhfield .b0 = 19 ; 
    mem [ x + 1 ] .cint = mem [ x + 1 ] .cint + 2 ; 
  } 
  fixneeded = false ; 
} 
void ztossknotlist ( p ) 
halfword p ; 
{halfword q  ; 
  halfword r  ; 
  q = p ; 
  do {
      r = mem [ q ] .hhfield .v.RH ; 
    freenode ( q , 7 ) ; 
    q = r ; 
  } while ( ! ( q == p ) ) ; 
} 
void zflushdashlist ( h ) 
halfword h ; 
{halfword p, q  ; 
  q = mem [ h ] .hhfield .v.RH ; 
  while ( q != 2 ) {
      
    p = q ; 
    q = mem [ q ] .hhfield .v.RH ; 
    freenode ( p , 3 ) ; 
  } 
  mem [ h ] .hhfield .v.RH = 2 ; 
} 
halfword ztossgrobject ( p ) 
halfword p ; 
{register halfword Result; halfword e  ; 
  e = 0 ; 
  switch ( mem [ p ] .hhfield .b0 ) 
  {case 1 : 
    {
      tossknotlist ( mem [ p + 1 ] .hhfield .v.RH ) ; 
      if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
      tossknotlist ( mem [ p + 1 ] .hhfield .lhfield ) ; 
    } 
    break ; 
  case 2 : 
    {
      tossknotlist ( mem [ p + 1 ] .hhfield .v.RH ) ; 
      if ( mem [ p + 1 ] .hhfield .lhfield != 0 ) 
      tossknotlist ( mem [ p + 1 ] .hhfield .lhfield ) ; 
      e = mem [ p + 6 ] .hhfield .v.RH ; 
    } 
    break ; 
  case 3 : 
    {
      if ( strref [ mem [ p + 1 ] .hhfield .v.RH ] < 127 ) 
      if ( strref [ mem [ p + 1 ] .hhfield .v.RH ] > 1 ) 
      decr ( strref [ mem [ p + 1 ] .hhfield .v.RH ] ) ; 
      else flushstring ( mem [ p + 1 ] .hhfield .v.RH ) ; 
    } 
    break ; 
  case 4 : 
  case 5 : 
    tossknotlist ( mem [ p + 1 ] .hhfield .v.RH ) ; 
    break ; 
  case 6 : 
  case 7 : 
    ; 
    break ; 
  } 
  freenode ( p , grobjectsize [ mem [ p ] .hhfield .b0 ] ) ; 
  Result = e ; 
  return(Result) ; 
} 
void ztossedges ( h ) 
halfword h ; 
{halfword p, q  ; 
  halfword r  ; 
  flushdashlist ( h ) ; 
  q = mem [ h + 7 ] .hhfield .v.RH ; 
  while ( ( q != 0 ) ) {
      
    p = q ; 
    q = mem [ q ] .hhfield .v.RH ; 
    r = tossgrobject ( p ) ; 
    if ( r != 0 ) 
    if ( mem [ r ] .hhfield .lhfield == 0 ) 
    tossedges ( r ) ; 
    else decr ( mem [ r ] .hhfield .lhfield ) ; 
  } 
  freenode ( h , 8 ) ; 
} 
void zringdelete ( p ) 
halfword p ; 
{halfword q  ; 
  q = mem [ p + 1 ] .cint ; 
  if ( q != 0 ) 
  if ( q != p ) 
  {
    while ( mem [ q + 1 ] .cint != p ) q = mem [ q + 1 ] .cint ; 
    mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  } 
} 
void zrecyclevalue ( p ) 
halfword p ; 
{/* 30 */ smallnumber t  ; 
  integer v  ; 
  integer vv  ; 
  halfword q, r, s, pp  ; 
  t = mem [ p ] .hhfield .b0 ; 
  if ( t < 17 ) 
  v = mem [ p + 1 ] .cint ; 
  switch ( t ) 
  {case 0 : 
  case 1 : 
  case 2 : 
  case 16 : 
  case 15 : 
    ; 
    break ; 
  case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
    ringdelete ( p ) ; 
    break ; 
  case 4 : 
    {
      if ( strref [ v ] < 127 ) 
      if ( strref [ v ] > 1 ) 
      decr ( strref [ v ] ) ; 
      else flushstring ( v ) ; 
    } 
    break ; 
  case 8 : 
  case 6 : 
    tossknotlist ( v ) ; 
    break ; 
  case 10 : 
    if ( mem [ v ] .hhfield .lhfield == 0 ) 
    tossedges ( v ) ; 
    else decr ( mem [ v ] .hhfield .lhfield ) ; 
    break ; 
  case 14 : 
  case 13 : 
  case 12 : 
    if ( v != 0 ) 
    {
      q = v + bignodesize [ t ] ; 
      do {
	  q = q - 2 ; 
	recyclevalue ( q ) ; 
      } while ( ! ( q == v ) ) ; 
      freenode ( v , bignodesize [ t ] ) ; 
    } 
    break ; 
  case 17 : 
  case 18 : 
    {
      q = mem [ p + 1 ] .hhfield .v.RH ; 
      while ( mem [ q ] .hhfield .lhfield != 0 ) q = mem [ q ] .hhfield .v.RH 
      ; 
      mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
      mem [ mem [ q ] .hhfield .v.RH + 1 ] .hhfield .lhfield = mem [ p + 1 ] .hhfield .lhfield ; 
      mem [ q ] .hhfield .v.RH = 0 ; 
      flushnodelist ( mem [ p + 1 ] .hhfield .v.RH ) ; 
    } 
    break ; 
  case 19 : 
    {
      maxc [ 17 ] = 0 ; 
      maxc [ 18 ] = 0 ; 
      maxlink [ 17 ] = 0 ; 
      maxlink [ 18 ] = 0 ; 
      q = mem [ 5 ] .hhfield .v.RH ; 
      while ( q != 5 ) {
	  
	s = q + 1 ; 
	while ( true ) {
	    
	  r = mem [ s ] .hhfield .v.RH ; 
	  if ( mem [ r ] .hhfield .lhfield == 0 ) 
	  goto lab30 ; 
	  if ( mem [ r ] .hhfield .lhfield != p ) 
	  s = r ; 
	  else {
	      
	    t = mem [ q ] .hhfield .b0 ; 
	    mem [ s ] .hhfield .v.RH = mem [ r ] .hhfield .v.RH ; 
	    mem [ r ] .hhfield .lhfield = q ; 
	    if ( abs ( mem [ r + 1 ] .cint ) > maxc [ t ] ) 
	    {
	      if ( maxc [ t ] > 0 ) 
	      {
		mem [ maxptr [ t ] ] .hhfield .v.RH = maxlink [ t ] ; 
		maxlink [ t ] = maxptr [ t ] ; 
	      } 
	      maxc [ t ] = abs ( mem [ r + 1 ] .cint ) ; 
	      maxptr [ t ] = r ; 
	    } 
	    else {
		
	      mem [ r ] .hhfield .v.RH = maxlink [ t ] ; 
	      maxlink [ t ] = r ; 
	    } 
	  } 
	} 
	lab30: q = mem [ r ] .hhfield .v.RH ; 
      } 
      if ( ( maxc [ 17 ] > 0 ) || ( maxc [ 18 ] > 0 ) ) 
      {
	if ( ( maxc [ 17 ] / 4096 >= maxc [ 18 ] ) ) 
	t = 17 ; 
	else t = 18 ; 
	s = maxptr [ t ] ; 
	pp = mem [ s ] .hhfield .lhfield ; 
	v = mem [ s + 1 ] .cint ; 
	if ( t == 17 ) 
	mem [ s + 1 ] .cint = -268435456L ; 
	else mem [ s + 1 ] .cint = -65536L ; 
	r = mem [ pp + 1 ] .hhfield .v.RH ; 
	mem [ s ] .hhfield .v.RH = r ; 
	while ( mem [ r ] .hhfield .lhfield != 0 ) r = mem [ r ] .hhfield .v.RH ; 
	q = mem [ r ] .hhfield .v.RH ; 
	mem [ r ] .hhfield .v.RH = 0 ; 
	mem [ q + 1 ] .hhfield .lhfield = mem [ pp + 1 ] .hhfield .lhfield ; 
	mem [ mem [ pp + 1 ] .hhfield .lhfield ] .hhfield .v.RH = q ; 
	{
	  mem [ pp ] .hhfield .b0 = 19 ; 
	  serialno = serialno + 64 ; 
	  mem [ pp + 1 ] .cint = serialno ; 
	} 
	if ( curexp == pp ) 
	if ( curtype == t ) 
	curtype = 19 ; 
	if ( internal [ 2 ] > 0 ) 
	if ( interesting ( p ) ) 
	{
	  begindiagnostic () ; 
	  printnl ( 816 ) ; 
	  if ( v > 0 ) 
	  printchar ( 45 ) ; 
	  if ( t == 17 ) 
	  vv = roundfraction ( maxc [ 17 ] ) ; 
	  else vv = maxc [ 18 ] ; 
	  if ( vv != 65536L ) 
	  printscaled ( vv ) ; 
	  printvariablename ( p ) ; 
	  while ( mem [ p + 1 ] .cint % 64 > 0 ) {
	      
	    print ( 601 ) ; 
	    mem [ p + 1 ] .cint = mem [ p + 1 ] .cint - 2 ; 
	  } 
	  if ( t == 17 ) 
	  printchar ( 61 ) ; 
	  else print ( 817 ) ; 
	  printdependency ( s , t ) ; 
	  enddiagnostic ( false ) ; 
	} 
	t = 35 - t ; 
	if ( maxc [ t ] > 0 ) 
	{
	  mem [ maxptr [ t ] ] .hhfield .v.RH = maxlink [ t ] ; 
	  maxlink [ t ] = maxptr [ t ] ; 
	} 
	if ( t != 17 ) 
	{register integer for_end; t = 17 ; for_end = 18 ; if ( t <= for_end) 
	do 
	  {
	    r = maxlink [ t ] ; 
	    while ( r != 0 ) {
		
	      q = mem [ r ] .hhfield .lhfield ; 
	      mem [ q + 1 ] .hhfield .v.RH = pplusfq ( mem [ q + 1 ] .hhfield .v.RH , makefraction ( mem [ r + 1 ] .cint , - (integer) v ) , s 
	      , t , 17 ) ; 
	      if ( mem [ q + 1 ] .hhfield .v.RH == depfinal ) 
	      makeknown ( q , depfinal ) ; 
	      q = r ; 
	      r = mem [ r ] .hhfield .v.RH ; 
	      freenode ( q , 2 ) ; 
	    } 
	  } 
	while ( t++ < for_end ) ; } 
	else {
	    register integer for_end; t = 17 ; for_end = 18 ; if ( t <= 
	for_end) do 
	  {
	    r = maxlink [ t ] ; 
	    while ( r != 0 ) {
		
	      q = mem [ r ] .hhfield .lhfield ; 
	      if ( t == 17 ) 
	      {
		if ( curexp == q ) 
		if ( curtype == 17 ) 
		curtype = 18 ; 
		mem [ q + 1 ] .hhfield .v.RH = poverv ( mem [ q + 1 ] .hhfield .v.RH , 65536L , 17 , 18 ) ; 
		mem [ q ] .hhfield .b0 = 18 ; 
		mem [ r + 1 ] .cint = roundfraction ( mem [ r + 1 ] .cint ) ; 
	      } 
	      mem [ q + 1 ] .hhfield .v.RH = pplusfq ( mem [ q + 1 ] .hhfield .v.RH , makescaled ( mem [ r + 1 ] .cint , - (integer) v ) , s ,	      18 , 18 ) ; 
	      if ( mem [ q + 1 ] .hhfield .v.RH == depfinal ) 
	      makeknown ( q , depfinal ) ; 
	      q = r ; 
	      r = mem [ r ] .hhfield .v.RH ; 
	      freenode ( q , 2 ) ; 
	    } 
	  } 
	while ( t++ < for_end ) ; } 
	flushnodelist ( s ) ; 
	if ( fixneeded ) 
	fixdependencies () ; 
	{
	  if ( aritherror ) 
	  cleararith () ; 
	} 
      } 
    } 
    break ; 
  case 20 : 
  case 21 : 
    confusion ( 815 ) ; 
    break ; 
  case 22 : 
  case 23 : 
    deletemacref ( mem [ p + 1 ] .cint ) ; 
    break ; 
  } 
  mem [ p ] .hhfield .b0 = 0 ; 
} 
void zflushcurexp ( v ) 
scaled v ; 
{switch ( curtype ) 
  {case 3 : 
  case 5 : 
  case 7 : 
  case 11 : 
  case 9 : 
  case 12 : 
  case 13 : 
  case 14 : 
  case 17 : 
  case 18 : 
  case 19 : 
    {
      recyclevalue ( curexp ) ; 
      freenode ( curexp , 2 ) ; 
    } 
    break ; 
  case 4 : 
    {
      if ( strref [ curexp ] < 127 ) 
      if ( strref [ curexp ] > 1 ) 
      decr ( strref [ curexp ] ) ; 
      else flushstring ( curexp ) ; 
    } 
    break ; 
  case 6 : 
  case 8 : 
    tossknotlist ( curexp ) ; 
    break ; 
  case 10 : 
    if ( mem [ curexp ] .hhfield .lhfield == 0 ) 
    tossedges ( curexp ) ; 
    else decr ( mem [ curexp ] .hhfield .lhfield ) ; 
    break ; 
    default: 
    ; 
    break ; 
  } 
  curtype = 16 ; 
  curexp = v ; 
} 
void zflusherror ( v ) 
scaled v ; 
{error () ; 
  flushcurexp ( v ) ; 
} 
void putgeterror ( ) 
{backerror () ; 
  getxnext () ; 
} 
void zputgetflusherror ( v ) 
scaled v ; 
{putgeterror () ; 
  flushcurexp ( v ) ; 
} 
void zflushbelowvariable ( p ) 
halfword p ; 
{halfword q, r  ; 
  if ( mem [ p ] .hhfield .b0 != 21 ) 
  recyclevalue ( p ) ; 
  else {
      
    q = mem [ p + 1 ] .hhfield .v.RH ; 
    while ( mem [ q ] .hhfield .b1 == 3 ) {
	
      flushbelowvariable ( q ) ; 
      r = q ; 
      q = mem [ q ] .hhfield .v.RH ; 
      freenode ( r , 3 ) ; 
    } 
    r = mem [ p + 1 ] .hhfield .lhfield ; 
    q = mem [ r ] .hhfield .v.RH ; 
    recyclevalue ( r ) ; 
    if ( mem [ p ] .hhfield .b1 <= 1 ) 
    freenode ( r , 2 ) ; 
    else freenode ( r , 3 ) ; 
    do {
	flushbelowvariable ( q ) ; 
      r = q ; 
      q = mem [ q ] .hhfield .v.RH ; 
      freenode ( r , 3 ) ; 
    } while ( ! ( q == 9 ) ) ; 
    mem [ p ] .hhfield .b0 = 0 ; 
  } 
} 
void zflushvariable ( p , t , discardsuffixes ) 
halfword p ; 
halfword t ; 
boolean discardsuffixes ; 
{/* 10 */ halfword q, r  ; 
  halfword n  ; 
  while ( t != 0 ) {
      
    if ( mem [ p ] .hhfield .b0 != 21 ) 
    goto lab10 ; 
    n = mem [ t ] .hhfield .lhfield ; 
    t = mem [ t ] .hhfield .v.RH ; 
    if ( n == 0 ) 
    {
      r = p + 1 ; 
      q = mem [ r ] .hhfield .v.RH ; 
      while ( mem [ q ] .hhfield .b1 == 3 ) {
	  
	flushvariable ( q , t , discardsuffixes ) ; 
	if ( t == 0 ) 
	if ( mem [ q ] .hhfield .b0 == 21 ) 
	r = q ; 
	else {
	    
	  mem [ r ] .hhfield .v.RH = mem [ q ] .hhfield .v.RH ; 
	  freenode ( q , 3 ) ; 
	} 
	else r = q ; 
	q = mem [ r ] .hhfield .v.RH ; 
      } 
    } 
    p = mem [ p + 1 ] .hhfield .lhfield ; 
    do {
	r = p ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } while ( ! ( mem [ p + 2 ] .hhfield .lhfield >= n ) ) ; 
    if ( mem [ p + 2 ] .hhfield .lhfield != n ) 
    goto lab10 ; 
  } 
  if ( discardsuffixes ) 
  flushbelowvariable ( p ) ; 
  else {
      
    if ( mem [ p ] .hhfield .b0 == 21 ) 
    p = mem [ p + 1 ] .hhfield .lhfield ; 
    recyclevalue ( p ) ; 
  } 
  lab10: ; 
} 
smallnumber zundtype ( p ) 
halfword p ; 
{register smallnumber Result; switch ( mem [ p ] .hhfield .b0 ) 
  {case 0 : 
  case 1 : 
    Result = 0 ; 
    break ; 
  case 2 : 
  case 3 : 
    Result = 3 ; 
    break ; 
  case 4 : 
  case 5 : 
    Result = 5 ; 
    break ; 
  case 6 : 
  case 7 : 
    Result = 7 ; 
    break ; 
  case 8 : 
  case 9 : 
    Result = 9 ; 
    break ; 
  case 10 : 
  case 11 : 
    Result = 11 ; 
    break ; 
  case 12 : 
  case 13 : 
  case 14 : 
  case 15 : 
    Result = mem [ p ] .hhfield .b0 ; 
    break ; 
  case 16 : 
  case 17 : 
  case 18 : 
  case 19 : 
    Result = 15 ; 
    break ; 
  } 
  return(Result) ; 
} 
void zclearsymbol ( p , saving ) 
halfword p ; 
boolean saving ; 
{halfword q  ; 
  q = eqtb [ p ] .v.RH ; 
  switch ( eqtb [ p ] .lhfield % 85 ) 
  {case 13 : 
  case 55 : 
  case 46 : 
  case 51 : 
    if ( ! saving ) 
    deletemacref ( q ) ; 
    break ; 
  case 43 : 
    if ( q != 0 ) 
    if ( saving ) 
    mem [ q ] .hhfield .b1 = 1 ; 
    else {
	
      flushbelowvariable ( q ) ; 
      freenode ( q , 2 ) ; 
    } 
    break ; 
    default: 
    ; 
    break ; 
  } 
  eqtb [ p ] = eqtb [ 2371 ] ; 
} 
void zsavevariable ( q ) 
halfword q ; 
{halfword p  ; 
  if ( saveptr != 0 ) 
  {
    p = getnode ( 2 ) ; 
    mem [ p ] .hhfield .lhfield = q ; 
    mem [ p ] .hhfield .v.RH = saveptr ; 
    mem [ p + 1 ] .hhfield = eqtb [ q ] ; 
    saveptr = p ; 
  } 
  clearsymbol ( q , ( saveptr != 0 ) ) ; 
} 
void zsaveinternal ( q ) 
halfword q ; 
{halfword p  ; 
  if ( saveptr != 0 ) 
  {
    p = getnode ( 2 ) ; 
    mem [ p ] .hhfield .lhfield = 2371 + q ; 
    mem [ p ] .hhfield .v.RH = saveptr ; 
    mem [ p + 1 ] .cint = internal [ q ] ; 
    saveptr = p ; 
  } 
} 
void unsave ( ) 
{halfword q  ; 
  halfword p  ; 
  while ( mem [ saveptr ] .hhfield .lhfield != 0 ) {
      
    q = mem [ saveptr ] .hhfield .lhfield ; 
    if ( q > 2371 ) 
    {
      if ( internal [ 7 ] > 0 ) 
      {
	begindiagnostic () ; 
	printnl ( 531 ) ; 
	print ( intname [ q - ( 2371 ) ] ) ; 
	printchar ( 61 ) ; 
	printscaled ( mem [ saveptr + 1 ] .cint ) ; 
	printchar ( 125 ) ; 
	enddiagnostic ( false ) ; 
      } 
      internal [ q - ( 2371 ) ] = mem [ saveptr + 1 ] .cint ; 
    } 
    else {
	
      if ( internal [ 7 ] > 0 ) 
      {
	begindiagnostic () ; 
	printnl ( 531 ) ; 
	print ( hash [ q ] .v.RH ) ; 
	printchar ( 125 ) ; 
	enddiagnostic ( false ) ; 
      } 
      clearsymbol ( q , false ) ; 
      eqtb [ q ] = mem [ saveptr + 1 ] .hhfield ; 
      if ( eqtb [ q ] .lhfield % 85 == 43 ) 
      {
	p = eqtb [ q ] .v.RH ; 
	if ( p != 0 ) 
	mem [ p ] .hhfield .b1 = 0 ; 
      } 
    } 
    p = mem [ saveptr ] .hhfield .v.RH ; 
    freenode ( saveptr , 2 ) ; 
    saveptr = p ; 
  } 
  p = mem [ saveptr ] .hhfield .v.RH ; 
  {
    mem [ saveptr ] .hhfield .v.RH = avail ; 
    avail = saveptr ; 
	;
#ifdef STAT
    decr ( dynused ) ; 
#endif /* STAT */
  } 
  saveptr = p ; 
} 
halfword zcopyknot ( p ) 
halfword p ; 
{register halfword Result; halfword q  ; 
  char k  ; 
  q = getnode ( 7 ) ; 
  {register integer for_end; k = 0 ; for_end = 6 ; if ( k <= for_end) do 
    mem [ q + k ] = mem [ p + k ] ; 
  while ( k++ < for_end ) ; } 
  Result = q ; 
  return(Result) ; 
} 
halfword zcopypath ( p ) 
halfword p ; 
{register halfword Result; halfword q, pp, qq  ; 
  q = copyknot ( p ) ; 
  qq = q ; 
  pp = mem [ p ] .hhfield .v.RH ; 
  while ( pp != p ) {
      
    mem [ qq ] .hhfield .v.RH = copyknot ( pp ) ; 
    qq = mem [ qq ] .hhfield .v.RH ; 
    pp = mem [ pp ] .hhfield .v.RH ; 
  } 
  mem [ qq ] .hhfield .v.RH = q ; 
  Result = q ; 
  return(Result) ; 
} 
halfword zhtapypoc ( p ) 
halfword p ; 
{/* 10 */ register halfword Result; halfword q, pp, qq, rr  ; 
  q = getnode ( 7 ) ; 
  qq = q ; 
  pp = p ; 
  while ( true ) {
      
    mem [ qq ] .hhfield .b1 = mem [ pp ] .hhfield .b0 ; 
    mem [ qq ] .hhfield .b0 = mem [ pp ] .hhfield .b1 ; 
    mem [ qq + 1 ] .cint = mem [ pp + 1 ] .cint ; 
    mem [ qq + 2 ] .cint = mem [ pp + 2 ] .cint ; 
    mem [ qq + 5 ] .cint = mem [ pp + 3 ] .cint ; 
    mem [ qq + 6 ] .cint = mem [ pp + 4 ] .cint ; 
    mem [ qq + 3 ] .cint = mem [ pp + 5 ] .cint ; 
    mem [ qq + 4 ] .cint = mem [ pp + 6 ] .cint ; 
    if ( mem [ pp ] .hhfield .v.RH == p ) 
    {
      mem [ q ] .hhfield .v.RH = qq ; 
      pathtail = pp ; 
      Result = q ; 
      goto lab10 ; 
    } 
    rr = getnode ( 7 ) ; 
    mem [ rr ] .hhfield .v.RH = qq ; 
    qq = rr ; 
    pp = mem [ pp ] .hhfield .v.RH ; 
  } 
  lab10: ; 
  return(Result) ; 
} 
fraction zcurlratio ( gamma , atension , btension ) 
scaled gamma ; 
scaled atension ; 
scaled btension ; 
{register fraction Result; fraction alpha, beta, num, denom, ff  ; 
  alpha = makefraction ( 65536L , atension ) ; 
  beta = makefraction ( 65536L , btension ) ; 
  if ( alpha <= beta ) 
  {
    ff = makefraction ( alpha , beta ) ; 
    ff = takefraction ( ff , ff ) ; 
    gamma = takefraction ( gamma , ff ) ; 
    beta = beta / 4096 ; 
    denom = takefraction ( gamma , alpha ) + 196608L - beta ; 
    num = takefraction ( gamma , 805306368L - alpha ) + beta ; 
  } 
  else {
      
    ff = makefraction ( beta , alpha ) ; 
    ff = takefraction ( ff , ff ) ; 
    beta = takefraction ( beta , ff ) / 4096 ; 
    denom = takefraction ( gamma , alpha ) + ( ff / 1365 ) - beta ; 
    num = takefraction ( gamma , 805306368L - alpha ) + beta ; 
  } 
  if ( num >= denom + denom + denom + denom ) 
  Result = 1073741824L ; 
  else Result = makefraction ( num , denom ) ; 
  return(Result) ; 
} 
void zsetcontrols ( p , q , k ) 
halfword p ; 
halfword q ; 
integer k ; 
{fraction rr, ss  ; 
  scaled lt, rt  ; 
  fraction sine  ; 
  lt = abs ( mem [ q + 4 ] .cint ) ; 
  rt = abs ( mem [ p + 6 ] .cint ) ; 
  rr = velocity ( st , ct , sf , cf , rt ) ; 
  ss = velocity ( sf , cf , st , ct , lt ) ; 
  if ( ( mem [ p + 6 ] .cint < 0 ) || ( mem [ q + 4 ] .cint < 0 ) ) 
  if ( ( ( st >= 0 ) && ( sf >= 0 ) ) || ( ( st <= 0 ) && ( sf <= 0 ) ) ) 
  {
    sine = takefraction ( abs ( st ) , cf ) + takefraction ( abs ( sf ) , ct ) 
    ; 
    if ( sine > 0 ) 
    {
      sine = takefraction ( sine , 268500992L ) ; 
      if ( mem [ p + 6 ] .cint < 0 ) 
      if ( abvscd ( abs ( sf ) , 268435456L , rr , sine ) < 0 ) 
      rr = makefraction ( abs ( sf ) , sine ) ; 
      if ( mem [ q + 4 ] .cint < 0 ) 
      if ( abvscd ( abs ( st ) , 268435456L , ss , sine ) < 0 ) 
      ss = makefraction ( abs ( st ) , sine ) ; 
    } 
  } 
  mem [ p + 5 ] .cint = mem [ p + 1 ] .cint + takefraction ( takefraction ( 
  deltax [ k ] , ct ) - takefraction ( deltay [ k ] , st ) , rr ) ; 
  mem [ p + 6 ] .cint = mem [ p + 2 ] .cint + takefraction ( takefraction ( 
  deltay [ k ] , ct ) + takefraction ( deltax [ k ] , st ) , rr ) ; 
  mem [ q + 3 ] .cint = mem [ q + 1 ] .cint - takefraction ( takefraction ( 
  deltax [ k ] , cf ) + takefraction ( deltay [ k ] , sf ) , ss ) ; 
  mem [ q + 4 ] .cint = mem [ q + 2 ] .cint - takefraction ( takefraction ( 
  deltay [ k ] , cf ) - takefraction ( deltax [ k ] , sf ) , ss ) ; 
  mem [ p ] .hhfield .b1 = 1 ; 
  mem [ q ] .hhfield .b0 = 1 ; 
} 
void zsolvechoices ( p , q , n ) 
halfword p ; 
halfword q ; 
halfword n ; 
{/* 40 10 */ integer k  ; 
  halfword r, s, t  ; 
  fraction aa, bb, cc, ff, acc  ; 
  scaled dd, ee  ; 
  scaled lt, rt  ; 
  k = 0 ; 
  s = p ; 
  while ( true ) {
      
    t = mem [ s ] .hhfield .v.RH ; 
    if ( k == 0 ) 
    switch ( mem [ s ] .hhfield .b1 ) 
    {case 2 : 
      if ( mem [ t ] .hhfield .b0 == 2 ) 
      {
	aa = narg ( deltax [ 0 ] , deltay [ 0 ] ) ; 
	nsincos ( mem [ p + 5 ] .cint - aa ) ; 
	ct = ncos ; 
	st = nsin ; 
	nsincos ( mem [ q + 3 ] .cint - aa ) ; 
	cf = ncos ; 
	sf = - (integer) nsin ; 
	setcontrols ( p , q , 0 ) ; 
	goto lab10 ; 
      } 
      else {
	  
	vv [ 0 ] = mem [ s + 5 ] .cint - narg ( deltax [ 0 ] , deltay [ 0 ] ) 
	; 
	if ( abs ( vv [ 0 ] ) > 188743680L ) 
	if ( vv [ 0 ] > 0 ) 
	vv [ 0 ] = vv [ 0 ] - 377487360L ; 
	else vv [ 0 ] = vv [ 0 ] + 377487360L ; 
	uu [ 0 ] = 0 ; 
	ww [ 0 ] = 0 ; 
      } 
      break ; 
    case 3 : 
      if ( mem [ t ] .hhfield .b0 == 3 ) 
      {
	mem [ p ] .hhfield .b1 = 1 ; 
	mem [ q ] .hhfield .b0 = 1 ; 
	lt = abs ( mem [ q + 4 ] .cint ) ; 
	rt = abs ( mem [ p + 6 ] .cint ) ; 
	if ( rt == 65536L ) 
	{
	  if ( deltax [ 0 ] >= 0 ) 
	  mem [ p + 5 ] .cint = mem [ p + 1 ] .cint + ( ( deltax [ 0 ] + 1 ) / 
	  3 ) ; 
	  else mem [ p + 5 ] .cint = mem [ p + 1 ] .cint + ( ( deltax [ 0 ] - 
	  1 ) / 3 ) ; 
	  if ( deltay [ 0 ] >= 0 ) 
	  mem [ p + 6 ] .cint = mem [ p + 2 ] .cint + ( ( deltay [ 0 ] + 1 ) / 
	  3 ) ; 
	  else mem [ p + 6 ] .cint = mem [ p + 2 ] .cint + ( ( deltay [ 0 ] - 
	  1 ) / 3 ) ; 
	} 
	else {
	    
	  ff = makefraction ( 65536L , 3 * rt ) ; 
	  mem [ p + 5 ] .cint = mem [ p + 1 ] .cint + takefraction ( deltax [ 
	  0 ] , ff ) ; 
	  mem [ p + 6 ] .cint = mem [ p + 2 ] .cint + takefraction ( deltay [ 
	  0 ] , ff ) ; 
	} 
	if ( lt == 65536L ) 
	{
	  if ( deltax [ 0 ] >= 0 ) 
	  mem [ q + 3 ] .cint = mem [ q + 1 ] .cint - ( ( deltax [ 0 ] + 1 ) / 
	  3 ) ; 
	  else mem [ q + 3 ] .cint = mem [ q + 1 ] .cint - ( ( deltax [ 0 ] - 
	  1 ) / 3 ) ; 
	  if ( deltay [ 0 ] >= 0 ) 
	  mem [ q + 4 ] .cint = mem [ q + 2 ] .cint - ( ( deltay [ 0 ] + 1 ) / 
	  3 ) ; 
	  else mem [ q + 4 ] .cint = mem [ q + 2 ] .cint - ( ( deltay [ 0 ] - 
	  1 ) / 3 ) ; 
	} 
	else {
	    
	  ff = makefraction ( 65536L , 3 * lt ) ; 
	  mem [ q + 3 ] .cint = mem [ q + 1 ] .cint - takefraction ( deltax [ 
	  0 ] , ff ) ; 
	  mem [ q + 4 ] .cint = mem [ q + 2 ] .cint - takefraction ( deltay [ 
	  0 ] , ff ) ; 
	} 
	goto lab10 ; 
      } 
      else {
	  
	cc = mem [ s + 5 ] .cint ; 
	lt = abs ( mem [ t + 4 ] .cint ) ; 
	rt = abs ( mem [ s + 6 ] .cint ) ; 
	if ( ( rt == 65536L ) && ( lt == 65536L ) ) 
	uu [ 0 ] = makefraction ( cc + cc + 65536L , cc + 131072L ) ; 
	else uu [ 0 ] = curlratio ( cc , rt , lt ) ; 
	vv [ 0 ] = - (integer) takefraction ( psi [ 1 ] , uu [ 0 ] ) ; 
	ww [ 0 ] = 0 ; 
      } 
      break ; 
    case 4 : 
      {
	uu [ 0 ] = 0 ; 
	vv [ 0 ] = 0 ; 
	ww [ 0 ] = 268435456L ; 
      } 
      break ; 
    } 
    else switch ( mem [ s ] .hhfield .b0 ) 
    {case 5 : 
    case 4 : 
      {
	if ( abs ( mem [ r + 6 ] .cint ) == 65536L ) 
	{
	  aa = 134217728L ; 
	  dd = 2 * delta [ k ] ; 
	} 
	else {
	    
	  aa = makefraction ( 65536L , 3 * abs ( mem [ r + 6 ] .cint ) - 
	  65536L ) ; 
	  dd = takefraction ( delta [ k ] , 805306368L - makefraction ( 65536L 
	  , abs ( mem [ r + 6 ] .cint ) ) ) ; 
	} 
	if ( abs ( mem [ t + 4 ] .cint ) == 65536L ) 
	{
	  bb = 134217728L ; 
	  ee = 2 * delta [ k - 1 ] ; 
	} 
	else {
	    
	  bb = makefraction ( 65536L , 3 * abs ( mem [ t + 4 ] .cint ) - 
	  65536L ) ; 
	  ee = takefraction ( delta [ k - 1 ] , 805306368L - makefraction ( 
	  65536L , abs ( mem [ t + 4 ] .cint ) ) ) ; 
	} 
	cc = 268435456L - takefraction ( uu [ k - 1 ] , aa ) ; 
	dd = takefraction ( dd , cc ) ; 
	lt = abs ( mem [ s + 4 ] .cint ) ; 
	rt = abs ( mem [ s + 6 ] .cint ) ; 
	if ( lt != rt ) 
	if ( lt < rt ) 
	{
	  ff = makefraction ( lt , rt ) ; 
	  ff = takefraction ( ff , ff ) ; 
	  dd = takefraction ( dd , ff ) ; 
	} 
	else {
	    
	  ff = makefraction ( rt , lt ) ; 
	  ff = takefraction ( ff , ff ) ; 
	  ee = takefraction ( ee , ff ) ; 
	} 
	ff = makefraction ( ee , ee + dd ) ; 
	uu [ k ] = takefraction ( ff , bb ) ; 
	acc = - (integer) takefraction ( psi [ k + 1 ] , uu [ k ] ) ; 
	if ( mem [ r ] .hhfield .b1 == 3 ) 
	{
	  ww [ k ] = 0 ; 
	  vv [ k ] = acc - takefraction ( psi [ 1 ] , 268435456L - ff ) ; 
	} 
	else {
	    
	  ff = makefraction ( 268435456L - ff , cc ) ; 
	  acc = acc - takefraction ( psi [ k ] , ff ) ; 
	  ff = takefraction ( ff , aa ) ; 
	  vv [ k ] = acc - takefraction ( vv [ k - 1 ] , ff ) ; 
	  if ( ww [ k - 1 ] == 0 ) 
	  ww [ k ] = 0 ; 
	  else ww [ k ] = - (integer) takefraction ( ww [ k - 1 ] , ff ) ; 
	} 
	if ( mem [ s ] .hhfield .b0 == 5 ) 
	{
	  aa = 0 ; 
	  bb = 268435456L ; 
	  do {
	      decr ( k ) ; 
	    if ( k == 0 ) 
	    k = n ; 
	    aa = vv [ k ] - takefraction ( aa , uu [ k ] ) ; 
	    bb = ww [ k ] - takefraction ( bb , uu [ k ] ) ; 
	  } while ( ! ( k == n ) ) ; 
	  aa = makefraction ( aa , 268435456L - bb ) ; 
	  theta [ n ] = aa ; 
	  vv [ 0 ] = aa ; 
	  {register integer for_end; k = 1 ; for_end = n - 1 ; if ( k <= 
	  for_end) do 
	    vv [ k ] = vv [ k ] + takefraction ( aa , ww [ k ] ) ; 
	  while ( k++ < for_end ) ; } 
	  goto lab40 ; 
	} 
      } 
      break ; 
    case 3 : 
      {
	cc = mem [ s + 3 ] .cint ; 
	lt = abs ( mem [ s + 4 ] .cint ) ; 
	rt = abs ( mem [ r + 6 ] .cint ) ; 
	if ( ( rt == 65536L ) && ( lt == 65536L ) ) 
	ff = makefraction ( cc + cc + 65536L , cc + 131072L ) ; 
	else ff = curlratio ( cc , lt , rt ) ; 
	theta [ n ] = - (integer) makefraction ( takefraction ( vv [ n - 1 ] ,	ff ) , 268435456L - takefraction ( ff , uu [ n - 1 ] ) ) ; 
	goto lab40 ; 
      } 
      break ; 
    case 2 : 
      {
	theta [ n ] = mem [ s + 3 ] .cint - narg ( deltax [ n - 1 ] , deltay [ 
	n - 1 ] ) ; 
	if ( abs ( theta [ n ] ) > 188743680L ) 
	if ( theta [ n ] > 0 ) 
	theta [ n ] = theta [ n ] - 377487360L ; 
	else theta [ n ] = theta [ n ] + 377487360L ; 
	goto lab40 ; 
      } 
      break ; 
    } 
    r = s ; 
    s = t ; 
    incr ( k ) ; 
  } 
  lab40: {
      register integer for_end; k = n - 1 ; for_end = 0 ; if ( k >= 
  for_end) do 
    theta [ k ] = vv [ k ] - takefraction ( theta [ k + 1 ] , uu [ k ] ) ; 
  while ( k-- > for_end ) ; } 
  s = p ; 
  k = 0 ; 
  do {
      t = mem [ s ] .hhfield .v.RH ; 
    nsincos ( theta [ k ] ) ; 
    st = nsin ; 
    ct = ncos ; 
    nsincos ( - (integer) psi [ k + 1 ] - theta [ k + 1 ] ) ; 
    sf = nsin ; 
    cf = ncos ; 
    setcontrols ( s , t , k ) ; 
    incr ( k ) ; 
    s = t ; 
  } while ( ! ( k == n ) ) ; 
  lab10: ; 
} 
void zmakechoices ( knots ) 
halfword knots ; 
{/* 30 */ halfword h  ; 
  halfword p, q  ; 
  integer k, n  ; 
  halfword s, t  ; 
  scaled delx, dely  ; 
  fraction sine, cosine  ; 
  {
    if ( aritherror ) 
    cleararith () ; 
  } 
  if ( internal [ 4 ] > 0 ) 
  printpath ( knots , 541 , true ) ; 
  p = knots ; 
  do {
      q = mem [ p ] .hhfield .v.RH ; 
    if ( mem [ p + 1 ] .cint == mem [ q + 1 ] .cint ) 
    if ( mem [ p + 2 ] .cint == mem [ q + 2 ] .cint ) 
    if ( mem [ p ] .hhfield .b1 > 1 ) 
    {
      mem [ p ] .hhfield .b1 = 1 ; 
      if ( mem [ p ] .hhfield .b0 == 4 ) 
      {
	mem [ p ] .hhfield .b0 = 3 ; 
	mem [ p + 3 ] .cint = 65536L ; 
      } 
      mem [ q ] .hhfield .b0 = 1 ; 
      if ( mem [ q ] .hhfield .b1 == 4 ) 
      {
	mem [ q ] .hhfield .b1 = 3 ; 
	mem [ q + 5 ] .cint = 65536L ; 
      } 
      mem [ p + 5 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ q + 3 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ p + 6 ] .cint = mem [ p + 2 ] .cint ; 
      mem [ q + 4 ] .cint = mem [ p + 2 ] .cint ; 
    } 
    p = q ; 
  } while ( ! ( p == knots ) ) ; 
  h = knots ; 
  while ( true ) {
      
    if ( mem [ h ] .hhfield .b0 != 4 ) 
    goto lab30 ; 
    if ( mem [ h ] .hhfield .b1 != 4 ) 
    goto lab30 ; 
    h = mem [ h ] .hhfield .v.RH ; 
    if ( h == knots ) 
    {
      mem [ h ] .hhfield .b0 = 5 ; 
      goto lab30 ; 
    } 
  } 
  lab30: ; 
  p = h ; 
  do {
      q = mem [ p ] .hhfield .v.RH ; 
    if ( mem [ p ] .hhfield .b1 >= 2 ) 
    {
      while ( ( mem [ q ] .hhfield .b0 == 4 ) && ( mem [ q ] .hhfield .b1 == 4 
      ) ) q = mem [ q ] .hhfield .v.RH ; 
      k = 0 ; 
      s = p ; 
      n = pathsize ; 
      do {
	  t = mem [ s ] .hhfield .v.RH ; 
	deltax [ k ] = mem [ t + 1 ] .cint - mem [ s + 1 ] .cint ; 
	deltay [ k ] = mem [ t + 2 ] .cint - mem [ s + 2 ] .cint ; 
	delta [ k ] = pythadd ( deltax [ k ] , deltay [ k ] ) ; 
	if ( k > 0 ) 
	{
	  sine = makefraction ( deltay [ k - 1 ] , delta [ k - 1 ] ) ; 
	  cosine = makefraction ( deltax [ k - 1 ] , delta [ k - 1 ] ) ; 
	  psi [ k ] = narg ( takefraction ( deltax [ k ] , cosine ) + 
	  takefraction ( deltay [ k ] , sine ) , takefraction ( deltay [ k ] ,	  cosine ) - takefraction ( deltax [ k ] , sine ) ) ; 
	} 
	incr ( k ) ; 
	s = t ; 
	if ( k == pathsize ) 
	overflow ( 546 , pathsize ) ; 
	if ( s == q ) 
	n = k ; 
      } while ( ! ( ( k >= n ) && ( mem [ s ] .hhfield .b0 != 5 ) ) ) ; 
      if ( k == n ) 
      psi [ n ] = 0 ; 
      else psi [ k ] = psi [ 1 ] ; 
      if ( mem [ q ] .hhfield .b0 == 4 ) 
      {
	delx = mem [ q + 5 ] .cint - mem [ q + 1 ] .cint ; 
	dely = mem [ q + 6 ] .cint - mem [ q + 2 ] .cint ; 
	if ( ( delx == 0 ) && ( dely == 0 ) ) 
	{
	  mem [ q ] .hhfield .b0 = 3 ; 
	  mem [ q + 3 ] .cint = 65536L ; 
	} 
	else {
	    
	  mem [ q ] .hhfield .b0 = 2 ; 
	  mem [ q + 3 ] .cint = narg ( delx , dely ) ; 
	} 
      } 
      if ( ( mem [ p ] .hhfield .b1 == 4 ) && ( mem [ p ] .hhfield .b0 == 1 ) 
      ) 
      {
	delx = mem [ p + 1 ] .cint - mem [ p + 3 ] .cint ; 
	dely = mem [ p + 2 ] .cint - mem [ p + 4 ] .cint ; 
	if ( ( delx == 0 ) && ( dely == 0 ) ) 
	{
	  mem [ p ] .hhfield .b1 = 3 ; 
	  mem [ p + 5 ] .cint = 65536L ; 
	} 
	else {
	    
	  mem [ p ] .hhfield .b1 = 2 ; 
	  mem [ p + 5 ] .cint = narg ( delx , dely ) ; 
	} 
      } 
      solvechoices ( p , q , n ) ; 
    } 
    else if ( mem [ p ] .hhfield .b1 == 0 ) 
    {
      mem [ p + 5 ] .cint = mem [ p + 1 ] .cint ; 
      mem [ p + 6 ] .cint = mem [ p + 2 ] .cint ; 
      mem [ q + 3 ] .cint = mem [ q + 1 ] .cint ; 
      mem [ q + 4 ] .cint = mem [ q + 2 ] .cint ; 
    } 
    p = q ; 
  } while ( ! ( p == h ) ) ; 
  if ( internal [ 4 ] > 0 ) 
  printpath ( knots , 542 , true ) ; 
  if ( aritherror ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 543 ) ; 
    } 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 544 ; 
      helpline [ 0 ] = 545 ; 
    } 
    putgeterror () ; 
    aritherror = false ; 
  } 
}