@x
@d banner=='This is TeX, Version 3.141 (+SISISI 1.0)'
@y
@d banner=='This is TeX, Version 3.141 (+SISISI 1.0) {+iSi 92}'
@z


@x
@!pool_name='TeXformats:SITEX3.POOL                  ';
  {string of length |file_name_size|; tells where the string pool appears}
@y
@!pool_name='TeXformats:ISITEX3.POOL                 ';
  {string of length |file_name_size|; tells where the string pool appears}
@z


@x
else  bad_pool('! I can''t read SITEX3.POOL.')
@.I can't read TEX.POOL@>
@y
else  bad_pool('! I can''t read ISITEX3.POOL.')
@.I can't read TEX.POOL@>
@z


@x
@!funktioniert: boolean;
@!zerleg: integer;
@y
@!funktioniert: boolean;
@!zerleg: integer;
@!alletr: trenn16;   {iSi 920114}
@!auswahl, schnuller: char;
@!memkorr: boolean; {iSi 920914 doku.mem korrigieren ja/nein}
@!indexi: integer;
@!uebersprungen: boolean;  {iSi 920921}
@!lex_ja, lex_ok: boolean; {iSi 920930 neue Eingabe `1E' statt `B'}
@z



@x
  abteilen(hc_si,hyf_si,hn,funktioniert,zerleg);
  for j:=0 to 64 do begin
    hyf_disc[j]:=null; hyfpen[j]:=inf_penalty;
  end;
@y
  if not hsstart then begin
{   wterm(' =iSi=> running hsinit'); wterm_cr;  }
    hsinit;
    hsstart := true;
{   wterm(' =iSi=> finished hsinit'); wterm_cr  } 
  end;

  if isidebug=1 then begin
    wterm(' =iSi=> abteilen von '); wwort(hc_si, hn); 
  end;

  abteilen(hc_si,hyf_si, alletr {iSi 920114}, hn,funktioniert,zerleg);

  if not funktioniert then begin
    if isidebug=1 then begin
      wterm_cr;
      wterm(' =iSi=> unbekanntes Wort: '); wwort(hc_si, hn);
      wterm_cr; 
      wterm(' =iSi=> suchen in mdb: '); wwort(hc_si, hn); wterm_cr; 
    end;
    if md_suchen(hc_si, hn, mdb, hyf_si) then begin
      if isidebug=1 then begin
        wterm(' =iSi=> gefunden in mdb: ');
        writewt(hc_si, hn, hyf_si);
        wterm_cr
      end;
      funktioniert := true
    end else begin
      if isidebug=1 then begin
        wterm(' =iSi=> nicht gefunden in mdb: ');
        wwort(hc_si, hn); wterm_cr; 
      end;
      repeat
        wterm_cr; wterm_cr;
        wterm('"');
        wwort(hc_si, hn);
        wterm('" ist ein unbekanntes Wort!');
        wterm_cr;
        wterm(0:2); 
        wterm(': neues Wort, merken in "'); wjob; wterm('.lex"');
        wterm_cr;
        wterm(1:2); 
        wterm(': neues Wort, Trennstellen angeben und merken in "'); wjob;
        wterm('.lex"');
        wterm_cr;
        wterm(9:2);
        wterm(': Tippfehler! - merken im File "'); wjob; wterm('.edt"');
        wterm_cr;
        wterm('Bitte waehlen Sie eine Bedeutung (0,1,9) aus:');
	wterm_cr;
        read(term_in, schnuller);
        auswahl := schnuller;
		read_ln(term_in);
      until ((xord[auswahl] >= 48) and (xord[auswahl] <= 49)) or
            (auswahl = '9');
      if (auswahl = '0') then begin
        { Da abteilen bei not funktioniert hyf_si unver"andert l"asst, }
        { muss hier jetzt hyf_si ``gel"oscht'' werden.                 }
        for indexi := 1 to hn do begin
          hyf_si[indexi] := keine
        end;
        if isidebug=1 then begin
          wterm(' =iSi=> mdb/mdm_eintragen: ');
          writewt(hc_si, hn, hyf_si); wterm_cr
        end;
        mdb_eintragen(hc_si, hn, hyf_si, true {neu}, true {used}, mdb);
        mdm_eintragen(hc_si, hn, hyf_si, true, mdm);
        funktioniert := true
      end else if (auswahl = '9') then begin
        mde_eintragen(hc_si, hn, mde)
      end else begin
        wterm('Bitte den Trennvektor angeben'); wterm_cr;
	wterm(' ("-" Nebentrennstelle, "=" Haupttrennstelle, ');
        wterm('"." Weiterruecken,'); wterm_cr;
        wterm(' Trennstrich unter den Buchstaben angeben, hinter dem ');
        wterm('getrennt werden soll):'); wterm_cr;
	wwort(hc_si, hn); wterm_cr;       
	indexi := 1; uebersprungen := false;
        read(term_in, auswahl);
        while (xord[auswahl] <> 10) and (indexi <= hn) do begin
          if (hc_si[indexi] >= 27) and
             (hc_si[indexi] <= 30) and
             not uebersprungen then begin
            { Ist in hc_si[] ein Umlaut, so steht am Bildschirm "x. }
            { Die Trennvektoreingabe unter dem " muss uebersprungen }
            { werden. }
            uebersprungen := true
          end else begin
            if auswahl = '.' then begin
	      hyf_si[indexi] := keine
            end else if auswahl = '-' then begin
              hyf_si[indexi] := neben
            end else if auswahl = '=' then begin
              hyf_si[indexi] := haupt
            end else begin
              hyf_si[indexi] := keine
            end;
            uebersprungen := false;
            indexi := indexi+1
          end;
          read(term_in, auswahl)
        end;  
        while (indexi) <= hn do begin {Rest von hyf_si mit . auff"ullen}
          hyf_si[indexi] := keine;
          indexi := indexi+1
        end;
        if isidebug=1 then begin
          wterm(' =iSi=> mdb/mdm_eintragen: ');
          writewt(hc_si, hn, hyf_si); wterm_cr
        end;
        mdb_eintragen(hc_si, hn, hyf_si, true {neu}, true {used}, mdb);
        mdm_eintragen(hc_si, hn, hyf_si, true, mdm);
        funktioniert := true
      end
    end
  end else begin
    if isidebug=1 then begin
      wterm(': '); writewt(hc_si, hn, hyf_si); wterm_cr
    end
  end;        

  if zerleg >= 2 then begin
   gleiche_weg(alletr, zerleg, hn); { eliminiert gleiche Trennvektoren }
   if zerleg >= 2 then begin        { jetzt sind es echte Alternativen }
    if isidebug=1 then begin
      wterm(' =iSi=> mehrdeutiges Wort: '); writewt(hc_si, hn, hyf_si);
      wterm_cr;
      wterm(' =iSi=> suchen in mdb: '); wwort(hc_si, hn); wterm_cr; 
    end;
    if md_suchen(hc_si, hn, mdb, hyf_si) then begin
      if isidebug=1 then begin
        wterm(' =iSi=> gefunden in mdb: '); writewt(hc_si, hn, hyf_si);
        wterm_cr
      end 
    end else begin
      if isidebug=1 then begin
        wterm(' =iSi=> nicht gefunden in mdb: ');
        wwort(hc_si, hn); wterm_cr
      end;
      if mehrdanz then begin
        repeat
          wterm_cr; wterm_cr;
          wterm('`');
          wwort(hc_si, hn);
          wterm(''' ist ein mehrdeutiges Wort!');
          wterm_cr;
          wterm(0:2); { wterm('/A'); }
          wterm(': nur die sicheren Trennstellen waehlen (also `');
          writewt(hc_si, hn, hyf_si);
          wterm(''')');
          wterm_cr;
          for indexi := 1 to zerleg do begin
            wterm(indexi:2); { wterm('/'); wterm(xchr[65+indexi]); }
            wterm(': `');
            writewt(hc_si, hn, alletr[indexi]);
            wterm('''');
            wterm_cr
          end;
          wterm(9:2);
          wterm(': Tippfehler! - merken im File `'); wjob; wterm('.edt''');
          wterm_cr;
          wterm('Bitte waehlen Sie eine Bedeutung z.B. `0''+`Enter'' aus:');
          wterm_cr;
          wterm(' (zusaetzlich `E'' z.B. `0E''+`Enter'': ');
          wterm('Wort auch fuer LEXIKON vormerken)');
          wterm_cr;
          read(term_in, schnuller);
          auswahl := schnuller;
          lex_ja := false; lex_ok := true;
          if xord[schnuller] <> 32 then begin
            read(term_in, schnuller);
            if xord[schnuller] <> 10 then begin
              if (schnuller = 'e') or (schnuller = 'E') then begin
                lex_ja := true; { lex_ok := true }
              end else begin
                { lex_ja := false; } lex_ok := false
              end;
			  read_ln(term_in);
            end
          end;
        until (((xord[auswahl] >= 48) and (xord[auswahl] <= 48+zerleg)) or
              (auswahl = '9')) and lex_ok;
        if (auswahl = '0') or ((auswahl = '0') and lex_ja) then begin
          if (auswahl = '0') and not lex_ja then begin
            if isidebug=1 then begin
              wterm(' =iSi=> mdb/mdm_eintragen: ');
              writewt(hc_si, hn, hyf_si); wterm_cr
            end;
            mdb_eintragen(hc_si, hn, hyf_si, false {neu}, true {used}, mdb);
            mdm_eintragen(hc_si, hn, hyf_si, false, mdm)
          end else begin { '0E' }
            if isidebug=1 then begin
              wterm(' =iSi=> mdb/mdm_eintragen: ');
              writewt(hc_si, hn, hyf_si); wterm_cr
            end; 
            mdb_eintragen(hc_si, hn, hyf_si, true {neu}, true {used}, mdb);
            mdm_eintragen(hc_si, hn, hyf_si, true, mdm)
          end;
        end else if (auswahl = '9') then begin
          mde_eintragen(hc_si, hn, mde)
        end else begin
          for j := 0 to maxwl do
             hyf_si[j] := alletr[xord[auswahl]-48][j];
          if not lex_ja then begin
            if isidebug=1 then begin
              wterm(' =iSi=> mdb/mdm_eintragen: ');
              writewt(hc_si, hn, hyf_si); wterm_cr
            end; 
            mdb_eintragen(hc_si, hn, hyf_si, false {neu}, true {used}, mdb);
            mdm_eintragen(hc_si, hn, hyf_si, false, mdm)
          end else begin { lex_ja }
            if isidebug=1 then begin
              wterm(' =iSi=> mdb/mdm_eintragen: ');
              writewt(hc_si, hn, hyf_si); wterm_cr
            end; 
            mdb_eintragen(hc_si, hn, hyf_si, true {neu}, true {used}, mdb);
            mdm_eintragen(hc_si, hn, hyf_si, true, mdm)
          end {if not lex_ja ...}
        end {if (auswahl = ...}
      end {if mehrdanz}
    end {if md_suchen ...}
   end {if zerleg >= 2}
  end; {if zerleg >= 2}

  for j:=0 to 64 do begin
    hyf_disc[j]:=null; hyfpen[j]:=inf_penalty;
  end;
@z


@x
@<Types in the outer block@>=
   string80 = packed array [0..80] of eight_bits;
   buchstabe = eight_bits;
   a_word = array[0..maxwl] of 0..256;
   wort = a_word;
   sperrvektor=array [0..maxwl] of boolean;
   dudt=array [0..maxwl] of boolean;{frueher kein type !!}
   { trennung = (keine, neben, nebenck, haupt, haupt3); }
   trennvektor = array [0..maxwl] of integer; { Trennstelle bei i ==>
                   zwischen Buchstabe i und i+1 wird getrennt }
   ktabtype = packed array [0..255] of buchstabe;
	verdschlue = 0..8388647; { 2**23 - 1 }	{ -PRAK!- unsigned long in C }
   varr = array [0..maxwl] of verdschlue;
   intarr = array [0..maxwl] of integer;

   { darf nicht als var Parameter uebergeben werden !!}
   infotype = record
                { frueher ein variantenRecord }
                ausnahme:boolean;
                untrennbar:boolean;
                { erste :0..7;
                  zweite:0..7; }
                erste :integer;
                zweite:integer;
                endung,vorsilbe,stamm,ehervor,stammallein:boolean;
              end;

  infobyte = eight_bits;

  { darf nicht als var Parameter uebergeben werden !!}
  tableentry=record
		  tabv:verdschlue;
        tabb:infobyte;
        frei:boolean;
        wiederfrei:boolean;
      end;

  hashelement = packed array [0..3] of eight_bits;
  htabtype = packed array [0..tabsize] of hashelement;

@y
@<Types in the outer block@>=
   string80 = packed array [0..80] of eight_bits;
   buchstabe = eight_bits;
   a_word = array[0..maxwl] of 0..256;
   wort = a_word;
   sperrvektor=array [0..maxwl] of boolean;
   dudt=array [0..maxwl] of boolean;{frueher kein type !!}
   { trennung = (keine, neben, nebenck, haupt, haupt3); }
   trennvektor = array [0..maxwl] of integer; { Trennstelle bei i ==>
                   zwischen Buchstabe i und i+1 wird getrennt }
   ktabtype = packed array [0..255] of buchstabe;
	verdschlue = 0..8388647; { 2**23 - 1 }	{ -PRAK!- unsigned long in C }
   varr = array [0..maxwl] of verdschlue;
   intarr = array [0..maxwl] of integer;

   { darf nicht als var Parameter uebergeben werden !!}
   infotype = record
                { frueher ein variantenRecord }
                ausnahme:boolean;
                untrennbar:boolean;
                { erste :0..7;
                  zweite:0..7; }
                erste :integer;
                zweite:integer;
                endung,vorsilbe,stamm,ehervor,stammallein:boolean;
              end;

  infobyte = eight_bits;

  { darf nicht als var Parameter uebergeben werden !!}
  tableentry=record
		  tabv:verdschlue;
        tabb:infobyte;
        frei:boolean;
        wiederfrei:boolean;
      end;

  hashelement = packed array [0..3] of eight_bits;
  htabtype = packed array [0..tabsize] of hashelement;

  trenn16 = array [1..16] of trennvektor; {iSi 921005 trenn8 -> trenn16}

                    {iSi 920103 begin}
  mdb_knoten = ^mdb_k;
  mdm_knoten = ^mdm_k;
  mdl_knoten = ^mdl_k;
  mde_knoten = ^mde_k; {HHHHH}

  mdb_k = record
            w12: wort;
            l1: integer;
            tr1: trennvektor;
            neu1: boolean;
            del1: boolean;    {gel"oscht ja/nein}
            used1: boolean;   {noch in Verwendung ja/nein}
			li, re: mdb_knoten;
          end;
                    {iSi 920103 end}

                    {iSi 920110 begin}

  mdm_k = record 
             w12: wort;
             l1: integer;
             tr1: trennvektor;
             neu1: boolean;
			 li, re: mdm_knoten;
           end;         
  mdl_k = record 
             w12: wort;
             l1: integer;
			 li, re: mdl_knoten;
          end;
  mde_k = record {HHHHH}
             w12: wort;
             l1: integer;
			 li, re: mde_knoten;
          end;

                    {iSi 920110 end} 

@z



@x
@<Global variables@>=
  ktab : ktabtype;
  htab : htabtype;
  anzahl : integer;
  hashfile : alpha_file;
  kombtab : array [1..5, 1..5] of integer;
  konsonant : array [1 .. 30] of boolean; {array [bst_a .. bst_sz]}
@y
@<Global variables@>=
  ktab : ktabtype;
  htab : htabtype;
  anzahl : integer;
  hashfile : alpha_file;

  hsmem, hslex, hsedt: alpha_file;   {iSi 920111}

  kombtab : array [1..5, 1..5] of integer;
  konsonant : array [1 .. 30] of boolean; {array [bst_a .. bst_sz]}

  hsstart: boolean;   {iSi 920114} {ist mdb schon initialisiert?}
  isidebug: integer;  {iSi 920917} 
  auswahl, schnuller: char;   {iSi 920917}
  mehrdanz: boolean;  {iSi 920924} {mehrdeutige W"orter anzeigen?}
  mdb: mdb_knoten; {iSi 920111}
  mdm: mdm_knoten; {iSi 920111}
  mdl: mdl_knoten; {iSi 920114}
  mde: mde_knoten; {iSi 920114}
  mdb_schnuller: mdb_k; {iSi HH; um web2c zu ueberlisten: sizeof(var) statt }
  mdm_schnuller: mdm_k; {sizeof(typ) }
  mdl_schnuller: mdl_k;
  mde_schnuller: mde_k;

  hsii, hsij: integer; {iSi 920114} {HS_Index_i, HS_Index_j}
@z



@x
     { Konsonantentabelle initialisieren }
   for bst:=bst_a to bst_sz do   konsonant[bst] := true;
   konsonant[bst_a] := false;
   konsonant[bst_e] := false;
   konsonant[bst_i] := false;
   konsonant[bst_o] := false;
   konsonant[bst_u] := false;
   konsonant[bst_ae] := false;
   konsonant[bst_oe] := false;
   konsonant[bst_ue] := false;
@y
     { Konsonantentabelle initialisieren }
   for bst:=bst_a to bst_sz do   konsonant[bst] := true;
   konsonant[bst_a] := false;
   konsonant[bst_e] := false;
   konsonant[bst_i] := false;
   konsonant[bst_o] := false;
   konsonant[bst_u] := false;
   konsonant[bst_ae] := false;
   konsonant[bst_oe] := false;
   konsonant[bst_ue] := false;

{     wterm_cr; wterm_cr;
     wterm_ln('====================');
     wterm_ln('This is iSiTeX, HS92');
     wterm_ln('====================');
     wterm_cr;

     wterm_ln(' =iSi=> init mdb, mdm, mdl, mde'); } 
     mdb := nil; 
     mdm := nil;
     mdl := nil;
     mde := nil;

     hsstart := false;
     isidebug := 0;

@z


@x
	procedure trennen (
			  { trennen }
			  zustand : integer;
			  anfang  : integer;
			  spv     : sperrvektor;
			  var ok1 : boolean;
			  { abteilen }
			  var tr   :trennvektor;
			  var dudtr:trennvektor;
			  var zerlegungen:integer ;
			  var dud:dudt; { array [0..maxwl] of boolean; }
			  var v:varr;
			  var ind,k:intarr;
			  var dudstop:sperrvektor;
			  { abteilen aufruf }
			  var w:wort;
			  var tr1:trennvektor;
			  laenge : integer );
@y
	procedure trennen (
			  { trennen }
			  zustand : integer;
			  anfang  : integer;
			  spv     : sperrvektor;
			  var ok1 : boolean;
			  { abteilen }
			  var alletr: trenn16;  {iSi HH}
			  var tr   :trennvektor;
			  var dudtr:trennvektor;
			  var zerlegungen:integer ;
			  var dud:dudt; { array [0..maxwl] of boolean; }
			  var v:varr;
			  var ind,k:intarr;
			  var dudstop:sperrvektor;
			  { abteilen aufruf }
			  var w:wort;
			  var tr1:trennvektor;
			  laenge : integer );
@z

@x
		gef, nichtok:boolean;
		schnitt:integer;
		inform:infotype;
		i:integer;
		ok_stamm, ok_vor, ok_end, ok_help:boolean;
		tri:integer;
		{ p_stamm }
		i1,tre:integer;
		ok : boolean;
		stop_ptr :integer;
		spvtmp   :sperrvektor;	{ lokale Kopie des Sperrvektors,
										  fr die bersetzung nach C notwendig.
										  -PRAK!- }
@y
		gef, nichtok:boolean;
		schnitt:integer;
		inform:infotype;
		i:integer;
		ok_stamm, ok_vor, ok_end, ok_help:boolean;
		tri:integer;
		{ p_stamm }
		i1,tre:integer;
		ok : boolean;
		stop_ptr :integer;
		spvtmp   :sperrvektor;	{ lokale Kopie des Sperrvektors,
										  fr die bersetzung nach C notwendig.
										  -PRAK!- }
        trlast: trennvektor;   {iSi 920114}
@z

@x
				for i := laenge downto 1 do
					begin
					if dudtr[i-1] = haupt3 then
						begin
						dudtr[i-1] := keine;
						tri := haupt3;
						end
					else
						tri := dudtr[i];

					if zerlegungen = 0 then
						tr1[i] := tri
					else
						tr1[i] := kombtab[tr1[i],tri];
					end;
				zerlegungen:=zerlegungen+1;
				ok1:= true
@y
               for i := laenge downto 1 do begin
                     if dudtr[i-1] = haupt3 then begin
                           dudtr[i-1] := keine;
                           tri := haupt3;
                        end
                     else
                        tri := dudtr[i];
                     if zerlegungen = 0 then
                        tr1[i] := tri
                     else
                        tr1[i] := kombtab[tr1[i],tri];

                     trlast[i] := tri;   {iSi 920114}

                  end;
               zerlegungen:=zerlegungen+1;

               for i := 0 to maxwl do
                 alletr[zerlegungen][i] := trlast[i];   {iSi 920114}

               ok1:= true
@z


@x

									trennen (2, schnitt+2, spv, ok_help,
												tr,dudtr,zerlegungen,dud,v,ind,k,
												dudstop,w,tr1,laenge);
@y
									trennen (2, schnitt+2, spv, ok_help, alletr,
												tr,dudtr,zerlegungen,dud,v,ind,k,
												dudstop,w,tr1,laenge);
@z

@x
							trennen (2, schnitt+1, spv, ok_help,
										tr,dudtr,zerlegungen,dud,v,ind,k,
										dudstop,w,tr1,laenge);
@y
							trennen (2, schnitt+1, spv, ok_help, alletr,
										tr,dudtr,zerlegungen,dud,v,ind,k,
										dudstop,w,tr1,laenge);
@z

@x
							trennen(1, schnitt+1, spv, ok_vor,
									  tr,dudtr,zerlegungen,dud,v,ind,k,
									  dudstop,w,tr1,laenge);
@y
							trennen(1, schnitt+1, spv, ok_vor, alletr,
									  tr,dudtr,zerlegungen,dud,v,ind,k,
									  dudstop,w,tr1,laenge);
@z

@x
											trennen (2, schnitt+2, spv, ok_help,tr,dudtr,
														zerlegungen,dud,v,ind,k,
														dudstop,w,tr1,laenge);
@y
											trennen (2, schnitt+2, spv, ok_help, alletr,
														tr,dudtr,
														zerlegungen,dud,v,ind,k,
														dudstop,w,tr1,laenge);
@z

@x
											trennen(5, schnitt, spv, ok_help,tr,dudtr,
													  zerlegungen,dud,v,ind,k,
													  dudstop,w,tr1,laenge);
@y
											trennen(5, schnitt, spv, ok_help, alletr,
													  tr,dudtr,
													  zerlegungen,dud,v,ind,k,
													  dudstop,w,tr1,laenge);
@z

@x
									trennen (2, schnitt+1, spv, ok_help,tr,dudtr,
												zerlegungen,dud,v,ind,k,
												dudstop,w,tr1,laenge);
@y
									trennen (2, schnitt+1, spv, ok_help, alletr,
												tr,dudtr,
												zerlegungen,dud,v,ind,k,
												dudstop,w,tr1,laenge);
@z

@x
										trennen (4, schnitt+1, spv, ok_stamm,tr,dudtr,
													zerlegungen,dud,v,ind,k,
													dudstop,w,tr1,laenge);
@y
										trennen (4, schnitt+1, spv, ok_stamm, alletr,
													tr,dudtr,
													zerlegungen,dud,v,ind,k,
													dudstop,w,tr1,laenge);
@z

@x
								trennen (2, schnitt+2, spv, ok_help,tr,dudtr,
											zerlegungen,dud,v,ind,k,
											dudstop,w,tr1,laenge);
@y
								trennen (2, schnitt+2, spv, ok_help, alletr,
											tr,dudtr,
											zerlegungen,dud,v,ind,k,
											dudstop,w,tr1,laenge);
@z

@x
								trennen(5, schnitt, spv, ok_help,tr,dudtr,
										  zerlegungen,dud,v,ind,k,
										  dudstop,w,tr1,laenge);
@y
								trennen(5, schnitt, spv, ok_help, alletr,
										  tr,dudtr,
										  zerlegungen,dud,v,ind,k,
										  dudstop,w,tr1,laenge);
@z

@x
						trennen (2, schnitt+1, spv, ok_help,tr,dudtr,
									zerlegungen,dud,v,ind,k,
									dudstop,w,tr1,laenge);
@y
						trennen (2, schnitt+1, spv, ok_help, alletr,
									tr,dudtr,
									zerlegungen,dud,v,ind,k,
									dudstop,w,tr1,laenge);
@z


@x
procedure abteilen ( var w:wort; var tr1:trennvektor;
			 laenge : integer; var ok:boolean;
			 var zerlegungen:integer );
@y

procedure wchar(c: halfword);
begin
    if c = 27 then begin
      wterm('"a')
    end else if c = 28 then begin
      wterm('"o')
    end else if c = 29 then begin
      wterm('"u')
    end else if c = 30 then begin
      wterm('"s')
    end else begin
      wterm(xchr[c+96])
    end
end;

procedure wwort(w: wort;
                l: integer);
  var i: integer;
begin
  for i := 1 to l do begin
    wchar(w[i])
  end
end;
 
procedure writewt(w: wort;
                  l: integer;
                  tr: trennvektor);
  var i: integer;
begin
  wchar(w[1]);
  for i := 2 to l-1 do begin
    if (tr[i-1] = nebenck) {and (w[i] = bst_c)} then begin
      wterm('k');
      wterm('-')
    end else if (tr[i] = haupt3) then begin
      wterm(xchr[w[i]+96]);
      wterm('=');
      wterm(xchr[w[i]+96]);
    end else if (tr[i] = haupt) then begin
      wchar(w[i]);
      wterm('=')
    end else if (tr[i] = neben) then begin
      wchar(w[i]);
      wterm('-') 
    end else begin
      wchar(w[i])
    end
  end;
  wchar(w[l])
end;

procedure wjob;
  var i:integer;
begin
  for i := str_start[job_name] to str_start[job_name+1]-1 do begin
    wterm(xchr[str_pool[i]])
  end
end;

function vergl(wrt1: wort;
               l1: integer;
               wrt2: wort;
               l2: integer): integer;
  label 99;
  var i: integer;
begin
  i := 1;
  while (i <= l1) and (i <= l2) do begin
    if wrt1[i] < wrt2[i] then begin
      vergl := -1;
      goto 99
    end else if wrt1[i] > wrt2[i] then begin
      vergl := 1;
      goto 99
    end;
    i := i+1
  end;
  if l1 < l2 then begin
    vergl := -1;
    goto 99
  end else if l1 > l2 then begin
  vergl := 1;
    goto 99
    end else begin
    vergl := 0;
    goto 99
  end;
  99:
end;

procedure gleiche_weg (var alletr: trenn16;
                       var zerleg: integer;
                       laenge: integer);

{ eliminiert bei Mehrdeutigkeiten (zerleg >= 2 !!!) eventuell gleiche }
{ trennvektoren und korrigiert alletr & zerleg                        }

  var i, j, k, ii: integer;
      gleich: boolean;

begin
  i := 1;
  repeat 
    j := i+1;                                       { zerleg >= 2 }
    repeat
      gleich := true;
      k := 1;                                       { laenge >= 1 }
      repeat                                          
        if alletr[i][k] = alletr[j][k] then begin
          k := k+1
        end else begin
          gleich := false
        end
      until (k > laenge) or (gleich = false);
      if gleich then begin
        for k := j to zerleg-1 do begin
          for ii := 0 to maxwl do
            alletr[k][ii] := alletr[k+1][ii]
        end;
        zerleg := zerleg-1
      end else begin
        j := j+1
      end
    until j > zerleg;
    i := i+1
  until i > zerleg-1
end;

procedure mdb_eintragen(w: wort;
                        l: integer;
                        tr: trennvektor;
                        neu: boolean;
                        used: boolean;
                        var mdb: mdb_knoten);
 
  var ii, test: integer;
begin
{ wterm(' =iSi=> mdb_eintragen von '); writewt(w, l, tr); wterm_cr; } 
  if mdb = nil then begin
    { new(mdb); }
    mdb := malloc(sizeof(mdb_schnuller));
    for ii := 0 to maxwl do
        mdb^.w12[ii] := w[ii];
    mdb^.l1 := l;
    for ii := 0 to maxwl do
        mdb^.tr1[ii] := tr[ii];
    mdb^.neu1 := neu;
    mdb^.used1 := used;
    mdb^.del1 := false;
    mdb^.li := nil;
    mdb^.re := nil;
    if isidebug=1 then begin
      wterm_cr
    end
  end else begin
    test := vergl(w, l, mdb^.w12, mdb^.l1);
    if test = -1 then begin
      if isidebug=1 then begin
{       wterm(' =iSi=> kleiner  als '); wwort(mdb^.w12, mdb^.l1); wterm_cr; }
        wterm('/')
      end;
      mdb_eintragen(w, l, tr, neu, used, mdb^.li)
    end else if test = 1 then begin
      if isidebug=1 then begin
{       wterm(' =iSi=> gr"osser als '); wwort(mdb^.w12, mdb^.l1); wterm_cr; }
        wterm('\')
      end;
      mdb_eintragen(w, l, tr, neu, used, mdb^.re)
    end else begin
      wterm(' =iSi=> mdb_eintragen vom gleichen Wort nocheinmal !!!');
      wterm_cr 
    end
  end
end;

{iSi 920102 end}
{iSi 920110 begin}

  procedure mdm_eintragen(w: wort;
			  l: integer;
                          tr: trennvektor;
			  neu: boolean;
                          var mdm: mdm_knoten);
    var rechts: mdm_knoten;
        ii: integer;
  begin
    if mdm = nil then begin
      { new(mdm); }
      mdm := malloc(sizeof(mdm_schnuller));
      for ii := 0 to maxwl do
          mdm^.w12[ii] := w[ii];
      mdm^.l1 := l;
      for ii := 0 to maxwl do
          mdm^.tr1[ii] := tr[ii];
      mdm^.neu1 := neu;
      mdm^.li := nil;
      mdm^.re := nil
    end else if mdm^.re = nil then begin
      { new(mdm^.re); }
      mdm^.re := malloc(sizeof(mdm_schnuller));
      for ii := 0 to maxwl do
          mdm^.re^.w12[ii] := w[ii];
      mdm^.re^.l1 := l;
      for ii := 0 to maxwl do
          mdm^.re^.tr1[ii] := tr[ii];
      mdm^.re^.neu1 := neu;
      mdm^.re^.li := nil;
      mdm^.re^.re := nil;
      mdm^.li := mdm^.re
    end else begin
      rechts := mdm^.re;
      { new(mdm^.re); }
      mdm^.re := malloc(sizeof(mdm_schnuller));
      for ii := 0 to maxwl do
          mdm^.re^.w12[ii] := w[ii];
      mdm^.re^.l1 := l;
      for ii := 0 to maxwl do
          mdm^.re^.tr1[ii] := tr[ii];
      mdm^.re^.neu1 := neu;
      mdm^.re^.li := nil;
      mdm^.re^.re := nil;
      rechts^.li := mdm^.re
    end
  end;

  procedure mdl_eintragen(w: wort;
			  l: integer;
                          var mdl: mdl_knoten);
    var rechts: mdl_knoten;
        ii: integer;
  begin
    if isidebug=1 then begin
      wterm(' =iSi=> mdl_eintragen von '); wwort(w, l); wterm_cr; 
    end;
    if mdl = nil then begin
      { new(mdl); }
      mdl := malloc(sizeof(mdl_schnuller));
      for ii := 0 to maxwl do
          mdl^.w12[ii] := w[ii];
      mdl^.l1 := l;
      mdl^.li := nil;
      mdl^.re := nil
    end else if mdl^.re = nil then begin
      { new(mdl^.re); }
      mdl^.re := malloc(sizeof(mdl_schnuller));
      for ii := 0 to maxwl do
          mdl^.re^.w12[ii] := w[ii];
      mdl^.re^.l1 := l;
      mdl^.re^.li := nil;
      mdl^.re^.re := nil;
      mdl^.li := mdl^.re
    end else begin
      rechts := mdl^.re;
      { new(mdl^.re); }
      mdl^.re := malloc(sizeof(mdl_schnuller));
      for ii := 0 to maxwl do
          mdl^.re^.w12[ii] := w[ii];
      mdl^.re^.l1 := l;
      mdl^.re^.li := nil;
      mdl^.re^.re := nil;
      rechts^.li := mdl^.re
    end
  end;
  procedure mde_eintragen(w: wort;
			  l: integer;
                          var mde: mde_knoten);
    var rechts: mde_knoten;
        ii: integer;
  begin
    if isidebug=1 then begin
      wterm(' =iSi=> mde_eintragen von '); wwort(w, l); wterm_cr; 
    end;
    if mde = nil then begin
      { new(mde); }
      mde := malloc(sizeof(mde_schnuller));
      for ii := 0 to maxwl do
          mde^.w12[ii] := w[ii];
      mde^.l1 := l;
      mde^.li := nil;
      mde^.re := nil
    end else if mde^.re = nil then begin
       { new(mde^.re); }
      mde^.re := malloc(sizeof(mde_schnuller));
      for ii := 0 to maxwl do
          mde^.re^.w12[ii] := w[ii];
      mde^.re^.l1 := l;
      mde^.re^.li := nil;
      mde^.re^.re := nil;
      mde^.li := mde^.re
    end else begin
      rechts := mde^.re;
      { new(mde^.re); }
      mde^.re := malloc(sizeof(mde_schnuller));
      for ii := 0 to maxwl do
          mde^.re^.w12[ii] := w[ii];
      mde^.re^.l1 := l;
      mde^.re^.li := nil;
      mde^.re^.re := nil;
      rechts^.li := mde^.re
    end
  end;
   
{iSi 920110 end}
{isi 920111 begin}

function md_suchen (w: wort;
                    l: integer;
                    var mdb: mdb_knoten;
                    var tr: trennvektor): boolean;
  var ii, test: integer;                    
begin
  if mdb = nil then begin
    md_suchen := false
  end else begin
    test := vergl(w, l, mdb^.w12, mdb^.l1);
    if test = -1 then begin
      md_suchen := md_suchen(w, l, mdb^.li, tr)
    end else if test = 1 then begin
      md_suchen := md_suchen(w, l, mdb^.re, tr)
    end else begin
      for ii := 0 to maxwl do
        tr[ii] := mdb^.tr1[ii];
      mdb^.used1 := true;
      md_suchen := true
    end
  end
end; 

function in_use (w: wort;
                 l: integer;
                 mdb: mdb_knoten): boolean;
  var test: integer;                    
begin
  if mdb = nil then begin
    wterm(' =iSi=> in_use Fehler: '); wwort(w, l);
    wterm(' nicht in mdb'); wterm_cr
  end else begin
    test := vergl(w, l, mdb^.w12, mdb^.l1);
    if test = -1 then begin
      in_use := in_use(w, l, mdb^.li)
    end else if test = 1 then begin
      in_use := in_use(w, l, mdb^.re)
    end else begin
      in_use := mdb^.used1;
      if isidebug=1 then begin
        if mdb^.used1 then begin
          wterm(' =iSi=> '); wwort(w, l); wterm(' in use'); wterm_cr
        end else begin
          wterm(' =iSi=> '); wwort(w, l); wterm(' not in use'); wterm_cr
        end
      end
    end
  end
end;

procedure hsinit;
  var i, j, l: integer;
      tr: trennvektor;
      w: wort;
      temp, auswahl, schnuller: char;
      neu, memkorr: boolean;
begin

     wterm_cr; wterm_cr;
     repeat
       wterm_ln('iSi debug Info ? [J/N]');
       read(term_in, auswahl);
       schnuller := auswahl;
	   read_ln(term_in);
     until (xord[auswahl] = 74) or (xord[auswahl] = 78) or
           (xord[auswahl] = 106) or (xord[auswahl] = 110);
     wterm_cr;
     if (xord[auswahl] = 74) or (xord[auswahl] = 106) then begin
       isidebug := 1
     end else begin
       isidebug := 0
     end;  

     for i := 1 to file_name_size do begin
       name_of_file[i] := ' '
     end;  
     j := str_start[job_name];
     i := 1;
     while (j < str_start[job_name+1]) and
           (i < file_name_size - 4) do begin
       name_of_file[i] := xchr[str_pool[j]];
       j := j+1;
       i := i+1
     end;
     name_of_file[i] := '.';
     name_of_file[i+1] := 'm';
     name_of_file[i+2] := 'e';
     name_of_file[i+3] := 'm';
     
     if not a_open_in(hsmem,TEX_INPUT_PATH) then begin
       if isidebug=1 then begin
         wterm(' =iSi=> cant a_open_in '); wjob; wterm('.mem');
         wterm_cr
       end
     end else begin

       repeat
         wterm_cr;
         wterm('Sollen Fehleintr"age gel"oscht werden? [J/N]'); wterm_cr;
         read(term_in, auswahl);
         schnuller := auswahl;
		 read_ln(term_in);
       until (xord[auswahl] = 74) or (xord[auswahl] = 78) or
             (xord[auswahl] = 106) or (xord[auswahl] = 110);
       wterm_cr; wterm_cr;
       if (xord[auswahl] = 74) or (xord [auswahl] = 106) then begin
         memkorr := true
       end else begin
         memkorr := false
       end;

       while not eof(hsmem) do begin
         read(hsmem, l);
         read_ln(hsmem);
         for i := 1 to l do begin
           read(hsmem, w[i]);
         end;
         read_ln(hsmem);
         for i := 1 to l do begin
           read(hsmem, tr[i]);
         end;
         read_ln(hsmem);
         read(hsmem, temp);
         read_ln(hsmem);
         if temp = xchr[116] then neu := true else neu := false;   {116 = t}
         if isidebug=1 then begin
           wterm(' =iSi=> reading from '); wjob; wterm('.mem: '); wwort(w, l); 
           wterm(', neu = '); wterm(temp); wterm_cr; 
         end;

         if memkorr then begin
           repeat
             wterm_cr;
             wterm('Soll ');
             writewt(w, l, tr);
             wterm(' gel"oscht werden? [J/N]'); wterm_cr;
             read(term_in, auswahl);
             schnuller := auswahl;
			 read_ln(term_in);
           until (xord[auswahl] = 74) or (xord[auswahl] = 78) or
                 (xord[auswahl] = 106) or (xord[auswahl] = 110);
           wterm_cr;
           if (xord[auswahl] = 74) or (xord [auswahl] = 106) then begin
             { nichts tun, Wort wird nicht eingetragen }
           end else begin
             if isidebug=1 then begin
               wterm(' =iSi=> mdb/mdm_eintragen: '); writewt(w, l, tr);
               wterm_cr 
             end;
             mdb_eintragen(w, l, tr, neu, false {used}, mdb);
             mdm_eintragen(w, l, tr, neu, mdm);
           end
         end else begin
           if isidebug=1 then begin
             wterm(' =iSi=> mdb/mdm_eintragen: '); writewt(w, l, tr);
             wterm_cr
           end; 
           mdb_eintragen(w, l, tr, neu, false {used}, mdb);
           mdm_eintragen(w, l, tr, neu, mdm)
         end
       end;
       if isidebug=1 then begin
         wterm_cr;
{        wterm(' =iSi=> closing '); wjob; wterm('.mem'); wterm_cr; }
       end;
       a_close(hsmem);
     end;

     repeat
       wterm_cr;
       wterm_ln('Sollen mehrdeutige W"orter angezeigt werden? [J/N]');
       read(term_in, auswahl);
       schnuller := auswahl;
	   read_ln(term_in);
     until (xord[auswahl] = 74) or (xord[auswahl] = 78) or
           (xord[auswahl] = 106) or (xord[auswahl] = 110);
     wterm_cr;
     if (xord[auswahl]=74) or (xord[auswahl]=106) then begin
       mehrdanz := true
     end else begin
       mehrdanz := false
     end

end; 

{iSi 920111 end}
 
procedure abteilen (var w:wort; var tr1:trennvektor;
                    var alletr: trenn16;                 {iSi 920114}
                    laenge : integer; var ok:boolean;
                    var zerlegungen:integer);
@z



@x
   var
		i:integer;
		dud:dudt; { array [0..maxwl] of boolean; }
		v:varr;
		ind,k:intarr;
		spv,dudstop:sperrvektor;
		tr, dudtr:trennvektor;
@y
   var
      i:integer;
      iSi_j: integer;   {iSi 920114}
      dud:dudt; {array [0..maxwl] of boolean; }
      v:varr;
      ind,k:intarr;
      tr, dudtr:trennvektor;
      spv,dudstop:sperrvektor;
@z


@x
		trennen(3, 1, spv, ok,
		tr,dudtr,zerlegungen,dud,v,ind,k,
		dudstop,w,tr1,laenge);
@y
		trennen(3, 1, spv, ok, alletr,
		tr,dudtr,zerlegungen,dud,v,ind,k,
		dudstop,w,tr1,laenge);
@z


@x
		for i:=0 to laenge do
		  if tr1[i]=nebenck then begin
			  tr1[i]:=keine;        { c-k wird zu -ck da sp\"ater dement- }
			  tr1[i-1]:=nebenck;    {sprechend getrennt wird }
		  end;
@y
      for i:=0 to laenge do
        if tr1[i]=nebenck then begin
           tr1[i]:=keine;        { c-k wird zu -ck da sp\"ater dement- }
           tr1[i-1]:=nebenck;    {sprechend getrennt wird }

           for iSi_j := 1 to zerlegungen do begin   {iSi 920114 begin}
             if (alletr[iSi_j][i] = nebenck) then begin
               alletr[iSi_j][i] := keine;
               alletr[iSi_j][i-1] := nebenck
             end
           end                                      {iSi 920114 end}

        end;
@z



@x
@ @<Finish the extensions@>=
for k:=0 to 15 do if write_open[k] then a_close(write_file[k])
@y
@ @<Finish the extensions@>=
for k:=0 to 15 do if write_open[k] then a_close(write_file[k]);

for hsii := 1 to file_name_size do begin
  name_of_file[hsii] := ' '
end;  
hsij := str_start[job_name];
hsii := 1;
while hsij < str_start[job_name+1] do begin
  name_of_file[hsii] := xchr[str_pool[hsij]];
  hsij := hsij+1;
  hsii := hsii+1
end;
name_of_file[hsii] := '.';
name_of_file[hsii+1] := 'm';
name_of_file[hsii+2] := 'e';
name_of_file[hsii+3] := 'm';
     
if not a_open_out(hsmem) then begin
  wterm_ln(' =iSi=> cant a_open_out '); wjob; wterm('.mem ');
  wterm_cr 
end else begin
{ wterm(' =iSi=> a_open_out '); wjob; wterm('.mem '); wterm_cr; } 
  while mdm <> nil do begin
    if in_use(mdm^.w12, mdm^.l1, mdb) then begin
      if isidebug=1 then begin
        wterm(' =iSi=> writing to '); wjob; wterm('.mem: ');
        writewt(mdm^.w12, mdm^.l1, mdm^.tr1); wterm_cr; 
      end;
      write_ln(hsmem, mdm^.l1);
      for k := 1 to mdm^.l1 do begin
        write(hsmem, mdm^.w12[k]);
      end;
      write_ln(hsmem);
      for k := 1 to mdm^.l1 do begin
        write(hsmem, mdm^.tr1[k]);
      end;
      write_ln(hsmem);
      if mdm^.neu1 then begin
        write(hsmem, xchr[116]);
        write_ln(hsmem);
        mdl_eintragen(mdm^.w12, mdm^.l1, mdl)
      end else begin
        write(hsmem, xchr[102]);
        write_ln(hsmem)
      end
    end else begin
      if isidebug=1 then begin
        wterm(' =iSi=> '); wwort(mdm^.w12, mdm^.l1);
        wterm(' not in use');
        wterm_cr
      end
    end;
    mdm := mdm^.li
  end;
  a_close(hsmem);
{  wterm(' =iSi=> a_close '); wjob; wterm('.mem '); wterm_cr; }
end;

for hsii := 1 to file_name_size do begin
  name_of_file[hsii] := ' '
end;  
hsij := str_start[job_name];
hsii := 1;
while hsij < str_start[job_name+1] do begin
  name_of_file[hsii] := xchr[str_pool[hsij]];
  hsij := hsij+1;
  hsii := hsii+1
end;
name_of_file[hsii] := '.';
name_of_file[hsii+1] := 'l';
name_of_file[hsii+2] := 'e';
name_of_file[hsii+3] := 'x';

if not a_open_out(hslex) then
  wterm_ln(' =iSi=> cant open hslex') 
else begin
{ wterm(' =iSi=> a_open_out '); wjob; wterm('.lex '); wterm_cr; }
  while mdl <> nil do begin
    if isidebug=1 then begin
      wterm(' =iSi=> writing to '); wjob; wterm('.lex: ');
      wwort(mdl^.w12, mdl^.l1); 
      wterm_cr
    end; 
    write(hslex, xchr[mdl^.l1]);
    for k := 1 to mdl^.l1 do begin
      if mdl^.w12[k] <= 26 then begin
        write(hslex, xchr[mdl^.w12[k]+96])
      end else begin
        if mdl^.w12[k] = 27 then begin
          write(hslex, '"a')
        end else if mdl^.w12[k] = 28 then begin 
          write(hslex, '"o') 
        end else if mdl^.w12[k] = 29 then begin
          write(hslex, '"u')
        end else if mdl^.w12[k] = 30 then begin
          write(hslex, '"s')
        end else begin
	  write(hslex, '-')
        end
      end	  
    end;
    write_ln(hslex);
    mdl := mdl^.li
  end;
  a_close(hslex);
{ wterm(' =iSi=> a_close '); wjob; wterm('.lex '); wterm_cr; }
end;

for hsii := 1 to file_name_size do begin
  name_of_file[hsii] := ' '
end;  
hsij := str_start[job_name];
hsii := 1;
while hsij < str_start[job_name+1] do begin
  name_of_file[hsii] := xchr[str_pool[hsij]];
  hsij := hsij+1;
  hsii := hsii+1
end;
name_of_file[hsii] := '.';
name_of_file[hsii+1] := 'e';
name_of_file[hsii+2] := 'd';
name_of_file[hsii+3] := 't';

if not a_open_out(hsedt) then
  wterm_ln(' =iSi=> cant open hsedt') 
else begin
{ wterm(' =iSi=> a_open_out '); wjob; wterm('.edt '); wterm_cr; }
  while mde <> nil do begin
    if isidebug=1 then begin
      wterm(' =iSi=> writing to '); wjob; wterm('.edt: ');
      wwort(mde^.w12, mde^.l1);
      wterm_cr
    end; 
    for k := 1 to mde^.l1 do begin
      if mde^.w12[k] <= 26 then begin
        write(hsedt, xchr[mde^.w12[k]+96])
      end else begin
        if mde^.w12[k] = 27 then begin
          write(hsedt, '"a')
        end else if mde^.w12[k] = 28 then begin 
          write(hsedt, '"o') 
        end else if mde^.w12[k] = 29 then begin
          write(hsedt, '"u')
        end else if mde^.w12[k] = 30 then begin
          write(hsedt, '"s')
        end else begin
	  write(hsedt, '--')
        end
      end	  
    end;
    write_ln(hsedt);
    mde := mde^.li
  end;
  a_close(hsedt);
{ wterm(' =iSi=> a_close '); wjob; wterm('.edt '); wterm_cr; }
end;
@z