#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 , alletr , tr , dudtr , 
zerlegungen , dud , v , ind , k , dudstop , w , tr1 , laenge ) 
integer zustand ; 
integer anfang ; 
sperrvektor spv ; 
boolean * ok1 ; 
trenn16 alletr ; 
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  ; 
  trennvektor trlast  ; 
  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 ] ; 
	trlast [ i ] = tri ; 
      } 
    while ( i-- > for_end ) ; } 
(*    zerlegungen )= (*zerlegungen )+ 1 ; 
    memcpy((void *)alletr[(*zerlegungen)],(void *)trlast,sizeof(trennvektor));
(*    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 , alletr , tr , dudtr , (*
	      zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ; 
	      okend = okhelp ; 
	    } 
	    trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , 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 , alletr , 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 , alletr , 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 , alletr , tr , dudtr , (*
		zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) 
		; 
		okstamm = okstamm || okhelp ; 
	      } 
	      trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , 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 , alletr , 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 , alletr , 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 , alletr , tr , dudtr , (*
	    zerlegungen ), dud , v , ind , k , dudstop , w , tr1 , laenge ) ; 
	    okstamm = okstamm || okhelp ; 
	  } 
	  trennen ( 2 , schnitt + 1 , spv , okhelp , alletr , 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 zwchar ( c ) 
halfword c ; 
{wchar_regmem 
  if ( c == 27 ) 
  {
    (void) Fputs( stdout ,  "\"a" ) ; 
  } 
  else if ( c == 28 ) 
  {
    (void) Fputs( stdout ,  "\"o" ) ; 
  } 
  else if ( c == 29 ) 
  {
    (void) Fputs( stdout ,  "\"u" ) ; 
  } 
  else if ( c == 30 ) 
  {
    (void) Fputs( stdout ,  "\"s" ) ; 
  } 
  else {
      
    (void) putc( Xchr ( c + 96 ) ,  stdout );
  } 
} 
void zwwort ( w , l ) 
wort w ; 
integer l ; 
{wwort_regmem 
  integer i  ; 
  {register integer for_end; i = 1 ; for_end = l ; if ( i <= for_end) do 
    {
      wchar ( w [ i ] ) ; 
    } 
  while ( i++ < for_end ) ; } 
} 
void zwritewt ( w , l , tr ) 
wort w ; 
integer l ; 
trennvektor tr ; 
{writewt_regmem 
  integer i  ; 
  wchar ( w [ 1 ] ) ; 
  {register integer for_end; i = 2 ; for_end = l - 1 ; if ( i <= for_end) do 
    {
      if ( ( tr [ i - 1 ] == nebenck ) ) 
      {
	(void) putc( 'k' ,  stdout );
	(void) putc( '-' ,  stdout );
      } 
      else if ( ( tr [ i ] == haupt3 ) ) 
      {
	(void) putc( Xchr ( w [ i ] + 96 ) ,  stdout );
	(void) putc( '=' ,  stdout );
	(void) putc( Xchr ( w [ i ] + 96 ) ,  stdout );
      } 
      else if ( ( tr [ i ] == haupt ) ) 
      {
	wchar ( w [ i ] ) ; 
	(void) putc( '=' ,  stdout );
      } 
      else if ( ( tr [ i ] == neben ) ) 
      {
	wchar ( w [ i ] ) ; 
	(void) putc( '-' ,  stdout );
      } 
      else {
	  
	wchar ( w [ i ] ) ; 
      } 
    } 
  while ( i++ < for_end ) ; } 
  wchar ( w [ l ] ) ; 
} 
void wjob ( ) 
{wjob_regmem 
  integer i  ; 
  {register integer for_end; i = strstart [ jobname ] ; for_end = strstart [ 
  jobname + 1 ] - 1 ; if ( i <= for_end) do 
    {
      (void) putc( Xchr ( strpool [ i ] ) ,  stdout );
    } 
  while ( i++ < for_end ) ; } 
} 
integer zvergl ( wrt1 , l1 , wrt2 , l2 ) 
wort wrt1 ; 
integer l1 ; 
wort wrt2 ; 
integer l2 ; 
{/* 99 */ register integer Result; vergl_regmem 
  integer i  ; 
  i = 1 ; 
  while ( ( i <= l1 ) && ( i <= l2 ) ) {
      
    if ( wrt1 [ i ] < wrt2 [ i ] ) 
    {
      Result = -1 ; 
      goto lab99 ; 
    } 
    else if ( wrt1 [ i ] > wrt2 [ i ] ) 
    {
      Result = 1 ; 
      goto lab99 ; 
    } 
    i = i + 1 ; 
  } 
  if ( l1 < l2 ) 
  {
    Result = -1 ; 
    goto lab99 ; 
  } 
  else if ( l1 > l2 ) 
  {
    Result = 1 ; 
    goto lab99 ; 
  } 
  else {
      
    Result = 0 ; 
    goto lab99 ; 
  } 
  lab99: ; 
  return(Result) ; 
} 
void zgleicheweg ( alletr , zerleg , laenge ) 
trenn16 alletr ; 
integer * zerleg ; 
integer laenge ; 
{gleicheweg_regmem 
  integer i, j, k  ; 
  boolean gleich  ; 
  i = 1 ; 
  do {
      j = i + 1 ; 
    do {
	gleich = true ; 
      k = 1 ; 
      do {
	  if ( alletr [ i ] [ k ] == alletr [ j ] [ k ] ) 
	{
	  k = k + 1 ; 
	} 
	else {
	    
	  gleich = false ; 
	} 
      } while ( ! ( ( k > laenge ) || ( gleich == false ) ) ) ; 
      if ( gleich ) 
      {
	{register integer for_end; k = j ; for_end = (*zerleg )- 1 ; if ( k <= 
	for_end) do 
	  {
		memcpy((void *)alletr[k],(void *)alletr[k+1],sizeof(trennvektor));
	  } 
	while ( k++ < for_end ) ; } 
(*        zerleg )= (*zerleg )- 1 ; 
      } 
      else {
	  
	j = j + 1 ; 
      } 
    } while ( ! ( j > (*zerleg )) ) ; 
    i = i + 1 ; 
  } while ( ! ( i > (*zerleg )- 1 ) ) ; 
} 
void zmdbeintragen ( w , l , tr , neu , used , mdb ) 
wort w ; 
integer l ; 
trennvektor tr ; 
boolean neu ; 
boolean used ; 
mdbknoten * mdb ; 
{mdbeintragen_regmem 
  integer test  ; 
  if ( (*mdb )== nil ) 
  {
(*    mdb )= (mdbknoten) malloc ( sizeof ( mdbschnuller ) ) ; 
memcpy((void *)(*    mdb )->w12 ,(void *) w ,sizeof(wort));
(*    mdb )->l1 = l ;
memcpy((void *)(*    mdb )->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(*    mdb )->neu1 = neu ; 
(*    mdb )->used1 = used ; 
(*    mdb )->del1 = false ; 
(*    mdb )->li = nil ; 
(*    mdb )->re = nil ; 
    if ( isidebug == 1 ) 
    {
      (void) putc('\n',  stdout );
    } 
  } 
  else {
      
    test = vergl ( w , l , (*mdb )->w12 , (*mdb )->l1 ) ; 
    if ( test == -1 ) 
    {
      if ( isidebug == 1 ) 
      {
	(void) putc( '/' ,  stdout );
      } 
      mdbeintragen ( w , l , tr , neu , used , (*mdb )->li ) ; 
    } 
    else if ( test == 1 ) 
    {
      if ( isidebug == 1 ) 
      {
	(void) putc( '\\' ,  stdout );
      } 
      mdbeintragen ( w , l , tr , neu , used , (*mdb )->re ) ; 
    } 
    else {
	
      (void) Fputs( stdout ,        " =iSi=> mdb_eintragen vom gleichen Wort nocheinmal !!!" ) ; 
      (void) putc('\n',  stdout );
    } 
  } 
} 
void zmdmeintragen ( w , l , tr , neu , mdm ) 
wort w ; 
integer l ; 
trennvektor tr ; 
boolean neu ; 
mdmknoten * mdm ; 
{mdmeintragen_regmem 
  mdmknoten rechts  ; 
  if ( (*mdm )== nil ) 
  {
(*    mdm )= (mdmknoten) malloc ( sizeof ( mdmschnuller ) ) ; 
	memcpy((void *)(*    mdm )->w12 ,(void *) w,sizeof(wort)) ;
(*    mdm )->l1 = l ;
	memcpy((void *)(*    mdm )->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(*    mdm )->neu1 = neu ;
(*    mdm )->li = nil ;
(*    mdm )->re = nil ;
	}
	else if ( (*mdm )->re == nil )
	{
(*    mdm )->re = (mdmknoten) malloc ( sizeof ( mdmschnuller ) ) ;
	memcpy((void *)(*    mdm )->re ->w12 ,(void *) w ,sizeof(wort));
(*    mdm )->re ->l1 = l ;
	memcpy((void *)(*    mdm )->re ->tr1 ,(void *) tr,sizeof(trennvektor)) ;
(*    mdm )->re ->neu1 = neu ;
(*    mdm )->re ->li = nil ;
(*    mdm )->re ->re = nil ;
(*    mdm )->li = (*mdm )->re ;
	}
	else {
		rechts = (*mdm )->re ;
(*    mdm )->re = (mdmknoten) malloc ( sizeof (mdmschnuller ) ) ;
	memcpy((void *)(*    mdm )->re ->w12 ,(void *) w ,sizeof(wort));
(*    mdm )->re ->l1 = l ;
	memcpy((void *)(*    mdm )->re ->tr1 ,(void *) tr ,sizeof(trennvektor));
(*    mdm )->re ->neu1 = neu ; 
(*    mdm )->re ->li = nil ; 
(*    mdm )->re ->re = nil ; 
    rechts ->li = (*mdm )->re ; 
  } 
} 
void zmdleintragen ( w , l , mdl ) 
wort w ; 
integer l ; 
mdlknoten * mdl ; 
{mdleintragen_regmem 
  mdlknoten rechts  ; 
  if ( isidebug == 1 ) 
  {
    (void) Fputs( stdout ,  " =iSi=> mdl_eintragen von " ) ; 
    wwort ( w , l ) ; 
    (void) putc('\n',  stdout );
  } 
  if ( (*mdl )== nil ) 
  {
(*    mdl )= (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ; 
  memcpy((void *)(*    mdl )->w12 ,(void *) w,sizeof(wort)) ;
(*    mdl )->l1 = l ; 
(*    mdl )->li = nil ; 
(*    mdl )->re = nil ; 
  } 
  else if ( (*mdl )->re == nil ) 
  {
(*    mdl )->re = (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ; 
  memcpy((void *)(*    mdl )->re ->w12 ,(void *) w,sizeof(wort)) ;
(*    mdl )->re ->l1 = l ; 
(*    mdl )->re ->li = nil ; 
(*    mdl )->re ->re = nil ; 
(*    mdl )->li = (*mdl )->re ; 
  } 
  else {
      
    rechts = (*mdl )->re ; 
(*    mdl )->re = (mdlknoten) malloc ( sizeof ( mdlschnuller ) ) ; 
  memcpy((void *)(*    mdl )->re ->w12 ,(void *) w,sizeof(wort)) ;
(*    mdl )->re ->l1 = l ; 
(*    mdl )->re ->li = nil ; 
(*    mdl )->re ->re = nil ; 
    rechts ->li = (*mdl )->re ; 
  } 
} 
void zmdeeintragen ( w , l , mde ) 
wort w ; 
integer l ; 
mdeknoten * mde ; 
{mdeeintragen_regmem 
  mdeknoten rechts  ; 
  if ( isidebug == 1 ) 
  {
    (void) Fputs( stdout ,  " =iSi=> mde_eintragen von " ) ; 
    wwort ( w , l ) ; 
    (void) putc('\n',  stdout );
  } 
  if ( (*mde )== nil ) 
  {
(*    mde )= (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ; 
  memcpy((void *)(*    mde )->w12 ,(void *) w,sizeof(wort)) ;
(*    mde )->l1 = l ; 
(*    mde )->li = nil ; 
(*    mde )->re = nil ; 
  } 
  else if ( (*mde )->re == nil ) 
  {
(*    mde )->re = (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ; 
  memcpy((void *)(*    mde )->re ->w12 ,(void *) w,sizeof(wort)) ;
(*    mde )->re ->l1 = l ; 
(*    mde )->re ->li = nil ; 
(*    mde )->re ->re = nil ; 
(*    mde )->li = (*mde )->re ; 
  } 
  else {
      
    rechts = (*mde )->re ; 
(*    mde )->re = (mdeknoten) malloc ( sizeof ( mdeschnuller ) ) ; 
  memcpy((void *)(*    mde )->re ->w12 ,(void *) w,sizeof(wort)) ;
(*    mde )->re ->l1 = l ; 
(*    mde )->re ->li = nil ; 
(*    mde )->re ->re = nil ; 
    rechts ->li = (*mde )->re ; 
  } 
} 
boolean zmdsuchen ( w , l , mdb , tr ) 
wort w ; 
integer l ; 
mdbknoten * mdb ; 
trennvektor tr ; 
{register boolean Result; mdsuchen_regmem 
  integer test  ; 
  if ( (*mdb )== nil ) 
  {
    Result = false ; 
  } 
  else {
      
    test = vergl ( w , l , (*mdb )->w12 , (*mdb )->l1 ) ; 
    if ( test == -1 ) 
    {
      Result = mdsuchen ( w , l , (*mdb )->li , tr ) ; 
    } 
    else if ( test == 1 ) 
    {
      Result = mdsuchen ( w , l , (*mdb )->re , tr ) ; 
    } 
    else {
	
      tr = (*mdb )->tr1 ; 
(*      mdb )->used1 = true ; 
      Result = true ; 
    } 
  } 
  return(Result) ; 
}