#define EXTERN extern
#include "mpd.h"
scaled zmexp ( x )
scaled x ;
{register scaled Result; smallnumber k ;
integer y, z ;
if ( x > 174436200L )
{
aritherror = true ;
Result = 2147483647L ;
}
else if ( x < -197694359L )
Result = 0 ;
else {
if ( x <= 0 )
{
z = -8 * x ;
y = 1048576L ;
}
else {
if ( x <= 127919879L )
z = 1023359037L - 8 * x ;
else z = 8 * ( 174436200L - x ) ;
y = 2147483647L ;
}
k = 1 ;
while ( z > 0 ) {
while ( z >= speclog [ k ] ) {
z = z - speclog [ k ] ;
y = y - 1 - ( ( y - twotothe [ k - 1 ] ) / twotothe [ k ] ) ;
}
incr ( k ) ;
}
if ( x <= 127919879L )
Result = ( y + 8 ) / 16 ;
else Result = y ;
}
return(Result) ;
}
angle znarg ( x , y )
integer x ;
integer y ;
{register angle Result; angle z ;
integer t ;
smallnumber k ;
char octant ;
if ( x >= 0 )
octant = 1 ;
else {
x = - (integer) x ;
octant = 2 ;
}
if ( y < 0 )
{
y = - (integer) y ;
octant = octant + 2 ;
}
if ( x < y )
{
t = y ;
y = x ;
x = t ;
octant = octant + 4 ;
}
if ( x == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 314 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 315 ;
helpline [ 0 ] = 309 ;
}
error () ;
Result = 0 ;
}
else {
while ( x >= 536870912L ) {
x = halfp ( x ) ;
y = halfp ( y ) ;
}
z = 0 ;
if ( y > 0 )
{
while ( x < 268435456L ) {
x = x + x ;
y = y + y ;
}
k = 0 ;
do {
y = y + y ;
incr ( k ) ;
if ( y > x )
{
z = z + specatan [ k ] ;
t = x ;
x = x + ( y / twotothe [ k + k ] ) ;
y = y - t ;
}
} while ( ! ( k == 15 ) ) ;
do {
y = y + y ;
incr ( k ) ;
if ( y > x )
{
z = z + specatan [ k ] ;
y = y - x ;
}
} while ( ! ( k == 26 ) ) ;
}
switch ( octant )
{case 1 :
Result = z ;
break ;
case 5 :
Result = 94371840L - z ;
break ;
case 6 :
Result = 94371840L + z ;
break ;
case 2 :
Result = 188743680L - z ;
break ;
case 4 :
Result = z - 188743680L ;
break ;
case 8 :
Result = - (integer) z - 94371840L ;
break ;
case 7 :
Result = z - 94371840L ;
break ;
case 3 :
Result = - (integer) z ;
break ;
}
}
return(Result) ;
}
void znsincos ( z )
angle z ;
{smallnumber k ;
char q ;
fraction r ;
integer x, y, t ;
while ( z < 0 ) z = z + 377487360L ;
z = z % 377487360L ;
q = z / 47185920L ;
z = z % 47185920L ;
x = 268435456L ;
y = x ;
if ( ! odd ( q ) )
z = 47185920L - z ;
k = 1 ;
while ( z > 0 ) {
if ( z >= specatan [ k ] )
{
z = z - specatan [ k ] ;
t = x ;
x = t + y / twotothe [ k ] ;
y = y - t / twotothe [ k ] ;
}
incr ( k ) ;
}
if ( y < 0 )
y = 0 ;
switch ( q )
{case 0 :
;
break ;
case 1 :
{
t = x ;
x = y ;
y = t ;
}
break ;
case 2 :
{
t = x ;
x = - (integer) y ;
y = t ;
}
break ;
case 3 :
x = - (integer) x ;
break ;
case 4 :
{
x = - (integer) x ;
y = - (integer) y ;
}
break ;
case 5 :
{
t = x ;
x = - (integer) y ;
y = - (integer) t ;
}
break ;
case 6 :
{
t = x ;
x = y ;
y = - (integer) t ;
}
break ;
case 7 :
y = - (integer) y ;
break ;
}
r = pythadd ( x , y ) ;
ncos = makefraction ( x , r ) ;
nsin = makefraction ( y , r ) ;
}
void newrandoms ( )
{char k ;
fraction x ;
{register integer for_end; k = 0 ; for_end = 23 ; if ( k <= for_end) do
{
x = randoms [ k ] - randoms [ k + 31 ] ;
if ( x < 0 )
x = x + 268435456L ;
randoms [ k ] = x ;
}
while ( k++ < for_end ) ; }
{register integer for_end; k = 24 ; for_end = 54 ; if ( k <= for_end) do
{
x = randoms [ k ] - randoms [ k - 24 ] ;
if ( x < 0 )
x = x + 268435456L ;
randoms [ k ] = x ;
}
while ( k++ < for_end ) ; }
jrandom = 54 ;
}
void zinitrandoms ( seed )
scaled seed ;
{fraction j, jj, k ;
char i ;
j = abs ( seed ) ;
while ( j >= 268435456L ) j = halfp ( j ) ;
k = 1 ;
{register integer for_end; i = 0 ; for_end = 54 ; if ( i <= for_end) do
{
jj = k ;
k = j - k ;
j = jj ;
if ( k < 0 )
k = k + 268435456L ;
randoms [ ( i * 21 ) % 55 ] = j ;
}
while ( i++ < for_end ) ; }
newrandoms () ;
newrandoms () ;
newrandoms () ;
}
scaled zunifrand ( x )
scaled x ;
{register scaled Result; scaled y ;
if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
y = takefraction ( abs ( x ) , randoms [ jrandom ] ) ;
if ( y == abs ( x ) )
Result = 0 ;
else if ( x > 0 )
Result = y ;
else Result = - (integer) y ;
return(Result) ;
}
scaled normrand ( )
{register scaled Result; integer x, u, l ;
do {
do { if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
x = takefraction ( 112429L , randoms [ jrandom ] - 134217728L ) ;
if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
u = randoms [ jrandom ] ;
} while ( ! ( abs ( x ) < u ) ) ;
x = makefraction ( x , u ) ;
l = 139548960L - mlog ( u ) ;
} while ( ! ( abvscd ( 1024 , l , x , x ) >= 0 ) ) ;
Result = x ;
return(Result) ;
}
#ifdef DEBUG
void zprintword ( w )
memoryword w ;
{printint ( w .cint ) ;
printchar ( 32 ) ;
printscaled ( w .cint ) ;
printchar ( 32 ) ;
printscaled ( w .cint / 4096 ) ;
println () ;
printint ( w .hhfield .lhfield ) ;
printchar ( 61 ) ;
printint ( w .hhfield .b0 ) ;
printchar ( 58 ) ;
printint ( w .hhfield .b1 ) ;
printchar ( 59 ) ;
printint ( w .hhfield .v.RH ) ;
printchar ( 32 ) ;
printint ( w .qqqq .b0 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b1 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b2 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b3 ) ;
}
#endif /* DEBUG */
void zshowtokenlist ( p , q , l , nulltally )
integer p ;
integer q ;
integer l ;
integer nulltally ;
{/* 10 */ smallnumber class, c ;
integer r, v ;
class = 3 ;
tally = nulltally ;
while ( ( p != 0 ) && ( tally < l ) ) {
if ( p == q )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
c = 9 ;
if ( ( p < 0 ) || ( p > memend ) )
{
print ( 505 ) ;
goto lab10 ;
}
if ( p < himemmin )
if ( mem [ p ] .hhfield .b1 == 15 )
if ( mem [ p ] .hhfield .b0 == 16 )
{
if ( class == 0 )
printchar ( 32 ) ;
v = mem [ p + 1 ] .cint ;
if ( v < 0 )
{
if ( class == 17 )
printchar ( 32 ) ;
printchar ( 91 ) ;
printscaled ( v ) ;
printchar ( 93 ) ;
c = 18 ;
}
else {
printscaled ( v ) ;
c = 0 ;
}
}
else if ( mem [ p ] .hhfield .b0 != 4 )
print ( 508 ) ;
else {
printchar ( 34 ) ;
slowprint ( mem [ p + 1 ] .cint ) ;
printchar ( 34 ) ;
c = 4 ;
}
else if ( ( mem [ p ] .hhfield .b1 != 14 ) || ( mem [ p ] .hhfield .b0 < 1
) || ( mem [ p ] .hhfield .b0 > 19 ) )
print ( 508 ) ;
else {
gpointer = p ;
printcapsule () ;
c = 8 ;
}
else {
r = mem [ p ] .hhfield .lhfield ;
if ( r >= 2372 )
{
if ( r < 2522 )
{
print ( 510 ) ;
r = r - ( 2372 ) ;
}
else if ( r < 2672 )
{
print ( 511 ) ;
r = r - ( 2522 ) ;
}
else {
print ( 512 ) ;
r = r - ( 2672 ) ;
}
printint ( r ) ;
printchar ( 41 ) ;
c = 8 ;
}
else if ( r < 1 )
if ( r == 0 )
{
if ( class == 17 )
printchar ( 32 ) ;
print ( 509 ) ;
c = 18 ;
}
else print ( 506 ) ;
else {
r = hash [ r ] .v.RH ;
if ( ( r < 0 ) || ( r >= maxstrptr ) )
print ( 507 ) ;
else {
c = charclass [ strpool [ strstart [ r ] ] ] ;
if ( c == class )
switch ( c )
{case 9 :
printchar ( 46 ) ;
break ;
case 5 :
case 6 :
case 7 :
case 8 :
;
break ;
default:
printchar ( 32 ) ;
break ;
}
print ( r ) ;
}
}
}
class = c ;
p = mem [ p ] .hhfield .v.RH ;
}
if ( p != 0 )
print ( 504 ) ;
lab10: ;
}
void runaway ( )
{if ( scannerstatus > 2 )
{
printnl ( 659 ) ;
switch ( scannerstatus )
{case 3 :
print ( 660 ) ;
break ;
case 4 :
case 5 :
print ( 661 ) ;
break ;
case 6 :
print ( 662 ) ;
break ;
}
println () ;
showtokenlist ( mem [ memtop - 2 ] .hhfield .v.RH , 0 , errorline - 10 , 0
) ;
}
}
halfword getavail ( )
{register halfword Result; halfword p ;
p = avail ;
if ( p != 0 )
avail = mem [ avail ] .hhfield .v.RH ;
else if ( memend < memmax )
{
incr ( memend ) ;
p = memend ;
}
else {
decr ( himemmin ) ;
p = himemmin ;
if ( himemmin <= lomemmax )
{
runaway () ;
overflow ( 316 , memmax + 1 ) ;
}
}
mem [ p ] .hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
Result = p ;
return(Result) ;
}
halfword zgetnode ( s )
integer s ;
{/* 40 10 20 */ register halfword Result; halfword p ;
halfword q ;
integer r ;
integer t, tt ;
lab20: p = rover ;
do {
q = p + mem [ p ] .hhfield .lhfield ;
while ( ( mem [ q ] .hhfield .v.RH == 65535L ) ) {
t = mem [ q + 1 ] .hhfield .v.RH ;
tt = mem [ q + 1 ] .hhfield .lhfield ;
if ( q == rover )
rover = t ;
mem [ t + 1 ] .hhfield .lhfield = tt ;
mem [ tt + 1 ] .hhfield .v.RH = t ;
q = q + mem [ q ] .hhfield .lhfield ;
}
r = q - s ;
if ( r > toint ( p + 1 ) )
{
mem [ p ] .hhfield .lhfield = r - p ;
rover = p ;
goto lab40 ;
}
if ( r == p )
if ( mem [ p + 1 ] .hhfield .v.RH != p )
{
rover = mem [ p + 1 ] .hhfield .v.RH ;
t = mem [ p + 1 ] .hhfield .lhfield ;
mem [ rover + 1 ] .hhfield .lhfield = t ;
mem [ t + 1 ] .hhfield .v.RH = rover ;
goto lab40 ;
}
mem [ p ] .hhfield .lhfield = q - p ;
p = mem [ p + 1 ] .hhfield .v.RH ;
} while ( ! ( p == rover ) ) ;
if ( s == 1073741824L )
{
Result = 65535L ;
goto lab10 ;
}
if ( lomemmax + 2 < himemmin )
if ( lomemmax + 2 <= 65535L )
{
if ( himemmin - lomemmax >= 1998 )
t = lomemmax + 1000 ;
else t = lomemmax + 1 + ( himemmin - lomemmax ) / 2 ;
if ( t > 65535L )
t = 65535L ;
p = mem [ rover + 1 ] .hhfield .lhfield ;
q = lomemmax ;
mem [ p + 1 ] .hhfield .v.RH = q ;
mem [ rover + 1 ] .hhfield .lhfield = q ;
mem [ q + 1 ] .hhfield .v.RH = rover ;
mem [ q + 1 ] .hhfield .lhfield = p ;
mem [ q ] .hhfield .v.RH = 65535L ;
mem [ q ] .hhfield .lhfield = t - lomemmax ;
lomemmax = t ;
mem [ lomemmax ] .hhfield .v.RH = 0 ;
mem [ lomemmax ] .hhfield .lhfield = 0 ;
rover = q ;
goto lab20 ;
}
overflow ( 316 , memmax + 1 ) ;
lab40: mem [ r ] .hhfield .v.RH = 0 ;
;
#ifdef STAT
varused = varused + s ;
#endif /* STAT */
Result = r ;
lab10: ;
return(Result) ;
}
void zfreenode ( p , s )
halfword p ;
halfword s ;
{halfword q ;
mem [ p ] .hhfield .lhfield = s ;
mem [ p ] .hhfield .v.RH = 65535L ;
q = mem [ rover + 1 ] .hhfield .lhfield ;
mem [ p + 1 ] .hhfield .lhfield = q ;
mem [ p + 1 ] .hhfield .v.RH = rover ;
mem [ rover + 1 ] .hhfield .lhfield = p ;
mem [ q + 1 ] .hhfield .v.RH = p ;
;
#ifdef STAT
varused = varused - s ;
#endif /* STAT */
}
void zflushlist ( p )
halfword p ;
{/* 30 */ halfword q, r ;
if ( p >= himemmin )
if ( p != memtop )
{
r = p ;
do {
q = r ;
r = mem [ r ] .hhfield .v.RH ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
if ( r < himemmin )
goto lab30 ;
} while ( ! ( r == memtop ) ) ;
lab30: mem [ q ] .hhfield .v.RH = avail ;
avail = p ;
}
}
void zflushnodelist ( p )
halfword p ;
{halfword q ;
while ( p != 0 ) {
q = p ;
p = mem [ p ] .hhfield .v.RH ;
if ( q < himemmin )
freenode ( q , 2 ) ;
else {
mem [ q ] .hhfield .v.RH = avail ;
avail = q ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
}
#ifdef DEBUG
void zcheckmem ( printlocs )
boolean printlocs ;
{/* 31 32 33 */ halfword p, q, r ;
boolean clobbered ;
{register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <= for_end)
do
freearr [ p ] = false ;
while ( p++ < for_end ) ; }
{register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
for_end) do
freearr [ p ] = false ;
while ( p++ < for_end ) ; }
p = avail ;
q = 0 ;
clobbered = false ;
while ( p != 0 ) {
if ( ( p > memend ) || ( p < himemmin ) )
clobbered = true ;
else if ( freearr [ p ] )
clobbered = true ;
if ( clobbered )
{
printnl ( 317 ) ;
printint ( q ) ;
goto lab31 ;
}
freearr [ p ] = true ;
q = p ;
p = mem [ q ] .hhfield .v.RH ;
}
lab31: ;
p = rover ;
q = 0 ;
clobbered = false ;
do {
if ( ( p >= lomemmax ) )
clobbered = true ;
else if ( ( mem [ p + 1 ] .hhfield .v.RH >= lomemmax ) )
clobbered = true ;
else if ( ! ( ( mem [ p ] .hhfield .v.RH == 65535L ) ) || ( mem [ p ] .hhfield .lhfield < 2 ) || ( p + mem [ p ] .hhfield .lhfield > lomemmax )
|| ( mem [ mem [ p + 1 ] .hhfield .v.RH + 1 ] .hhfield .lhfield != p ) )
clobbered = true ;
if ( clobbered )
{
printnl ( 318 ) ;
printint ( q ) ;
goto lab32 ;
}
{register integer for_end; q = p ; for_end = p + mem [ p ] .hhfield .lhfield - 1 ; if ( q <= for_end) do
{
if ( freearr [ q ] )
{
printnl ( 319 ) ;
printint ( q ) ;
goto lab32 ;
}
freearr [ q ] = true ;
}
while ( q++ < for_end ) ; }
q = p ;
p = mem [ p + 1 ] .hhfield .v.RH ;
} while ( ! ( p == rover ) ) ;
lab32: ;
p = 0 ;
while ( p <= lomemmax ) {
if ( ( mem [ p ] .hhfield .v.RH == 65535L ) )
{
printnl ( 320 ) ;
printint ( p ) ;
}
while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ;
while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ;
}
q = 5 ;
p = mem [ q ] .hhfield .v.RH ;
while ( p != 5 ) {
if ( mem [ p + 1 ] .hhfield .lhfield != q )
{
printnl ( 609 ) ;
printint ( p ) ;
}
p = mem [ p + 1 ] .hhfield .v.RH ;
while ( true ) {
r = mem [ p ] .hhfield .lhfield ;
q = p ;
p = mem [ q ] .hhfield .v.RH ;
if ( r == 0 )
goto lab33 ;
if ( mem [ mem [ p ] .hhfield .lhfield + 1 ] .cint >= mem [ r + 1 ] .cint )
{
printnl ( 610 ) ;
printint ( p ) ;
}
}
lab33: ;
}
if ( printlocs )
{
q = memmax ;
r = memmax ;
printnl ( 321 ) ;
{register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <=
for_end) do
if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) )
{
if ( p > q + 1 )
{
if ( q > r )
{
print ( 322 ) ;
printint ( q ) ;
}
printchar ( 32 ) ;
printint ( p ) ;
r = p ;
}
q = p ;
}
while ( p++ < for_end ) ; }
{register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
for_end) do
if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) ||
wasfree [ p ] ) )
{
if ( p > q + 1 )
{
if ( q > r )
{
print ( 322 ) ;
printint ( q ) ;
}
printchar ( 32 ) ;
printint ( p ) ;
r = p ;
}
q = p ;
}
while ( p++ < for_end ) ; }
if ( q > r )
{
print ( 322 ) ;
printint ( q ) ;
}
}
{register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <= for_end)
do
wasfree [ p ] = freearr [ p ] ;
while ( p++ < for_end ) ; }
{register integer for_end; p = himemmin ; for_end = memend ; if ( p <=
for_end) do
wasfree [ p ] = freearr [ p ] ;
while ( p++ < for_end ) ; }
wasmemend = memend ;
waslomax = lomemmax ;
washimin = himemmin ;
}
#endif /* DEBUG */
#ifdef DEBUG
void zsearchmem ( p )
halfword p ;
{integer q ;
{register integer for_end; q = 0 ; for_end = lomemmax ; if ( q <= for_end)
do
{
if ( mem [ q ] .hhfield .v.RH == p )
{
printnl ( 323 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
if ( mem [ q ] .hhfield .lhfield == p )
{
printnl ( 324 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ; }
{register integer for_end; q = himemmin ; for_end = memend ; if ( q <=
for_end) do
{
if ( mem [ q ] .hhfield .v.RH == p )
{
printnl ( 323 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
if ( mem [ q ] .hhfield .lhfield == p )
{
printnl ( 324 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ; }
{register integer for_end; q = 1 ; for_end = 2371 ; if ( q <= for_end) do
{
if ( eqtb [ q ] .v.RH == p )
{
printnl ( 473 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ; }
}
#endif /* DEBUG */
void zprintop ( c )
quarterword c ;
{if ( c <= 15 )
printtype ( c ) ;
else switch ( c )
{case 30 :
print ( 348 ) ;
break ;
case 31 :
print ( 349 ) ;
break ;
case 32 :
print ( 350 ) ;
break ;
case 33 :
print ( 351 ) ;
break ;
case 34 :
print ( 352 ) ;
break ;
case 35 :
print ( 353 ) ;
break ;
case 36 :
print ( 354 ) ;
break ;
case 37 :
print ( 355 ) ;
break ;
case 38 :
print ( 356 ) ;
break ;
case 39 :
print ( 357 ) ;
break ;
case 40 :
print ( 358 ) ;
break ;
case 41 :
print ( 359 ) ;
break ;
case 42 :
print ( 360 ) ;
break ;
case 43 :
print ( 361 ) ;
break ;
case 44 :
print ( 362 ) ;
break ;
case 45 :
print ( 363 ) ;
break ;
case 46 :
print ( 364 ) ;
break ;
case 47 :
print ( 365 ) ;
break ;
case 48 :
print ( 366 ) ;
break ;
case 49 :
print ( 367 ) ;
break ;
case 50 :
print ( 368 ) ;
break ;
case 51 :
print ( 369 ) ;
break ;
case 52 :
print ( 370 ) ;
break ;
case 53 :
print ( 371 ) ;
break ;
case 54 :
print ( 372 ) ;
break ;
case 55 :
print ( 373 ) ;
break ;
case 56 :
print ( 374 ) ;
break ;
case 57 :
print ( 375 ) ;
break ;
case 58 :
print ( 376 ) ;
break ;
case 59 :
print ( 377 ) ;
break ;
case 60 :
print ( 378 ) ;
break ;
case 61 :
print ( 379 ) ;
break ;
case 62 :
print ( 380 ) ;
break ;
case 63 :
print ( 381 ) ;
break ;
case 64 :
print ( 382 ) ;
break ;
case 65 :
print ( 383 ) ;
break ;
case 66 :
print ( 384 ) ;
break ;
case 67 :
print ( 385 ) ;
break ;
case 68 :
print ( 386 ) ;
break ;
case 69 :
print ( 387 ) ;
break ;
case 70 :
print ( 388 ) ;
break ;
case 71 :
print ( 389 ) ;
break ;
case 72 :
print ( 390 ) ;
break ;
case 73 :
print ( 391 ) ;
break ;
case 74 :
print ( 392 ) ;
break ;
case 75 :
print ( 393 ) ;
break ;
case 76 :
print ( 394 ) ;
break ;
case 77 :
print ( 395 ) ;
break ;
case 78 :
print ( 396 ) ;
break ;
case 79 :
print ( 397 ) ;
break ;
case 80 :
print ( 398 ) ;
break ;
case 81 :
print ( 399 ) ;
break ;
case 82 :
print ( 400 ) ;
break ;
case 83 :
print ( 401 ) ;
break ;
case 84 :
print ( 402 ) ;
break ;
case 85 :
print ( 403 ) ;
break ;
case 86 :
print ( 404 ) ;
break ;
case 87 :
print ( 405 ) ;
break ;
case 88 :
printchar ( 43 ) ;
break ;
case 89 :
printchar ( 45 ) ;
break ;
case 90 :
printchar ( 42 ) ;
break ;
case 91 :
printchar ( 47 ) ;
break ;
case 92 :
print ( 406 ) ;
break ;
case 93 :
print ( 311 ) ;
break ;
case 94 :
print ( 407 ) ;
break ;
case 95 :
print ( 408 ) ;
break ;
case 96 :
printchar ( 60 ) ;
break ;
case 97 :
print ( 409 ) ;
break ;
case 98 :
printchar ( 62 ) ;
break ;
case 99 :
print ( 410 ) ;
break ;
case 100 :
printchar ( 61 ) ;
break ;
case 101 :
print ( 411 ) ;
break ;
case 102 :
print ( 38 ) ;
break ;
case 103 :
print ( 412 ) ;
break ;
case 104 :
print ( 413 ) ;
break ;
case 105 :
print ( 414 ) ;
break ;
case 106 :
print ( 415 ) ;
break ;
case 107 :
print ( 416 ) ;
break ;
case 108 :
print ( 417 ) ;
break ;
case 109 :
print ( 418 ) ;
break ;
case 110 :
print ( 419 ) ;
break ;
case 111 :
print ( 420 ) ;
break ;
case 112 :
print ( 421 ) ;
break ;
case 114 :
print ( 422 ) ;
break ;
case 115 :
print ( 423 ) ;
break ;
case 116 :
print ( 424 ) ;
break ;
case 117 :
print ( 425 ) ;
break ;
case 118 :
print ( 426 ) ;
break ;
case 119 :
print ( 427 ) ;
break ;
case 120 :
print ( 428 ) ;
break ;
case 121 :
print ( 429 ) ;
break ;
default:
print ( 322 ) ;
break ;
}
}
void fixdateandtime ( )
{dateandtime ( internal [ 16 ] , internal [ 15 ] , internal [ 14 ] , internal
[ 13 ] ) ;
internal [ 16 ] = internal [ 16 ] * 65536L ;
internal [ 15 ] = internal [ 15 ] * 65536L ;
internal [ 14 ] = internal [ 14 ] * 65536L ;
internal [ 13 ] = internal [ 13 ] * 65536L ;
}
halfword zidlookup ( j , l )
integer j ;
integer l ;
{/* 40 */ register halfword Result; integer h ;
halfword p ;
halfword k ;
if ( l == 1 )
{
p = buffer [ j ] + 1 ;
hash [ p ] .v.RH = p - 1 ;
goto lab40 ;
}
h = buffer [ j ] ;
{register integer for_end; k = j + 1 ; for_end = j + l - 1 ; if ( k <=
for_end) do
{
h = h + h + buffer [ k ] ;
while ( h >= 1777 ) h = h - 1777 ;
}
while ( k++ < for_end ) ; }
p = h + 257 ;
while ( true ) {
if ( hash [ p ] .v.RH > 0 )
if ( ( strstart [ nextstr [ hash [ p ] .v.RH ] ] - strstart [ hash [ p ] .v.RH ] ) == l )
if ( streqbuf ( hash [ p ] .v.RH , j ) )
goto lab40 ;
if ( hash [ p ] .lhfield == 0 )
{
if ( hash [ p ] .v.RH > 0 )
{
do {
if ( ( hashused == 257 ) )
overflow ( 472 , 2100 ) ;
decr ( hashused ) ;
} while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ;
hash [ p ] .lhfield = hashused ;
p = hashused ;
}
{
if ( poolptr + l > maxpoolptr )
if ( poolptr + l > poolsize )
docompaction ( l ) ;
else maxpoolptr = poolptr + l ;
}
{register integer for_end; k = j ; for_end = j + l - 1 ; if ( k <=
for_end) do
{
strpool [ poolptr ] = buffer [ k ] ;
incr ( poolptr ) ;
}
while ( k++ < for_end ) ; }
hash [ p ] .v.RH = makestring () ;
strref [ hash [ p ] .v.RH ] = 127 ;
;
#ifdef STAT
incr ( stcount ) ;
#endif /* STAT */
goto lab40 ;
}
p = hash [ p ] .lhfield ;
}
lab40: Result = p ;
return(Result) ;
}
halfword znewnumtok ( v )
scaled v ;
{register halfword Result; halfword p ;
p = getnode ( 2 ) ;
mem [ p + 1 ] .cint = v ;
mem [ p ] .hhfield .b0 = 16 ;
mem [ p ] .hhfield .b1 = 15 ;
Result = p ;
return(Result) ;
}
void zflushtokenlist ( p )
halfword p ;
{halfword q ;
while ( p != 0 ) {
q = p ;
p = mem [ p ] .hhfield .v.RH ;
if ( q >= himemmin )
{
mem [ q ] .hhfield .v.RH = avail ;
avail = q ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
else {
switch ( mem [ q ] .hhfield .b0 )
{case 1 :
case 2 :
case 16 :
;
break ;
case 4 :
{
if ( strref [ mem [ q + 1 ] .cint ] < 127 )
if ( strref [ mem [ q + 1 ] .cint ] > 1 )
decr ( strref [ mem [ q + 1 ] .cint ] ) ;
else flushstring ( mem [ q + 1 ] .cint ) ;
}
break ;
case 3 :
case 5 :
case 7 :
case 11 :
case 9 :
case 6 :
case 8 :
case 10 :
case 14 :
case 13 :
case 12 :
case 17 :
case 18 :
case 19 :
{
gpointer = q ;
tokenrecycle () ;
}
break ;
default:
confusion ( 503 ) ;
break ;
}
freenode ( q , 2 ) ;
}
}
}
void zdeletemacref ( p )
halfword p ;
{if ( mem [ p ] .hhfield .lhfield == 0 )
flushtokenlist ( p ) ;
else decr ( mem [ p ] .hhfield .lhfield ) ;
}
void zprintcmdmod ( c , m )
integer c ;
integer m ;
{switch ( c )
{case 20 :
print ( 477 ) ;
break ;
case 76 :
print ( 476 ) ;
break ;
case 61 :
print ( 478 ) ;
break ;
case 78 :
print ( 475 ) ;
break ;
case 34 :
print ( 479 ) ;
break ;
case 80 :
print ( 58 ) ;
break ;
case 81 :
print ( 44 ) ;
break ;
case 59 :
print ( 480 ) ;
break ;
case 62 :
print ( 481 ) ;
break ;
case 29 :
print ( 482 ) ;
break ;
case 79 :
print ( 474 ) ;
break ;
case 83 :
print ( 468 ) ;
break ;
case 28 :
print ( 483 ) ;
break ;
case 9 :
print ( 484 ) ;
break ;
case 12 :
print ( 485 ) ;
break ;
case 15 :
print ( 486 ) ;
break ;
case 48 :
print ( 123 ) ;
break ;
case 65 :
print ( 91 ) ;
break ;
case 16 :
print ( 487 ) ;
break ;
case 17 :
print ( 488 ) ;
break ;
case 70 :
print ( 489 ) ;
break ;
case 49 :
print ( 322 ) ;
break ;
case 26 :
print ( 490 ) ;
break ;
case 10 :
printchar ( 92 ) ;
break ;
case 67 :
print ( 125 ) ;
break ;
case 66 :
print ( 93 ) ;
break ;
case 14 :
print ( 491 ) ;
break ;
case 11 :
print ( 492 ) ;
break ;
case 82 :
print ( 59 ) ;
break ;
case 19 :
print ( 493 ) ;
break ;
case 77 :
print ( 494 ) ;
break ;
case 30 :
print ( 495 ) ;
break ;
case 72 :
print ( 496 ) ;
break ;
case 37 :
print ( 497 ) ;
break ;
case 60 :
print ( 498 ) ;
break ;
case 71 :
print ( 499 ) ;
break ;
case 73 :
print ( 500 ) ;
break ;
case 74 :
print ( 501 ) ;
break ;
case 31 :
print ( 502 ) ;
break ;
case 1 :
if ( m == 0 )
print ( 682 ) ;
else print ( 683 ) ;
break ;
case 2 :
print ( 465 ) ;
break ;
case 3 :
print ( 466 ) ;
break ;
case 18 :
if ( m <= 2 )
if ( m == 1 )
print ( 696 ) ;
else if ( m < 1 )
print ( 469 ) ;
else print ( 697 ) ;
else if ( m == 55 )
print ( 698 ) ;
else if ( m == 46 )
print ( 699 ) ;
else print ( 700 ) ;
break ;
case 7 :
if ( m <= 1 )
if ( m == 1 )
print ( 703 ) ;
else print ( 470 ) ;
else if ( m == 2372 )
print ( 701 ) ;
else print ( 702 ) ;
break ;
case 63 :
switch ( m )
{case 1 :
print ( 705 ) ;
break ;
case 2 :
printchar ( 64 ) ;
break ;
case 3 :
print ( 706 ) ;
break ;
default:
print ( 704 ) ;
break ;
}
break ;
case 58 :
if ( m >= 2372 )
if ( m == 2372 )
print ( 717 ) ;
else if ( m == 2522 )
print ( 718 ) ;
else print ( 719 ) ;
else if ( m < 2 )
print ( 720 ) ;
else if ( m == 2 )
print ( 721 ) ;
else print ( 722 ) ;
break ;
case 6 :
if ( m == 0 )
print ( 732 ) ;
else print ( 629 ) ;
break ;
case 4 :
case 5 :
switch ( m )
{case 1 :
print ( 759 ) ;
break ;
case 2 :
print ( 467 ) ;
break ;
case 3 :
print ( 760 ) ;
break ;
default:
print ( 761 ) ;
break ;
}
break ;
case 35 :
case 36 :
case 39 :
case 57 :
case 47 :
case 52 :
case 38 :
case 45 :
case 56 :
case 50 :
case 53 :
case 54 :
printop ( m ) ;
break ;
case 32 :
printtype ( m ) ;
break ;
case 84 :
if ( m == 0 )
print ( 960 ) ;
else print ( 961 ) ;
break ;
case 25 :
switch ( m )
{case 0 :
print ( 273 ) ;
break ;
case 1 :
print ( 274 ) ;
break ;
case 2 :
print ( 275 ) ;
break ;
default:
print ( 967 ) ;
break ;
}
break ;
case 23 :
if ( m == 0 )
print ( 968 ) ;
else print ( 969 ) ;
break ;
case 24 :
switch ( m )
{case 0 :
print ( 983 ) ;
break ;
case 1 :
print ( 984 ) ;
break ;
case 2 :
print ( 985 ) ;
break ;
case 3 :
print ( 986 ) ;
break ;
default:
print ( 987 ) ;
break ;
}
break ;
case 33 :
case 64 :
{
if ( c == 33 )
print ( 990 ) ;
else print ( 991 ) ;
print ( 992 ) ;
print ( hash [ m ] .v.RH ) ;
}
break ;
case 43 :
if ( m == 0 )
print ( 993 ) ;
else print ( 994 ) ;
break ;
case 13 :
print ( 995 ) ;
break ;
case 55 :
case 46 :
case 51 :
{
printcmdmod ( 18 , c ) ;
print ( 996 ) ;
println () ;
showtokenlist ( mem [ mem [ m ] .hhfield .v.RH ] .hhfield .v.RH , 0 , 1000 , 0 ) ;
}
break ;
case 8 :
print ( 997 ) ;
break ;
case 42 :
print ( intname [ m ] ) ;
break ;
case 69 :
if ( m == 1 )
print ( 1007 ) ;
else if ( m == 0 )
print ( 1006 ) ;
else print ( 1008 ) ;
break ;
case 68 :
if ( m == 6 )
print ( 1009 ) ;
else if ( m == 13 )
print ( 1011 ) ;
else print ( 1010 ) ;
break ;
case 21 :
if ( m == 4 )
print ( 1020 ) ;
else print ( 1021 ) ;
break ;
case 27 :
if ( m < 1 )
print ( 1034 ) ;
else if ( m == 1 )
print ( 1035 ) ;
else print ( 1036 ) ;
break ;
case 22 :
switch ( m )
{case 0 :
print ( 1051 ) ;
break ;
case 1 :
print ( 1052 ) ;
break ;
case 2 :
print ( 1053 ) ;
break ;
case 3 :
print ( 1054 ) ;
break ;
default:
print ( 1055 ) ;
break ;
}
break ;
case 75 :
switch ( m )
{case 0 :
print ( 1073 ) ;
break ;
case 1 :
print ( 1074 ) ;
break ;
case 2 :
print ( 1076 ) ;
break ;
case 3 :
print ( 1078 ) ;
break ;
case 5 :
print ( 1075 ) ;
break ;
case 6 :
print ( 1077 ) ;
break ;
case 7 :
print ( 1079 ) ;
break ;
case 11 :
print ( 1080 ) ;
break ;
default:
print ( 1081 ) ;
break ;
}
break ;
default:
print ( 614 ) ;
break ;
}
}
void zshowmacro ( p , q , l )
halfword p ;
integer q ;
integer l ;
{/* 10 */ halfword r ;
p = mem [ p ] .hhfield .v.RH ;
while ( mem [ p ] .hhfield .lhfield > 7 ) {
r = mem [ p ] .hhfield .v.RH ;
mem [ p ] .hhfield .v.RH = 0 ;
showtokenlist ( p , 0 , l , 0 ) ;
mem [ p ] .hhfield .v.RH = r ;
p = r ;
if ( l > 0 )
l = l - tally ;
else goto lab10 ;
}
tally = 0 ;
switch ( mem [ p ] .hhfield .lhfield )
{case 0 :
print ( 513 ) ;
break ;
case 1 :
case 2 :
case 3 :
{
printchar ( 60 ) ;
printcmdmod ( 58 , mem [ p ] .hhfield .lhfield ) ;
print ( 514 ) ;
}
break ;
case 4 :
print ( 515 ) ;
break ;
case 5 :
print ( 516 ) ;
break ;
case 6 :
print ( 517 ) ;
break ;
case 7 :
print ( 518 ) ;
break ;
}
showtokenlist ( mem [ p ] .hhfield .v.RH , q , l - tally , 0 ) ;
lab10: ;
}
void zinitbignode ( p )
halfword p ;
{halfword q ;
smallnumber s ;
s = bignodesize [ mem [ p ] .hhfield .b0 ] ;
q = getnode ( s ) ;
do {
s = s - 2 ;
{
mem [ q + s ] .hhfield .b0 = 19 ;
serialno = serialno + 64 ;
mem [ q + s + 1 ] .cint = serialno ;
}
mem [ q + s ] .hhfield .b1 = halfp ( s ) + sector0 [ mem [ p ] .hhfield .b0 ] ;
mem [ q + s ] .hhfield .v.RH = 0 ;
} while ( ! ( s == 0 ) ) ;
mem [ q ] .hhfield .v.RH = p ;
mem [ p + 1 ] .cint = q ;
}
halfword idtransform ( )
{register halfword Result; halfword p, q, r ;
p = getnode ( 2 ) ;
mem [ p ] .hhfield .b0 = 12 ;
mem [ p ] .hhfield .b1 = 14 ;
mem [ p + 1 ] .cint = 0 ;
initbignode ( p ) ;
q = mem [ p + 1 ] .cint ;
r = q + 12 ;
do {
r = r - 2 ;
mem [ r ] .hhfield .b0 = 16 ;
mem [ r + 1 ] .cint = 0 ;
} while ( ! ( r == q ) ) ;
mem [ q + 5 ] .cint = 65536L ;
mem [ q + 11 ] .cint = 65536L ;
Result = p ;
return(Result) ;
}
void znewroot ( x )
halfword x ;
{halfword p ;
p = getnode ( 2 ) ;
mem [ p ] .hhfield .b0 = 0 ;
mem [ p ] .hhfield .b1 = 0 ;
mem [ p ] .hhfield .v.RH = x ;
eqtb [ x ] .v.RH = p ;
}
void zprintvariablename ( p )
halfword p ;
{/* 40 10 */ halfword q ;
halfword r ;
while ( mem [ p ] .hhfield .b1 >= 5 ) {
switch ( mem [ p ] .hhfield .b1 )
{case 5 :
printchar ( 120 ) ;
break ;
case 6 :
printchar ( 121 ) ;
break ;
case 7 :
print ( 521 ) ;
break ;
case 8 :
print ( 522 ) ;
break ;
case 9 :
print ( 523 ) ;
break ;
case 10 :
print ( 524 ) ;
break ;
case 11 :
print ( 525 ) ;
break ;
case 12 :
print ( 526 ) ;
break ;
case 13 :
print ( 527 ) ;
break ;
case 14 :
{
print ( 528 ) ;
printint ( p + 0 ) ;
goto lab10 ;
}
break ;
}
print ( 529 ) ;
p = mem [ p - sectoroffset [ mem [ p ] .hhfield .b1 ] ] .hhfield .v.RH ;
}
q = 0 ;
while ( mem [ p ] .hhfield .b1 > 1 ) {
if ( mem [ p ] .hhfield .b1 == 3 )
{
r = newnumtok ( mem [ p + 2 ] .cint ) ;
do {
p = mem [ p ] .hhfield .v.RH ;
} while ( ! ( mem [ p ] .hhfield .b1 == 4 ) ) ;
}
else if ( mem [ p ] .hhfield .b1 == 2 )
{
p = mem [ p ] .hhfield .v.RH ;
goto lab40 ;
}
else {
if ( mem [ p ] .hhfield .b1 != 4 )
confusion ( 520 ) ;
r = getavail () ;
mem [ r ] .hhfield .lhfield = mem [ p + 2 ] .hhfield .lhfield ;
}
mem [ r ] .hhfield .v.RH = q ;
q = r ;
lab40: p = mem [ p + 2 ] .hhfield .v.RH ;
}
r = getavail () ;
mem [ r ] .hhfield .lhfield = mem [ p ] .hhfield .v.RH ;
mem [ r ] .hhfield .v.RH = q ;
if ( mem [ p ] .hhfield .b1 == 1 )
print ( 519 ) ;
showtokenlist ( r , 0 , 2147483647L , tally ) ;
flushtokenlist ( r ) ;
lab10: ;
}
boolean zinteresting ( p )
halfword p ;
{register boolean Result; smallnumber t ;
if ( internal [ 3 ] > 0 )
Result = true ;
else {
t = mem [ p ] .hhfield .b1 ;
if ( t >= 5 )
if ( t != 14 )
t = mem [ mem [ p - sectoroffset [ t ] ] .hhfield .v.RH ] .hhfield .b1 ;
Result = ( t != 14 ) ;
}
return(Result) ;
}
halfword znewstructure ( p )
halfword p ;
{register halfword Result; halfword q, r ;
switch ( mem [ p ] .hhfield .b1 )
{case 0 :
{
q = mem [ p ] .hhfield .v.RH ;
r = getnode ( 2 ) ;
eqtb [ q ] .v.RH = r ;
}
break ;
case 3 :
{
q = p ;
do {
q = mem [ q ] .hhfield .v.RH ;
} while ( ! ( mem [ q ] .hhfield .b1 == 4 ) ) ;
q = mem [ q + 2 ] .hhfield .v.RH ;
r = q + 1 ;
do {
q = r ;
r = mem [ r ] .hhfield .v.RH ;
} while ( ! ( r == p ) ) ;
r = getnode ( 3 ) ;
mem [ q ] .hhfield .v.RH = r ;
mem [ r + 2 ] .cint = mem [ p + 2 ] .cint ;
}
break ;
case 4 :
{
q = mem [ p + 2 ] .hhfield .v.RH ;
r = mem [ q + 1 ] .hhfield .lhfield ;
do {
q = r ;
r = mem [ r ] .hhfield .v.RH ;
} while ( ! ( r == p ) ) ;
r = getnode ( 3 ) ;
mem [ q ] .hhfield .v.RH = r ;
mem [ r + 2 ] = mem [ p + 2 ] ;
if ( mem [ p + 2 ] .hhfield .lhfield == 0 )
{
q = mem [ p + 2 ] .hhfield .v.RH + 1 ;
while ( mem [ q ] .hhfield .v.RH != p ) q = mem [ q ] .hhfield .v.RH ;
mem [ q ] .hhfield .v.RH = r ;
}
}
break ;
default:
confusion ( 530 ) ;
break ;
}
mem [ r ] .hhfield .v.RH = mem [ p ] .hhfield .v.RH ;
mem [ r ] .hhfield .b0 = 21 ;
mem [ r ] .hhfield .b1 = mem [ p ] .hhfield .b1 ;
mem [ r + 1 ] .hhfield .lhfield = p ;
mem [ p ] .hhfield .b1 = 2 ;
q = getnode ( 3 ) ;
mem [ p ] .hhfield .v.RH = q ;
mem [ r + 1 ] .hhfield .v.RH = q ;
mem [ q + 2 ] .hhfield .v.RH = r ;
mem [ q ] .hhfield .b0 = 0 ;
mem [ q ] .hhfield .b1 = 4 ;
mem [ q ] .hhfield .v.RH = 9 ;
mem [ q + 2 ] .hhfield .lhfield = 0 ;
Result = r ;
return(Result) ;
}
halfword zfindvariable ( t )
halfword t ;
{/* 10 */ register halfword Result; halfword p, q, r, s ;
halfword pp, qq, rr, ss ;
integer n ;
memoryword saveword ;
p = mem [ t ] .hhfield .lhfield ;
t = mem [ t ] .hhfield .v.RH ;
if ( eqtb [ p ] .lhfield % 85 != 43 )
{
Result = 0 ;
goto lab10 ;
}
if ( eqtb [ p ] .v.RH == 0 )
newroot ( p ) ;
p = eqtb [ p ] .v.RH ;
pp = p ;
while ( t != 0 ) {
if ( mem [ pp ] .hhfield .b0 != 21 )
{
if ( mem [ pp ] .hhfield .b0 > 21 )
{
Result = 0 ;
goto lab10 ;
}
ss = newstructure ( pp ) ;
if ( p == pp )
p = ss ;
pp = ss ;
}
if ( mem [ p ] .hhfield .b0 != 21 )
p = newstructure ( p ) ;
if ( t < himemmin )
{
n = mem [ t + 1 ] .cint ;
pp = mem [ mem [ pp + 1 ] .hhfield .lhfield ] .hhfield .v.RH ;
q = mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ;
saveword = mem [ q + 2 ] ;
mem [ q + 2 ] .cint = 2147483647L ;
s = p + 1 ;
do {
r = s ;
s = mem [ s ] .hhfield .v.RH ;
} while ( ! ( n <= mem [ s + 2 ] .cint ) ) ;
if ( n == mem [ s + 2 ] .cint )
p = s ;
else {
p = getnode ( 3 ) ;
mem [ r ] .hhfield .v.RH = p ;
mem [ p ] .hhfield .v.RH = s ;
mem [ p + 2 ] .cint = n ;
mem [ p ] .hhfield .b1 = 3 ;
mem [ p ] .hhfield .b0 = 0 ;
}
mem [ q + 2 ] = saveword ;
}
else {
n = mem [ t ] .hhfield .lhfield ;
ss = mem [ pp + 1 ] .hhfield .lhfield ;
do {
rr = ss ;
ss = mem [ ss ] .hhfield .v.RH ;
} while ( ! ( n <= mem [ ss + 2 ] .hhfield .lhfield ) ) ;
if ( n < mem [ ss + 2 ] .hhfield .lhfield )
{
qq = getnode ( 3 ) ;
mem [ rr ] .hhfield .v.RH = qq ;
mem [ qq ] .hhfield .v.RH = ss ;
mem [ qq + 2 ] .hhfield .lhfield = n ;
mem [ qq ] .hhfield .b1 = 4 ;
mem [ qq ] .hhfield .b0 = 0 ;
mem [ qq + 2 ] .hhfield .v.RH = pp ;
ss = qq ;
}
if ( p == pp )
{
p = ss ;
pp = ss ;
}
else {
pp = ss ;
s = mem [ p + 1 ] .hhfield .lhfield ;
do {
r = s ;
s = mem [ s ] .hhfield .v.RH ;
} while ( ! ( n <= mem [ s + 2 ] .hhfield .lhfield ) ) ;
if ( n == mem [ s + 2 ] .hhfield .lhfield )
p = s ;
else {
q = getnode ( 3 ) ;
mem [ r ] .hhfield .v.RH = q ;
mem [ q ] .hhfield .v.RH = s ;
mem [ q + 2 ] .hhfield .lhfield = n ;
mem [ q ] .hhfield .b1 = 4 ;
mem [ q ] .hhfield .b0 = 0 ;
mem [ q + 2 ] .hhfield .v.RH = p ;
p = q ;
}
}
}
t = mem [ t ] .hhfield .v.RH ;
}
if ( mem [ pp ] .hhfield .b0 >= 21 )
if ( mem [ pp ] .hhfield .b0 == 21 )
pp = mem [ pp + 1 ] .hhfield .lhfield ;
else {
Result = 0 ;
goto lab10 ;
}
if ( mem [ p ] .hhfield .b0 == 21 )
p = mem [ p + 1 ] .hhfield .lhfield ;
if ( mem [ p ] .hhfield .b0 == 0 )
{
if ( mem [ pp ] .hhfield .b0 == 0 )
{
mem [ pp ] .hhfield .b0 = 15 ;
mem [ pp + 1 ] .cint = 0 ;
}
mem [ p ] .hhfield .b0 = mem [ pp ] .hhfield .b0 ;
mem [ p + 1 ] .cint = 0 ;
}
Result = p ;
lab10: ;
return(Result) ;
}