#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 ) ; 
}