#define EXTERN extern

#define EXTERN extern
#include "texd.h"

void zpostlinebreak ( finalwidowpenalty )
integer finalwidowpenalty ;
{/* 30 31 */ postlinebreak_regmem
halfword q, r, s ;
boolean discbreak ;
boolean postdiscbreak ;
scaled curwidth ;
scaled curindent ;
quarterword t ;
integer pen ;
halfword curline ;
q = mem [ bestbet + 1 ] .hh .v.RH ;
curp = 0 ;
do {
r = q ;
q = mem [ q + 1 ] .hh .v.LH ;
mem [ r + 1 ] .hh .v.LH = curp ;
curp = r ;
} while ( ! ( q == 0 ) ) ;
curline = curlist .pgfield + 1 ;
do {
q = mem [ curp + 1 ] .hh .v.RH ;
discbreak = false ;
postdiscbreak = false ;
if ( q != 0 )
if ( mem [ q ] .hh.b0 == 10 )
{
deleteglueref ( mem [ q + 1 ] .hh .v.LH ) ;
mem [ q + 1 ] .hh .v.LH = eqtb [ 10290 ] .hh .v.RH ;
mem [ q ] .hh.b1 = 9 ;
incr ( mem [ eqtb [ 10290 ] .hh .v.RH ] .hh .v.RH ) ;
goto lab30 ;
}
else {

if ( mem [ q ] .hh.b0 == 7 )
{
t = mem [ q ] .hh.b1 ;
if ( t == 0 )
r = mem [ q ] .hh .v.RH ;
else {

r = q ;
while ( t > 1 ) {

r = mem [ r ] .hh .v.RH ;
decr ( t ) ;
}
s = mem [ r ] .hh .v.RH ;
r = mem [ s ] .hh .v.RH ;
mem [ s ] .hh .v.RH = 0 ;
flushnodelist ( mem [ q ] .hh .v.RH ) ;
mem [ q ] .hh.b1 = 0 ;
}
if ( mem [ q + 1 ] .hh .v.RH != 0 )
{
s = mem [ q + 1 ] .hh .v.RH ;
while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ;
mem [ s ] .hh .v.RH = r ;
r = mem [ q + 1 ] .hh .v.RH ;
mem [ q + 1 ] .hh .v.RH = 0 ;
postdiscbreak = true ;
}
if ( mem [ q + 1 ] .hh .v.LH != 0 )
{
s = mem [ q + 1 ] .hh .v.LH ;
if ( mem [ s ] .hh.b0 == 12 )
{
s = mem [ s ] .hh .v.RH ;
mem [ mem [ q + 1 ] .hh .v.LH ] .hh .v.RH = 0 ;
flushnodelist ( mem [ q + 1 ] .hh .v.LH ) ;
}
mem [ q ] .hh .v.RH = s ;
while ( mem [ s ] .hh .v.RH != 0 ) s = mem [ s ] .hh .v.RH ;
mem [ q + 1 ] .hh .v.LH = 0 ;
q = s ;
}
mem [ q ] .hh .v.RH = r ;
discbreak = true ;
}
else if ( ( mem [ q ] .hh.b0 == 9 ) || ( mem [ q ] .hh.b0 == 11 ) )
mem [ q + 1 ] .cint = 0 ;
}
else {

q = memtop - 3 ;
while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ;
}
r = newparamglue ( 8 ) ;
mem [ r ] .hh .v.RH = mem [ q ] .hh .v.RH ;
mem [ q ] .hh .v.RH = r ;
q = r ;
lab30: ;
r = mem [ q ] .hh .v.RH ;
mem [ q ] .hh .v.RH = 0 ;
q = mem [ memtop - 3 ] .hh .v.RH ;
mem [ memtop - 3 ] .hh .v.RH = r ;
if ( eqtb [ 10289 ] .hh .v.RH != 0 )
{
r = newparamglue ( 7 ) ;
mem [ r ] .hh .v.RH = q ;
q = r ;
}
if ( curline > lastspecialline )
{
curwidth = secondwidth ;
curindent = secondindent ;
}
else if ( eqtb [ 10812 ] .hh .v.RH == 0 )
{
curwidth = firstwidth ;
curindent = firstindent ;
}
else {

curwidth = mem [ eqtb [ 10812 ] .hh .v.RH + 2 * curline ] .cint ;
curindent = mem [ eqtb [ 10812 ] .hh .v.RH + 2 * curline - 1 ] .cint ;
}
adjusttail = memtop - 5 ;
justbox = hpack ( q , curwidth , 0 ) ;
mem [ justbox + 4 ] .cint = curindent ;
appendtovlist ( justbox ) ;
if ( memtop - 5 != adjusttail )
{
mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh .v.RH ;
curlist .tailfield = adjusttail ;
}
adjusttail = 0 ;
if ( curline + 1 != bestline )
{
pen = eqtb [ 12676 ] .cint ;
if ( curline == curlist .pgfield + 1 )
pen = pen + eqtb [ 12668 ] .cint ;
if ( curline + 2 == bestline )
pen = pen + finalwidowpenalty ;
if ( discbreak )
pen = pen + eqtb [ 12671 ] .cint ;
if ( pen != 0 )
{
r = newpenalty ( pen ) ;
mem [ curlist .tailfield ] .hh .v.RH = r ;
curlist .tailfield = r ;
}
}
incr ( curline ) ;
curp = mem [ curp + 1 ] .hh .v.LH ;
if ( curp != 0 )
if ( ! postdiscbreak )
{
r = memtop - 3 ;
while ( true ) {

q = mem [ r ] .hh .v.RH ;
if ( q == mem [ curp + 1 ] .hh .v.RH )
goto lab31 ;
if ( ( q >= himemmin ) )
goto lab31 ;
if ( ( mem [ q ] .hh.b0 < 9 ) )
goto lab31 ;
if ( mem [ q ] .hh.b1 == 2 )
if ( mem [ q ] .hh.b0 == 11 )
goto lab31 ;
r = q ;
}
lab31: if ( r != memtop - 3 )
{
mem [ r ] .hh .v.RH = 0 ;
flushnodelist ( mem [ memtop - 3 ] .hh .v.RH ) ;
mem [ memtop - 3 ] .hh .v.RH = q ;
}
}
} while ( ! ( curp == 0 ) ) ;
if ( ( curline != bestline ) || ( mem [ memtop - 3 ] .hh .v.RH != 0 ) )
confusion ( 935 ) ;
curlist .pgfield = bestline - 1 ;
}
smallnumber zreconstitute ( j , n , bchar , hchar )
smallnumber j ;
smallnumber n ;
halfword bchar ;
halfword hchar ;
{/* 22 30 */ register smallnumber Result; reconstitute_regmem
halfword p ;
halfword t ;
fourquarters q ;
halfword currh ;
halfword testchar ;
scaled w ;
fontindex k ;
smallnumber ii ;
hyphenpassed = 0 ;
t = memtop - 4 ;
w = 0 ;
mem [ memtop - 4 ] .hh .v.RH = 0 ;
{register integer for_end; ii = n ; for_end = j ; if ( ii >= for_end) do
if ( dirtyumlaut [ ii ] != 0 )
n = ii - 1 ;
while ( ii-- > for_end ) ; }
curl = hu [ j ] ;
curq = t ;
if ( j == 0 )
{
ligaturepresent = initlig ;
p = initlist ;
if ( ligaturepresent )
lfthit = initlft ;
while ( p > 0 ) {

{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = mem [ p ] .hh.b1 ;
}
p = mem [ p ] .hh .v.RH ;
}
}
else if ( curl < 256 )
{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = curl ;
}
ligstack = 0 ;
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
lab22: if ( curl == 256 )
{
k = bcharlabel [ hf ] ;
if ( k == fontmemsize )
goto lab30 ;
else q = fontinfo [ k ] .qqqq ;
}
else {

q = fontinfo [ charbase [ hf ] + curl ] .qqqq ;
if ( ( ( q .b2 ) % 4 ) != 1 )
goto lab30 ;
k = ligkernbase [ hf ] + q .b3 ;
q = fontinfo [ k ] .qqqq ;
if ( q .b0 > 128 )
{
k = ligkernbase [ hf ] + 256 * q .b2 + q .b3 + 32768L - 256 * ( 128 ) ;
q = fontinfo [ k ] .qqqq ;
}
}
if ( currh < 256 )
testchar = currh ;
else testchar = curr ;
while ( true ) {

if ( q .b1 == testchar )
if ( q .b0 <= 128 )
if ( currh < 256 )
{
hyphenpassed = j ;
hchar = 256 ;
currh = 256 ;
goto lab22 ;
}
else {

if ( hchar < 256 )
if ( hyfpen [ j ] != 10000 )
{
hyphenpassed = j ;
hchar = 256 ;
}
if ( q .b2 < 128 )
{
if ( curl == 256 )
lfthit = true ;
if ( j == n )
if ( ligstack == 0 )
rthit = true ;
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
switch ( q .b2 )
{case 1 :
case 5 :
{
curl = q .b3 ;
ligaturepresent = true ;
}
break ;
case 2 :
case 6 :
{
curr = q .b3 ;
if ( ligstack > 0 )
mem [ ligstack ] .hh.b1 = curr ;
else {

ligstack = newligitem ( curr ) ;
if ( j == n )
bchar = 256 ;
else {

p = getavail () ;
mem [ ligstack + 1 ] .hh .v.RH = p ;
mem [ p ] .hh.b1 = hu [ j + 1 ] ;
mem [ p ] .hh.b0 = hf ;
}
}
}
break ;
case 3 :
{
curr = q .b3 ;
p = ligstack ;
ligstack = newligitem ( curr ) ;
mem [ ligstack ] .hh .v.RH = p ;
}
break ;
case 7 :
case 11 :
{
if ( ligaturepresent )
{
p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ;
if ( lfthit )
{
mem [ p ] .hh.b1 = 2 ;
lfthit = false ;
}
if ( false )
if ( ligstack == 0 )
{
incr ( mem [ p ] .hh.b1 ) ;
rthit = false ;
}
mem [ curq ] .hh .v.RH = p ;
t = p ;
ligaturepresent = false ;
}
curq = t ;
curl = q .b3 ;
ligaturepresent = true ;
}
break ;
default:
{
curl = q .b3 ;
ligaturepresent = true ;
if ( ligstack > 0 )
{
if ( mem [ ligstack + 1 ] .hh .v.RH > 0 )
{
mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ;
t = mem [ t ] .hh .v.RH ;
incr ( j ) ;
}
p = ligstack ;
ligstack = mem [ p ] .hh .v.RH ;
freenode ( p , 2 ) ;
if ( ligstack == 0 )
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
else curr = mem [ ligstack ] .hh.b1 ;
}
else if ( j == n )
goto lab30 ;
else {

{
mem [ t ] .hh .v.RH = getavail () ;
t = mem [ t ] .hh .v.RH ;
mem [ t ] .hh.b0 = hf ;
mem [ t ] .hh.b1 = curr ;
}
incr ( j ) ;
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
}
}
break ;
}
if ( q .b2 > 4 )
if ( q .b2 != 7 )
goto lab30 ;
goto lab22 ;
}
w = fontinfo [ kernbase [ hf ] + 256 * q .b2 + q .b3 ] .cint ;
goto lab30 ;
}
if ( q .b0 >= 128 )
if ( currh == 256 )
goto lab30 ;
else {

currh = 256 ;
goto lab22 ;
}
k = k + q .b0 + 1 ;
q = fontinfo [ k ] .qqqq ;
}
lab30: ;
if ( ligaturepresent )
{
p = newligature ( hf , curl , mem [ curq ] .hh .v.RH ) ;
if ( lfthit )
{
mem [ p ] .hh.b1 = 2 ;
lfthit = false ;
}
if ( rthit )
if ( ligstack == 0 )
{
incr ( mem [ p ] .hh.b1 ) ;
rthit = false ;
}
mem [ curq ] .hh .v.RH = p ;
t = p ;
ligaturepresent = false ;
}
if ( w != 0 )
{
mem [ t ] .hh .v.RH = newkern ( w ) ;
t = mem [ t ] .hh .v.RH ;
w = 0 ;
}
if ( ligstack > 0 )
{
curq = t ;
curl = mem [ ligstack ] .hh.b1 ;
ligaturepresent = true ;
{
if ( mem [ ligstack + 1 ] .hh .v.RH > 0 )
{
mem [ t ] .hh .v.RH = mem [ ligstack + 1 ] .hh .v.RH ;
t = mem [ t ] .hh .v.RH ;
incr ( j ) ;
}
p = ligstack ;
ligstack = mem [ p ] .hh .v.RH ;
freenode ( p , 2 ) ;
if ( ligstack == 0 )
{
if ( j < n )
curr = hu [ j + 1 ] ;
else curr = bchar ;
if ( hyfpen [ j ] != 10000 )
currh = hchar ;
else currh = 256 ;
}
else curr = mem [ ligstack ] .hh.b1 ;
}
goto lab22 ;
}
Result = j ;
return(Result) ;
}
void zhashfunk ( w , anfang , ende , v , ind , k )
wort w ;
integer anfang ;
integer ende ;
varr v ;
intarr ind ;
intarr k ;
{hashfunk_regmem
long vacc, indacc, kacc ;
integer i ;
vacc = 31415L ;
indacc = 152L ;
kacc = 271L ;
{register integer for_end; i = anfang ; for_end = ende ; if ( i <= for_end)
do
{
;
vacc = ( vacc * 31 + w [ i ] ) % 8388648L ;
v [ i ] = vacc ;
indacc = ( indacc * 33 + w [ i ] ) % ( tabsize + 1 ) ;
ind [ i ] = indacc ;
kacc = ( kacc * 15 + w [ i ] ) % ( ( tabsize + 1 ) / 2 ) ;
k [ i ] = 2 * kacc + 1 ;
}
while ( i++ < for_end ) ; }
}
void zunpackinfo ( b , iausnahme , iuntrennbar , ierste , izweite , iendung ,
ivorsilbe , istamm , iehervor , istammallein )
infobyte b ;
boolean * iausnahme ;
boolean * iuntrennbar ;
integer * ierste ;
integer * izweite ;
boolean * iendung ;
boolean * ivorsilbe ;
boolean * istamm ;
boolean * iehervor ;
boolean * istammallein ;
{unpackinfo_regmem
if ( odd ( b ) )
{
* iausnahme = true ;
b = b / 2 ;
if ( odd ( b ) )
* iuntrennbar = true ;
else *iuntrennbar = false ;
b = b / 2 ;
* ierste = b % 8 ;
* izweite = b / 8 ;
}
else {

* iausnahme = false ;
b = b / 2 ;
if ( odd ( b ) )
* iendung = true ;
else *iendung = false ;
b = b / 2 ;
if ( odd ( b ) )
* ivorsilbe = true ;
else *ivorsilbe = false ;
b = b / 2 ;
if ( odd ( b ) )
* istamm = true ;
else *istamm = false ;
b = b / 2 ;
if ( odd ( b ) )
* iehervor = true ;
else *iehervor = false ;
b = b / 2 ;
if ( odd ( b ) )
* istammallein = true ;
else *istammallein = false ;
}
}
void zunpackentry ( h , etabv , etabb , efrei , ewiederfrei )
hashelement h ;
verdschlue * etabv ;
infobyte * etabb ;
boolean * efrei ;
boolean * ewiederfrei ;
{unpackentry_regmem
;
* etabv = h [ 0 ] + h [ 1 ] * 256 + h [ 2 ] * 256 * 256 ;
if ( odd ( h [ 3 ] ) )
{
;
* etabb = h [ 3 ] ;
* efrei = false ;
* ewiederfrei = false ;
}
else {

;
* etabb = h [ 3 ] % 64 ;
if ( odd ( h [ 3 ] / 64 ) )
* efrei = true ;
else *efrei = false ;
if ( odd ( h [ 3 ] / 128 ) )
* ewiederfrei = true ;
else *ewiederfrei = false ;
}
}
void zhashsuch ( v , ind , k , iausnahme , iuntrennbar , ierste , izweite ,
iendung , ivorsilbe , istamm , iehervor , istammallein , g )
verdschlue v ;
integer ind ;
integer k ;
boolean * iausnahme ;
boolean * iuntrennbar ;
integer * ierste ;
integer * izweite ;
boolean * iendung ;
boolean * ivorsilbe ;
boolean * istamm ;
boolean * iehervor ;
boolean * istammallein ;
boolean * g ;
{hashsuch_regmem
boolean gef, ngef ;
integer j ;
tableentry entry ;
gef = false ;
ngef = false ;
j = ind ;
do {
unpackentry ( htab [ j ] , entry .tabv , entry .tabb , entry .frei ,
entry .wiederfrei ) ;
if ( entry .frei )
ngef = true ;
else if ( ( v == entry .tabv ) && ! entry .wiederfrei )
{
unpackinfo ( entry .tabb , *iausnahme , *iuntrennbar , *ierste , *izweite , *
iendung , *ivorsilbe , *istamm , *iehervor , *istammallein ) ;
gef = true ;
}
else j = ( j + k ) % ( tabsize + 1 ) ;
} while ( ! ( gef || ngef ) ) ;
* g = gef ;
}
void zhashload ( status )
integer * status ;
{hashload_regmem
integer i ;
tableentry e ;
{register integer for_end; i = 1 ; for_end = FILENAMESIZE ; if ( i <=
for_end) do
nameoffile [ i ] = ' ' ;
while ( i++ < for_end ) ; }
nameoffile [ 1 ] = 'h' ;
nameoffile [ 2 ] = 'f' ;
nameoffile [ 3 ] = '3' ;
namelength = 3 ;
anzahl = 0 ;
if ( aopenin ( hashfile , TEXINPUTPATH ) )
{
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
{
int help;
fscanf ( hashfile, "%d", &help );
htab [i][0] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][1] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][2] = (eightbits) help;
fscanf ( hashfile, "%d", &help );
htab [i][3] = (eightbits) help;
unpackentry ( htab [ i ] , e .tabv , e .tabb , e .frei , e .wiederfrei
) ;
if ( ! e .frei && ! e .wiederfrei )
anzahl = anzahl + 1 ;
}
while ( i++ < for_end ) ; }
* status = 0 ;
aclose ( hashfile ) ;
}
else *status = 1 ;
}
void zpackinfo ( i , b )
infotype i ;
infobyte * b ;
{packinfo_regmem
* b = 0 ;
if ( i .ausnahme )
{
;
if ( i .untrennbar )
;
else ;
* b = 1 + 2 * ord ( i .untrennbar ) + 4 * i .erste + 32 * i .zweite ;
}
else {

;
* b = 2 * ord ( i .endung ) + 4 * ord ( i .vorsilbe ) + 8 * ord ( i .stamm )
+ 16 * ord ( i .ehervor ) + 32 * ord ( i .stammallein ) ;
}
}
void zpackentry ( e , h )
tableentry e ;
hashelement h ;
{packentry_regmem
;
h [ 0 ] = e .tabv % 256 ;
e .tabv = e .tabv / 256 ;
h [ 1 ] = e .tabv % 256 ;
h [ 2 ] = e .tabv / 256 ;
if ( odd ( e .tabb ) )
h [ 3 ] = e .tabb ;
else {

;
h [ 3 ] = e .tabb + 64 * ord ( e .frei ) + 128 * ord ( e .wiederfrei ) ;
}
}
void zhashetr ( w , laenge , i , g )
wort w ;
integer laenge ;
infotype i ;
boolean * g ;
{hashetr_regmem
varr v1 ;
intarr ind1, k1 ;
verdschlue v ;
integer ind, k, j, e ;
boolean gef, ngef ;
tableentry entry ;
hashelement helem ;
if ( anzahl >= tabsize )
{
;
* g = false ;
}
else {

;
if ( ( anzahl < 10 ) || ( anzahl % 100 == 0 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s", " -Anzahl:" , (long)anzahl , ". " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s", " -Anzahl:" , (long)anzahl , ". " ) ;
}
}
hashfunk ( w , 1 , laenge , v1 , ind1 , k1 ) ;
v = v1 [ laenge ] ;
ind = ind1 [ laenge ] ;
k = k1 [ laenge ] ;
gef = false ;
ngef = false ;
do {
;
unpackentry ( htab [ ind ] , entry .tabv , entry .tabb , entry .frei ,
entry .wiederfrei ) ;
if ( entry .frei || entry .wiederfrei )
{
anzahl = anzahl + 1 ;
ngef = true ;
entry .tabv = v ;
packinfo ( i , entry .tabb ) ;
entry .frei = false ;
entry .wiederfrei = false ;
packentry ( entry , helem ) ;
memcpy((void *)htab [ ind ] , (void *)helem , sizeof(hashelement));
}
else {

;
gef = v == entry .tabv ;
if ( ! gef )
ind = ( ind + k ) % ( tabsize + 1 ) ;
}
} while ( ! ( gef || ngef ) ) ;
* g = ngef ;
}
}
void hashempty ( )
{hashempty_regmem
integer i ;
tableentry elem ;
hashelement he ;
elem .tabv = 0 ;
elem .tabb = 0 ;
elem .frei = true ;
elem .wiederfrei = false ;
packentry ( elem , he ) ;
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
memcpy((void *)htab [ i ] , (void *)he, sizeof(hashelement));
while ( i++ < for_end ) ; }
anzahl = 0 ;
}
void zhashsave ( status )
integer * status ;
{hashsave_regmem
integer i ;
{register integer for_end; i = 1 ; for_end = FILENAMESIZE ; if ( i <=
for_end) do
nameoffile [ i ] = ' ' ;
while ( i++ < for_end ) ; }
nameoffile [ 1 ] = 'h' ;
nameoffile [ 2 ] = 'f' ;
nameoffile [ 3 ] = '3' ;
namelength = 3 ;
if ( aopenout ( hashfile ) )
{
{register integer for_end; i = 0 ; for_end = tabsize ; if ( i <= for_end)
do
{
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 0 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 1 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 2 ] ) ;
(void) fprintf( hashfile , "%4ld", (long)htab [ i ] [ 3 ] ) ;
(void) putc('\n', hashfile );
}
while ( i++ < for_end ) ; }
* status = 0 ;
aclose ( hashfile ) ;
}
else *status = 1 ;
}
integer hashsize ( )
{register integer Result; hashsize_regmem
Result = anzahl ;
return(Result) ;
}
void zzahl ( line , i , ende , j )
string80 line ;
integer * i ;
integer ende ;
integer * j ;
{zahl_regmem
boolean aus ;
* j = 0 ;
do {
if ( *i <= ende )
if ( ktab [ line [ *i ] ] == 46 )
* i = *i + 1 ;
else aus = true ;
else aus = true ;
} while ( ! ( aus ) ) ;
do {
if ( *i <= ende )
{
switch ( line [ *i ] )
{case 48 :
case 49 :
case 50 :
case 51 :
case 52 :
case 53 :
case 54 :
case 55 :
case 56 :
case 57 :
{
* j = 10 * *j + line [ *i ] - 48 ;
* i = *i + 1 ;
}
break ;
}
if ( ( line [ *i ] != 48 ) && ( line [ *i ] != 49 ) && ( line [ *i ] != 50
) && ( line [ *i ] != 51 ) && ( line [ *i ] != 52 ) && ( line [ *i ] != 53
) && ( line [ *i ] != 54 ) && ( line [ *i ] != 55 ) && ( line [ *i ] != 56
) && ( line [ *i ] != 57 ) )
aus = true ;
}
else aus = true ;
} while ( ! ( aus ) ) ;
}
void zinfobau ( line , anfang , ende , informausnahme , informuntrennbar ,
informerste , informzweite , informendung , informvorsilbe , informstamm ,
informehervor , informstammallein , g )
string80 line ;
integer anfang ;
integer ende ;
boolean * informausnahme ;
boolean * informuntrennbar ;
integer * informerste ;
integer * informzweite ;
boolean * informendung ;
boolean * informvorsilbe ;
boolean * informstamm ;
boolean * informehervor ;
boolean * informstammallein ;
boolean * g ;
{infobau_regmem
integer i, j ;
boolean ok, fehler ;
buchstabe b ;
* g = false ;
* informausnahme = false ;
* informendung = false ;
* informvorsilbe = false ;
* informehervor = false ;
* informstamm = false ;
* informstammallein = false ;
i = anfang ;
ok = false ;
fehler = false ;
do {
if ( i <= ende )
if ( line [ i ] == 46 )
i = i + 1 ;
else ok = true ;
else fehler = true ;
} while ( ! ( ok || fehler ) ) ;
if ( ! fehler )
{
b = ktab [ line [ i ] ] ;
if ( b == bsta )
{
* informausnahme = true ;
i = i + 1 ;
if ( ktab [ line [ i ] ] == bstu )
{
i = i + 1 ;
* informuntrennbar = true ;
}
else *informuntrennbar = false ;
zahl ( line , i , ende , j ) ;
if ( j == 0 )
{
* informerste = 7 ;
* informzweite = 7 ;
}
else {

j = j - 2 ;
if ( ( j >= 0 ) && ( j <= 6 ) )
* informerste = j ;
else fehler = true ;
zahl ( line , i , ende , j ) ;
if ( j == 0 )
* informzweite = 7 ;
else {

j = j - *informerste - 4 ;
if ( ( j >= 0 ) && ( j <= 6 ) )
* informzweite = j ;
else fehler = true ;
}
}
if ( ! fehler )
* g = true ;
}
else {

ok = false ;
do {
switch ( b )
{case 22 :
* informvorsilbe = true ;
break ;
case 5 :
* informendung = true ;
break ;
case 19 :
* informstamm = true ;
break ;
case 2 :
* informehervor = true ;
break ;
case 20 :
* informstammallein = true ;
break ;
case 31 :
;
break ;
default:
fehler = true ;
break ;
}
if ( i == ende )
ok = true ;
else {

i = i + 1 ;
b = ktab [ line [ i ] ] ;
}
} while ( ! ( ok || fehler ) ) ;
if ( ! fehler )
* g = ( *informvorsilbe || *informendung || *informstamm ) && ( ! *
informehervor || *informvorsilbe && *informendung ) && ( ! *
informstammallein || *informstamm ) ;
}
}
}
void zeintragen ( line , l )
string80 line ;
integer l ;
{eintragen_regmem
integer i, laenge ;
infotype inform ;
wort w ;
boolean g ;
laenge = 1 ;
while ( line [ laenge ] != 46 ) laenge = laenge + 1 ;
laenge = laenge - 1 ;
if ( laenge >= 1 )
{
if ( laenge <= maxwl )
{
infobau ( line , laenge + 1 , l , inform .ausnahme , inform .untrennbar
, inform .erste , inform .zweite , inform .endung , inform .vorsilbe ,
inform .stamm , inform .ehervor , inform .stammallein , g ) ;
if ( ! g )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " Info falsch: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " Info falsch: " ) ;
}
}
else {

{register integer for_end; i = 1 ; for_end = laenge ; if ( i <=
for_end) do
w [ i ] = ktab [ line [ i ] ] ;
while ( i++ < for_end ) ; }
hashetr ( w , laenge , inform , g ) ;
if ( ! g )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " Tabellenfehler: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " Tabellenfehler: " ) ;
}
}
}
if ( ! g )
{
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end)
do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
else {

println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " zu langes Wort: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " zu langes Wort: " ) ;
}
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
else {

println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " Falsche Zeile: " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " Falsche Zeile: " ) ;
}
{register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( line [ i ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( line [ i ] ) , logfile );
}
while ( i++ < for_end ) ; }
println () ;
}
}
void znaechsterbst ( i , tr , dudstop , b , w )
integer * i ;
trennvektor tr ;
sperrvektor dudstop ;
buchstabe * b ;
wort w ;
{naechsterbst_regmem
if ( ( *i > 0 ) && ( tr [ *i ] == keine ) && ! dudstop [ *i ] )
{
* b = w [ *i ] ;
* i = *i - 1 ;
}
else *b = trennzeichen ;
}
void zduden ( tr , w , tr1 , dudtr , dud , dudstop , laenge , ok , zerlegungen
)
trennvektor tr ;
wort w ;
trennvektor tr1 ;
trennvektor dudtr ;
dudt dud ;
sperrvektor dudstop ;
integer laenge ;
boolean * ok ;
integer * zerlegungen ;
{duden_regmem
integer i ;
integer j ;
integer zust ;
boolean aus ;
integer tre ;
integer letzte ;
integer l, lalt ;
buchstabe b ;
i = laenge ;
{register integer for_end; j = 0 ; for_end = laenge ; if ( j <= for_end) do
dudtr [ j ] = tr [ j ] ;
while ( j++ < for_end ) ; }
while ( ( i > 0 ) && ! dud [ i ] ) i = i - 1 ;
while ( i > 0 ) {

zust = 1 ;
aus = false ;
letzte = 0 ;
l = kons ;
b = w [ i ] ;
i = i - 1 ;
do {
{
tre = i + 1 ;
lalt = l ;
switch ( b )
{case 1 :
{
l = voka ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 15 :
{
l = voko ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 29 :
{
l = vokue ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 28 :
{
l = vokoe ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 27 :
{
l = vokae ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 5 :
{
l = voke ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsti )
{
l = vokie ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
i = i + 1 ;
l = voke ;
b = bsti ;
}
}
}
break ;
case 9 :
{
l = voki ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
l = vokei ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bsta )
{
l = vokai ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
}
break ;
case 21 :
{
l = voku ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bste )
{
l = vokeu ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bsta )
{
l = vokau ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstae )
{
l = vokaeu ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstq )
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
}
break ;
case 20 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsts )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 8 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bstc )
{
naechsterbst ( i , tr , dudstop , b , w ) ;
if ( b == bsts )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
else if ( b == bstp )
naechsterbst ( i , tr , dudstop , b , w ) ;
else if ( b == bstt )
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 2 :
case 3 :
case 4 :
case 6 :
case 7 :
case 10 :
case 11 :
case 12 :
case 13 :
case 14 :
case 16 :
case 17 :
case 18 :
case 19 :
case 22 :
case 23 :
case 24 :
case 26 :
case 30 :
{
l = kons ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 25 :
{
l = voky ;
naechsterbst ( i , tr , dudstop , b , w ) ;
}
break ;
case 31 :
case 0 :
aus = true ;
break ;
}
}
if ( ! aus )
switch ( zust )
{case 1 :
if ( l == kons )
zust = 2 ;
else zust = 4 ;
break ;
case 2 :
if ( l != kons )
zust = 3 ;
break ;
case 3 :
if ( l == kons )
zust = 6 ;
else if ( l != lalt )
{
zust = 4 ;
letzte = tre ;
dudtr [ letzte ] = neben ;
}
break ;
case 4 :
if ( l == kons )
zust = 6 ;
else zust = 3 ;
break ;
case 6 :
if ( l == kons )
{
zust = 2 ;
letzte = tre ;
if ( ( w [ tre ] == bstc ) && ( w [ tre + 1 ] == bstk ) )
dudtr [ letzte ] = nebenck ;
else dudtr [ letzte ] = neben ;
}
else {

zust = 4 ;
letzte = tre ;
dudtr [ letzte ] = neben ;
}
break ;
}
} while ( ! ( aus ) ) ;
if ( zust == 2 )
dudtr [ letzte ] = keine ;
else if ( zust == 4 )
if ( ( lalt < vokie ) || ( lalt > vokeu ) )
dudtr [ letzte ] = keine ;
while ( ( i > 0 ) && ! dud [ i ] ) i = i - 1 ;
}
}
void ztrennen ( zustand , anfang , spv , ok1 , tr , dudtr , zerlegungen , dud
, v , ind , k , dudstop , w , tr1 , laenge )
integer zustand ;
integer anfang ;
sperrvektor spv ;
boolean * ok1 ;
trennvektor tr ;
trennvektor dudtr ;
integer * zerlegungen ;
dudt dud ;
varr v ;
intarr ind ;
intarr k ;
sperrvektor dudstop ;
wort w ;
trennvektor tr1 ;
integer laenge ;
{trennen_regmem
boolean gef, nichtok ;
integer schnitt ;
infotype inform ;
integer i ;
boolean okstamm, okvor, okend, okhelp ;
integer tri ;
integer i1, tre ;
boolean ok ;
integer stopptr ;
sperrvektor spvtmp ;
memcpy((void *)spvtmp, (void *)spv, sizeof(sperrvektor)) ;
* ok1 = false ;
if ( anfang == laenge + 1 )
if ( ( zustand == 2 ) || ( zustand == 4 ) )
{
dud [ anfang - 1 ] = true ;
duden ( tr , w , tr1 , dudtr , dud , dudstop , laenge , ok , *zerlegungen )
;
{register integer for_end; i = laenge ; for_end = 1 ; if ( i >= for_end)
do
{
if ( dudtr [ i - 1 ] == haupt3 )
{
dudtr [ i - 1 ] = keine ;
tri = haupt3 ;
}
else tri = dudtr [ i ] ;
if ( *zerlegungen == 0 )
tr1 [ i ] = tri ;
else tr1 [ i ] = kombtab [ tr1 [ i ] ][ tri ] ;
}
while ( i-- > for_end ) ; }
* zerlegungen = *zerlegungen + 1 ;
* ok1 = true ;
}
else ;
else {

hashfunk ( w , anfang , laenge , v , ind , k ) ;
schnitt = laenge ;
nichtok = false ;
do {
do { if ( spv [ schnitt ] )
gef = false ;
else {

hashsuch ( v [ schnitt ] , ind [ schnitt ] , k [ schnitt ] , inform
.ausnahme , inform .untrennbar , inform .erste , inform .zweite ,
inform .endung , inform .vorsilbe , inform .stamm , inform .ehervor
, inform .stammallein , gef ) ;
}
if ( gef )
spv [ schnitt ] = true ;
else schnitt = schnitt - 1 ;
} while ( ! ( gef || ( schnitt == anfang - 1 ) ) ) ;
if ( gef )
{
if ( ! inform .ausnahme )
{
if ( inform .endung && ( zustand == 2 ) )
{
okend = false ;
if ( ( w [ anfang ] == bstc ) || ( w [ anfang ] == bsth ) )
{
dud [ anfang - 1 ] = true ;
tr [ anfang - 1 ] = neben ;
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okend = okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okend = okend || okhelp ;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
* ok1 = *ok1 || okend ;
}
else okend = false ;
if ( inform .vorsilbe )
{
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
dud [ schnitt ] = true ;
trennen ( 1 , schnitt + 1 , spv , okvor , tr , dudtr , *zerlegungen
, dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
dud [ schnitt ] = false ;
* ok1 = *ok1 || okvor ;
}
else okvor = false ;
if ( inform .stamm && ! okvor )
{
if ( ! inform .stammallein )
{
okstamm = false ;
stopptr = 0 ;
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
if ( inform .ausnahme )
{
if ( inform .erste != 7 )
{
tre = anfang + inform .erste + 1 ;
tr [ tre ] = neben ;
if ( inform .zweite != 7 )
{
tre = tre + inform .zweite + 2 ;
if ( inform .untrennbar )
{
stopptr = tre ;
dudstop [ stopptr ] = true ;
}
else tr [ tre ] = neben ;
}
else {

if ( inform .untrennbar )
{
tr [ tre ] = keine ;
stopptr = tre ;
dudstop [ tre ] = true ;
}
}
}
else {

stopptr = schnitt - 1 ;
dudstop [ stopptr ] = true ;
}
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge )
;
okstamm = okhelp ;
}
if ( ( schnitt >= 2 ) && ( schnitt < laenge ) )
if ( konsonant [ w [ schnitt ] ] && ! konsonant [ w [ schnitt +
1 ] ] && ( w [ schnitt ] == w [ schnitt - 1 ] ) )
{
trennen ( 5 , schnitt , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge )
;
okstamm = okstamm || okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
if ( inform .ausnahme )
{register integer for_end; i1 = anfang - 1 ; for_end = schnitt
; if ( i1 <= for_end) do
{
tr [ i1 ] = keine ;
dud [ i1 ] = false ;
dudstop [ stopptr ] = false ;
}
while ( i1++ < for_end ) ; }
else {

tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
}
* ok1 = *ok1 || okstamm ;
}
else if ( ( anfang == 1 ) && ( schnitt == laenge ) )
{
dud [ anfang - 1 ] = true ;
tr [ anfang - 1 ] = haupt ;
trennen ( 4 , schnitt + 1 , spv , okstamm , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
* ok1 = *ok1 || okstamm ;
}
}
}
else {

okstamm = false ;
stopptr = 0 ;
if ( zustand == 1 )
tr [ anfang - 1 ] = neben ;
else {

dud [ anfang - 1 ] = true ;
if ( zustand == 5 )
tr [ anfang - 1 ] = haupt3 ;
else tr [ anfang - 1 ] = haupt ;
}
if ( inform .ausnahme )
{
if ( inform .erste != 7 )
{
tre = anfang + inform .erste + 1 ;
tr [ tre ] = neben ;
if ( inform .zweite != 7 )
{
tre = tre + inform .zweite + 2 ;
if ( inform .untrennbar )
{
stopptr = tre ;
dudstop [ stopptr ] = true ;
}
else tr [ tre ] = neben ;
}
else {

if ( inform .untrennbar )
{
tr [ tre ] = keine ;
stopptr = tre ;
dudstop [ tre ] = true ;
}
}
}
else {

stopptr = schnitt - 1 ;
dudstop [ stopptr ] = true ;
}
}
if ( schnitt < laenge )
if ( ( w [ schnitt + 1 ] == bsts ) && ! spv [ schnitt + 1 ] )
{
spv [ schnitt + 1 ] = true ;
trennen ( 2 , schnitt + 2 , spv , okhelp , tr , dudtr , *
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okhelp ;
}
if ( ( schnitt >= 2 ) && ( schnitt < laenge ) )
if ( konsonant [ w [ schnitt ] ] && ! konsonant [ w [ schnitt + 1 ]
] && ( w [ schnitt ] == w [ schnitt - 1 ] ) )
{
trennen ( 5 , schnitt , spv , okhelp , tr , dudtr , *zerlegungen ,
dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
}
trennen ( 2 , schnitt + 1 , spv , okhelp , tr , dudtr , *zerlegungen
, dud , v , ind , k , dudstop , w , tr1 , laenge ) ;
okstamm = okstamm || okhelp ;
if ( inform .ausnahme )
{register integer for_end; i1 = anfang - 1 ; for_end = schnitt
; if ( i1 <= for_end) do
{
tr [ i1 ] = keine ;
dud [ i1 ] = false ;
dudstop [ stopptr ] = false ;
}
while ( i1++ < for_end ) ; }
else {

tr [ anfang - 1 ] = keine ;
dud [ anfang - 1 ] = false ;
}
* ok1 = *ok1 || okstamm ;
}
schnitt = schnitt - 1 ;
nichtok = schnitt == anfang - 1 ;
}
else nichtok = true ;
} while ( ! ( nichtok ) ) ;
}
memcpy((void *)spv, (void *)spvtmp, sizeof(sperrvektor)) ;
}
void zabteilen ( w , tr1 , laenge , ok , zerlegungen )
wort w ;
trennvektor tr1 ;
integer laenge ;
boolean * ok ;
integer * zerlegungen ;
{/* 99 */ abteilen_regmem
integer i ;
dudt dud ;
varr v ;
intarr ind, k ;
sperrvektor spv, dudstop ;
trennvektor tr, dudtr ;
tr1 [ 0 ] = keine ;
{register integer for_end; i = 0 ; for_end = laenge ; if ( i <= for_end) do
{
tr [ i ] = keine ;
spv [ i ] = false ;
dudstop [ i ] = false ;
dud [ i ] = false ;
if ( i > 0 )
if ( ( w [ i ] == trennzeichen ) || ( w [ i ] == sonderzeichen ) )
{
* zerlegungen = 0 ;
* ok = false ;
goto lab99 ;
}
}
while ( i++ < for_end ) ; }
* zerlegungen = 0 ;
trennen ( 3 , 1 , spv , *ok , tr , dudtr , *zerlegungen , dud , v , ind , k ,
dudstop , w , tr1 , laenge ) ;
{register integer for_end; i = 0 ; for_end = laenge ; if ( i <= for_end) do
if ( tr1 [ i ] == nebenck )
{
tr1 [ i ] = keine ;
tr1 [ i - 1 ] = nebenck ;
}
while ( i++ < for_end ) ; }
lab99: ;
}
boolean zisdirtyumlaut ( p )
halfword p ;
{register boolean Result; isdirtyumlaut_regmem
boolean res ;
halfword q ;
res = false ;
if ( p != 0 )
if ( mem [ p ] .hh.b0 == 7 )
if ( mem [ p + 1 ] .hh .v.LH != 0 )
if ( mem [ mem [ p + 1 ] .hh .v.LH ] .hh .v.RH != 0 )
if ( mem [ mem [ mem [ p + 1 ] .hh .v.LH ] .hh .v.RH ] .hh .v.RH != 0 )
{
q = mem [ p + 1 ] .hh .v.LH ;
if ( mem [ q ] .hh.b0 == 12 )
q = mem [ q ] .hh .v.RH ;
if ( ( mem [ q ] .hh.b0 == 11 ) && ( mem [ q + 1 ] .cint == specletterID )
&& ( mem [ q ] .hh .v.RH >= himemmin ) && ( mem [ mem [ mem [ q ] .hh
.v.RH ] .hh .v.RH ] .hh.b0 == 11 ) )
res = true ;
}
Result = res ;
return(Result) ;
}
integer zgetcharof ( s )
halfword s ;
{register integer Result; getcharof_regmem
halfword q ;
q = mem [ s + 1 ] .hh .v.LH ;
if ( mem [ q ] .hh.b0 == 12 )
q = mem [ q ] .hh .v.RH ;
Result = mem [ mem [ mem [ q ] .hh .v.RH ] .hh .v.RH + 1 ] .cint ;
return(Result) ;
}
integer zgetfontof ( s )
halfword s ;
{register integer Result; getfontof_regmem
halfword q ;
q = mem [ s + 1 ] .hh .v.LH ;
if ( mem [ q ] .hh.b0 == 12 )
q = mem [ q ] .hh .v.RH ;
Result = mem [ mem [ q ] .hh .v.RH ] .hh.b0 ;
return(Result) ;
}
void hyphenate ( )
{/* 50 30 31 40 41 42 45 10 */ hyphenate_regmem
schar i, j, l, kk ;
halfword q, r, s, qq, qr, holdr ;
halfword bchar ;
short xchgchar[11] ;
schar addchar, xchgi, xchgk, xchghu ;
halfword spechyf ;
integer sij ;
halfword majortail, minortail ;
ASCIIcode c ;
schar cloc ;
integer rcount ;
halfword hyfnode ;
triepointer z ;
integer v ;
boolean funktioniert ;
integer zerleg ;
hyphpointer h ;
strnumber k ;
poolpointer u ;
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
hyf [ j ] = 0 ;
while ( j++ < for_end ) ; }
h = hc [ 1 ] ;
incr ( hn ) ;
hc [ hn ] = curlang ;
{register integer for_end; j = 2 ; for_end = hn ; if ( j <= for_end) do
h = ( h + h + hc [ j ] ) % 607 ;
while ( j++ < for_end ) ; }
while ( true ) {

k = hyphword [ h ] ;
if ( k == 0 )
goto lab45 ;
if ( ( strstart [ k + 1 ] - strstart [ k ] ) < hn )
goto lab45 ;
if ( ( strstart [ k + 1 ] - strstart [ k ] ) == hn )
{
j = 1 ;
u = strstart [ k ] ;
do {
if ( strpool [ u ] < hc [ j ] )
goto lab45 ;
if ( strpool [ u ] > hc [ j ] )
goto lab30 ;
incr ( j ) ;
incr ( u ) ;
} while ( ! ( j > hn ) ) ;
s = hyphlist [ h ] ;
while ( s != 0 ) {

hyf [ mem [ s ] .hh .v.LH ] = 1 ;
s = mem [ s ] .hh .v.RH ;
}
decr ( hn ) ;
goto lab40 ;
}
lab30: ;
if ( h > 0 )
decr ( h ) ;
else h = 607 ;
}
lab45: decr ( hn ) ;
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
hcsi [ j ] = ktab [ hc [ j ] ] ;
while ( j++ < for_end ) ; }
if ( odd ( eqtb [ 12719 ] .cint / 2 ) )
{
if ( ! odd ( eqtb [ 12720 ] .cint / 2 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s\n", " <* debugging output section #" , (long)2 , " *>" )
;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s\n", " <* debugging output section #" , (long)2 , " *>" ) ;
}
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " hc:" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " hc:" ) ;
}
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( hc [ j ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( hc [ j ] ) , logfile );
}
while ( j++ < for_end ) ; }
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%c\n", ':' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%c\n", ':' ) ;
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " hc_si:" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " hc_si:" ) ;
}
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( revtab [ hcsi [ j ] ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( revtab [ hcsi [ j ] ] ) , logfile );
}
while ( j++ < for_end ) ; }
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%c\n", ':' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%c\n", ':' ) ;
}
}
if ( odd ( eqtb [ 12719 ] .cint / 4 ) )
{
if ( ! odd ( eqtb [ 12720 ] .cint / 4 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s\n", " <* debugging output section #" , (long)4 , " *>" )
;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s\n", " <* debugging output section #" , (long)4 , " *>" ) ;
}
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", "< decimal character codes >" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", "< decimal character codes >" ) ;
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " hc:" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " hc:" ) ;
}
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
{
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%ld%c", (long)hc [ j ] , '-' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%ld%c", (long)hc [ j ] , '-' ) ;
}
if ( ( ( j + 1 ) % 16 ) == 0 )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " " ) ;
}
}
}
while ( j++ < for_end ) ; }
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " hc_si:" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " hc_si:" ) ;
}
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
{
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%ld%c", (long)revtab [ hcsi [ j ] ] , '-' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%ld%c", (long)revtab [ hcsi [ j ] ] , '-' ) ;
}
if ( ( ( j + 1 ) % 16 ) == 0 )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " " ) ;
}
}
}
while ( j++ < for_end ) ; }
println () ;
println () ;
}
abteilen ( hcsi , hyfsi , hn , funktioniert , zerleg ) ;
{register integer for_end; j = 0 ; for_end = 64 ; if ( j <= for_end) do
{
hyfdisc [ j ] = 0 ;
hyfpen [ j ] = 10000 ;
}
while ( j++ < for_end ) ; }
if ( funktioniert )
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
{
if ( hyfsi [ j ] == neben )
hyfpen [ j ] = eqtb [ 12718 ] .cint ;
else if ( hyfsi [ j ] == haupt )
hyfpen [ j ] = eqtb [ 12666 ] .cint ;
else if ( hyfsi [ j ] == nebenck )
{
hyfpen [ j + 1 ] = eqtb [ 12718 ] .cint ;
s = getnode ( 2 ) ;
mem [ s ] .hh.b0 = 7 ;
hyfdisc [ j + 1 ] = s ;
mem [ s + 1 ] .hh .v.LH = newpenalty ( eqtb [ 12718 ] .cint ) ;
s = mem [ s + 1 ] .hh .v.LH ;
mem [ s ] .hh.b1 = 0 ;
mem [ s ] .hh .v.RH = newcharacter ( hf , hu [ j + 2 ] ) ;
mem [ mem [ s ] .hh .v.RH ] .hh .v.RH = 0 ;
s = hyfdisc [ j + 1 ] ;
mem [ s + 1 ] .hh .v.RH = 0 ;
mem [ s ] .hh .v.RH = 0 ;
}
else if ( hyfsi [ j ] == haupt3 )
{
hyfpen [ j - 1 ] = eqtb [ 12666 ] .cint ;
s = getnode ( 2 ) ;
mem [ s ] .hh.b0 = 7 ;
hyfdisc [ j - 1 ] = s ;
mem [ s + 1 ] .hh .v.LH = newpenalty ( eqtb [ 12666 ] .cint ) ;
s = mem [ s + 1 ] .hh .v.LH ;
mem [ s ] .hh.b1 = 1 ;
mem [ s ] .hh .v.RH = newcharacter ( hf , hu [ j ] ) ;
mem [ mem [ s ] .hh .v.RH ] .hh .v.RH = 0 ;
s = hyfdisc [ j - 1 ] ;
mem [ s + 1 ] .hh .v.RH = 0 ;
mem [ s ] .hh .v.RH = 0 ;
}
}
while ( j++ < for_end ) ; }
if ( odd ( eqtb [ 12719 ] .cint / 8 ) )
{
if ( ! odd ( eqtb [ 12720 ] .cint / 8 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s\n", " <* debugging output section #" , (long)8 , " *>" )
;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s\n", " <* debugging output section #" , (long)8 , " *>" ) ;
}
}
if ( funktioniert )
{
{register integer for_end; j = 0 ; for_end = hn ; if ( j <= for_end) do
if ( hyfpen [ j ] != 10000 )
{
if ( hyfdisc [ j ] != 0 )
{
if ( mem [ mem [ hyfdisc [ j ] + 1 ] .hh .v.LH ] .hh.b1 == 0 )
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%c%c", Xchr ( hu [ j + 1 ] ) , '-' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%c%c", Xchr ( hu [ j + 1 ] ) , '-' ) ;
}
else {

if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%c%c%c", Xchr ( hu [ j + 1 ] ) , Xchr ( hu [ j + 1 ] ) , '=' ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%c%c%c", Xchr ( hu [ j + 1 ] ) , Xchr ( hu [ j + 1 ] ) , '=' ) ;
}
}
else {

{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( hu [ j ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( hu [ j ] ) , logfile );
}
if ( hyfpen [ j ] == eqtb [ 12666 ] .cint )
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( '=' , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( '=' , logfile );
}
else {

if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( '-' , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( '-' , logfile );
}
}
}
else {

{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) putc( Xchr ( hu [ j ] ) , stdout );
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) putc( Xchr ( hu [ j ] ) , logfile );
}
}
while ( j++ < for_end ) ; }
}
else {

{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " no hyphens were found in this word!" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " no hyphens were found in this word!" ) ;
}
}
println () ;
}
goto lab31 ;
lab40: hyfpen [ 0 ] = 10000 ;
{register integer for_end; j = 1 ; for_end = hn ; if ( j <= for_end) do
if ( odd ( hyf [ j ] ) )
hyfpen [ j ] = eqtb [ 12666 ] .cint ;
else hyfpen [ j ] = 10000 ;
while ( j++ < for_end ) ; }
lab31: ;
{register integer for_end; j = lhyf ; for_end = hn - rhyf ; if ( j <=
for_end) do
if ( hyfpen [ j ] != 10000 )
goto lab41 ;
while ( j++ < for_end ) ; }
return ;
lab41: ;
q = mem [ hb ] .hh .v.RH ;
mem [ hb ] .hh .v.RH = 0 ;
r = mem [ ha ] .hh .v.RH ;
mem [ ha ] .hh .v.RH = 0 ;
bchar = 256 ;
holdr = newkern ( 1235 ) ;
mem [ holdr ] .hh .v.RH = r ;
if ( ! ( hb >= himemmin ) )
if ( mem [ hb ] .hh.b0 == 6 )
if ( odd ( mem [ hb ] .hh.b1 ) )
bchar = fontbchar [ hf ] ;
if ( ( ha >= himemmin ) )
if ( mem [ ha ] .hh.b0 != hf )
goto lab42 ;
else {

initlist = ha ;
initlig = false ;
hu [ 0 ] = mem [ ha ] .hh.b1 ;
}
else if ( isdirtyumlaut ( ha ) )
{
if ( getfontof ( ha ) != hf )
goto lab42 ;
else {

initlist = ha ;
initlig = false ;
hu [ 0 ] = getcharof ( ha ) ;
}
}
else if ( mem [ ha ] .hh.b0 == 6 )
if ( mem [ ha + 1 ] .hh.b0 != hf )
goto lab42 ;
else {

initlist = mem [ ha + 1 ] .hh .v.RH ;
initlig = true ;
initlft = ( mem [ ha ] .hh.b1 > 1 ) ;
hu [ 0 ] = mem [ ha + 1 ] .hh.b1 ;
if ( initlist == 0 )
if ( initlft )
{
hu [ 0 ] = 256 ;
initlig = false ;
}
freenode ( ha , 2 ) ;
}
else {

if ( ! ( r >= himemmin ) )
if ( mem [ r ] .hh.b0 == 6 )
if ( mem [ r ] .hh.b1 > 1 )
goto lab42 ;
j = 1 ;
s = ha ;
initlist = 0 ;
goto lab50 ;
}
s = curp ;
while ( mem [ s ] .hh .v.RH != ha ) s = mem [ s ] .hh .v.RH ;
j = 0 ;
goto lab50 ;
lab42: s = ha ;
j = 0 ;
hu [ 0 ] = 256 ;
initlig = false ;
initlist = 0 ;
lab50: qq = holdr ;
{register integer for_end; kk = j ; for_end = hn ; if ( kk <= for_end) do
if ( dirtyumlaut [ kk ] != 0 )
{
while ( mem [ qq ] .hh .v.RH != dirtyumlaut [ kk ] ) qq = mem [ qq ] .hh
.v.RH ;
qr = mem [ qq ] .hh .v.RH ;
{register integer for_end; i = 1 ; for_end = mem [ qr ] .hh.b1 ; if ( i
<= for_end) do
if ( qr != 0 )
qr = mem [ qr ] .hh .v.RH ;
else {

{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", "...??..X --> ????? !" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", "...??..X --> ????? !" ) ;
}
}
while ( i++ < for_end ) ; }
if ( qr != 0 )
{
mem [ qq ] .hh .v.RH = mem [ qr ] .hh .v.RH ;
mem [ qr ] .hh .v.RH = 0 ;
}
else mem [ qq ] .hh .v.RH = 0 ;
}
while ( kk++ < for_end ) ; }
if ( dirtyumlaut [ -1 ] != 0 )
{
qq = holdr ;
while ( ( mem [ qq ] .hh .v.RH != dirtyumlaut [ -1 ] ) && ( mem [ qq ] .hh
.v.RH != 0 ) ) qq = mem [ qq ] .hh .v.RH ;
if ( mem [ qq ] .hh .v.RH == dirtyumlaut [ -1 ] )
{
mem [ qq ] .hh .v.RH = mem [ dirtyumlaut [ -1 ] ] .hh .v.RH ;
mem [ dirtyumlaut [ -1 ] ] .hh .v.RH = 0 ;
}
else {

{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) Fputs( stdout , " *** ERROR: node list is damaged! " ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) Fputs( logfile , " *** ERROR: node list is damaged! " ) ;
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", "(post hyphenation - unhinge a whatsit node)" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", "(post hyphenation - unhinge a whatsit node)" ) ;
}
}
}
r = holdr ;
while ( mem [ r ] .hh .v.RH != 0 ) {

if ( ( memmin <= mem [ r ] .hh .v.RH ) && ( mem [ r ] .hh .v.RH <= memmax
) )
r = mem [ r ] .hh .v.RH ;
else {

(void) putc('\n', logfile );
(void) putc('\n', stdout );
(void) fprintf( logfile , "%s\n", "???$ - ERROR in node list!" ) ;
(void) fprintf( stdout , "%s\n", "???$ - ERROR in node list!" ) ;
kk = depththreshold ;
l = breadthmax ;
depththreshold = 100 ;
breadthmax = 100 ;
shownodelist ( holdr ) ;
mem [ r ] .hh .v.RH = 0 ;
depththreshold = kk ;
breadthmax = l ;
}
}
flushnodelist ( holdr ) ;
if ( dirtyumlaut [ -1 ] != 0 )
{
mem [ s ] .hh .v.RH = dirtyumlaut [ -1 ] ;
s = mem [ s ] .hh .v.RH ;
}
do {
if ( dirtyumlaut [ j ] != 0 )
{
mem [ s ] .hh .v.RH = dirtyumlaut [ j ] ;
while ( mem [ s ] .hh .v.RH > 0 ) s = mem [ s ] .hh .v.RH ;
mem [ memtop - 4 ] .hh .v.RH = 0 ;
j = j + 1 ;
hyphenpassed = 0 ;
if ( hyfpen [ j - 1 ] != 10000 )
{
l = j ;
hyphenpassed = j - 1 ;
if ( odd ( eqtb [ 12719 ] .cint / 16 ) )
{
if ( ! odd ( eqtb [ 12720 ] .cint / 16 ) )
{
println () ;
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s%ld%s\n", " <* debugging output section #" , (long)16 , " *>" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s%ld%s\n", " <* debugging output section #" , (long)16 , " *>" ) ;
}
}
{
if ( ( fileoffset != 0 ) || ( termoffset != 0 ) )
println () ;
if ( selector != 18 )
(void) fprintf( stdout , "%s\n", " *** append a hyphen immediatly after a dirty umlaut!" ) ;
if ( ( selector == 18 ) || ( selector == 19 ) )
(void) fprintf( logfile , "%s\n", " *** append a hyphen immediatly after a dirty umlaut!" ) ;
}
}
}
}
else {

l = j ;
j = reconstitute ( j , hn , bchar , hyfchar ) + 1 ;
if ( hyphenpassed == 0 )
{
mem [ s ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
while ( mem [ s ] .hh .v.RH > 0 ) s = mem [ s ] .hh .v.RH ;
if ( hyfpen [ j - 1 ] != 10000 )
{
l = j ;
hyphenpassed = j - 1 ;
mem [ memtop - 4 ] .hh .v.RH = 0 ;
}
}
}
if ( hyphenpassed > 0 )
do {
r = getnode ( 2 ) ;
mem [ r ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
mem [ r ] .hh.b0 = 7 ;
majortail = r ;
rcount = 0 ;
while ( mem [ majortail ] .hh .v.RH > 0 ) {

majortail = mem [ majortail ] .hh .v.RH ;
incr ( rcount ) ;
}
i = hyphenpassed ;
hyf [ i ] = 0 ;
if ( ( hyfpen [ i ] != 10000 ) && ( hyfpen [ i ] != eqtb [ 12666 ] .cint
) )
minortail = newpenalty ( hyfpen [ i ] ) ;
else minortail = 0 ;
hyfpen [ i ] = 10000 ;
mem [ r + 1 ] .hh .v.LH = minortail ;
hyfnode = newcharacter ( hf , hyfchar ) ;
xchgk = i ;
if ( hyfdisc [ xchgk ] != 0 )
{
spechyf = mem [ hyfdisc [ xchgk ] + 1 ] .hh .v.LH ;
addchar = mem [ spechyf ] .hh.b1 ;
xchgi = 1 ;
do {
spechyf = mem [ spechyf ] .hh .v.RH ;
if ( spechyf != 0 )
{
xchgchar [ xchgi ] = mem [ spechyf ] .hh.b1 ;
incr ( xchgi ) ;
}
} while ( ! ( spechyf == 0 ) ) ;
if ( hyfnode != 0 )
{
xchgchar [ xchgi ] = hyfchar ;
{
mem [ hyfnode ] .hh .v.RH = avail ;
avail = hyfnode ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
else decr ( xchgi ) ;
xchghu = i - xchgi + addchar + 2 ;
{register integer for_end; xchgk = 1 ; for_end = xchgi ; if ( xchgk
<= for_end) do
{
xchgchar [ 0 ] = hu [ xchghu ] ;
hu [ xchghu ] = xchgchar [ xchgk ] ;
xchgchar [ xchgk ] = xchgchar [ 0 ] ;
incr ( xchghu ) ;
}
while ( xchgk++ < for_end ) ; }
xchgk = i ;
i = xchghu - 1 ;
xchghu = xchghu - xchgi ;
}
else if ( hyfnode != 0 )
{
incr ( i ) ;
c = hu [ i ] ;
hu [ i ] = hyfchar ;
{
mem [ hyfnode ] .hh .v.RH = avail ;
avail = hyfnode ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
while ( l <= i ) {

l = reconstitute ( l , i , fontbchar [ hf ] , 256 ) + 1 ;
if ( mem [ memtop - 4 ] .hh .v.RH > 0 )
{
if ( minortail == 0 )
mem [ r + 1 ] .hh .v.LH = mem [ memtop - 4 ] .hh .v.RH ;
else mem [ minortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
minortail = mem [ memtop - 4 ] .hh .v.RH ;
while ( mem [ minortail ] .hh .v.RH > 0 ) minortail = mem [
minortail ] .hh .v.RH ;
}
}
if ( hyfdisc [ xchgk ] != 0 )
{
i = xchgk ;
l = i + 1 ;
{register integer for_end; xchgk = 1 ; for_end = xchgi ; if ( xchgk
<= for_end) do
{
hu [ xchghu ] = xchgchar [ xchgk ] ;
incr ( xchghu ) ;
}
while ( xchgk++ < for_end ) ; }
}
else if ( hyfnode != 0 )
{
hu [ i ] = c ;
l = i ;
decr ( i ) ;
}
minortail = 0 ;
mem [ r + 1 ] .hh .v.RH = 0 ;
cloc = 0 ;
if ( bcharlabel [ hf ] < fontmemsize )
{
decr ( l ) ;
c = hu [ l ] ;
cloc = l ;
hu [ l ] = 256 ;
}
while ( l < j ) {

do {
l = reconstitute ( l , hn , bchar , 256 ) + 1 ;
if ( cloc > 0 )
{
hu [ cloc ] = c ;
cloc = 0 ;
}
if ( mem [ memtop - 4 ] .hh .v.RH > 0 )
{
if ( minortail == 0 )
mem [ r + 1 ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
else mem [ minortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
minortail = mem [ memtop - 4 ] .hh .v.RH ;
while ( mem [ minortail ] .hh .v.RH > 0 ) minortail = mem [
minortail ] .hh .v.RH ;
}
} while ( ! ( l >= j ) ) ;
while ( l > j ) {

j = reconstitute ( j , hn , bchar , 256 ) + 1 ;
mem [ majortail ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ;
while ( mem [ majortail ] .hh .v.RH > 0 ) {

majortail = mem [ majortail ] .hh .v.RH ;
incr ( rcount ) ;
}
}
}
if ( rcount > 127 )
{
mem [ s ] .hh .v.RH = mem [ r ] .hh .v.RH ;
mem [ r ] .hh .v.RH = 0 ;
flushnodelist ( r ) ;
}
else {

mem [ s ] .hh .v.RH = r ;
mem [ r ] .hh.b1 = rcount ;
}
s = majortail ;
hyphenpassed = j - 1 ;
mem [ memtop - 4 ] .hh .v.RH = 0 ;
} while ( ! ( ( hyfpen [ j - 1 ] == 10000 ) ) ) ;
} while ( ! ( j > hn ) ) ;
mem [ s ] .hh .v.RH = q ;
siq = s ;
{register integer for_end; j = 0 ; for_end = 64 ; if ( j <= for_end) do
if ( hyfdisc [ j ] != 0 )
{
flushnodelist ( hyfdisc [ j ] ) ;
}
while ( j++ < for_end ) ; }
flushlist ( initlist ) ;
}