Decompress source files

EUMEL’s TEXT dataspaces wastes a lot of storage space. Some files were
therefore “compressed” by storing them as a single line, reducing
overhead significantly.

3 files changed, 2767 insertions, 200 deletions

diff --git a/mp-bap/ls-MP BAP 1 b/mp-bap/ls-MP BAP 1
index be7e3d2..9fa1a4b 100644
--- a/mp-bap/ls-MP BAP 1
+++ b/mp-bap/ls-MP BAP 1
@@ -22,98 +22,1325 @@ PACKET ls mp bap 1  DEFINES                (*******************************)
        mp bap pausendauer, 
        mp bap wertungsschluessel: 
  
-LET maxspalten         =            70,{}    maxzeilen          =            14,{}    kleinster wert     =             1,{}    oben unten return  = ""3""10""13"",{}    punkt              =           "+",{}    punkt und zurueck  =        "+"8"",{}    piep               =         ""7"",{}    blank              =           " ";{}INT  VAR aktuelle werkstueckbreite,{}         aktuelle werkstueckhoehe,{}         kleinster aktueller zeichencode,{}         groesster aktueller zeichencode,{}         aktuelle anzahl der arbeitsphasen,{}
-         aktuelle arbeitsphasendauer in minuten,{}         aktuelle pausendauer in minuten;{}TEXT VAR aktuelles fehlerzeichen,{}         nach rechts,{}         nach links,{}         nach oben,{}         nach unten,{}         ausbesserung,{}         naechstes;{}BOOL VAR inversdarstellung;{}ROW 11 REAL VAR bewertung;{}WINDOW VAR w1, w2, w3, w4;{}PROC stdvoreinstellung der parameter:{}  aktuelle werkstueckbreite               :=     15;{}  aktuelle werkstueckhoehe                :=     12;{}  kleinster aktueller zeichencode         :=     65;{}
-  groesster aktueller zeichencode         :=     90;{}  aktuelle anzahl der arbeitsphasen       :=      3;{}  aktuelle arbeitsphasendauer in minuten  :=     10;{}  aktuelle pausendauer in minuten         :=      2;{}  aktuelles fehlerzeichen                 :=    "F";{}  nach rechts                             :=  ""2"";{}  nach links                              :=  ""8"";{}  nach oben                               :=  ""3"";{}  nach unten                              := ""10"";{}  ausbesserung                            :=  ""1"";{}
-  naechstes                               := ""27"";{}  inversdarstellung                       :=  FALSE;{}  bewertung := ROW 11 REAL : (0.0, 0.1, 0.2, 0.3, 0.4, 0.5,{}                                   0.6, 0.7, 0.8, 0.9, 1.0){}END PROC stdvoreinstellung der parameter;{}PROC werkstueckdefinition (INT VAR breite, hoehe, kleinster, groesster,{}                           TEXT VAR fzeichen, BOOL VAR invers):{}  breite        := aktuelle werkstueckbreite;{}  hoehe         := aktuelle werkstueckhoehe;{}
-  kleinster     := kleinster aktueller zeichencode;{}  groesster     := groesster aktueller zeichencode;{}  fzeichen      := aktuelles fehlerzeichen;{}  invers        := inversdarstellung{}END PROC werkstueckdefinition;{}PROC tastendefinition (TEXT VAR rechts, links, hoch, runter, aus, nach):{}  rechts        := nach rechts;{}  links         := nach links;{}  hoch          := nach oben;{}  runter        := nach unten;{}  aus           := ausbesserung;{}  nach          := naechstes{}END PROC tastendefinition;{}
-PROC phasendefinition (INT VAR aphasenzahl, aphasendauer, pausendauer):{}  aphasenzahl   := aktuelle anzahl der arbeitsphasen;{}  aphasendauer  := aktuelle arbeitsphasendauer in minuten;{}  pausendauer   := aktuelle pausendauer in minuten{}END PROC phasendefinition;{}PROC bewertungsschluessel (ROW 11 REAL VAR schluessel):{}  INT VAR zeiger;{}  FOR zeiger FROM 1 UPTO 11 REP{}    schluessel [zeiger] := bewertung [zeiger]{}  PER{}END PROC bewertungsschluessel;{}PROC mp bap einstellung anzeigen:{}  aktuellen parameterzustand anzeigen;{}
-  regenerate menuscreen{}END PROC mp bap einstellung anzeigen;{}PROC mp bap standardwerte:{}  standardwerte einstellen;{}  regenerate menuscreen{}END PROC mp bap standardwerte;{}PROC mp bap breite des werkstuecks:{}  breite des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap breite des werkstuecks;{}PROC mp bap hoehe des werkstuecks:{}  hoehe des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap hoehe des werkstuecks;{}PROC mp bap invers normal:{}  werkstueckdarstellung einstellen;{}
-  regenerate menuscreen{}END PROC mp bap invers normal;{}PROC mp bap zeichensatz:{}  zeichensatz einstellen;{}  regenerate menuscreen{}END PROC mp bap zeichensatz;{}PROC mp bap fehlerzeichen:{}  fehlerzeichen veraendern;{}  regenerate menuscreen{}END PROC mp bap fehlerzeichen;{}PROC mp bap tastenbelegung:{}  tastaturbelegung einstellen;{}  regenerate menuscreen{}END PROC mp bap tastenbelegung;{}PROC mp bap anzahl arbeitsphasen:{}  anzahl der arbeitsphasen festlegen;{}  regenerate menuscreen{}END PROC mp bap anzahl arbeitsphasen;{}
-PROC mp bap dauer einer arbeitsphase:{}  dauer einer arbeitsphase festlegen;{}  regenerate menuscreen{}END PROC mp bap dauer einer arbeitsphase;{}PROC mp bap pausendauer:{}  pausendauer festlegen;{}  regenerate menuscreen{}END PROC mp bap pausendauer;{}PROC mp bap wertungsschluessel:{}  wertungsschluessel veraendern;{}  regenerate menuscreen{}END PROC mp bap wertungsschluessel;{}PROC aktuellen parameterzustand anzeigen:{}  zeige die fenster;{}  fuelle die fenster mit inhalt;{}  gib hinweis aus.{}
-  zeige die fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41,  2, 38, 20);{}    w3 := window ( 1,  1, 79, 24);{}    page; show (w1); show (w2).{}  fuelle die fenster mit inhalt:{}    zeige inhalt fenster 1;{}    zeige inhalt fenster 2.{}  zeige inhalt fenster 1:{}    zeige eingestellte parameter an (w1).{}  zeige inhalt fenster 2:{}    gib bewertungsschluessel aus (w2).{}  gib hinweis aus:{}    out footnote (w3, anwendungstext (2)); pause.{}END PROC aktuellen parameterzustand anzeigen;{}
-PROC zeige eingestellte parameter an (WINDOW VAR w):{}  zeige ueberschrift;{}  zeige werkstueckdefinition;{}  zeige tastenbelegung;{}  zeige simulationszeiten.{}  zeige ueberschrift:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 1)))).{}  zeige werkstueckdefinition:{}    cursor (w, 2,  3); out (w, anwendungstext ( 6));{}                       out (w, text (aktuelle werkstueckbreite, 3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  4); out (w, anwendungstext ( 7));{}
-                       out (w, text (aktuelle werkstueckhoehe,  3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  5); out (w, anwendungstext ( 8));{}                        IF inversdarstellung{}                           THEN out (w, anwendungstext (29)){}                           ELSE out (w, anwendungstext (30)){}                        FI;{}    cursor (w, 2,  6); out (w, anwendungstext ( 9));{}                       out (w, zeichensatz);{}    cursor (w, 2,  7); out (w, anwendungstext (10));{}
-                       out (blank + aktuelles fehlerzeichen).{}  zeige tastenbelegung:{}    cursor (w, 2,  9); out (w, anwendungstext (11));{}                       out (w, tastenbezeichnung (nach rechts));{}    cursor (w, 2, 10); out (w, anwendungstext (12));{}                       out (w, tastenbezeichnung (nach links));{}    cursor (w, 2, 11); out (w, anwendungstext (13));{}                       out (w, tastenbezeichnung (nach oben));{}    cursor (w, 2, 12); out (w, anwendungstext (14));{}                       out (w, tastenbezeichnung (nach unten));{}
-    cursor (w, 2, 13); out (w, anwendungstext (15));{}                       out (w, tastenbezeichnung (ausbesserung));{}    cursor (w, 2, 14); out (w, anwendungstext (16));{}                       out (w, tastenbezeichnung (naechstes)).{}  zeige simulationszeiten:{}    cursor (w, 2, 16); out (w, anwendungstext (17));{}                       out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}    cursor (w, 2, 17); out (w, anwendungstext (18));{}                       out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}
-                       out (w, anwendungstext (51));{}    cursor (w, 2, 18); out (w, anwendungstext (19));{}                       out (w, text (aktuelle pausendauer in minuten, 4));{}                       out (w, anwendungstext (51));{}    cursor (w, 2, 20); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  zeichensatz:{}    blank + code (kleinster aktueller zeichencode) + "..." +{}            code (groesster aktueller zeichencode) + " ("  +{}            text (groesster aktueller zeichencode{}
-                   - kleinster aktueller zeichencode + 1, 2) +{}            anwendungstext (28) + ")".{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC zeige eingestellte parameter an;{}PROC gib bewertungsschluessel aus (WINDOW VAR w):{}  zeichne koordinatenkreuz;{}
-  trage messwerte ein.{}  zeichne koordinatenkreuz:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 4))));{}    cursor (w, 2,  3); out (w, anwendungstext (20));{}    cursor (w, 2,  4); out (w, anwendungstext (21));{}    cursor (w, 2,  6); out (w, anwendungstext (23));{}    cursor (w, 2,  7); out (w, anwendungstext (22));{}    cursor (w, 2,  8); out (w, anwendungstext (22));{}    cursor (w, 2,  9); out (w, anwendungstext (22));{}    cursor (w, 2, 10); out (w, anwendungstext (22));{}
-    cursor (w, 2, 11); out (w, anwendungstext (24));{}    cursor (w, 2, 12); out (w, anwendungstext (22));{}    cursor (w, 2, 13); out (w, anwendungstext (22));{}    cursor (w, 2, 14); out (w, anwendungstext (22));{}    cursor (w, 2, 15); out (w, anwendungstext (22));{}    cursor (w, 2, 16); out (w, anwendungstext (25));{}    cursor (w, 2, 17); out (w, anwendungstext (26));{}    cursor (w, 2, 19); out (w, anwendungstext (27)).{}  trage messwerte ein:{}    INT CONST abszisse :: 16, ordinate :: 2;{}
-    INT VAR nr;{}    FOR nr FROM 1 UPTO 11 REP{}      zeichne einen punkt{}    PER.{}  zeichne einen punkt:{}    cursor (w, ordinate + 3 * nr, abszisse - nachkommastelle); out (punkt).{}  nachkommastelle:{}    int(bewertung [nr] * 10.0).{}END PROC gib bewertungsschluessel aus;{}PROC standardwerte einstellen:{}  zeige fenster;{}  zeige eingestellte parameter an (w1);{}  gib information aus;{}  hole bestaetigung ein.{}  zeige fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41, 10, 37, 12);{}
-    w3 := window (41,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib information aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (67));{}    cursor (w2, 2, 4); out (w2, anwendungstext (68));{}    cursor (w2, 2, 7); out (w2, anwendungstext (69));{}    cursor (w2, 2, 9); out (w2, anwendungstext (70));{}    cursor (w2, 2,10); out (w2, anwendungstext (71));{}    cursor (w2, 2,11); out (w2, anwendungstext (72));{}
-    cursor (w2, 2,12); out (w2, anwendungstext (73)).{}  hole bestaetigung ein:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (66))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (66)){}       THEN stdvoreinstellung der parameter;{}            gib positive rueckmeldung{}    FI.{}  gib positive rueckmeldung:{}    page (w1);{}    zeige eingestellte parameter an (w1);{}    cleop  (w3, 2, 3); out (anwendungstext (221));{}    cursor (w3, 2, 5); out (anwendungstext (  3));{}
-    pause.{}END PROC standardwerte einstellen;{}PROC breite des werkstuecks einstellen:{}  zeige die fenster;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige die fenster:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
-    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxspalten,     3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle werkstueckbreite, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (57))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (216)){}
-       THEN LEAVE breite des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (60));{}    aktuelle werkstueckbreite := ermittelter wert (1, maxspalten,{}                                                aktuelle werkstueckbreite).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}
-    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (62)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC breite des werkstuecks einstellen;{}PROC hoehe des werkstuecks einstellen:{}  fenster zeigen;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
-  fenster zeigen:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxzeilen,      3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}
-                       out (w1, text (aktuelle werkstueckhoehe, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (63))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (217)){}       THEN LEAVE hoehe des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (64));{}    aktuelle werkstueckhoehe := ermittelter wert (1, maxzeilen,{}
-                                                  aktuelle werkstueckhoehe).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (65)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC hoehe des werkstuecks einstellen;{}PROC werkstueckdarstellung einstellen:{}  fenster zeigen;{}
-  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  REP{}    bestaetigung einholen;{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3){}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (32,  2, 46,  6);{}    w3 := window ( 2,  9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (74));{}
-                       out (w1, anwendungstext (76));{}    cursor (w1, 2, 4); out (w1, anwendungstext (74));{}                       out (w1, anwendungstext (77));{}    cursor (w1, 2, 6); out (w1, anwendungstext (75));{}                       IF inversdarstellung{}                          THEN out (w1, anwendungstext (77)){}                          ELSE out (w1, anwendungstext (76)){}                       FI.{}  bestaetigung einholen:{}    page (w2);{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (89))));{}
-    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (78)){}       THEN veraendere darstellungsart{}       ELSE LEAVE werkstueckdarstellung einstellen{}    FI.{}  veraendere darstellungsart:{}    IF inversdarstellung{}       THEN inversdarstellung := FALSE{}       ELSE inversdarstellung := TRUE{}    FI.{}  benutzer ist einverstanden:{}    cleop (w2, 1, 3);{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (99)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC werkstueckdarstellung einstellen;{}
-PROC zeichensatz einstellen:{}  zeige fenster;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    erfrage das neue fehlerzeichen;{}    ermittle das kleinste zeichen;{}    ermittle das groesste zeichen;{}    page (w1);{}    gib eingestellten zeichensatz an{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}
-  gib eingestellten zeichensatz an:{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (80));{}    cursor (w2, 2, 4); out (w2, anwendungstext (81));{}
-    cursor (w2, 2, 5); out (w2, anwendungstext (82));{}    cursor (w2, 2, 6); out (w2, anwendungstext (83));{}    cursor (w2, 2, 8); out (w2, anwendungstext (84));{}    cursor (w2, 2, 9); out (w2, anwendungstext (85));{}    cursor (w2, 2,10); out (w2, anwendungstext (86));{}    cursor (w2, 2,12); out (w2, anwendungstext (87));{}    cursor (w2, 2,13); out (w2, anwendungstext (88)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}
-    IF no (w3, anwendungstext (91)){}       THEN LEAVE zeichensatz einstellen{}    FI.{}  erfrage das neue fehlerzeichen:{}    gib vollstaendigen zeichensatz aus;{}    gib fehlerzeicheninformationen aus;{}    REP{}      lasse fehlerzeichen eingeben{}    UNTIL fehlerzeichen ist ok PER.{}  gib vollstaendigen zeichensatz aus:{}    page (w1); page (w2); page (w3);{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (92))));{}    gib zeichenkette aus (w1, 33, 126, 0).{}  gib fehlerzeicheninformationen aus:{}
-    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3);  out (w2, anwendungstext (95));{}    cursor (w2, 2, 4);  out (w2, anwendungstext (96));{}    cursor (w2, 2, 6);  out (w2, anwendungstext (97)).{}  lasse fehlerzeichen eingeben:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (100))));{}    cursor (w3, 2, 3);{}    out (w3, anwendungstext (101));{}    cursor on; inchar (aktuelles fehlerzeichen); cursor off;{}    IF fehlerzeichen ist ok{}
-       THEN out (w3, aktuelles fehlerzeichen);{}            markiere das fehlerzeichen im ersten fenster;{}       ELSE lege beschwerde ein{}    FI.{}  fehlerzeichen ist ok:{}        code (aktuelles fehlerzeichen) >=  33{}    AND code (aktuelles fehlerzeichen) <= 126.{}  markiere das fehlerzeichen im ersten fenster:{}    positioniere cursor in zeichenkette (w1, 33, code (aktuelles fehlerzeichen));{}    out (w1, invers (aktuelles fehlerzeichen)).{}  lege beschwerde ein:{}    piepse;{}    cursor (w2, 2, 8); out (w2, anwendungstext (102));{}
-    cursor (w2, 2,10); out (w2, anwendungstext (103));{}    cursor (w2, 2,11); out (w2, anwendungstext (104));{}    cursor (w2, 2,12); out (w2, anwendungstext (105));{}    cursor (w2, 2,13); out (w2, anwendungstext (106));{}    cursor (w2, 2,14); out (w2, anwendungstext (107)).{}  ermittle das kleinste zeichen:{}    page (w2); page (w3);{}    gib kleinste zeichencode informationen aus;{}    lasse den vorbereich festlegen.{}  ermittle das groesste zeichen:{}    lasse den nachbereich festlegen.{}  gib kleinste zeichencode informationen aus:{}
-    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (111));{}    cursor (w2, 2, 4); out (w2, anwendungstext (112));{}    cursor (w2, 2, 5); out (w2, anwendungstext (113));{}    cursor (w2, 2, 6); out (w2, anwendungstext (114));{}    cursor (w2, 2, 8); out (w2, anwendungstext (115));{}    cursor (w2, 2, 9); out (w2, anwendungstext (116));{}    cursor (w2, 2,10); out (w2, anwendungstext (117));{}    cursor (w2, 2,11); out (w2, anwendungstext (118));{}
-    cursor (w2, 2,13); out (w2, anwendungstext (119));{}    cursor (w2, 2,14); out (w2, anwendungstext (120)).{}  lasse den vorbereich festlegen:{}    INT VAR s, z; page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (123));{}    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    kleinster aktueller zeichencode := code (aktuelles fehlerzeichen);{}
-    groesster aktueller zeichencode := code (aktuelles fehlerzeichen);{}    kleinster aktueller zeichencode := eingabe mit intervallanzeige ( w1, 33,{}                                       code (aktuelles fehlerzeichen),{}                                       kleinster aktueller zeichencode, s, z);{}    cursor off.{}  lasse den nachbereich festlegen:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (124));{}
-    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    groesster aktueller zeichencode := eingabe mit intervallanzeige ( w1,{}                                       code (aktuelles fehlerzeichen), 126,{}                                       groesster aktueller zeichencode, s, z);{}    cursor off.{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (126)){}
-       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC zeichensatz einstellen;{}PROC fehlerzeichen veraendern:{}  fenster zeigen;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    lasse fehlerzeichen einstellen{}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}  gib eingestellten zeichensatz an:{}
-    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (131));{}    cursor (w2, 2, 4); out (w2, anwendungstext (132));{}    cursor (w2, 2, 5); out (w2, anwendungstext (133));{}
-    cursor (w2, 2, 7); out (w2, anwendungstext (134));{}    cursor (w2, 2, 8); out (w2, anwendungstext (135));{}    cursor (w2, 2, 9); out (w2, anwendungstext (136)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF no (w3, anwendungstext (137)){}       THEN LEAVE fehlerzeichen veraendern{}    FI.{}  lasse fehlerzeichen einstellen:{}    INT VAR s, z, fehlercode :: code (aktuelles fehlerzeichen);{}    page (w3); cursor (w3, 1, 1);{}
-    out (w3, center (w3, invers (anwendungstext (138))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (139));{}    cursor (w3, 2, 4); out (w3, anwendungstext (140));{}    cursor (w3, 2, 5); out (w3, anwendungstext (141));{}    get cursor (s, z); cursor on;{}    fehlercode := eingabe mit elementanzeige (w1,{}                                              kleinster aktueller zeichencode,{}                                              groesster aktueller zeichencode,{}                                              fehlercode, s, z);{}
-    cursor off;{}    aktuelles fehlerzeichen := code (fehlercode).{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (142)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC fehlerzeichen veraendern;{}PROC tastaturbelegung einstellen:{}  ROW 6 TEXT VAR tastenname, taste;{}  fenster zeigen;{}  REP{}    tastaturneubelegung vornehmen{}  UNTIL benutzer ist einverstanden PER.{}
-  fenster zeigen:{}    w1 := window ( 2,  2, 28, 10);{}    w2 := window ( 2, 14, 28, 10);{}    w3 := window (32, 10, 46, 14);{}    w4 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3); show (w4).{}  tastaturneubelegung vornehmen:{}    alte tastenbelegung einlesen;{}    tastenbelegung anzeigen;{}    bedienhinweise ausgeben;{}    veraenderung erfragen;{}    neue tastenbelegung erfragen;{}    hinweis zur bewertung und stand ausgeben.{}  alte tastenbelegung einlesen:{}    INT VAR z1;{}
-    FOR z1 FROM 1 UPTO 6 REP{}      tastenname [z1] := anwendungstext (z1 + 10){}    PER;{}    taste [1] := nach rechts;{}    taste [2] := nach links;{}    taste [3] := nach oben;{}    taste [4] := nach unten;{}    taste [5] := ausbesserung;{}    taste [6] := naechstes;{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (151)))).{}  tastenbelegung anzeigen:{}    INT VAR cspa, czei;{}    cursor (w1, 2, 3); out (w1, tastenname [1]);{}                       out (w1, tastenbezeichnung (taste [1]));{}
-                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 4); out (w1, tastenname [2]);{}                       out (w1, tastenbezeichnung (taste [2]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 5); out (w1, tastenname [3]);{}                       out (w1, tastenbezeichnung (taste [3]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 6); out (w1, tastenname [4]);{}
-                       out (w1, tastenbezeichnung (taste [4]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 8); out (w1, tastenname [5]);{}                       out (w1, tastenbezeichnung (taste [5]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2,10); out (w1, tastenname [6]);{}                       out (w1, tastenbezeichnung (taste [6]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei).{}
-  bedienhinweise ausgeben:{}    cursor (w2, 1, 1); out (center (w2, invers (anwendungstext (152))));{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (52))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (153));{}    cursor (w3, 2, 4); out (w3, anwendungstext (154));{}    cursor (w3, 2, 6); out (w3, anwendungstext (155));{}    cursor (w3, 2, 7); out (w3, anwendungstext (156));{}    cursor (w3, 2, 8); out (w3, anwendungstext (157));{}    cursor (w3, 2, 9); out (w3, anwendungstext (158));{}
-    cursor (w3, 2,11); out (w3, anwendungstext (159));{}    cursor (w3, 2,12); out (w3, anwendungstext (160));{}    cursor (w3, 2,13); out (w3, anwendungstext (161));{}    cursor (w3, 2,14); out (w3, anwendungstext (162)).{}  veraenderung erfragen:{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3);{}    IF no (w4, anwendungstext (164)){}       THEN LEAVE tastaturbelegung einstellen{}    FI.{}  neue tastenbelegung erfragen:{}    INT VAR z2; page (w4);{}
-    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3); out (w4, anwendungstext (165));{}    FOR z2 FROM 1 UPTO 6 REP{}      gib tastenhinweis;{}      hole tastatureingabe;{}      tastenbelegung anzeigen{}    PER.{}  gib tastenhinweis:{}    cleol (w4, 2, 5); out (w4, tastenname [z2]).{}  hole tastatureingabe:{}    INT VAR s, z; get cursor (w4, s, z);{}    cursor on; inchar (taste [z2]); cursor off;{}    cursor (w4, s, z); out (w4, tastenbezeichnung (taste [z2])).{}
-  hinweis zur bewertung und stand ausgeben:{}    IF neue tastenbelegung ist ok{}       THEN akzeptiere{}       ELSE akzeptiere nicht{}    FI.{}  neue tastenbelegung ist ok:{}    INT VAR zeiger; TEXT VAR tastenkette :: "";{}    FOR zeiger FROM 1 UPTO 6 REP{}      IF pos (tastenkette, taste [zeiger]) > 0{}         THEN LEAVE neue tastenbelegung ist ok WITH FALSE{}         ELSE tastenkette CAT taste [zeiger]{}      FI{}    PER;{}    TRUE.{}  akzeptiere:{}    cursor (w2, 3, 4);{}    out (w2, anwendungstext (166));{}
-    cursor (w2, 7, 6);{}    out (w2, anwendungstext (167)).{}  akzeptiere nicht:{}    cursor (w2, 3, 3); out (w2, anwendungstext (168));{}    cursor (w2, 3, 4); out (w2, anwendungstext (169));{}    cursor (w2, 3, 6); out (w2, anwendungstext (170));{}    cursor (w2, 3, 7); out (w2, anwendungstext (171));{}    cursor (w2, 3, 9); out (w2, anwendungstext (172));{}    cursor (w2, 5,10); out (w2, anwendungstext (173)).{}  benutzer ist einverstanden:{}    page (w4);{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}
-    IF neue tastenbelegung ist ok{}       THEN gib hinweis auf abspeicherung{}       ELSE frage nach neueingabe{}    FI.{}  gib hinweis auf abspeicherung:{}    cursor (w4, 3, 3); out (w4, anwendungstext (174));{}    neue tastenbelegung festschreiben;{}    cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}    cursor on; pause; cursor off;{}    TRUE.{}  neue tastenbelegung festschreiben:{}    nach rechts   := taste [1];{}    nach links    := taste [2];{}    nach oben     := taste [3];{}    nach unten    := taste [4];{}
-    ausbesserung  := taste [5];{}    naechstes     := taste [6].{}  frage nach neueingabe:{}    cursor (w4, 2, 3);{}    IF yes (w4, anwendungstext (175)){}       THEN cleop (w2, 1, 3); FALSE{}       ELSE alte tastenbelegung einlesen;{}            tastenbelegung anzeigen;{}            cleop  (w4, 2, 3); out (w4, anwendungstext (176));{}            cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}            cursor on; pause; cursor off;{}            TRUE{}    FI.{}END PROC tastaturbelegung einstellen;{}
-PROC simulationszeiten anzeigen (WINDOW VAR w):{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (181))));{}  cursor (w, 2, 3); out (w, anwendungstext (17));{}                    out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}  cursor (w, 2, 4); out (w, anwendungstext (18));{}                    out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}                    out (w, anwendungstext (51));{}  cursor (w, 2, 5); out (w, anwendungstext (19));{}                    out (w, text (aktuelle pausendauer in minuten, 4));{}
-                    out (w, anwendungstext (51));{}  cursor (w, 2, 7); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC simulationszeiten anzeigen;{}PROC anzahl der arbeitsphasen festlegen:{}
-  INT CONST minwert :: 2, maxwert :: 20;{}  zeige fenster;{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
-    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle anzahl der arbeitsphasen, 2)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (182))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (218)){}
-       THEN LEAVE anzahl der arbeitsphasen festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (183));{}    aktuelle anzahl der arbeitsphasen := ermittelter wert (minwert, maxwert,{}                                         aktuelle anzahl der arbeitsphasen).{}  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}
-    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (184)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC anzahl der arbeitsphasen festlegen;{}PROC dauer einer arbeitsphase festlegen:{}  INT CONST minwert :: 1, maxwert :: 60;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}
-    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}
-    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle arbeitsphasendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (187))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (219)){}       THEN LEAVE dauer einer arbeitsphase festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}
-    cursor (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (188));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle arbeitsphasendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                  aktuelle arbeitsphasendauer in minuten).{}  benutzer ist einverstanden:{}
-    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (189)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC dauer einer arbeitsphase festlegen;{}PROC pausendauer festlegen:{}  INT CONST minwert :: 1, maxwert :: 30;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
-  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}
-                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle pausendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (191))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (220)){}       THEN LEAVE pausendauer festlegen{}    FI.{}
-  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (192));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle pausendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                          aktuelle pausendauer in minuten).{}
-  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (193)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC pausendauer festlegen;{}PROC wertungsschluessel veraendern:{}  INT CONST abszisse :: 16, ordinate :: 2;{}  zeige fenster;{}  gib bewertungsschluessel aus (w1);{}  gib informationen aus;{}  stelle frage nach veraenderung;{}  REP{}    neueinstellung{}  UNTIL benutzer ist einverstanden PER.{}
-  zeige fenster:{}    w1 := window ( 2,  2, 38, 22);{}    w2 := window (42, 10, 37, 14);{}    w3 := window (42,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib informationen aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (195));{}    cursor (w2, 2, 4); out (w2, anwendungstext (196));{}    cursor (w2, 2, 6); out (w2, anwendungstext (197));{}    cursor (w2, 2, 7); out (w2, anwendungstext (198));{}    cursor (w2, 2, 8); out (w2, anwendungstext (199));{}
-    cursor (w2, 2,11); out (w2, anwendungstext (200));{}    cursor (w2, 2,12); out (w2, anwendungstext (201));{}    cursor (w2, 2,13); out (w2, anwendungstext (202)).{}  stelle frage nach veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (205))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (206)){}       THEN LEAVE wertungsschluessel veraendern{}       ELSE gib hinweis auf linkes fenster{}    FI.{}  gib hinweis auf linkes fenster:{}    cleop  (w3, 2, 3); out (w3, anwendungstext (211));{}
-    cursor (w3, 2, 4); out (w3, anwendungstext (212));{}    cursor (w3, 2, 5); out (w3, anwendungstext (213)).{}  neueinstellung:{}    INT VAR zeiger;{}    cursor an;{}    FOR zeiger FROM 1 UPTO 11 REP{}      gehe auf aktuelle punktposition;{}      lasse verschieben{}    PER;{}    cursor aus.{}  gehe auf aktuelle punktposition:{}    cursor (w1, ordinate + 3 * zeiger, abszisse - nachkommastelle).{}  nachkommastelle:{}    int (bewertung [zeiger] * 10.0).{}  lasse verschieben:{}    TEXT VAR eingabezeichen; INT VAR position;{}
-    REP{}      inchar (eingabezeichen);{}      position := pos (oben unten return, eingabezeichen);{}      fuehre angemessene reaktion aus{}    UNTIL position = 3 PER.{}  fuehre angemessene reaktion aus:{}    SELECT position OF{}      CASE 1: steige auf{}      CASE 2: steige ab{}      CASE 3: (* tue nichts *){}      OTHERWISE piepse{}    END SELECT.{}  steige auf:{}    IF bewertung [zeiger] < 1.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] INCR 0.1;{}            schreibe neuen punkt{}
-       ELSE piepse{}    FI.{}  steige ab:{}    IF bewertung [zeiger] > 0.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] DECR 0.1;{}            schreibe neuen punkt{}       ELSE piepse{}    FI.{}  loesche alten punkt:{}    INT VAR tabspalte, tabzeile;{}    gehe auf aktuelle punktposition;{}    get cursor (w1, tabspalte, tabzeile);{}    IF tabspalte = ordinate + 3 OR tabzeile = abszisse{}       THEN out (w1, "|"){}       ELSE out (w1, blank){}    FI.{}  schreibe neuen punkt:{}    gehe auf aktuelle punktposition;{}
-    out (w1, punkt und zurueck).{}  benutzer ist einverstanden:{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (207)){}       THEN TRUE{}       ELSE gib hinweis auf linkes fenster;{}            FALSE{}    FI.{}END PROC wertungsschluessel veraendern;{}PROC cleol (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cursor (w, cursorspalte, cursorzeile);{}  IF remaining lines (w) > 1{}     THEN out (w, (areaxsize (w) - cursorspalte + 1) * blank){}     ELSE out (w, (areaxsize (w) - cursorspalte) * blank){}
-  FI;{}  cursor (w, cursorspalte, cursorzeile){}END PROC cleol;{}PROC cleop (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cleol (w, cursorspalte, cursorzeile);{}  INT VAR i;{}  FOR i FROM 1 UPTO remaining lines (w) REP{}    cleol (w, 1, cursorzeile + i){}  PER;{}  cursor  (w, cursorspalte, cursorzeile){}END PROC cleop;{}PROC cursor an:{}  INT VAR spalte, zeile;{}  get cursor (spalte, zeile); cursor on; cursor (spalte, zeile){}END PROC cursor an;{}PROC cursor aus:{}  INT VAR spalte, zeile;{}
-  get cursor (spalte, zeile); cursor off; cursor (spalte, zeile){}END PROC cursor aus;{}INT PROC eingabe mit intervallanzeige (WINDOW VAR w, INT CONST minwert,{}                                       maxwert, anfangswert, cursorspalte,{}                                       cursorzeile):{}  BOOL VAR ist aufsteigend :: minwert = anfangswert;{}  INT  VAR aktueller wert  :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
-      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            IF ist aufsteigend{}               THEN loesche alte markierung{}               ELSE markiere neues zeichen{}            FI{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}
-    IF aktueller wert < maxwert{}       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            IF ist aufsteigend{}               THEN markiere neues zeichen{}               ELSE loesche alte markierung{}            FI{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, 33, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, 33, aktueller wert);{}
-    out (w, invers (code (aktueller wert)));{}    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit intervallanzeige;{}INT PROC eingabe mit elementanzeige (WINDOW VAR w, INT CONST minwert,{}                                     maxwert, anfangswert,{}                                     cursorspalte, cursorzeile):{}  INT VAR aktueller wert :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
-      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maxwert{}
-       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, minwert, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, minwert, aktueller wert);{}    out (w, invers (code (aktueller wert)));{}
-    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit elementanzeige;{}PROC werkstueck zeigen (WINDOW VAR w):{}  INT VAR zaehler, spalte, zeile;{}  page (w);{}  werkstueckaufhaenger (spalte, zeile);{}  schreibe werkstueck zeilenweise.{}  schreibe werkstueck zeilenweise:{}    FOR zaehler FROM 1 UPTO aktuelle werkstueckhoehe REP{}      positioniere den cursor;{}      bastle eine zeile;{}      gib eine zeile aus{}    PER.{}  positioniere den cursor:{}    cursor (w, spalte,  zeile + zaehler - 1).{}
-  bastle eine zeile:{}    TEXT VAR zeileninhalt := "";{}    INT VAR z;{}    FOR z FROM 1 UPTO aktuelle werkstueckbreite REP{}      zeileninhalt CAT code (random (kleinster aktueller zeichencode,{}                                     groesster aktueller zeichencode)){}    PER.{}  gib eine zeile aus:{}    IF inversdarstellung{}       THEN out (w, invers (zeileninhalt)){}       ELSE out (w, zeileninhalt){}    FI.{}END PROC werkstueck zeigen;{}PROC werkstueckaufhaenger (INT VAR spalte, zeile):{}  spalte := ((maxspalten - aktuelle werkstueckbreite) DIV 2) + 3;{}
-  zeile  := ((maxzeilen  - aktuelle werkstueckhoehe ) DIV 2) + 2;{}  IF inversdarstellung THEN spalte DECR 1 FI{}END PROC werkstueckaufhaenger;{}PROC gib zeichenkette aus (WINDOW VAR w,{}                           INT CONST kleinster, groesster, markiertes):{}  INT VAR zaehler;{}  FOR zaehler FROM kleinster UPTO groesster REP{}    positioniere cursor in zeichenkette (w, kleinster, zaehler);{}    IF zaehler = markiertes{}       THEN out (w, invers (code (zaehler))){}       ELSE out (w, code (zaehler)){}
-    FI{}  PER{}END PROC gib zeichenkette aus;{}PROC positioniere cursor in zeichenkette (WINDOW VAR w,{}                                          INT CONST mincode, position):{}  cursor (w, 4 + ((position - mincode) DIV 19) * 5,{}             3 + ((position - mincode) MOD 19)){}END PROC positioniere cursor in zeichenkette;{}TEXT PROC tastenbezeichnung (TEXT CONST zeichen):{}  IF code (zeichen) >= 33 AND code (zeichen) <= 126{}     THEN "<" + zeichen + ">"{}     ELSE umgesetzter code{}  FI.{}  umgesetzter code:{}
-    SELECT code (zeichen) OF{}      CASE   1: anwendungstext (31){}      CASE   2: anwendungstext (32){}      CASE   3: anwendungstext (33){}      CASE   8: anwendungstext (34){}      CASE   9: anwendungstext (35){}      CASE  10: anwendungstext (36){}      CASE  11: anwendungstext (37){}      CASE  12: anwendungstext (38){}      CASE  13: anwendungstext (39){}      CASE  16: anwendungstext (40){}      CASE  27: anwendungstext (41){}      CASE  32: anwendungstext (42){}      CASE 214: anwendungstext (43){}
-      CASE 215: anwendungstext (44){}      CASE 216: anwendungstext (45){}      CASE 217: anwendungstext (46){}      CASE 218: anwendungstext (47){}      CASE 219: anwendungstext (48){}      CASE 251: anwendungstext (49){}      OTHERWISE anwendungstext (50){}  END SELECT{}END PROC tastenbezeichnung;{}INT PROC ermittelter wert (INT CONST minimum, maximum, startwert):{}  INT VAR aktueller wert, eingelesener wert;{}  cursor an;{}  aktueller wert := startwert;{}  REP{}    gib dreistellig aus und positioniere zurueck (aktueller wert, FALSE);{}
-    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}      CASE 1: erhoehe aktuellen wert wenn moeglich{}      CASE 2: erniedrige aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  cursor aus;{}  aktueller wert.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maximum{}       THEN aktueller wert INCR 1{}       ELSE piepse{}    FI.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minimum{}
-       THEN aktueller wert DECR 1{}       ELSE piepse{}    FI.{}END PROC ermittelter wert;{}PROC gib dreistellig aus und positioniere zurueck (INT CONST wert,{}                                                   BOOL CONST mit wertwandel):{}  INT VAR spalte, zeile; get cursor (spalte, zeile);{}  IF mit wertwandel{}     THEN out ("'" + code (wert) + "'"){}     ELSE out (text (wert, 3)){}  FI;{}  cursor (spalte, zeile);{}END PROC gib dreistellig aus und positioniere zurueck;{}PROC hole position aus vorgabe (TEXT CONST vorgabe, INT VAR position):{}
-  TEXT VAR eingabezeichen; INT VAR spa, zei;{}  REP{}    get cursor (spa, zei); inchar (eingabezeichen); cursor (spa, zei);{}    position := pos (vorgabe, eingabezeichen);{}    IF position = 0 THEN piepse; cursor (spa, zei) FI{}  UNTIL position > 0 PER{}END PROC hole position aus vorgabe;{}PROC piepse:{}  INT VAR spa, zei; get cursor (spa, zei); out (piep); cursor (spa, zei){}END PROC piepse;{}END PACKET ls mp bap 1;{}stdvoreinstellung der parameter{}
+LET maxspalten         =            70,
+    maxzeilen          =            14,
+    kleinster wert     =             1,
+    oben unten return  = ""3""10""13"",
+    punkt              =           "+",
+    punkt und zurueck  =        "+"8"",
+    piep               =         ""7"",
+    blank              =           " ";
+INT  VAR aktuelle werkstueckbreite,
+         aktuelle werkstueckhoehe,
+         kleinster aktueller zeichencode,
+         groesster aktueller zeichencode,
+         aktuelle anzahl der arbeitsphasen,
+
+         aktuelle arbeitsphasendauer in minuten,
+         aktuelle pausendauer in minuten;
+TEXT VAR aktuelles fehlerzeichen,
+         nach rechts,
+         nach links,
+         nach oben,
+         nach unten,
+         ausbesserung,
+         naechstes;
+BOOL VAR inversdarstellung;
+ROW 11 REAL VAR bewertung;
+WINDOW VAR w1, w2, w3, w4;
+PROC stdvoreinstellung der parameter:
+  aktuelle werkstueckbreite               :=     15;
+  aktuelle werkstueckhoehe                :=     12;
+  kleinster aktueller zeichencode         :=     65;
+
+  groesster aktueller zeichencode         :=     90;
+  aktuelle anzahl der arbeitsphasen       :=      3;
+  aktuelle arbeitsphasendauer in minuten  :=     10;
+  aktuelle pausendauer in minuten         :=      2;
+  aktuelles fehlerzeichen                 :=    "F";
+  nach rechts                             :=  ""2"";
+  nach links                              :=  ""8"";
+  nach oben                               :=  ""3"";
+  nach unten                              := ""10"";
+  ausbesserung                            :=  ""1"";
+
+  naechstes                               := ""27"";
+  inversdarstellung                       :=  FALSE;
+  bewertung := ROW 11 REAL : (0.0, 0.1, 0.2, 0.3, 0.4, 0.5,
+                                   0.6, 0.7, 0.8, 0.9, 1.0)
+END PROC stdvoreinstellung der parameter;
+PROC werkstueckdefinition (INT VAR breite, hoehe, kleinster, groesster,
+                           TEXT VAR fzeichen, BOOL VAR invers):
+  breite        := aktuelle werkstueckbreite;
+  hoehe         := aktuelle werkstueckhoehe;
+
+  kleinster     := kleinster aktueller zeichencode;
+  groesster     := groesster aktueller zeichencode;
+  fzeichen      := aktuelles fehlerzeichen;
+  invers        := inversdarstellung
+END PROC werkstueckdefinition;
+PROC tastendefinition (TEXT VAR rechts, links, hoch, runter, aus, nach):
+  rechts        := nach rechts;
+  links         := nach links;
+  hoch          := nach oben;
+  runter        := nach unten;
+  aus           := ausbesserung;
+  nach          := naechstes
+END PROC tastendefinition;
+
+PROC phasendefinition (INT VAR aphasenzahl, aphasendauer, pausendauer):
+  aphasenzahl   := aktuelle anzahl der arbeitsphasen;
+  aphasendauer  := aktuelle arbeitsphasendauer in minuten;
+  pausendauer   := aktuelle pausendauer in minuten
+END PROC phasendefinition;
+PROC bewertungsschluessel (ROW 11 REAL VAR schluessel):
+  INT VAR zeiger;
+  FOR zeiger FROM 1 UPTO 11 REP
+    schluessel [zeiger] := bewertung [zeiger]
+  PER
+END PROC bewertungsschluessel;
+PROC mp bap einstellung anzeigen:
+  aktuellen parameterzustand anzeigen;
+
+  regenerate menuscreen
+END PROC mp bap einstellung anzeigen;
+PROC mp bap standardwerte:
+  standardwerte einstellen;
+  regenerate menuscreen
+END PROC mp bap standardwerte;
+PROC mp bap breite des werkstuecks:
+  breite des werkstuecks einstellen;
+  regenerate menuscreen
+END PROC mp bap breite des werkstuecks;
+PROC mp bap hoehe des werkstuecks:
+  hoehe des werkstuecks einstellen;
+  regenerate menuscreen
+END PROC mp bap hoehe des werkstuecks;
+PROC mp bap invers normal:
+  werkstueckdarstellung einstellen;
+
+  regenerate menuscreen
+END PROC mp bap invers normal;
+PROC mp bap zeichensatz:
+  zeichensatz einstellen;
+  regenerate menuscreen
+END PROC mp bap zeichensatz;
+PROC mp bap fehlerzeichen:
+  fehlerzeichen veraendern;
+  regenerate menuscreen
+END PROC mp bap fehlerzeichen;
+PROC mp bap tastenbelegung:
+  tastaturbelegung einstellen;
+  regenerate menuscreen
+END PROC mp bap tastenbelegung;
+PROC mp bap anzahl arbeitsphasen:
+  anzahl der arbeitsphasen festlegen;
+  regenerate menuscreen
+END PROC mp bap anzahl arbeitsphasen;
+
+PROC mp bap dauer einer arbeitsphase:
+  dauer einer arbeitsphase festlegen;
+  regenerate menuscreen
+END PROC mp bap dauer einer arbeitsphase;
+PROC mp bap pausendauer:
+  pausendauer festlegen;
+  regenerate menuscreen
+END PROC mp bap pausendauer;
+PROC mp bap wertungsschluessel:
+  wertungsschluessel veraendern;
+  regenerate menuscreen
+END PROC mp bap wertungsschluessel;
+PROC aktuellen parameterzustand anzeigen:
+  zeige die fenster;
+  fuelle die fenster mit inhalt;
+  gib hinweis aus.
+
+  zeige die fenster:
+    w1 := window ( 2,  2, 37, 20);
+    w2 := window (41,  2, 38, 20);
+    w3 := window ( 1,  1, 79, 24);
+    page; show (w1); show (w2).
+  fuelle die fenster mit inhalt:
+    zeige inhalt fenster 1;
+    zeige inhalt fenster 2.
+  zeige inhalt fenster 1:
+    zeige eingestellte parameter an (w1).
+  zeige inhalt fenster 2:
+    gib bewertungsschluessel aus (w2).
+  gib hinweis aus:
+    out footnote (w3, anwendungstext (2)); pause.
+END PROC aktuellen parameterzustand anzeigen;
+
+PROC zeige eingestellte parameter an (WINDOW VAR w):
+  zeige ueberschrift;
+  zeige werkstueckdefinition;
+  zeige tastenbelegung;
+  zeige simulationszeiten.
+  zeige ueberschrift:
+    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 1)))).
+  zeige werkstueckdefinition:
+    cursor (w, 2,  3); out (w, anwendungstext ( 6));
+                       out (w, text (aktuelle werkstueckbreite, 3));
+                       out (w, anwendungstext (28));
+    cursor (w, 2,  4); out (w, anwendungstext ( 7));
+
+                       out (w, text (aktuelle werkstueckhoehe,  3));
+                       out (w, anwendungstext (28));
+    cursor (w, 2,  5); out (w, anwendungstext ( 8));
+                        IF inversdarstellung
+                           THEN out (w, anwendungstext (29))
+                           ELSE out (w, anwendungstext (30))
+                        FI;
+    cursor (w, 2,  6); out (w, anwendungstext ( 9));
+                       out (w, zeichensatz);
+    cursor (w, 2,  7); out (w, anwendungstext (10));
+
+                       out (blank + aktuelles fehlerzeichen).
+  zeige tastenbelegung:
+    cursor (w, 2,  9); out (w, anwendungstext (11));
+                       out (w, tastenbezeichnung (nach rechts));
+    cursor (w, 2, 10); out (w, anwendungstext (12));
+                       out (w, tastenbezeichnung (nach links));
+    cursor (w, 2, 11); out (w, anwendungstext (13));
+                       out (w, tastenbezeichnung (nach oben));
+    cursor (w, 2, 12); out (w, anwendungstext (14));
+                       out (w, tastenbezeichnung (nach unten));
+
+    cursor (w, 2, 13); out (w, anwendungstext (15));
+                       out (w, tastenbezeichnung (ausbesserung));
+    cursor (w, 2, 14); out (w, anwendungstext (16));
+                       out (w, tastenbezeichnung (naechstes)).
+  zeige simulationszeiten:
+    cursor (w, 2, 16); out (w, anwendungstext (17));
+                       out (w, text (aktuelle anzahl der arbeitsphasen, 4));
+    cursor (w, 2, 17); out (w, anwendungstext (18));
+                       out (w, text (aktuelle arbeitsphasendauer in minuten, 4));
+
+                       out (w, anwendungstext (51));
+    cursor (w, 2, 18); out (w, anwendungstext (19));
+                       out (w, text (aktuelle pausendauer in minuten, 4));
+                       out (w, anwendungstext (51));
+    cursor (w, 2, 20); out (w, anwendungstext ( 5));
+                       out (w, gesamtdauerangabe).
+  zeichensatz:
+    blank + code (kleinster aktueller zeichencode) + "..." +
+            code (groesster aktueller zeichencode) + " ("  +
+            text (groesster aktueller zeichencode
+
+                   - kleinster aktueller zeichencode + 1, 2) +
+            anwendungstext (28) + ")".
+  gesamtdauerangabe:
+    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).
+  arbeitsdauer:
+      aktuelle anzahl der arbeitsphasen
+    * aktuelle arbeitsphasendauer in minuten.
+  pausendauer:
+      (aktuelle anzahl der arbeitsphasen - 1)
+    * aktuelle pausendauer in minuten.
+END PROC zeige eingestellte parameter an;
+PROC gib bewertungsschluessel aus (WINDOW VAR w):
+  zeichne koordinatenkreuz;
+
+  trage messwerte ein.
+  zeichne koordinatenkreuz:
+    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 4))));
+    cursor (w, 2,  3); out (w, anwendungstext (20));
+    cursor (w, 2,  4); out (w, anwendungstext (21));
+    cursor (w, 2,  6); out (w, anwendungstext (23));
+    cursor (w, 2,  7); out (w, anwendungstext (22));
+    cursor (w, 2,  8); out (w, anwendungstext (22));
+    cursor (w, 2,  9); out (w, anwendungstext (22));
+    cursor (w, 2, 10); out (w, anwendungstext (22));
+
+    cursor (w, 2, 11); out (w, anwendungstext (24));
+    cursor (w, 2, 12); out (w, anwendungstext (22));
+    cursor (w, 2, 13); out (w, anwendungstext (22));
+    cursor (w, 2, 14); out (w, anwendungstext (22));
+    cursor (w, 2, 15); out (w, anwendungstext (22));
+    cursor (w, 2, 16); out (w, anwendungstext (25));
+    cursor (w, 2, 17); out (w, anwendungstext (26));
+    cursor (w, 2, 19); out (w, anwendungstext (27)).
+  trage messwerte ein:
+    INT CONST abszisse :: 16, ordinate :: 2;
+
+    INT VAR nr;
+    FOR nr FROM 1 UPTO 11 REP
+      zeichne einen punkt
+    PER.
+  zeichne einen punkt:
+    cursor (w, ordinate + 3 * nr, abszisse - nachkommastelle); out (punkt).
+  nachkommastelle:
+    int(bewertung [nr] * 10.0).
+END PROC gib bewertungsschluessel aus;
+PROC standardwerte einstellen:
+  zeige fenster;
+  zeige eingestellte parameter an (w1);
+  gib information aus;
+  hole bestaetigung ein.
+  zeige fenster:
+    w1 := window ( 2,  2, 37, 20);
+    w2 := window (41, 10, 37, 12);
+
+    w3 := window (41,  2, 37,  6);
+    page; show (w1); show (w2); show (w3).
+  gib information aus:
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3); out (w2, anwendungstext (67));
+    cursor (w2, 2, 4); out (w2, anwendungstext (68));
+    cursor (w2, 2, 7); out (w2, anwendungstext (69));
+    cursor (w2, 2, 9); out (w2, anwendungstext (70));
+    cursor (w2, 2,10); out (w2, anwendungstext (71));
+    cursor (w2, 2,11); out (w2, anwendungstext (72));
+
+    cursor (w2, 2,12); out (w2, anwendungstext (73)).
+  hole bestaetigung ein:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (66))));
+    cursor (w3, 2, 3);
+    IF yes (w3, anwendungstext (66))
+       THEN stdvoreinstellung der parameter;
+            gib positive rueckmeldung
+    FI.
+  gib positive rueckmeldung:
+    page (w1);
+    zeige eingestellte parameter an (w1);
+    cleop  (w3, 2, 3); out (anwendungstext (221));
+    cursor (w3, 2, 5); out (anwendungstext (  3));
+
+    pause.
+END PROC standardwerte einstellen;
+PROC breite des werkstuecks einstellen:
+  zeige die fenster;
+  hinweise an den benutzer ausgeben;
+  werkstueck zeigen (w3);
+  erfrage veraenderung;
+  REP
+    neuen wert vom bildschirm holen
+  UNTIL benutzer ist einverstanden PER.
+  zeige die fenster:
+    w1 := window ( 2, 2, 26, 6);
+    w2 := window (30, 2, 48, 6);
+    w3 := window (2, 9, 77, 16);
+    page; show (w1); show (w2).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));
+                       out (w1, text (kleinster wert, 3));
+    cursor (w1, 2, 4); out (w1, anwendungstext (54));
+                       out (w1, text (maxspalten,     3));
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));
+                       out (w1, text (aktuelle werkstueckbreite, 3)).
+  erfrage veraenderung:
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (57))));
+    cursor (w2, 2, 3);
+    IF no (anwendungstext (216))
+
+       THEN LEAVE breite des werkstuecks einstellen
+    FI.
+  neuen wert vom bildschirm holen:
+    cleop  (w2, 2, 3); out (w2, anwendungstext (58));
+    cursor (w2, 2, 4); out (w2, anwendungstext (59));
+    cursor (w2, 2, 6); out (w2, anwendungstext (60));
+    aktuelle werkstueckbreite := ermittelter wert (1, maxspalten,
+                                                aktuelle werkstueckbreite).
+  benutzer ist einverstanden :
+    gib aktuelle infos aus;
+    hole bestaetigung.
+  gib aktuelle infos aus:
+
+    hinweise an den benutzer ausgeben;
+    werkstueck zeigen (w3);
+    cleop (w2, 1, 3).
+  hole bestaetigung:
+    cursor (w2, 2, 3);
+    IF yes (w2, anwendungstext (62))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC breite des werkstuecks einstellen;
+PROC hoehe des werkstuecks einstellen:
+  fenster zeigen;
+  hinweise an den benutzer ausgeben;
+  werkstueck zeigen (w3);
+  erfrage veraenderung;
+  REP
+    neuen wert vom bildschirm holen
+  UNTIL benutzer ist einverstanden PER.
+
+  fenster zeigen:
+    w1 := window ( 2, 2, 26, 6);
+    w2 := window (30, 2, 48, 6);
+    w3 := window (2, 9, 77, 16);
+    page; show (w1); show (w2).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));
+                       out (w1, text (kleinster wert, 3));
+    cursor (w1, 2, 4); out (w1, anwendungstext (54));
+                       out (w1, text (maxzeilen,      3));
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));
+
+                       out (w1, text (aktuelle werkstueckhoehe, 3)).
+  erfrage veraenderung:
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (63))));
+    cursor (w2, 2, 3);
+    IF no (anwendungstext (217))
+       THEN LEAVE hoehe des werkstuecks einstellen
+    FI.
+  neuen wert vom bildschirm holen:
+    cleop  (w2, 2, 3); out (w2, anwendungstext (58));
+    cursor (w2, 2, 4); out (w2, anwendungstext (59));
+    cursor (w2, 2, 6); out (w2, anwendungstext (64));
+    aktuelle werkstueckhoehe := ermittelter wert (1, maxzeilen,
+
+                                                  aktuelle werkstueckhoehe).
+  benutzer ist einverstanden :
+    gib aktuelle infos aus;
+    hole bestaetigung.
+  gib aktuelle infos aus:
+    hinweise an den benutzer ausgeben;
+    werkstueck zeigen (w3);
+    cleop (w2, 1, 3).
+  hole bestaetigung:
+    cursor (w2, 2, 3);
+    IF yes (w2, anwendungstext (65))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC hoehe des werkstuecks einstellen;
+PROC werkstueckdarstellung einstellen:
+  fenster zeigen;
+
+  hinweise an den benutzer ausgeben;
+  werkstueck zeigen (w3);
+  REP
+    bestaetigung einholen;
+    hinweise an den benutzer ausgeben;
+    werkstueck zeigen (w3)
+  UNTIL benutzer ist einverstanden PER.
+  fenster zeigen:
+    w1 := window ( 2,  2, 28,  6);
+    w2 := window (32,  2, 46,  6);
+    w3 := window ( 2,  9, 77, 16);
+    page; show (w1); show (w2).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+    cursor (w1, 2, 3); out (w1, anwendungstext (74));
+
+                       out (w1, anwendungstext (76));
+    cursor (w1, 2, 4); out (w1, anwendungstext (74));
+                       out (w1, anwendungstext (77));
+    cursor (w1, 2, 6); out (w1, anwendungstext (75));
+                       IF inversdarstellung
+                          THEN out (w1, anwendungstext (77))
+                          ELSE out (w1, anwendungstext (76))
+                       FI.
+  bestaetigung einholen:
+    page (w2);
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (89))));
+
+    cursor (w2, 2, 3);
+    IF yes (w2, anwendungstext (78))
+       THEN veraendere darstellungsart
+       ELSE LEAVE werkstueckdarstellung einstellen
+    FI.
+  veraendere darstellungsart:
+    IF inversdarstellung
+       THEN inversdarstellung := FALSE
+       ELSE inversdarstellung := TRUE
+    FI.
+  benutzer ist einverstanden:
+    cleop (w2, 1, 3);
+    cursor (w2, 2, 3);
+    IF yes (w2, anwendungstext (99))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC werkstueckdarstellung einstellen;
+
+PROC zeichensatz einstellen:
+  zeige fenster;
+  gib eingestellten zeichensatz an;
+  gib bedienhinweise aus;
+  erfrage neueinstellung;
+  REP
+    erfrage das neue fehlerzeichen;
+    ermittle das kleinste zeichen;
+    ermittle das groesste zeichen;
+    page (w1);
+    gib eingestellten zeichensatz an
+  UNTIL benutzer ist einverstanden PER.
+  zeige fenster:
+    w1 := window ( 2,  2, 28, 22);
+    w2 := window (32, 10, 46, 14);
+    w3 := window (32,  2, 46,  6);
+    page; show (w1); show (w2); show (w3).
+
+  gib eingestellten zeichensatz an:
+    cursor (w1, 1, 1);
+    out (w1, center (w1, invers (anwendungstext (79))));
+    gib zeichenkette aus (w1, kleinster aktueller zeichencode,
+                              groesster aktueller zeichencode,
+                              code (aktuelles fehlerzeichen)).
+  gib bedienhinweise aus:
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3); out (w2, anwendungstext (80));
+    cursor (w2, 2, 4); out (w2, anwendungstext (81));
+
+    cursor (w2, 2, 5); out (w2, anwendungstext (82));
+    cursor (w2, 2, 6); out (w2, anwendungstext (83));
+    cursor (w2, 2, 8); out (w2, anwendungstext (84));
+    cursor (w2, 2, 9); out (w2, anwendungstext (85));
+    cursor (w2, 2,10); out (w2, anwendungstext (86));
+    cursor (w2, 2,12); out (w2, anwendungstext (87));
+    cursor (w2, 2,13); out (w2, anwendungstext (88)).
+  erfrage neueinstellung:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (90))));
+    cursor (w3, 2, 3);
+
+    IF no (w3, anwendungstext (91))
+       THEN LEAVE zeichensatz einstellen
+    FI.
+  erfrage das neue fehlerzeichen:
+    gib vollstaendigen zeichensatz aus;
+    gib fehlerzeicheninformationen aus;
+    REP
+      lasse fehlerzeichen eingeben
+    UNTIL fehlerzeichen ist ok PER.
+  gib vollstaendigen zeichensatz aus:
+    page (w1); page (w2); page (w3);
+    cursor (w1, 1, 1);
+    out (w1, center (w1, invers (anwendungstext (92))));
+    gib zeichenkette aus (w1, 33, 126, 0).
+  gib fehlerzeicheninformationen aus:
+
+    cursor (w2, 1, 1);
+    out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3);  out (w2, anwendungstext (95));
+    cursor (w2, 2, 4);  out (w2, anwendungstext (96));
+    cursor (w2, 2, 6);  out (w2, anwendungstext (97)).
+  lasse fehlerzeichen eingeben:
+    cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (100))));
+    cursor (w3, 2, 3);
+    out (w3, anwendungstext (101));
+    cursor on; inchar (aktuelles fehlerzeichen); cursor off;
+    IF fehlerzeichen ist ok
+
+       THEN out (w3, aktuelles fehlerzeichen);
+            markiere das fehlerzeichen im ersten fenster;
+       ELSE lege beschwerde ein
+    FI.
+  fehlerzeichen ist ok:
+        code (aktuelles fehlerzeichen) >=  33
+    AND code (aktuelles fehlerzeichen) <= 126.
+  markiere das fehlerzeichen im ersten fenster:
+    positioniere cursor in zeichenkette (w1, 33, code (aktuelles fehlerzeichen));
+    out (w1, invers (aktuelles fehlerzeichen)).
+  lege beschwerde ein:
+    piepse;
+    cursor (w2, 2, 8); out (w2, anwendungstext (102));
+
+    cursor (w2, 2,10); out (w2, anwendungstext (103));
+    cursor (w2, 2,11); out (w2, anwendungstext (104));
+    cursor (w2, 2,12); out (w2, anwendungstext (105));
+    cursor (w2, 2,13); out (w2, anwendungstext (106));
+    cursor (w2, 2,14); out (w2, anwendungstext (107)).
+  ermittle das kleinste zeichen:
+    page (w2); page (w3);
+    gib kleinste zeichencode informationen aus;
+    lasse den vorbereich festlegen.
+  ermittle das groesste zeichen:
+    lasse den nachbereich festlegen.
+  gib kleinste zeichencode informationen aus:
+
+    cursor (w2, 1, 1);
+    out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3); out (w2, anwendungstext (111));
+    cursor (w2, 2, 4); out (w2, anwendungstext (112));
+    cursor (w2, 2, 5); out (w2, anwendungstext (113));
+    cursor (w2, 2, 6); out (w2, anwendungstext (114));
+    cursor (w2, 2, 8); out (w2, anwendungstext (115));
+    cursor (w2, 2, 9); out (w2, anwendungstext (116));
+    cursor (w2, 2,10); out (w2, anwendungstext (117));
+    cursor (w2, 2,11); out (w2, anwendungstext (118));
+
+    cursor (w2, 2,13); out (w2, anwendungstext (119));
+    cursor (w2, 2,14); out (w2, anwendungstext (120)).
+  lasse den vorbereich festlegen:
+    INT VAR s, z; page (w3); cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (121))));
+    cursor (w3, 2, 3); out (w3, anwendungstext (122));
+    cursor (w3, 2, 4); out (w3, anwendungstext (123));
+    cursor (w3, 2, 5); out (w3, anwendungstext (125));
+    get cursor (s, z); cursor on;
+    kleinster aktueller zeichencode := code (aktuelles fehlerzeichen);
+
+    groesster aktueller zeichencode := code (aktuelles fehlerzeichen);
+    kleinster aktueller zeichencode := eingabe mit intervallanzeige ( w1, 33,
+                                       code (aktuelles fehlerzeichen),
+                                       kleinster aktueller zeichencode, s, z);
+    cursor off.
+  lasse den nachbereich festlegen:
+    cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (121))));
+    cursor (w3, 2, 3); out (w3, anwendungstext (122));
+    cursor (w3, 2, 4); out (w3, anwendungstext (124));
+
+    cursor (w3, 2, 5); out (w3, anwendungstext (125));
+    get cursor (s, z); cursor on;
+    groesster aktueller zeichencode := eingabe mit intervallanzeige ( w1,
+                                       code (aktuelles fehlerzeichen), 126,
+                                       groesster aktueller zeichencode, s, z);
+    cursor off.
+  benutzer ist einverstanden:
+    page (w3); cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (90))));
+    cursor (w3, 2, 3);
+    IF yes (w3, anwendungstext (126))
+
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC zeichensatz einstellen;
+PROC fehlerzeichen veraendern:
+  fenster zeigen;
+  gib eingestellten zeichensatz an;
+  gib bedienhinweise aus;
+  erfrage neueinstellung;
+  REP
+    lasse fehlerzeichen einstellen
+  UNTIL benutzer ist einverstanden PER.
+  fenster zeigen:
+    w1 := window ( 2,  2, 28, 22);
+    w2 := window (32, 10, 46, 14);
+    w3 := window (32,  2, 46,  6);
+    page; show (w1); show (w2); show (w3).
+  gib eingestellten zeichensatz an:
+
+    cursor (w1, 1, 1);
+    out (w1, center (w1, invers (anwendungstext (79))));
+    gib zeichenkette aus (w1, kleinster aktueller zeichencode,
+                              groesster aktueller zeichencode,
+                              code (aktuelles fehlerzeichen)).
+  gib bedienhinweise aus:
+    cursor (w2, 1, 1);
+    out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3); out (w2, anwendungstext (131));
+    cursor (w2, 2, 4); out (w2, anwendungstext (132));
+    cursor (w2, 2, 5); out (w2, anwendungstext (133));
+
+    cursor (w2, 2, 7); out (w2, anwendungstext (134));
+    cursor (w2, 2, 8); out (w2, anwendungstext (135));
+    cursor (w2, 2, 9); out (w2, anwendungstext (136)).
+  erfrage neueinstellung:
+    cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (130))));
+    cursor (w3, 2, 3);
+    IF no (w3, anwendungstext (137))
+       THEN LEAVE fehlerzeichen veraendern
+    FI.
+  lasse fehlerzeichen einstellen:
+    INT VAR s, z, fehlercode :: code (aktuelles fehlerzeichen);
+    page (w3); cursor (w3, 1, 1);
+
+    out (w3, center (w3, invers (anwendungstext (138))));
+    cursor (w3, 2, 3); out (w3, anwendungstext (139));
+    cursor (w3, 2, 4); out (w3, anwendungstext (140));
+    cursor (w3, 2, 5); out (w3, anwendungstext (141));
+    get cursor (s, z); cursor on;
+    fehlercode := eingabe mit elementanzeige (w1,
+                                              kleinster aktueller zeichencode,
+                                              groesster aktueller zeichencode,
+                                              fehlercode, s, z);
+
+    cursor off;
+    aktuelles fehlerzeichen := code (fehlercode).
+  benutzer ist einverstanden:
+    page (w3); cursor (w3, 1, 1);
+    out (w3, center (w3, invers (anwendungstext (130))));
+    cursor (w3, 2, 3);
+    IF yes (w3, anwendungstext (142))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC fehlerzeichen veraendern;
+PROC tastaturbelegung einstellen:
+  ROW 6 TEXT VAR tastenname, taste;
+  fenster zeigen;
+  REP
+    tastaturneubelegung vornehmen
+  UNTIL benutzer ist einverstanden PER.
+
+  fenster zeigen:
+    w1 := window ( 2,  2, 28, 10);
+    w2 := window ( 2, 14, 28, 10);
+    w3 := window (32, 10, 46, 14);
+    w4 := window (32,  2, 46,  6);
+    page; show (w1); show (w2); show (w3); show (w4).
+  tastaturneubelegung vornehmen:
+    alte tastenbelegung einlesen;
+    tastenbelegung anzeigen;
+    bedienhinweise ausgeben;
+    veraenderung erfragen;
+    neue tastenbelegung erfragen;
+    hinweis zur bewertung und stand ausgeben.
+  alte tastenbelegung einlesen:
+    INT VAR z1;
+
+    FOR z1 FROM 1 UPTO 6 REP
+      tastenname [z1] := anwendungstext (z1 + 10)
+    PER;
+    taste [1] := nach rechts;
+    taste [2] := nach links;
+    taste [3] := nach oben;
+    taste [4] := nach unten;
+    taste [5] := ausbesserung;
+    taste [6] := naechstes;
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (151)))).
+  tastenbelegung anzeigen:
+    INT VAR cspa, czei;
+    cursor (w1, 2, 3); out (w1, tastenname [1]);
+                       out (w1, tastenbezeichnung (taste [1]));
+
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);
+    cursor (w1, 2, 4); out (w1, tastenname [2]);
+                       out (w1, tastenbezeichnung (taste [2]));
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);
+    cursor (w1, 2, 5); out (w1, tastenname [3]);
+                       out (w1, tastenbezeichnung (taste [3]));
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);
+    cursor (w1, 2, 6); out (w1, tastenname [4]);
+
+                       out (w1, tastenbezeichnung (taste [4]));
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);
+    cursor (w1, 2, 8); out (w1, tastenname [5]);
+                       out (w1, tastenbezeichnung (taste [5]));
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);
+    cursor (w1, 2,10); out (w1, tastenname [6]);
+                       out (w1, tastenbezeichnung (taste [6]));
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei).
+
+  bedienhinweise ausgeben:
+    cursor (w2, 1, 1); out (center (w2, invers (anwendungstext (152))));
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (52))));
+    cursor (w3, 2, 3); out (w3, anwendungstext (153));
+    cursor (w3, 2, 4); out (w3, anwendungstext (154));
+    cursor (w3, 2, 6); out (w3, anwendungstext (155));
+    cursor (w3, 2, 7); out (w3, anwendungstext (156));
+    cursor (w3, 2, 8); out (w3, anwendungstext (157));
+    cursor (w3, 2, 9); out (w3, anwendungstext (158));
+
+    cursor (w3, 2,11); out (w3, anwendungstext (159));
+    cursor (w3, 2,12); out (w3, anwendungstext (160));
+    cursor (w3, 2,13); out (w3, anwendungstext (161));
+    cursor (w3, 2,14); out (w3, anwendungstext (162)).
+  veraenderung erfragen:
+    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));
+    cursor (w4, 2, 3);
+    IF no (w4, anwendungstext (164))
+       THEN LEAVE tastaturbelegung einstellen
+    FI.
+  neue tastenbelegung erfragen:
+    INT VAR z2; page (w4);
+
+    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));
+    cursor (w4, 2, 3); out (w4, anwendungstext (165));
+    FOR z2 FROM 1 UPTO 6 REP
+      gib tastenhinweis;
+      hole tastatureingabe;
+      tastenbelegung anzeigen
+    PER.
+  gib tastenhinweis:
+    cleol (w4, 2, 5); out (w4, tastenname [z2]).
+  hole tastatureingabe:
+    INT VAR s, z; get cursor (w4, s, z);
+    cursor on; inchar (taste [z2]); cursor off;
+    cursor (w4, s, z); out (w4, tastenbezeichnung (taste [z2])).
+
+  hinweis zur bewertung und stand ausgeben:
+    IF neue tastenbelegung ist ok
+       THEN akzeptiere
+       ELSE akzeptiere nicht
+    FI.
+  neue tastenbelegung ist ok:
+    INT VAR zeiger; TEXT VAR tastenkette :: "";
+    FOR zeiger FROM 1 UPTO 6 REP
+      IF pos (tastenkette, taste [zeiger]) > 0
+         THEN LEAVE neue tastenbelegung ist ok WITH FALSE
+         ELSE tastenkette CAT taste [zeiger]
+      FI
+    PER;
+    TRUE.
+  akzeptiere:
+    cursor (w2, 3, 4);
+    out (w2, anwendungstext (166));
+
+    cursor (w2, 7, 6);
+    out (w2, anwendungstext (167)).
+  akzeptiere nicht:
+    cursor (w2, 3, 3); out (w2, anwendungstext (168));
+    cursor (w2, 3, 4); out (w2, anwendungstext (169));
+    cursor (w2, 3, 6); out (w2, anwendungstext (170));
+    cursor (w2, 3, 7); out (w2, anwendungstext (171));
+    cursor (w2, 3, 9); out (w2, anwendungstext (172));
+    cursor (w2, 5,10); out (w2, anwendungstext (173)).
+  benutzer ist einverstanden:
+    page (w4);
+    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));
+
+    IF neue tastenbelegung ist ok
+       THEN gib hinweis auf abspeicherung
+       ELSE frage nach neueingabe
+    FI.
+  gib hinweis auf abspeicherung:
+    cursor (w4, 3, 3); out (w4, anwendungstext (174));
+    neue tastenbelegung festschreiben;
+    cursor (w4, 3, 5); out (w4, anwendungstext (  2));
+    cursor on; pause; cursor off;
+    TRUE.
+  neue tastenbelegung festschreiben:
+    nach rechts   := taste [1];
+    nach links    := taste [2];
+    nach oben     := taste [3];
+    nach unten    := taste [4];
+
+    ausbesserung  := taste [5];
+    naechstes     := taste [6].
+  frage nach neueingabe:
+    cursor (w4, 2, 3);
+    IF yes (w4, anwendungstext (175))
+       THEN cleop (w2, 1, 3); FALSE
+       ELSE alte tastenbelegung einlesen;
+            tastenbelegung anzeigen;
+            cleop  (w4, 2, 3); out (w4, anwendungstext (176));
+            cursor (w4, 3, 5); out (w4, anwendungstext (  2));
+            cursor on; pause; cursor off;
+            TRUE
+    FI.
+END PROC tastaturbelegung einstellen;
+
+PROC simulationszeiten anzeigen (WINDOW VAR w):
+  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (181))));
+  cursor (w, 2, 3); out (w, anwendungstext (17));
+                    out (w, text (aktuelle anzahl der arbeitsphasen, 4));
+  cursor (w, 2, 4); out (w, anwendungstext (18));
+                    out (w, text (aktuelle arbeitsphasendauer in minuten, 4));
+                    out (w, anwendungstext (51));
+  cursor (w, 2, 5); out (w, anwendungstext (19));
+                    out (w, text (aktuelle pausendauer in minuten, 4));
+
+                    out (w, anwendungstext (51));
+  cursor (w, 2, 7); out (w, anwendungstext ( 5));
+                       out (w, gesamtdauerangabe).
+  gesamtdauerangabe:
+    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).
+  arbeitsdauer:
+      aktuelle anzahl der arbeitsphasen
+    * aktuelle arbeitsphasendauer in minuten.
+  pausendauer:
+      (aktuelle anzahl der arbeitsphasen - 1)
+    * aktuelle pausendauer in minuten.
+END PROC simulationszeiten anzeigen;
+PROC anzahl der arbeitsphasen festlegen:
+
+  INT CONST minwert :: 2, maxwert :: 20;
+  zeige fenster;
+    hinweise an den benutzer ausgeben;
+    simulationszeiten anzeigen (w2);
+    erfrage veraenderung;
+  REP
+    neuen wert vom bildschirm holen
+  UNTIL benutzer ist einverstanden PER.
+  zeige fenster:
+    w1 := window ( 2,  2, 28,  6);
+    w2 := window (22, 12, 37,  7);
+    w3 := window (32,  2, 47,  6);
+    page; show (w1); show (w2); show (w3).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));
+                       out (w1, text (minwert, 2));
+    cursor (w1, 2, 4); out (w1, anwendungstext (54));
+                       out (w1, text (maxwert, 2));
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));
+                       out (w1, text (aktuelle anzahl der arbeitsphasen, 2)).
+  erfrage veraenderung:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (182))));
+    cursor (w3, 2, 3);
+    IF no (anwendungstext (218))
+
+       THEN LEAVE anzahl der arbeitsphasen festlegen
+    FI.
+  neuen wert vom bildschirm holen:
+    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));
+    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));
+    cursor (w3, 2, 6); out (w3, anwendungstext (183));
+    aktuelle anzahl der arbeitsphasen := ermittelter wert (minwert, maxwert,
+                                         aktuelle anzahl der arbeitsphasen).
+  benutzer ist einverstanden:
+    hinweise an den benutzer ausgeben;
+    simulationszeiten anzeigen (w2);
+
+    cleop (w3, 2, 3);
+    IF yes (w3, anwendungstext (184))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC anzahl der arbeitsphasen festlegen;
+PROC dauer einer arbeitsphase festlegen:
+  INT CONST minwert :: 1, maxwert :: 60;
+  zeige fenster;
+  hinweise an den benutzer ausgeben;
+  simulationszeiten anzeigen (w2);
+  erfrage veraenderung;
+  REP
+    neuen wert vom bildschirm holen
+  UNTIL benutzer ist einverstanden PER.
+  zeige fenster:
+    w1 := window ( 2,  2, 28,  6);
+    w2 := window (22, 12, 37,  7);
+
+    w3 := window (32,  2, 47,  6);
+    page; show (w1); show (w2); show (w3).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));
+                       out (w1, text (minwert, 2));
+                       out (w1, anwendungstext (51));
+    cursor (w1, 2, 4); out (w1, anwendungstext (54));
+                       out (w1, text (maxwert, 2));
+                       out (w1, anwendungstext (51));
+
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));
+                       out (w1, text (aktuelle arbeitsphasendauer in minuten, 2));
+                       out (w1, anwendungstext (51)).
+  erfrage veraenderung:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (187))));
+    cursor (w3, 2, 3);
+    IF no (anwendungstext (219))
+       THEN LEAVE dauer einer arbeitsphase festlegen
+    FI.
+  neuen wert vom bildschirm holen:
+    INT VAR spa, zei;
+    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));
+
+    cursor (w3, 2, 3); out (w3, anwendungstext ( 58));
+    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));
+    cursor (w3, 2, 6); out (w3, anwendungstext (188));
+    get cursor (w3, spa, zei);
+    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));
+    cursor (w3, spa, zei);
+    aktuelle arbeitsphasendauer in minuten
+                               := ermittelter wert (minwert, maxwert,
+                                  aktuelle arbeitsphasendauer in minuten).
+  benutzer ist einverstanden:
+
+    hinweise an den benutzer ausgeben;
+    simulationszeiten anzeigen (w2);
+    cleop (w3, 2, 3);
+    IF yes (w3, anwendungstext (189))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC dauer einer arbeitsphase festlegen;
+PROC pausendauer festlegen:
+  INT CONST minwert :: 1, maxwert :: 30;
+  zeige fenster;
+  hinweise an den benutzer ausgeben;
+  simulationszeiten anzeigen (w2);
+  erfrage veraenderung;
+  REP
+    neuen wert vom bildschirm holen
+  UNTIL benutzer ist einverstanden PER.
+
+  zeige fenster:
+    w1 := window ( 2,  2, 28,  6);
+    w2 := window (22, 12, 37,  7);
+    w3 := window (32,  2, 47,  6);
+    page; show (w1); show (w2); show (w3).
+  hinweise an den benutzer ausgeben:
+    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));
+                       out (w1, text (minwert, 2));
+                       out (w1, anwendungstext (51));
+    cursor (w1, 2, 4); out (w1, anwendungstext (54));
+
+                       out (w1, text (maxwert, 2));
+                       out (w1, anwendungstext (51));
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));
+                       out (w1, text (aktuelle pausendauer in minuten, 2));
+                       out (w1, anwendungstext (51)).
+  erfrage veraenderung:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (191))));
+    cursor (w3, 2, 3);
+    IF no (anwendungstext (220))
+       THEN LEAVE pausendauer festlegen
+    FI.
+
+  neuen wert vom bildschirm holen:
+    INT VAR spa, zei;
+    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));
+    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));
+    cursor (w3, 2, 6); out (w3, anwendungstext (192));
+    get cursor (w3, spa, zei);
+    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));
+    cursor (w3, spa, zei);
+    aktuelle pausendauer in minuten
+                               := ermittelter wert (minwert, maxwert,
+                                          aktuelle pausendauer in minuten).
+
+  benutzer ist einverstanden:
+    hinweise an den benutzer ausgeben;
+    simulationszeiten anzeigen (w2);
+    cleop (w3, 2, 3);
+    IF yes (w3, anwendungstext (193))
+       THEN TRUE
+       ELSE FALSE
+    FI.
+END PROC pausendauer festlegen;
+PROC wertungsschluessel veraendern:
+  INT CONST abszisse :: 16, ordinate :: 2;
+  zeige fenster;
+  gib bewertungsschluessel aus (w1);
+  gib informationen aus;
+  stelle frage nach veraenderung;
+  REP
+    neueinstellung
+  UNTIL benutzer ist einverstanden PER.
+
+  zeige fenster:
+    w1 := window ( 2,  2, 38, 22);
+    w2 := window (42, 10, 37, 14);
+    w3 := window (42,  2, 37,  6);
+    page; show (w1); show (w2); show (w3).
+  gib informationen aus:
+    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));
+    cursor (w2, 2, 3); out (w2, anwendungstext (195));
+    cursor (w2, 2, 4); out (w2, anwendungstext (196));
+    cursor (w2, 2, 6); out (w2, anwendungstext (197));
+    cursor (w2, 2, 7); out (w2, anwendungstext (198));
+    cursor (w2, 2, 8); out (w2, anwendungstext (199));
+
+    cursor (w2, 2,11); out (w2, anwendungstext (200));
+    cursor (w2, 2,12); out (w2, anwendungstext (201));
+    cursor (w2, 2,13); out (w2, anwendungstext (202)).
+  stelle frage nach veraenderung:
+    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (205))));
+    cursor (w3, 2, 3);
+    IF no (anwendungstext (206))
+       THEN LEAVE wertungsschluessel veraendern
+       ELSE gib hinweis auf linkes fenster
+    FI.
+  gib hinweis auf linkes fenster:
+    cleop  (w3, 2, 3); out (w3, anwendungstext (211));
+
+    cursor (w3, 2, 4); out (w3, anwendungstext (212));
+    cursor (w3, 2, 5); out (w3, anwendungstext (213)).
+  neueinstellung:
+    INT VAR zeiger;
+    cursor an;
+    FOR zeiger FROM 1 UPTO 11 REP
+      gehe auf aktuelle punktposition;
+      lasse verschieben
+    PER;
+    cursor aus.
+  gehe auf aktuelle punktposition:
+    cursor (w1, ordinate + 3 * zeiger, abszisse - nachkommastelle).
+  nachkommastelle:
+    int (bewertung [zeiger] * 10.0).
+  lasse verschieben:
+    TEXT VAR eingabezeichen; INT VAR position;
+
+    REP
+      inchar (eingabezeichen);
+      position := pos (oben unten return, eingabezeichen);
+      fuehre angemessene reaktion aus
+    UNTIL position = 3 PER.
+  fuehre angemessene reaktion aus:
+    SELECT position OF
+      CASE 1: steige auf
+      CASE 2: steige ab
+      CASE 3: (* tue nichts *)
+      OTHERWISE piepse
+    END SELECT.
+  steige auf:
+    IF bewertung [zeiger] < 1.0
+       THEN loesche alten punkt;
+            bewertung [zeiger] INCR 0.1;
+            schreibe neuen punkt
+
+       ELSE piepse
+    FI.
+  steige ab:
+    IF bewertung [zeiger] > 0.0
+       THEN loesche alten punkt;
+            bewertung [zeiger] DECR 0.1;
+            schreibe neuen punkt
+       ELSE piepse
+    FI.
+  loesche alten punkt:
+    INT VAR tabspalte, tabzeile;
+    gehe auf aktuelle punktposition;
+    get cursor (w1, tabspalte, tabzeile);
+    IF tabspalte = ordinate + 3 OR tabzeile = abszisse
+       THEN out (w1, "|")
+       ELSE out (w1, blank)
+    FI.
+  schreibe neuen punkt:
+    gehe auf aktuelle punktposition;
+
+    out (w1, punkt und zurueck).
+  benutzer ist einverstanden:
+    cleop (w3, 2, 3);
+    IF yes (w3, anwendungstext (207))
+       THEN TRUE
+       ELSE gib hinweis auf linkes fenster;
+            FALSE
+    FI.
+END PROC wertungsschluessel veraendern;
+PROC cleol (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):
+  cursor (w, cursorspalte, cursorzeile);
+  IF remaining lines (w) > 1
+     THEN out (w, (areaxsize (w) - cursorspalte + 1) * blank)
+     ELSE out (w, (areaxsize (w) - cursorspalte) * blank)
+
+  FI;
+  cursor (w, cursorspalte, cursorzeile)
+END PROC cleol;
+PROC cleop (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):
+  cleol (w, cursorspalte, cursorzeile);
+  INT VAR i;
+  FOR i FROM 1 UPTO remaining lines (w) REP
+    cleol (w, 1, cursorzeile + i)
+  PER;
+  cursor  (w, cursorspalte, cursorzeile)
+END PROC cleop;
+PROC cursor an:
+  INT VAR spalte, zeile;
+  get cursor (spalte, zeile); cursor on; cursor (spalte, zeile)
+END PROC cursor an;
+PROC cursor aus:
+  INT VAR spalte, zeile;
+
+  get cursor (spalte, zeile); cursor off; cursor (spalte, zeile)
+END PROC cursor aus;
+INT PROC eingabe mit intervallanzeige (WINDOW VAR w, INT CONST minwert,
+                                       maxwert, anfangswert, cursorspalte,
+                                       cursorzeile):
+  BOOL VAR ist aufsteigend :: minwert = anfangswert;
+  INT  VAR aktueller wert  :: anfangswert, alter wert, eingelesener wert;
+  REP
+    hole position aus vorgabe (oben unten return, eingelesener wert);
+    SELECT eingelesener wert OF
+
+      CASE 1: erniedrige aktuellen wert wenn moeglich
+      CASE 2: erhoehe aktuellen wert wenn moeglich
+    END SELECT
+  UNTIL eingelesener wert = 3 PER;
+  aktueller wert.
+  erniedrige aktuellen wert wenn moeglich:
+    IF aktueller wert > minwert
+       THEN alter wert := aktueller wert;
+            aktueller wert DECR 1;
+            IF ist aufsteigend
+               THEN loesche alte markierung
+               ELSE markiere neues zeichen
+            FI
+       ELSE piepse
+    FI.
+  erhoehe aktuellen wert wenn moeglich:
+
+    IF aktueller wert < maxwert
+       THEN alter wert := aktueller wert;
+            aktueller wert INCR 1;
+            IF ist aufsteigend
+               THEN markiere neues zeichen
+               ELSE loesche alte markierung
+            FI
+       ELSE piepse
+    FI.
+  loesche alte markierung:
+    positioniere cursor in zeichenkette (w, 33, alter wert);
+    out (w, code (alter wert) + "  ");
+    cursor (cursorspalte, cursorzeile).
+  markiere neues zeichen:
+    positioniere cursor in zeichenkette (w, 33, aktueller wert);
+
+    out (w, invers (code (aktueller wert)));
+    cursor (cursorspalte, cursorzeile).
+END PROC eingabe mit intervallanzeige;
+INT PROC eingabe mit elementanzeige (WINDOW VAR w, INT CONST minwert,
+                                     maxwert, anfangswert,
+                                     cursorspalte, cursorzeile):
+  INT VAR aktueller wert :: anfangswert, alter wert, eingelesener wert;
+  REP
+    hole position aus vorgabe (oben unten return, eingelesener wert);
+    SELECT eingelesener wert OF
+
+      CASE 1: erniedrige aktuellen wert wenn moeglich
+      CASE 2: erhoehe aktuellen wert wenn moeglich
+    END SELECT
+  UNTIL eingelesener wert = 3 PER;
+  aktueller wert.
+  erniedrige aktuellen wert wenn moeglich:
+    IF aktueller wert > minwert
+       THEN alter wert := aktueller wert;
+            aktueller wert DECR 1;
+            loesche alte markierung;
+            markiere neues zeichen
+       ELSE piepse
+    FI.
+  erhoehe aktuellen wert wenn moeglich:
+    IF aktueller wert < maxwert
+
+       THEN alter wert := aktueller wert;
+            aktueller wert INCR 1;
+            loesche alte markierung;
+            markiere neues zeichen
+       ELSE piepse
+    FI.
+  loesche alte markierung:
+    positioniere cursor in zeichenkette (w, minwert, alter wert);
+    out (w, code (alter wert) + "  ");
+    cursor (cursorspalte, cursorzeile).
+  markiere neues zeichen:
+    positioniere cursor in zeichenkette (w, minwert, aktueller wert);
+    out (w, invers (code (aktueller wert)));
+
+    cursor (cursorspalte, cursorzeile).
+END PROC eingabe mit elementanzeige;
+PROC werkstueck zeigen (WINDOW VAR w):
+  INT VAR zaehler, spalte, zeile;
+  page (w);
+  werkstueckaufhaenger (spalte, zeile);
+  schreibe werkstueck zeilenweise.
+  schreibe werkstueck zeilenweise:
+    FOR zaehler FROM 1 UPTO aktuelle werkstueckhoehe REP
+      positioniere den cursor;
+      bastle eine zeile;
+      gib eine zeile aus
+    PER.
+  positioniere den cursor:
+    cursor (w, spalte,  zeile + zaehler - 1).
+
+  bastle eine zeile:
+    TEXT VAR zeileninhalt := "";
+    INT VAR z;
+    FOR z FROM 1 UPTO aktuelle werkstueckbreite REP
+      zeileninhalt CAT code (random (kleinster aktueller zeichencode,
+                                     groesster aktueller zeichencode))
+    PER.
+  gib eine zeile aus:
+    IF inversdarstellung
+       THEN out (w, invers (zeileninhalt))
+       ELSE out (w, zeileninhalt)
+    FI.
+END PROC werkstueck zeigen;
+PROC werkstueckaufhaenger (INT VAR spalte, zeile):
+  spalte := ((maxspalten - aktuelle werkstueckbreite) DIV 2) + 3;
+
+  zeile  := ((maxzeilen  - aktuelle werkstueckhoehe ) DIV 2) + 2;
+  IF inversdarstellung THEN spalte DECR 1 FI
+END PROC werkstueckaufhaenger;
+PROC gib zeichenkette aus (WINDOW VAR w,
+                           INT CONST kleinster, groesster, markiertes):
+  INT VAR zaehler;
+  FOR zaehler FROM kleinster UPTO groesster REP
+    positioniere cursor in zeichenkette (w, kleinster, zaehler);
+    IF zaehler = markiertes
+       THEN out (w, invers (code (zaehler)))
+       ELSE out (w, code (zaehler))
+
+    FI
+  PER
+END PROC gib zeichenkette aus;
+PROC positioniere cursor in zeichenkette (WINDOW VAR w,
+                                          INT CONST mincode, position):
+  cursor (w, 4 + ((position - mincode) DIV 19) * 5,
+             3 + ((position - mincode) MOD 19))
+END PROC positioniere cursor in zeichenkette;
+TEXT PROC tastenbezeichnung (TEXT CONST zeichen):
+  IF code (zeichen) >= 33 AND code (zeichen) <= 126
+     THEN "<" + zeichen + ">"
+     ELSE umgesetzter code
+  FI.
+  umgesetzter code:
+
+    SELECT code (zeichen) OF
+      CASE   1: anwendungstext (31)
+      CASE   2: anwendungstext (32)
+      CASE   3: anwendungstext (33)
+      CASE   8: anwendungstext (34)
+      CASE   9: anwendungstext (35)
+      CASE  10: anwendungstext (36)
+      CASE  11: anwendungstext (37)
+      CASE  12: anwendungstext (38)
+      CASE  13: anwendungstext (39)
+      CASE  16: anwendungstext (40)
+      CASE  27: anwendungstext (41)
+      CASE  32: anwendungstext (42)
+      CASE 214: anwendungstext (43)
+
+      CASE 215: anwendungstext (44)
+      CASE 216: anwendungstext (45)
+      CASE 217: anwendungstext (46)
+      CASE 218: anwendungstext (47)
+      CASE 219: anwendungstext (48)
+      CASE 251: anwendungstext (49)
+      OTHERWISE anwendungstext (50)
+  END SELECT
+END PROC tastenbezeichnung;
+INT PROC ermittelter wert (INT CONST minimum, maximum, startwert):
+  INT VAR aktueller wert, eingelesener wert;
+  cursor an;
+  aktueller wert := startwert;
+  REP
+    gib dreistellig aus und positioniere zurueck (aktueller wert, FALSE);
+
+    hole position aus vorgabe (oben unten return, eingelesener wert);
+    SELECT eingelesener wert OF
+      CASE 1: erhoehe aktuellen wert wenn moeglich
+      CASE 2: erniedrige aktuellen wert wenn moeglich
+    END SELECT
+  UNTIL eingelesener wert = 3 PER;
+  cursor aus;
+  aktueller wert.
+  erhoehe aktuellen wert wenn moeglich:
+    IF aktueller wert < maximum
+       THEN aktueller wert INCR 1
+       ELSE piepse
+    FI.
+  erniedrige aktuellen wert wenn moeglich:
+    IF aktueller wert > minimum
+
+       THEN aktueller wert DECR 1
+       ELSE piepse
+    FI.
+END PROC ermittelter wert;
+PROC gib dreistellig aus und positioniere zurueck (INT CONST wert,
+                                                   BOOL CONST mit wertwandel):
+  INT VAR spalte, zeile; get cursor (spalte, zeile);
+  IF mit wertwandel
+     THEN out ("'" + code (wert) + "'")
+     ELSE out (text (wert, 3))
+  FI;
+  cursor (spalte, zeile);
+END PROC gib dreistellig aus und positioniere zurueck;
+PROC hole position aus vorgabe (TEXT CONST vorgabe, INT VAR position):
+
+  TEXT VAR eingabezeichen; INT VAR spa, zei;
+  REP
+    get cursor (spa, zei); inchar (eingabezeichen); cursor (spa, zei);
+    position := pos (vorgabe, eingabezeichen);
+    IF position = 0 THEN piepse; cursor (spa, zei) FI
+  UNTIL position > 0 PER
+END PROC hole position aus vorgabe;
+PROC piepse:
+  INT VAR spa, zei; get cursor (spa, zei); out (piep); cursor (spa, zei)
+END PROC piepse;
+END PACKET ls mp bap 1;
+stdvoreinstellung der parameter
+
 
diff --git a/mp-bap/ls-MP BAP 2 b/mp-bap/ls-MP BAP 2
index 0cd66ff..4ae047c 100644
--- a/mp-bap/ls-MP BAP 2
+++ b/mp-bap/ls-MP BAP 2
@@ -22,105 +22,1375 @@ LET maxeintraege             =                    800,
     auswertdateipostfix      =        " - Auswertung", 
     protokolldateityp        =                   1955, 
     maxspalten               =                     70, 
-    maxzeilen                =                     14,{}    blank                    =                    " ",{}    trenn                    =                    "|",{}    werkstueckendekennung    =                      1,{}    pausenendekennung        =                      2,{}    simulationsendekennung   =                      3,{}    markierung ein           =                 ""15"",{}    markierung aus           =                " "14"",{}    stdschrifttyp            =                     "",{}
-    stdxstart                =                    0.0,{}    stdystart                =                    0.0,{}    stdfeldbreite            =                   21.0,{}    stdfeldlaenge            =                   29.5;{}LET  KONTROLLTABELLE = STRUCT (INT  letzter eintrag,{}                                    breite, hoehe,{}                                    kleinster code, groesster code,{}                                    anzahl aphasen, aphasendauer,{}                                    pausendauer,{}
-                               TEXT datum, uhrzeit, fehlerzeichen,{}                                    nach rechts, nach links,{}                                    nach oben, nach unten,{}                                    ausbesserung, naechstes,{}                               BOOL inversdarstellung,{}                               ROW  11 REAL bewertung,{}                               ROW maxeintraege KONTROLLE tabelle),{}     KONTROLLE       = STRUCT (INT  eintragskennung,{}                                    produktionsfehler,{}
-                                    anzahl korrekturen,{}                                    anzahl bedienfehler,{}                               REAL anfang, ende, differenz),{}     WERKSTUECK      = ROW maxspalten ROW maxzeilen INT;{}INT  VAR breite, hoehe, kleinster code, groesster code,{}         anzahl aphasen, aphasendauer, pausendauer,{}         eckspalte, eckzeile, x, y, xsize, ysize;{}TEXT VAR fehlerzeichen, nach rechts, nach links, nach oben, nach unten,{}         ausbesserung, naechstes, datum, uhrzeit;{}
-TEXT VAR protokollschrifttyp :: stdschrifttyp;{}REAL VAR xstart              :: stdxstart,{}         ystart              :: stdystart,{}         schreibfeldbreite   :: stdfeldbreite,{}         schreibfeldlaenge   :: stdfeldlaenge;{}ROW 11 REAL VAR bewertung;{}BOOL VAR inversdarstellung,{}         kontrolldatei zur vatertask ::  TRUE,{}         mit kurzprotokoll           ::  TRUE,{}         mit anmerkungen             ::  TRUE,{}         auswertung geht zum drucker :: FALSE;{}WERKSTUECK VAR werkstueck;{}
-PROC bildschirmarbeitsplatz:{}  kontrolldatei zur vatertask := FALSE;{}  install menu (menukarte);{}  handle menu  (menubezeichnung);{}END PROC bildschirmarbeitsplatz;{}PROC bap:{}  bildschirmarbeitsplatz{}END PROC bap;{}PROC materialpruefung:{}  TEXT VAR benutzerkennung :: "", protokollname, alter dateiname :: std;{}  install menu (menukarte, FALSE);{}  kontrolldatei zur vatertask := TRUE;{}  ermittle eingestellte parameter;{}  bereite den bildschirm vor;{}  ermittle die benutzerkennung;{}  gib benutzerhinweise aus;{}
-  arbeitsplatzsimulation ausfuehren (benutzerkennung, protokollname);{}  forget (protokollname, quiet);{}  last param (alter dateiname).{}  bereite den bildschirm vor:{}    WINDOW VAR w :: window ( 2, 10, 77, 14);{}    page;{}    show (w);{}    out (w, center (w, anwendungstext (400))).{}  ermittle die benutzerkennung:{}    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{}    IF benutzerkennung = ""{}       THEN cursor on; page;{}            LEAVE materialpruefung{}    FI.{}
-  gib benutzerhinweise aus:{}    boxinfo (w, anwendungstext (402));{}    boxinfo (w, anwendungstext (403));{}    boxinfo (w, anwendungstext (404));{}    gib bedieninformationen aus (2);{}    boxinfo (w, anwendungstext (405));{}    boxinfo (w, anwendungstext (406));{}    boxinfo (w, anwendungstext (407));{}    boxinfo (w, anwendungstext (408)).{}END PROC materialpruefung;{}PROC mp:{}  materialpruefung{}END PROC mp;{}PROC mp bap simulation ausfuehren:{}  TEXT VAR benutzerkennung :: "", dateiname;{}
-  kontrolldatei zur vatertask := FALSE;{}  ermittle eingestellte parameter;{}  bereite den bildschirm vor;{}  ermittle die benutzerkennung;{}  arbeitsplatzsimulation ausfuehren (benutzerkennung, dateiname);{}  regenerate menuscreen.{}  bereite den bildschirm vor:{}    WINDOW VAR w :: window (2,2,77,22);{}    page;{}    out (w, center (w, anwendungstext (399))).{}  ermittle die benutzerkennung:{}    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{}    IF benutzerkennung = ""{}
-       THEN regenerate menuscreen;{}            LEAVE mp bap simulation ausfuehren{}    FI.{}END PROC mp bap simulation ausfuehren;{}PROC mp bap auswertung auf bildschirm:{}  auswertung geht zum drucker := FALSE;{}  lasse protokolldateien auswaehlen;{}  werte protokolldateien aus;{}  regenerate menuscreen.{}  lasse protokolldateien auswaehlen:{}    THESAURUS VAR verfuegbare;{}    verfuegbare := infix namen (ALL myself, protokolldateipraefix,{}                                            protokolldateityp);{}
-    IF NOT not empty (verfuegbare){}       THEN noch kein protokoll{}       ELSE biete auswahl an{}    FI.{}  noch kein protokoll:{}    regenerate menuscreen;{}    menuinfo (anwendungstext (424));{}    LEAVE mp bap auswertung auf bildschirm.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, anwendungstext (421),{}                             anwendungstext (422), FALSE).{}  werte protokolldateien aus:{}    INT VAR k;{}    steige ggf bei leerem thesaurus aus;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}
-      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              gib hinweis auf auswertung;{}              simulationsauswertung (name (verfuegbare, k), TRUE);{}              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{}              fehlerbehandlung{}      FI{}    PER.{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN regenerate menuscreen;{}            menuinfo (anwendungstext (423));{}            LEAVE mp bap auswertung auf bildschirm{}
-    FI.{}  gib hinweis auf auswertung:{}    page;{}    WINDOW VAR fenster :: window ( 2, 2, 77, 22);{}    show (fenster);{}    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));{}    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (274))).{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen;{}            menuinfo (invers (errormessage));{}            clear error; enable stop;{}            LEAVE mp bap auswertung auf bildschirm{}    FI.{}
-END PROC mp bap auswertung auf bildschirm;{}PROC mp bap drucken von auswertungen:{}  auswertung geht zum drucker := TRUE;{}  lasse protokolldateien auswaehlen;{}  werte protokolldateien aus;{}  regenerate menuscreen.{}  lasse protokolldateien auswaehlen:{}    THESAURUS VAR verfuegbare;{}    verfuegbare := infix namen (ALL myself, protokolldateipraefix,{}                                            protokolldateityp);{}    IF NOT not empty (verfuegbare){}       THEN noch kein protokoll{}       ELSE biete auswahl an{}
-    FI.{}  noch kein protokoll:{}    regenerate menuscreen;{}    menuinfo (anwendungstext (424));{}    LEAVE mp bap drucken von auswertungen.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, anwendungstext (425),{}                             anwendungstext (422), FALSE).{}  werte protokolldateien aus:{}    INT VAR k;{}    steige ggf bei leerem thesaurus aus;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              gib hinweis auf auswertung;{}
-              simulationsauswertung (name (verfuegbare, k), FALSE);{}              print (name (verfuegbare, k) + auswertdateipostfix);{}              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{}              fehlerbehandlung{}      FI{}    PER.{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN regenerate menuscreen;{}            menuinfo (anwendungstext (423));{}            LEAVE mp bap drucken von auswertungen{}    FI.{}  gib hinweis auf auswertung:{}
-    page;{}    WINDOW VAR fenster :: window ( 2, 2, 77, 22);{}    show (fenster);{}    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));{}    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (270))).{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen;{}            menuinfo (invers (errormessage));{}            clear error; enable stop;{}            LEAVE mp bap drucken von auswertungen{}    FI.{}END PROC mp bap drucken von auswertungen;{}
-PROC mp bap protokollumfang festlegen:{}  page;{}  zeige aktuellen protokollumfang an;{}  gib erlaeuterungen zum protokollumfang;{}  frage nach umfangsaenderung;{}  regenerate menuscreen{}END PROC mp bap protokollumfang festlegen;{}PROC mp bap kurzauswertung:{}  page;{}  zeige aktuelle kurzauswertungseinstellung an;{}  gib erlaeuterungen zur kurzauswertung;{}  frage nach kurzauswertungsaenderung;{}  regenerate menuscreen{}END PROC mp bap kurzauswertung;{}PROC druckereinstellung fuer protokolldatei (TEXT CONST schrifttyp,{}
-                                             REAL CONST linker rand,{}                                                        oberer rand,{}                                                        feldbreite,{}                                                        feldlaenge):{}  protokollschrifttyp := schrifttyp;{}  xstart              := linker rand;{}  ystart              := oberer rand;{}  schreibfeldbreite   := feldbreite;{}  schreibfeldlaenge   := feldlaenge;{}END PROC druckereinstellung fuer protokolldatei;{}
-PROC stddruckereinstellung fuer protokolldatei:{}  protokollschrifttyp := stdschrifttyp;{}  xstart              := stdxstart;{}  ystart              := stdystart;{}  schreibfeldbreite   := stdfeldbreite;{}  schreibfeldlaenge   := stdfeldlaenge{}END PROC stddruckereinstellung fuer protokolldatei;{}                 (********************************){}PROC arbeitsplatzsimulation ausfuehren (TEXT CONST kennung,{}                                        TEXT VAR   dateiname):{}  ermittle eingestellte parameter;{}
-  lege datei mit kennung an (kennung, dateiname);{}  cursor on;{}  fuehre simulation durch (dateiname);{}  schicke ggf protokolldatei zur vatertask;{}  gib ggf kurzprotokoll aus.{}  schicke ggf protokolldatei zur vatertask:{}    IF kontrolldatei zur vatertask{}       THEN command dialogue (FALSE);{}            save (dateiname);{}            command dialogue (TRUE){}    FI.{}  gib ggf kurzprotokoll aus:{}    IF mit kurzprotokoll{}       THEN kurzauswertung auf bildschirm (dateiname){}       ELSE page; put (anwendungstext (271)){}
-    FI.{}END PROC arbeitsplatzsimulation ausfuehren;{}PROC ermittle eingestellte parameter:{}  werkstueckdefinition (breite, hoehe, kleinster code, groesster code,{}                        fehlerzeichen, inversdarstellung);{}  tastendefinition     (nach rechts, nach links, nach oben, nach unten,{}                        ausbesserung, naechstes);{}  phasendefinition     (anzahl aphasen, aphasendauer, pausendauer);{}  bewertungsschluessel (bewertung);{}END PROC ermittle eingestellte parameter;{}PROC lege datei mit kennung an (TEXT CONST kennung, TEXT VAR datname):{}
-  BOUND KONTROLLTABELLE VAR tab;{}  TEXT VAR interner name :: protokolldateipraefix;{}  interner name CAT kennung;{}  lege neue datei an;{}  type (old (datname), protokolldateityp).{}  lege neue datei an:{}    INT VAR i :: 0; TEXT VAR bezeichnung;{}    REP{}      i INCR 1;{}      bezeichnung := interner name + " /" + text (i){}    UNTIL NOT exists (bezeichnung) PER;{}    tab := new (bezeichnung);{}    initialisiere tabelle;{}    datname := bezeichnung.{}  initialisiere tabelle:{}    tab.letzter eintrag := 0.{}
-END PROC lege datei mit kennung an;{}PROC fuehre simulation durch (TEXT CONST dateiname):{}  BOUND KONTROLLTABELLE VAR tab :: old (dateiname);{}  TEXT CONST moegliche eingabezeichen :: nach rechts  + nach links +{}                                         nach oben    + nach unten +{}                                         ausbesserung + naechstes;{}  treffe vorbereitungen;{}  trage grunddaten in tabelle;{}  simuliere.{}  treffe vorbereitungen:{}     initialisierungen;{}     WINDOW VAR fenster :: window (  1,  9, 79, 16);{}
-     page;{}     gib bedieninformationen aus (2);{}     werkstueckaufhaenger (eckspalte, eckzeile);{}     weise auf arbeitsbeginn hin;{}     beginn der arbeitsphase      :=               clock (1);{}     beginn der bearbeitung       := beginn der arbeitsphase;{}     arbeitsphasenlaenge          := real (aphasendauer * 60).{}  initialisierungen:{}    INT  VAR eintragzaehler        :: 0,{}             arbeitsphasenzaehler  :: 1,{}             werkstueckzaehler     :: 0,{}             bedienfehlerzaehler   :: 0,{}
-             korrekturzaehler      :: 0,{}             produktionsfehler,{}             cursorspalte relativ,{}             cursorzeile  relativ;{}    REAL VAR beginn der arbeitsphase,{}             beginn der bearbeitung,{}             arbeitsphasenlaenge,{}             arbeitsphasenueberziehung,{}             pausenueberziehung.{}  weise auf arbeitsbeginn hin:{}    page (fenster);{}    boxinfo (fenster, anwendungstext (252), 5, maxint);{}    clear buffer.{}  trage grunddaten in tabelle:{}    tab.datum               := date;{}
-    tab.uhrzeit             := time of day;{}    tab.breite              := breite;{}    tab.hoehe               := hoehe;{}    tab.kleinster code      := kleinster code;{}    tab.groesster code      := groesster code;{}    tab.anzahl aphasen      := anzahl aphasen;{}    tab.aphasendauer        := aphasendauer;{}    tab.pausendauer         := pausendauer;{}    tab.fehlerzeichen       := fehlerzeichen;{}    tab.nach rechts         := nach rechts;{}    tab.nach links          := nach links;{}    tab.nach oben           := nach oben;{}
-    tab.nach unten          := nach unten;{}    tab.ausbesserung        := ausbesserung;{}    tab.naechstes           := naechstes;{}    tab.inversdarstellung   := inversdarstellung;{}    tab.bewertung           := bewertung;{}    eintragzaehler          := 1.{}  simuliere:{}    REP{}      gib holehinweis;{}      hole werkstueck  (werkstueck, produktionsfehler);{}      zeige werkstueck (werkstueck, fenster);{}      lasse werkstueck bearbeiten{}    UNTIL simulationsende erreicht PER.{}  gib holehinweis:{}
-    page (fenster);{}    cursor (fenster, 2, 3); out (fenster, anwendungstext (253)).{}  lasse werkstueck bearbeiten:{}    initialisiere den relativcursor;{}    setze cursor;{}    clear buffer;{}    bearbeite das werkstueck.{}  initialisiere den relativcursor:{}    cursorspalte relativ := 1;{}    cursorzeile relativ  := 1.{}  setze cursor:{}    IF inversdarstellung{}       THEN cursor (fenster, eckspalte + cursorspalte relativ,{}                             eckzeile  + cursorzeile  relativ - 1);{}
-       ELSE cursor (fenster, eckspalte + cursorspalte relativ - 1,{}                             eckzeile  + cursorzeile  relativ - 1);{}    FI.{}  bearbeite das werkstueck:{}    BOOL VAR werkstueck voll bearbeitet :: FALSE;{}    REP{}      hole eingabe und werte aus{}    UNTIL werkstueck voll bearbeitet PER.{}  hole eingabe und werte aus:{}    TEXT VAR eingabezeichen := incharety (100);{}    SELECT eingabezeichenposition OF{}      CASE 1: wenn moeglich nach rechts{}      CASE 2: wenn moeglich nach links{}
-      CASE 3: wenn moeglich nach oben{}      CASE 4: wenn moeglich nach unten{}      CASE 5: wenn moeglich ausbessern{}      CASE 6: beende werkstueckbearbeitung{}      OTHERWISE entscheide ob gepiepst wird{}    END SELECT.{}  eingabezeichenposition:{}    pos (moegliche eingabezeichen, eingabezeichen).{}  wenn moeglich nach rechts:{}    IF cursorspalte relativ < breite{}       THEN cursorspalte relativ INCR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach links:{}
-    IF cursorspalte relativ > 1{}       THEN cursorspalte relativ DECR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach oben:{}    IF cursorzeile relativ > 1{}       THEN cursorzeile relativ DECR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}  wenn moeglich nach unten:{}    IF cursorzeile relativ < hoehe{}       THEN cursorzeile relativ INCR 1;{}            setze cursor{}       ELSE registriere bedienfehler{}    FI.{}
-  wenn moeglich ausbessern:{}    IF werkstueck [cursorspalte relativ][cursorzeile relativ] = code (fehlerzeichen){}       THEN werkstueck [cursorspalte relativ][cursorzeile relativ] := code (blank);{}            korrekturzaehler INCR 1;{}            get cursor (fenster, x, y);{}            out (fenster, blank);{}            cursor (fenster, x, y);{}       ELSE registriere bedienfehler{}    FI.{}  registriere bedienfehler:{}    piepse; bedienfehlerzaehler INCR 1.{}  entscheide ob gepiepst wird:{}    IF eingabezeichen <> "" THEN piepse FI.{}
-  beende werkstueckbearbeitung:{}    IF   simulationsende erreicht{}         THEN trage simulationsende in tabelle ein{}    ELIF arbeitsphasenende erreicht{}         THEN trage werkstueckdaten in tabelle ein;{}              ermittle ueberziehung der arbeitsphase;{}              lege eine pause ein{}    ELSE trage werkstueckdaten in tabelle ein{}    FI;{}    werkstueck voll bearbeitet := TRUE.{}  lege eine pause ein:{}    nimm pausendaten;{}    weise auf pausenanfang hin;{}    pausiere;{}    weise auf pausenende hin;{}
-    registriere pausenueberziehung.{}  nimm pausendaten:{}    REAL VAR pausenanfang :: clock (1),{}             pausenende   :: pausenanfang + real (pausendauer * 60);.{}  weise auf pausenanfang hin:{}    page (fenster);{}    boxnotice (fenster, anwendungstext (255), 5, x, y, xsize, ysize).{}  pausiere:{}    REP{}      pause (int ((pausenende - clock (1)) * 10.0)){}    UNTIL clock (1) >= pausenende PER.{}  weise auf pausenende hin:{}    page (fenster);{}    pausenanfang := clock (1);{}    piepse;{}
-    clear buffer;{}    boxinfo (fenster, anwendungstext (256), 5, maxint);{}    pausenende   := clock (1).{}  registriere pausenueberziehung:{}    pausenueberziehung := pausenende - pausenanfang;{}    trage pausenueberziehung in tabelle ein.{}  trage werkstueckdaten in tabelle ein:{}    REAL VAR bearbeitungsende :: clock (1);{}    tab.tabelle [eintragzaehler].eintragskennung    := werkstueckendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{}
-    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{}    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;{}    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;{}    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;{}    erhoehe eintragzaehler;{}    beginn der bearbeitung := clock (1);{}    werkstueckzaehler INCR 1;{}    bedienfehlerzaehler := 0;{}    korrekturzaehler    := 0.{}  trage pausenueberziehung in tabelle ein:{}
-    tab.tabelle [eintragzaehler].eintragskennung    := pausenendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := 0;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := 0;{}    tab.tabelle [eintragzaehler].anzahl bedienfehler:= 0;{}    tab.tabelle [eintragzaehler].anfang             := pausenanfang;{}    tab.tabelle [eintragzaehler].ende               := pausenende;{}    tab.tabelle [eintragzaehler].differenz          := pausenueberziehung;{}    erhoehe eintragzaehler;{}    arbeitsphasenzaehler    INCR 1;{}
-    beginn der bearbeitung  := clock (1);{}    beginn der arbeitsphase := clock (1);{}    bearbeitungslaenge bestimmen.{}  trage simulationsende in tabelle ein:{}    bearbeitungsende := clock (1);{}    tab.tabelle [eintragzaehler].eintragskennung    := simulationsendekennung;{}    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;{}    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{}    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{}
-    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;{}    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;{}    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;{}    tab.letzter eintrag                             := eintragzaehler.{}  bearbeitungszeit:{}    bearbeitungsende - beginn der bearbeitung.{}  erhoehe eintragzaehler:{}    IF eintragzaehler < maxeintraege{}       THEN eintragzaehler INCR 1{}       ELSE trage simulationsende in tabelle ein;{}
-            errorstop (anwendungstext (254)){}    FI.{}  ermittle ueberziehung der arbeitsphase:{}    arbeitsphasenueberziehung := clock (1) - beginn der arbeitsphase{}                                           - arbeitsphasenlaenge.{}  bearbeitungslaenge bestimmen:{}    arbeitsphasenlaenge := real (aphasendauer * 60){}                                - arbeitsphasenueberziehung{}                                - pausenueberziehung.{}  arbeitsphasenende erreicht:{}    clock (1) - beginn der arbeitsphase >= arbeitsphasenlaenge.{}
-  simulationsende erreicht:{}    arbeitsphasenzaehler = anzahl aphasen AND arbeitsphasenende erreicht.{}END PROC fuehre simulation durch;{}PROC gib bedieninformationen aus (INT CONST zeile):{}  WINDOW VAR f1 :: window ( 2, zeile, 35, 6),{}             f2 :: window (40, zeile, 39, 6);{}  show (f1); show (f2);{}  cursor (f1, 2, 1); out (f1, anwendungstext (11));{}                     out (f1, tastenbezeichnung ( nach rechts));{}  cursor (f1, 2, 2); out (f1, anwendungstext (12));{}                     out (f1, tastenbezeichnung ( nach links));{}
-  cursor (f1, 2, 3); out (f1, anwendungstext (13));{}                     out (f1, tastenbezeichnung ( nach oben));{}  cursor (f1, 2, 4); out (f1, anwendungstext (14));{}                     out (f1, tastenbezeichnung ( nach unten));{}  cursor (f1, 2, 5); out (f1, anwendungstext (15));{}                     out (f1, tastenbezeichnung ( ausbesserung));{}  cursor (f1, 2, 6); out (f1, anwendungstext (16));{}                     out (f1, tastenbezeichnung ( naechstes));{}  cursor (f2, 2, 1); out (f2, anwendungstext (17));{}
-                     out (f2, text (anzahl aphasen, 4));{}  cursor (f2, 2, 2); out (f2, anwendungstext (18));{}                     out (f2, text (aphasendauer,   4));{}                     out (f2, anwendungstext (51));{}  cursor (f2, 2, 3); out (f2, anwendungstext (19));{}                     out (f2, text (pausendauer,    4));{}                     out (f2, anwendungstext (51));{}  cursor (f2, 2, 4); out (f2, anwendungstext ( 5));{}                     out (f2, text (gesamtzeit,      4));{}                     out (f2, anwendungstext (51));{}
-  cursor (f2, 2, 6); out (f2, anwendungstext (251));{}                     out (f2, 3 * blank);{}                     out (f2, fehlerzeichen).{}END PROC gib bedieninformationen aus;{}INT PROC gesamtzeit:{}  anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer{}END PROC gesamtzeit;{}PROC hole werkstueck (WERKSTUECK VAR w, INT VAR anzahl fehler):{}  INT VAR spaltenzaehler, zeilenzaehler;{}  anzahl fehler := 0;{}  FOR zeilenzaehler FROM 1 UPTO hoehe REP{}    ermittle eine zeile{}  PER.{}
-  ermittle eine zeile:{}    FOR spaltenzaehler FROM 1 UPTO breite REP{}      ermittle eine position;{}      ggf fehler registrieren{}    PER.{}  ermittle eine position:{}    w [spaltenzaehler][zeilenzaehler] := zufallscode.{}  zufallscode:{}    random (kleinster code, groesster code).{}  ggf fehler registrieren:{}    IF w [spaltenzaehler][zeilenzaehler] = code (fehlerzeichen){}       THEN anzahl fehler INCR 1{}    FI.{}END PROC hole werkstueck;{}PROC zeige werkstueck (WERKSTUECK CONST w, WINDOW VAR f):{}
-  INT VAR spaltenzaehler, zeilenzaehler;{}  page (f);{}  FOR zeilenzaehler FROM 1 UPTO hoehe REP{}    zeige eine zeile{}  PER.{}  zeige eine zeile:{}    cursor (f, eckspalte, eckzeile + zeilenzaehler - 1);{}    ggf invers einschalten;{}    FOR spaltenzaehler FROM 1 UPTO breite REP{}      out (f, code (w [spaltenzaehler][zeilenzaehler])){}    PER;{}    ggf invers ausschalten.{}  ggf invers einschalten:{}    IF inversdarstellung THEN out (f, markierung ein) FI.{}  ggf invers ausschalten:{}    IF inversdarstellung THEN out (f, markierung aus) FI.{}
-END PROC zeige werkstueck;{}PROC kurzauswertung auf bildschirm (TEXT CONST dateiname):{}  WINDOW VAR fenster :: window (  2, 10, 77, 13);{}  show (fenster);{}  clear buffer;{}  notiere ueberschrift;{}  notiere ergebnis.{}  notiere ueberschrift:{}    cursor (fenster, 1, 1);{}    out (fenster, center (fenster, anwendungstext (275)));{}    cursor (fenster, 1, 2);{}    out (fenster, center (fenster, anwendungstext (276))).{}  notiere ergebnis:{}    BOUND KONTROLLTABELLE CONST k := old (dateiname);{}    ermittle die simulationsdaten;{}
-    notiere gesamtzahl werkstuecke;{}    notiere zeichengesamtzahl;{}    notiere bedienfehler;{}    notiere benoetigte zeit;{}    notiere gesamtausbesserungsrate;{}    notiere gesamtbewertungsfaktor;{}    notiere gesamtbewertungszahl mit pausenueberziehung;{}    cursor (1, 24); out (anwendungstext (2));{}    pause.{}  ermittle die simulationsdaten:{}    INT  VAR z, anzahl zeichen pro werkstueck,{}             anzahl werkstuecke        ::   0,{}             anzahl bedienfehler       ::   0,{}             anzahl produktionsfehler  ::   0,{}
-             anzahl korrekturen        ::   0;{}    REAL VAR gesamtzahl zeichen, anteil korrekturen,{}             gesamtzeit                :: 0.0,{}             pausenueberzug            :: 0.0;{}    FOR z FROM 1 UPTO k.letzter eintrag REP{}      IF   k.tabelle [z].eintragskennung = werkstueckendekennung{}           THEN anzahl werkstuecke       INCR 1;{}                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;{}                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{}
-                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;{}                gesamtzeit               INCR k.tabelle [z].differenz;{}      ELIF k.tabelle [z].eintragskennung = pausenendekennung{}           THEN pausenueberzug           INCR k.tabelle [z].differenz;{}      FI{}    PER;{}    anzahl zeichen pro werkstueck := k.breite * k.hoehe;{}    gesamtzahl zeichen            :=   real (anzahl werkstuecke){}                                     * real (anzahl zeichen pro werkstueck);{}
-    IF anzahl produktionsfehler = 0{}       THEN anteil korrekturen    := 1.0{}       ELSE anteil korrekturen    :=   real (anzahl korrekturen){}                                     / real (anzahl produktionsfehler){}    FI.{}  notiere gesamtzahl werkstuecke:{}    cursor (fenster, 12, 4); out (fenster, anwendungstext (277));{}                             out (fenster, text (anzahl werkstuecke, 8)).{}  notiere zeichengesamtzahl:{}    cursor (fenster, 12, 5); out (fenster, anwendungstext (278));{}                             out (fenster, zahl aus zeichenkette).{}
-  zahl aus zeichenkette:{}    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{}  notiere bedienfehler:{}    cursor (fenster, 12, 6); out (fenster, anwendungstext (279));{}                             out (fenster, text (anzahl bedienfehler, 8)).{}  notiere benoetigte zeit:{}    cursor (fenster, 12, 7); out (fenster, anwendungstext (280));{}                             out (fenster, text (gesamtzeit,         8, 2)).{}  notiere gesamtausbesserungsrate:{}    cursor (fenster, 12, 9); out (fenster, anwendungstext (281));{}
-                             out (fenster, text (anteil korrekturen, 8, 2)).{}  notiere gesamtbewertungsfaktor:{}    cursor (fenster, 12,10); out (fenster, anwendungstext (282));{}                             out (fenster, text (bewertungsfaktor, 8, 2)).{}  bewertungsfaktor:{}    bewertungsmasszahl (anteil korrekturen).{}  notiere gesamtbewertungszahl mit pausenueberziehung:{}    cursor (fenster, 12, 12); out (fenster, (anwendungstext (283)));{}                              out (fenster, text (gesamtwertung,   8, 2));{}
-    cursor (fenster, 12, 13); out (fenster, (anwendungstext (284)));{}                              out (fenster, 8 * "=").{}  gesamtwertung:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}                               * bewertungsfaktor{}    FI.{}END PROC kurzauswertung auf bildschirm;{}PROC simulationsauswertung (TEXT CONST dateiname, BOOL CONST mit zeigen):{}  TEXT CONST auswertdatei :: dateiname + auswertdateipostfix;{}  ermittle die kenndaten aus der protokolldatei (dateiname);{}
-  notiere ueberschrift 1               (auswertdatei);{}  notiere die kenndaten der simulation (auswertdatei);{}  notiere die werkstueckkenndaten      (auswertdatei);{}  notiere ein beispielwerkstueck       (auswertdatei);{}  notiere ueberschrift 2               (auswertdatei);{}  notiere gesamtergebnisse             (auswertdatei, dateiname);{}  notiere ueberschrift 3               (auswertdatei);{}  notiere tabellenkopf                 (auswertdatei);{}  notiere einzelne werkstueckdaten     (auswertdatei, dateiname);{}
-  notiere ggf die anmerkungen;{}  zeige ggf auswertung auf bildschirm.{}  notiere ggf die anmerkungen:{}    IF mit anmerkungen{}       THEN notiere anmerkungen        (auswertdatei);{}    FI.{}  zeige ggf auswertung auf bildschirm:{}    IF mit zeigen{}       THEN cursor on; show (auswertdatei); cursor off{}    FI.{}END PROC simulationsauswertung;{}PROC ermittle die kenndaten aus der protokolldatei (TEXT CONST dateiname):{}  BOUND KONTROLLTABELLE CONST k := old (dateiname);{}  breite                    := k.breite;{}
-  hoehe                     := k.hoehe;{}  kleinster code            := k.kleinster code;{}  groesster code            := k.groesster code;{}  fehlerzeichen             := k.fehlerzeichen;{}  inversdarstellung         := k.inversdarstellung;{}  nach rechts               := k.nach rechts;{}  nach links                := k.nach links;{}  nach oben                 := k.nach oben;{}  nach unten                := k.nach unten;{}  ausbesserung              := k.ausbesserung;{}  naechstes                 := k.naechstes;{}
-  anzahl aphasen            := k.anzahl aphasen;{}  aphasendauer              := k.aphasendauer;{}  pausendauer               := k.pausendauer;{}  datum                     := k.datum;{}  uhrzeit                   := k.uhrzeit;{}  bewertung                 := k.bewertung;{}END PROC ermittle die kenndaten aus der protokolldatei;{}PROC notiere ueberschrift 1 (TEXT CONST auswertdatei):{}  IF exists (auswertdatei){}     THEN forget (auswertdatei, quiet){}  FI;{}  FILE VAR f :: sequential file (output, auswertdatei);{}
-  IF auswertung geht zum drucker{}     THEN schreibe druckeranweisungen{}  FI;{}  putline (f, center (auswertdatei));{}  putline (f, center (length (auswertdatei) * "="));{}  put (f, anwendungstext (272)); put (f, datum); put (f, 26 * blank);{}  put (f, anwendungstext (273)); putline (f, uhrzeit);{}  line (f);{}  putline (f, center (anwendungstext (291)));{}  putline (f, center (length (anwendungstext (291)) * "=")).{}  schreibe druckeranweisungen:{}    write (f, "#type (""");{}    write (f, protokollschrifttyp);{}
-    write (f, """)##limit (");{}    write (f, text (schreibfeldbreite));{}    write (f, ")##pagelength (");{}    write (f, text (schreibfeldlaenge));{}    write (f, ")##start (");{}    write (f, text (xstart));{}    write (f, ",");{}    write (f, text (ystart));{}    write (f, ")#"); line (f).{}END PROC notiere ueberschrift 1;{}PROC notiere ueberschrift 2 (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  putline (f, center (anwendungstext (285)));{}  putline (f, center (length (anwendungstext (285)) * "=")){}
-END PROC notiere ueberschrift 2;{}PROC notiere ueberschrift 3 (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  line (f, 2);{}  putline (f, center (anwendungstext (311)));{}  putline (f, center (length (anwendungstext (311)) * "="));{}  line (f){}END PROC notiere ueberschrift 3;{}PROC notiere die kenndaten der simulation (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  ROW 6 TEXT VAR ausgabe;{}  bestuecke ausgabezeilen;{}  schreibe ausgabezeilen.{}
-  bestuecke ausgabezeilen:{}    ausgabe [1] :=   anwendungstext (11){}                   + gleichlang (tastenbezeichnung (nach rechts ), 23){}                   + anwendungstext (17){}                   + text (anzahl aphasen,   4);{}    ausgabe [2] :=   anwendungstext (12){}                   + gleichlang (tastenbezeichnung (nach links  ), 23){}                   + anwendungstext (18){}                   + text (aphasendauer,     4) + anwendungstext (51);{}    ausgabe [3] :=   anwendungstext (13){}
-                   + gleichlang (tastenbezeichnung (nach oben   ), 23){}                   + anwendungstext (19){}                   + text (pausendauer,      4) + anwendungstext (51);{}    ausgabe [4] :=   anwendungstext (14){}                   + gleichlang (tastenbezeichnung (nach unten  ), 23){}                   + anwendungstext ( 5){}                   + text (simulationsdauer, 4) + anwendungstext (51);{}    ausgabe [5] :=   anwendungstext (15){}                   + gleichlang (tastenbezeichnung (ausbesserung), 23);{}
-    ausgabe [6] :=   anwendungstext (16){}                   + gleichlang (tastenbezeichnung (naechstes   ), 23){}                   + anwendungstext (251){}                   + (3 * blank) + fehlerzeichen.{}  simulationsdauer:{}    anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer.{}  schreibe ausgabezeilen:{}    INT VAR i;{}    FOR i FROM 1 UPTO 6 REP{}      putline (f, ausgabe [i]){}    PER;{}    line (f).{}END PROC notiere die kenndaten der simulation;{}PROC notiere die werkstueckkenndaten (TEXT CONST auswertdatei):{}
-  FILE VAR f :: sequential file (output, auswertdatei);{}  ROW 4 TEXT VAR ausgabe;{}  bestuecke ausgabezeilen;{}  schreibe ausgabezeilen.{}  bestuecke ausgabezeilen:{}    ausgabe [1] :=  anwendungstext (292) + text (breite,        4) +{}                    anwendungstext (296);{}    ausgabe [2] :=  anwendungstext (293) + text (hoehe,          4) +{}                    anwendungstext (296);{}    ausgabe [3] :=  anwendungstext (294) + text (breite * hoehe, 4) +{}                    anwendungstext (296);{}
-    ausgabe [4] :=  anwendungstext (295) + zeichenumfang.{}  zeichenumfang:{}    " " + code (kleinster code) + " ... " + code (groesster code) +{}    " (" + text (groesster code - kleinster code + 1, 3) +{}    anwendungstext (296) + ")".{}  schreibe ausgabezeilen:{}    INT VAR i;{}    FOR i FROM 1 UPTO 4 REP putline (f, ausgabe [i]) PER;{}    line (f).{}END PROC notiere die werkstueckkenndaten;{}PROC notiere ein beispielwerkstueck (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}
-  WERKSTUECK VAR beispiel;{}  INT VAR beispielfehler;{}  hole werkstueck (beispiel, beispielfehler);{}  notiere ueberschrift;{}  notiere werkstueckzeilen;{}  notiere werkstueckleerzeilen.{}  notiere ueberschrift:{}    putline (f, center (anwendungstext (297)));{}    putline (f, center (length (anwendungstext (297)) * "-")).{}  notiere werkstueckzeilen:{}    INT VAR bs, bz;{}    FOR bz FROM 1 UPTO hoehe REP{}      notiere eine zeile{}    PER.{}  notiere eine zeile:{}    TEXT VAR beispielzeile :: "";{}
-    konstruiere beispielzeile;{}    gib beispielzeile aus.{}  konstruiere beispielzeile:{}    beispielzeile CAT (((80 - breite) DIV 2) * blank);{}    FOR bs FROM 1 UPTO breite REP{}      beispielzeile CAT code (beispiel [bs][bz]){}    PER.{}  gib beispielzeile aus:{}    putline (f, beispielzeile).{}  notiere werkstueckleerzeilen:{}    line (f, maxzeilen - hoehe + 1).{}END PROC notiere ein beispielwerkstueck;{}PROC notiere gesamtergebnisse (TEXT CONST auswertdatei, protokolldatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}
-  BOUND KONTROLLTABELLE CONST k :: old (protokolldatei);{}  ermittle die simulationsdaten;{}    notiere gesamtzahl werkstuecke;{}    notiere anzahl zeichen pro werkstueck;{}    notiere zeichengesamtzahl;{}    notiere bedienfehler;{}    notiere produktionsfehlerzahl;{}    notiere fehlerkorrekturen;{}    notiere gesamtzeit mit pausenueberziehung;{}    notiere zeichenzahl pro sekunde mit;{}    notiere gesamtausbesserungsrate;{}    notiere gesamtbewertungsfaktor  mit;{}    notiere gesamtbewertungszahl    mit;{}
-    notiere gesamtzeit ohne pausenueberziehung;{}    notiere zeichenzahl pro sekunde ohne;{}    notiere gesamtbewertungszahl    ohne.{}  ermittle die simulationsdaten:{}    INT  VAR z, anzahl zeichen pro werkstueck,{}             anzahl werkstuecke        ::   0,{}             anzahl bedienfehler       ::   0,{}             anzahl produktionsfehler  ::   0,{}             anzahl korrekturen        ::   0;{}    REAL VAR gesamtzahl zeichen, anteil korrekturen,{}             gesamtzeit                :: 0.0,{}
-             pausenueberzug            :: 0.0;{}    FOR z FROM 1 UPTO k.letzter eintrag REP{}      IF   k.tabelle [z].eintragskennung = werkstueckendekennung{}           THEN anzahl werkstuecke       INCR 1;{}                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;{}                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{}                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;{}                gesamtzeit               INCR k.tabelle [z].differenz;{}
-      ELIF k.tabelle [z].eintragskennung = pausenendekennung{}           THEN pausenueberzug           INCR k.tabelle [z].differenz;{}      FI{}    PER;{}    anzahl zeichen pro werkstueck := k.breite * k.hoehe;{}    gesamtzahl zeichen            :=   real (anzahl werkstuecke){}                                     * real (anzahl zeichen pro werkstueck);{}    IF anzahl produktionsfehler = 0{}       THEN anteil korrekturen    := 1.0{}       ELSE anteil korrekturen    :=   real (anzahl korrekturen){}
-                                     / real (anzahl produktionsfehler){}    FI.{}  notiere gesamtzahl werkstuecke:{}    put (f, anwendungstext (277)); putline (f, text (anzahl werkstuecke, 8)).{}  notiere anzahl zeichen pro werkstueck:{}    put (f, anwendungstext (286)); putline (f, text (breite * hoehe,     8)).{}  notiere zeichengesamtzahl:{}    put (f, anwendungstext (278)); putline (f, zahl aus zeichenkette);{}    line (f).{}  zahl aus zeichenkette:{}    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{}
-  notiere produktionsfehlerzahl:{}    put (f, anwendungstext (287)); putline (f, text (anzahl produktionsfehler, 8)).{}  notiere fehlerkorrekturen:{}    put (f, anwendungstext (288)); putline (f, text (anzahl korrekturen, 8)).{}  notiere bedienfehler:{}    put (f, anwendungstext (279)); putline (f, text (anzahl bedienfehler,8));{}    line (f).{}  notiere gesamtzeit mit pausenueberziehung:{}    put (f, anwendungstext (301)); put (f, text (gesamtzeit mit, 8, 1));{}    putline (f, anwendungstext (300)).{}
-  gesamtzeit mit:{}    gesamtzeit + pausenueberzug.{}  notiere zeichenzahl pro sekunde mit:{}    put (f, anwendungstext (302));{}    putline (f, text (zeichenpro sec mit, 8, 1));{}    line (f).{}  zeichen pro sec mit:{}    IF gesamtzeit + pausenueberzug > 0.0{}       THEN gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}       ELSE 0.0{}    FI.{}  notiere gesamtausbesserungsrate:{}    put (f, anwendungstext (281)); putline (f, text (anteil korrekturen, 8, 1)).{}  notiere gesamtbewertungsfaktor mit:{}
-    put (f, anwendungstext (282)); putline (f, text (bewertungsfaktor, 8, 1));{}    line (f).{}  bewertungsfaktor:{}    bewertungsmasszahl (anteil korrekturen).{}  notiere gesamtbewertungszahl mit:{}    put (f, (anwendungstext (283))); putline (f, text (gesamtwertung mit,   8, 1));{}    put (f, (anwendungstext (284))); putline (f, 8 * "=").{}  gesamtwertung mit:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){}                               * bewertungsfaktor{}
-    FI.{}  notiere gesamtzeit ohne pausenueberziehung:{}    put (f, anwendungstext (303)); put (f, text (gesamtzeit, 8, 1));{}    putline (f, anwendungstext (300)).{}  notiere zeichenzahl pro sekunde ohne:{}    put (f, anwendungstext (302));{}    putline (f, text (zeichenpro sec ohne, 8, 1)).{}  zeichen pro sec ohne:{}    IF gesamtzeit > 0.0{}       THEN gesamtzahl zeichen / gesamtzeit{}       ELSE 0.0{}    FI.{}  notiere gesamtbewertungszahl ohne:{}    put (f, (anwendungstext (304))); putline (f, text (gesamtwertung ohne,   8, 1));{}
-    put (f, (anwendungstext (284))); putline (f, 8 * "=").{}  gesamtwertung ohne:{}    IF gesamtzeit = 0.0{}       THEN 0.0{}       ELSE gesamtzahl zeichen / gesamtzeit * bewertungsfaktor{}    FI.{}END PROC notiere gesamtergebnisse;{}PROC notiere tabellenkopf (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  putline (f, anwendungstext (312));{}  putline (f, anwendungstext (313));{}  putline (f, anwendungstext (314));{}  putline (f, anwendungstext (315));{}  putline (f, anwendungstext (316));{}
-  putline (f, anwendungstext (317));{}  putline (f, anwendungstext (318));{}END PROC notiere tabellenkopf;{}PROC notiere einzelne werkstueckdaten (TEXT CONST auswertdatei, dateiname):{}  BOUND KONTROLLTABELLE CONST k :: old (dateiname);{}  FILE VAR f :: sequential file (output, auswertdatei);{}  INT  VAR zeiger, werkstuecknummer :: 0;{}  TEXT VAR ausgabezeile :: "";{}  FOR zeiger FROM 1 UPTO k.letzter eintrag REP{}   notiere bearbeitungszeile{}  PER.{}  notiere bearbeitungszeile:{}    IF   k.tabelle [zeiger].eintragskennung = werkstueckendekennung{}
-         THEN werkstuecknummer INCR 1;{}              schreibe werkstueckzeile{}    ELIF k.tabelle [zeiger].eintragskennung = pausenendekennung{}         THEN schreibe pausenzeile{}    ELIF k.tabelle [zeiger].eintragskennung = simulationsendekennung{}         THEN werkstuecknummer INCR 1;{}              schreibe abschluss{}    ELSE putline (f, 75 * "?"){}    FI.{}  schreibe werkstueckzeile:{}    konstruiere ausgabezeile;{}    putline (f, ausgabezeile).{}  konstruiere ausgabezeile:{}    ausgabezeile := "";{}
-    ausgabezeile CAT text (werkstuecknummer, 5);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].anzahl bedienfehler, 5);{}    ausgabezeile CAT 3 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].produktionsfehler,   6);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (k.tabelle [zeiger].anzahl korrekturen,  6);{}    ausgabezeile CAT 2 * blank;{}    ausgabezeile CAT trenn;{}
-    ausgabezeile CAT text (k.tabelle [zeiger].differenz,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (zeichen pro zeiteinheit,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (einzelausbesserungsrate,  6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}    ausgabezeile CAT text (bewertungsmasszahl (einzelausbesserungsrate), 6, 1);{}    ausgabezeile CAT blank;{}    ausgabezeile CAT trenn;{}
-    ausgabezeile CAT text (endbewertungszahl, 6, 1);{}    ausgabezeile CAT blank.{}  zeichen pro zeiteinheit:{}    real (breite * hoehe) / k.tabelle [zeiger].differenz.{}  einzelausbesserungsrate:{}    IF k.tabelle [zeiger].produktionsfehler = 0{}       THEN 0.0{}       ELSE   real (k.tabelle [zeiger].anzahl korrekturen){}            / real (k.tabelle [zeiger].produktionsfehler ){}    FI.{}  endbewertungszahl:{}    real (breite * hoehe) / k.tabelle [zeiger].differenz{}                          * bewertungsmasszahl (einzelausbesserungsrate).{}
-  schreibe pausenzeile:{}    line (f);{}    put     (f, anwendungstext (320));{}    put     (f, text (k.tabelle [zeiger].differenz, 6, 1));{}    putline (f, anwendungstext (300));{}    line (f).{}  schreibe abschluss:{}    putline (f, anwendungstext (318));{}    putline (f, anwendungstext (319));{}    line (f);{}    konstruiere ausgabezeile;{}    ausgabezeile := "(" +{}                    subtext (ausgabezeile, 2, length (ausgabezeile) - 1) +{}                    ")";{}    putline (f, ausgabezeile).{}
-END PROC notiere einzelne werkstueckdaten;{}PROC notiere anmerkungen (TEXT CONST auswertdatei):{}  FILE VAR f :: sequential file (output, auswertdatei);{}  line (f);{}  schreibe kopf;{}  schreibe hinweis auf letztes werkstueck;{}  schreibe hinweis auf bedienfehler;{}  erlaeutere bewertungsschluessel;{}  stelle bewertungsschluessel graphisch dar;{}  schreibe rest.{}  schreibe kopf:{}    putline (f, center (anwendungstext (325)));{}    putline (f, center (length (anwendungstext (325)) * "="));{}    line (f).{}
-  schreibe hinweis auf letztes werkstueck:{}    INT VAR i;{}    FOR i FROM 326 UPTO 337 REP{}      putline (f, anwendungstext (i)){}    PER;{}    line (f).{}  schreibe hinweis auf bedienfehler:{}    FOR i FROM 339 UPTO 341 REP{}      putline (f, anwendungstext (i)){}    PER;{}    line (f).{}  erlaeutere bewertungsschluessel:{}    FOR i FROM 343 UPTO 372 REP{}      putline (f, anwendungstext (i)){}    PER.{}  stelle bewertungsschluessel graphisch dar:{}    putline (f, anwendungstext (374));{}    putline (f, anwendungstext (375));{}
-    ermittle die startposition;{}    zeichne diagramm;{}    trage werte ein.{}  ermittle die startposition:{}    modify (f);{}    INT VAR zeilenpos :: lines (f) + 2, spaltenpos :: 18.{}  zeichne diagramm:{}    cursor (f, spaltenpos, zeilenpos     , anwendungstext (20));{}    cursor (f, spaltenpos, zeilenpos +  1, anwendungstext (21));{}    cursor (f, spaltenpos, zeilenpos +  3, anwendungstext (23));{}    cursor (f, spaltenpos, zeilenpos +  4, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  5, anwendungstext (22));{}
-    cursor (f, spaltenpos, zeilenpos +  6, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  7, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos +  8, anwendungstext (24));{}    cursor (f, spaltenpos, zeilenpos +  9, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 10, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 11, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 12, anwendungstext (22));{}    cursor (f, spaltenpos, zeilenpos + 13, anwendungstext (25));{}
-    cursor (f, spaltenpos, zeilenpos + 14, anwendungstext (26));{}    cursor (f, spaltenpos, zeilenpos + 15, anwendungstext (27)).{}  trage werte ein:{}    zeilenpos INCR 13;{}    INT VAR bwzeiger;{}    FOR bwzeiger FROM 1 UPTO 11 REP{}      cursor (f, spaltenpos + 3 * bwzeiger, zeilenpos - konkreter wert, "+"){}    PER.{}  konkreter wert:{}    int (bewertung [bwzeiger] * 10.0).{}  schreibe rest:{}    output (f);{}    line (f, 2);{}    FOR i FROM 377 UPTO 387 REP{}      putline (f, anwendungstext (i)){}
-    PER;{}    haenge an jede zeile ein blank an.{}  haenge an jede zeile ein blank an:{}    TEXT VAR inhalt;{}    INT  VAR zeilenzeiger;{}    modify (f);{}    FOR zeilenzeiger FROM 1 UPTO lines (f) REP{}      to line (f, zeilenzeiger);{}      read record (f, inhalt);{}      inhalt CAT blank;{}      write record (f, inhalt){}    PER;{}    to line (f,1).{}END PROC notiere anmerkungen;{}PROC cursor (FILE VAR f, INT CONST spa, zei, TEXT CONST text):{}  positioniere an zeile;{}  positioniere an spalte;{}
-  gib text an position aus.{}  positioniere an zeile:{}    IF zeile noch nicht vorhanden{}       THEN schaffe zeile und gehe dorthin{}       ELSE to line (f,zei){}    FI.{}  zeile noch nicht vorhanden:{}    zei > lines (f).{}  schaffe zeile und gehe dorthin:{}    INT VAR zaehler 1;{}    IF lines (f) = 0{}       THEN to line (f,lines (f));{}            insert record (f);{}    FI;{}    FOR zaehler 1 FROM lines (f)  UPTO zei REP{}      to line (f,lines (f));{}      down (f);insert record (f){}    PER;{}
-    to line(f,zei).{}  positioniere an spalte:{}    TEXT VAR alter satz :: "", neuer satz :: "", restsatz ::"";{}    INT VAR satzlaenge;{}    read record (f,alter satz);{}    satzlaenge := length (alter satz);{}    IF satzlaenge = 0{}       THEN neuer satz CAT (spa -1) * " "{}    ELIF satzlaenge >= spa{}       THEN neuer satz := subtext(alter satz,1,spa-1);{}            restsatz   := subtext(alter satz, spa + length (text));{}       ELSE neuer satz := alter satz;{}            neuer satz CAT (spa - satzlaenge - 1) * " "{}
-    FI.{}  gib text an position aus:{}   neuer satz CAT text;{}   IF restsatz <> ""{}      THEN neuer satz CAT restsatz{}   FI;{}   write record(f,neuer satz).{} END PROC cursor;{}TEXT PROC gleichlang (TEXT CONST text, INT CONST laenge):{}  TEXT VAR intern :: compress (text);{}  INT  VAR anzahl :: laenge - length (intern);{}  IF anzahl < 0{}     THEN subtext (intern, 1, laenge){}     ELSE intern + (anzahl * blank){}  FI{}END PROC gleichlang;{}REAL PROC bewertungsmasszahl (REAL CONST wert):{}  REAL VAR interner wert := round (wert, 1);{}
-  IF interner wert > wert{}     THEN interner wert DECR 0.1{}  FI;{}  interpoliere.{}  interpoliere:{}    REAL VAR unterer wert, oberer wert;{}    unterer wert := interner wert;{}    IF unterer wert = 1.0{}       THEN oberer wert := 1.0{}       ELSE oberer  wert := unterer wert + 0.1{}    FI;{}    unterer wert := bewertung (int (unterer wert * 10.0) + 1);{}    oberer  wert := bewertung (int (oberer  wert * 10.0) + 1);{}    unterer wert + (oberer wert - unterer wert) * faktor.{}  faktor:{}    frac (wert * 10.0).{}
-END PROC bewertungsmasszahl;{}PROC zeige aktuellen protokollumfang an:{}  WINDOW VAR w :: window (2, 2, 34,  5);{}  show (w);{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{}  IF mit anmerkungen{}     THEN cursor (w, 2, 4); out (w, anwendungstext (432)){}     ELSE cursor (w, 2, 4); out (w, anwendungstext (433));{}  FI.{}END PROC zeige aktuellen protokollumfang an;{}PROC gib erlaeuterungen zum protokollumfang:{}  WINDOW VAR f :: window ( 2, 9, 77, 15);{}  show (f);{}  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (434))));{}
-  cursor (f, 5, 3); out (f, anwendungstext (435));{}  cursor (f, 5, 4); out (f, anwendungstext (436));{}  cursor (f, 5, 5); out (f, anwendungstext (437));{}  cursor (f, 5, 6); out (f, anwendungstext (438));{}  cursor (f, 5, 8); out (f, anwendungstext (439));{}  cursor (f, 5, 9); out (f, anwendungstext (440));{}  cursor (f, 5,10); out (f, anwendungstext (441));{}  cursor (f, 5,11); out (f, anwendungstext (442));{}  cursor (f, 5,13); out (f, anwendungstext (443));{}  cursor (f, 5,14); out (f, anwendungstext (444));{}
-END PROC gib erlaeuterungen zum protokollumfang;{}PROC frage nach umfangsaenderung:{}  WINDOW VAR fenster :: window (38, 2, 41, 5);{}  show (fenster);{}  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (451))));{}  cursor (fenster, 4, 3); out (fenster, anwendungstext (452));{}  cursor (fenster, 4, 4);{}  IF yes (fenster, anwendungstext (453)){}     THEN  mit anmerkungen := NOT mit anmerkungen{}  FI.{}END PROC frage nach umfangsaenderung;{}PROC zeige aktuelle kurzauswertungseinstellung an:{}
-  WINDOW VAR w :: window ( 2, 2, 34,  5);{}  show (w);{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{}  IF mit kurzprotokoll{}     THEN cursor (w, 7, 4); out (w, anwendungstext (461));{}     ELSE cursor (w, 7, 4); out (w, anwendungstext (462));{}  FI.{}END PROC zeige aktuelle kurzauswertungseinstellung an;{}PROC gib erlaeuterungen zur kurzauswertung:{}  WINDOW VAR f :: window ( 2, 9, 77, 15);{}  show (f);{}  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (463))));{}
-  cursor (f, 5, 3); out (f, anwendungstext (464));{}  cursor (f, 5, 4); out (f, anwendungstext (465));{}  cursor (f, 5, 5); out (f, anwendungstext (466));{}  cursor (f, 5, 6); out (f, anwendungstext (467));{}  cursor (f, 5, 8); out (f, anwendungstext (468));{}  cursor (f, 5, 9); out (f, anwendungstext (469));{}  cursor (f, 5,10); out (f, anwendungstext (470));{}  cursor (f, 5,11); out (f, anwendungstext (471));{}  cursor (f, 5,13); out (f, anwendungstext (472));{}  cursor (f, 5,14); out (f, anwendungstext (473));{}
-END PROC gib erlaeuterungen zur kurzauswertung;{}PROC frage nach kurzauswertungsaenderung:{}  WINDOW VAR fenster :: window (38, 2, 41, 5);{}  show (fenster);{}  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (481))));{}  cursor (fenster, 5, 3); out (fenster, anwendungstext (482));{}  cursor (fenster, 5, 4);{}  IF yes (fenster, anwendungstext (483)){}     THEN  mit kurzprotokoll := NOT mit kurzprotokoll{}  FI.{}END PROC frage nach kurzauswertungsaenderung;{}END PACKET ls mp bap 2;{}
+    maxzeilen                =                     14,
+    blank                    =                    " ",
+    trenn                    =                    "|",
+    werkstueckendekennung    =                      1,
+    pausenendekennung        =                      2,
+    simulationsendekennung   =                      3,
+    markierung ein           =                 ""15"",
+    markierung aus           =                " "14"",
+    stdschrifttyp            =                     "",
+
+    stdxstart                =                    0.0,
+    stdystart                =                    0.0,
+    stdfeldbreite            =                   21.0,
+    stdfeldlaenge            =                   29.5;
+LET  KONTROLLTABELLE = STRUCT (INT  letzter eintrag,
+                                    breite, hoehe,
+                                    kleinster code, groesster code,
+                                    anzahl aphasen, aphasendauer,
+                                    pausendauer,
+
+                               TEXT datum, uhrzeit, fehlerzeichen,
+                                    nach rechts, nach links,
+                                    nach oben, nach unten,
+                                    ausbesserung, naechstes,
+                               BOOL inversdarstellung,
+                               ROW  11 REAL bewertung,
+                               ROW maxeintraege KONTROLLE tabelle),
+     KONTROLLE       = STRUCT (INT  eintragskennung,
+                                    produktionsfehler,
+
+                                    anzahl korrekturen,
+                                    anzahl bedienfehler,
+                               REAL anfang, ende, differenz),
+     WERKSTUECK      = ROW maxspalten ROW maxzeilen INT;
+INT  VAR breite, hoehe, kleinster code, groesster code,
+         anzahl aphasen, aphasendauer, pausendauer,
+         eckspalte, eckzeile, x, y, xsize, ysize;
+TEXT VAR fehlerzeichen, nach rechts, nach links, nach oben, nach unten,
+         ausbesserung, naechstes, datum, uhrzeit;
+
+TEXT VAR protokollschrifttyp :: stdschrifttyp;
+REAL VAR xstart              :: stdxstart,
+         ystart              :: stdystart,
+         schreibfeldbreite   :: stdfeldbreite,
+         schreibfeldlaenge   :: stdfeldlaenge;
+ROW 11 REAL VAR bewertung;
+BOOL VAR inversdarstellung,
+         kontrolldatei zur vatertask ::  TRUE,
+         mit kurzprotokoll           ::  TRUE,
+         mit anmerkungen             ::  TRUE,
+         auswertung geht zum drucker :: FALSE;
+WERKSTUECK VAR werkstueck;
+
+PROC bildschirmarbeitsplatz:
+  kontrolldatei zur vatertask := FALSE;
+  install menu (menukarte);
+  handle menu  (menubezeichnung);
+END PROC bildschirmarbeitsplatz;
+PROC bap:
+  bildschirmarbeitsplatz
+END PROC bap;
+PROC materialpruefung:
+  TEXT VAR benutzerkennung :: "", protokollname, alter dateiname :: std;
+  install menu (menukarte, FALSE);
+  kontrolldatei zur vatertask := TRUE;
+  ermittle eingestellte parameter;
+  bereite den bildschirm vor;
+  ermittle die benutzerkennung;
+  gib benutzerhinweise aus;
+
+  arbeitsplatzsimulation ausfuehren (benutzerkennung, protokollname);
+  forget (protokollname, quiet);
+  last param (alter dateiname).
+  bereite den bildschirm vor:
+    WINDOW VAR w :: window ( 2, 10, 77, 14);
+    page;
+    show (w);
+    out (w, center (w, anwendungstext (400))).
+  ermittle die benutzerkennung:
+    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));
+    IF benutzerkennung = ""
+       THEN cursor on; page;
+            LEAVE materialpruefung
+    FI.
+
+  gib benutzerhinweise aus:
+    boxinfo (w, anwendungstext (402));
+    boxinfo (w, anwendungstext (403));
+    boxinfo (w, anwendungstext (404));
+    gib bedieninformationen aus (2);
+    boxinfo (w, anwendungstext (405));
+    boxinfo (w, anwendungstext (406));
+    boxinfo (w, anwendungstext (407));
+    boxinfo (w, anwendungstext (408)).
+END PROC materialpruefung;
+PROC mp:
+  materialpruefung
+END PROC mp;
+PROC mp bap simulation ausfuehren:
+  TEXT VAR benutzerkennung :: "", dateiname;
+
+  kontrolldatei zur vatertask := FALSE;
+  ermittle eingestellte parameter;
+  bereite den bildschirm vor;
+  ermittle die benutzerkennung;
+  arbeitsplatzsimulation ausfuehren (benutzerkennung, dateiname);
+  regenerate menuscreen.
+  bereite den bildschirm vor:
+    WINDOW VAR w :: window (2,2,77,22);
+    page;
+    out (w, center (w, anwendungstext (399))).
+  ermittle die benutzerkennung:
+    benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));
+    IF benutzerkennung = ""
+
+       THEN regenerate menuscreen;
+            LEAVE mp bap simulation ausfuehren
+    FI.
+END PROC mp bap simulation ausfuehren;
+PROC mp bap auswertung auf bildschirm:
+  auswertung geht zum drucker := FALSE;
+  lasse protokolldateien auswaehlen;
+  werte protokolldateien aus;
+  regenerate menuscreen.
+  lasse protokolldateien auswaehlen:
+    THESAURUS VAR verfuegbare;
+    verfuegbare := infix namen (ALL myself, protokolldateipraefix,
+                                            protokolldateityp);
+
+    IF NOT not empty (verfuegbare)
+       THEN noch kein protokoll
+       ELSE biete auswahl an
+    FI.
+  noch kein protokoll:
+    regenerate menuscreen;
+    menuinfo (anwendungstext (424));
+    LEAVE mp bap auswertung auf bildschirm.
+  biete auswahl an:
+    verfuegbare := menusome (verfuegbare, anwendungstext (421),
+                             anwendungstext (422), FALSE).
+  werte protokolldateien aus:
+    INT VAR k;
+    steige ggf bei leerem thesaurus aus;
+    FOR k FROM 1 UPTO highest entry (verfuegbare) REP
+
+      IF name (verfuegbare, k) <> ""
+         THEN disable stop;
+              gib hinweis auf auswertung;
+              simulationsauswertung (name (verfuegbare, k), TRUE);
+              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);
+              fehlerbehandlung
+      FI
+    PER.
+  steige ggf bei leerem thesaurus aus:
+    IF NOT not empty (verfuegbare)
+       THEN regenerate menuscreen;
+            menuinfo (anwendungstext (423));
+            LEAVE mp bap auswertung auf bildschirm
+
+    FI.
+  gib hinweis auf auswertung:
+    page;
+    WINDOW VAR fenster :: window ( 2, 2, 77, 22);
+    show (fenster);
+    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));
+    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (274))).
+  fehlerbehandlung:
+    IF is error
+       THEN regenerate menuscreen;
+            menuinfo (invers (errormessage));
+            clear error; enable stop;
+            LEAVE mp bap auswertung auf bildschirm
+    FI.
+
+END PROC mp bap auswertung auf bildschirm;
+PROC mp bap drucken von auswertungen:
+  auswertung geht zum drucker := TRUE;
+  lasse protokolldateien auswaehlen;
+  werte protokolldateien aus;
+  regenerate menuscreen.
+  lasse protokolldateien auswaehlen:
+    THESAURUS VAR verfuegbare;
+    verfuegbare := infix namen (ALL myself, protokolldateipraefix,
+                                            protokolldateityp);
+    IF NOT not empty (verfuegbare)
+       THEN noch kein protokoll
+       ELSE biete auswahl an
+
+    FI.
+  noch kein protokoll:
+    regenerate menuscreen;
+    menuinfo (anwendungstext (424));
+    LEAVE mp bap drucken von auswertungen.
+  biete auswahl an:
+    verfuegbare := menusome (verfuegbare, anwendungstext (425),
+                             anwendungstext (422), FALSE).
+  werte protokolldateien aus:
+    INT VAR k;
+    steige ggf bei leerem thesaurus aus;
+    FOR k FROM 1 UPTO highest entry (verfuegbare) REP
+      IF name (verfuegbare, k) <> ""
+         THEN disable stop;
+              gib hinweis auf auswertung;
+
+              simulationsauswertung (name (verfuegbare, k), FALSE);
+              print (name (verfuegbare, k) + auswertdateipostfix);
+              forget (name (verfuegbare, k) + auswertdateipostfix, quiet);
+              fehlerbehandlung
+      FI
+    PER.
+  steige ggf bei leerem thesaurus aus:
+    IF NOT not empty (verfuegbare)
+       THEN regenerate menuscreen;
+            menuinfo (anwendungstext (423));
+            LEAVE mp bap drucken von auswertungen
+    FI.
+  gib hinweis auf auswertung:
+
+    page;
+    WINDOW VAR fenster :: window ( 2, 2, 77, 22);
+    show (fenster);
+    cursor (fenster, 1,  9); out (fenster, center (fenster, name (verfuegbare, k)));
+    cursor (fenster, 1, 12); out (fenster, center (anwendungstext (270))).
+  fehlerbehandlung:
+    IF is error
+       THEN regenerate menuscreen;
+            menuinfo (invers (errormessage));
+            clear error; enable stop;
+            LEAVE mp bap drucken von auswertungen
+    FI.
+END PROC mp bap drucken von auswertungen;
+
+PROC mp bap protokollumfang festlegen:
+  page;
+  zeige aktuellen protokollumfang an;
+  gib erlaeuterungen zum protokollumfang;
+  frage nach umfangsaenderung;
+  regenerate menuscreen
+END PROC mp bap protokollumfang festlegen;
+PROC mp bap kurzauswertung:
+  page;
+  zeige aktuelle kurzauswertungseinstellung an;
+  gib erlaeuterungen zur kurzauswertung;
+  frage nach kurzauswertungsaenderung;
+  regenerate menuscreen
+END PROC mp bap kurzauswertung;
+PROC druckereinstellung fuer protokolldatei (TEXT CONST schrifttyp,
+
+                                             REAL CONST linker rand,
+                                                        oberer rand,
+                                                        feldbreite,
+                                                        feldlaenge):
+  protokollschrifttyp := schrifttyp;
+  xstart              := linker rand;
+  ystart              := oberer rand;
+  schreibfeldbreite   := feldbreite;
+  schreibfeldlaenge   := feldlaenge;
+END PROC druckereinstellung fuer protokolldatei;
+
+PROC stddruckereinstellung fuer protokolldatei:
+  protokollschrifttyp := stdschrifttyp;
+  xstart              := stdxstart;
+  ystart              := stdystart;
+  schreibfeldbreite   := stdfeldbreite;
+  schreibfeldlaenge   := stdfeldlaenge
+END PROC stddruckereinstellung fuer protokolldatei;
+                 (********************************)
+PROC arbeitsplatzsimulation ausfuehren (TEXT CONST kennung,
+                                        TEXT VAR   dateiname):
+  ermittle eingestellte parameter;
+
+  lege datei mit kennung an (kennung, dateiname);
+  cursor on;
+  fuehre simulation durch (dateiname);
+  schicke ggf protokolldatei zur vatertask;
+  gib ggf kurzprotokoll aus.
+  schicke ggf protokolldatei zur vatertask:
+    IF kontrolldatei zur vatertask
+       THEN command dialogue (FALSE);
+            save (dateiname);
+            command dialogue (TRUE)
+    FI.
+  gib ggf kurzprotokoll aus:
+    IF mit kurzprotokoll
+       THEN kurzauswertung auf bildschirm (dateiname)
+       ELSE page; put (anwendungstext (271))
+
+    FI.
+END PROC arbeitsplatzsimulation ausfuehren;
+PROC ermittle eingestellte parameter:
+  werkstueckdefinition (breite, hoehe, kleinster code, groesster code,
+                        fehlerzeichen, inversdarstellung);
+  tastendefinition     (nach rechts, nach links, nach oben, nach unten,
+                        ausbesserung, naechstes);
+  phasendefinition     (anzahl aphasen, aphasendauer, pausendauer);
+  bewertungsschluessel (bewertung);
+END PROC ermittle eingestellte parameter;
+PROC lege datei mit kennung an (TEXT CONST kennung, TEXT VAR datname):
+
+  BOUND KONTROLLTABELLE VAR tab;
+  TEXT VAR interner name :: protokolldateipraefix;
+  interner name CAT kennung;
+  lege neue datei an;
+  type (old (datname), protokolldateityp).
+  lege neue datei an:
+    INT VAR i :: 0; TEXT VAR bezeichnung;
+    REP
+      i INCR 1;
+      bezeichnung := interner name + " /" + text (i)
+    UNTIL NOT exists (bezeichnung) PER;
+    tab := new (bezeichnung);
+    initialisiere tabelle;
+    datname := bezeichnung.
+  initialisiere tabelle:
+    tab.letzter eintrag := 0.
+
+END PROC lege datei mit kennung an;
+PROC fuehre simulation durch (TEXT CONST dateiname):
+  BOUND KONTROLLTABELLE VAR tab :: old (dateiname);
+  TEXT CONST moegliche eingabezeichen :: nach rechts  + nach links +
+                                         nach oben    + nach unten +
+                                         ausbesserung + naechstes;
+  treffe vorbereitungen;
+  trage grunddaten in tabelle;
+  simuliere.
+  treffe vorbereitungen:
+     initialisierungen;
+     WINDOW VAR fenster :: window (  1,  9, 79, 16);
+
+     page;
+     gib bedieninformationen aus (2);
+     werkstueckaufhaenger (eckspalte, eckzeile);
+     weise auf arbeitsbeginn hin;
+     beginn der arbeitsphase      :=               clock (1);
+     beginn der bearbeitung       := beginn der arbeitsphase;
+     arbeitsphasenlaenge          := real (aphasendauer * 60).
+  initialisierungen:
+    INT  VAR eintragzaehler        :: 0,
+             arbeitsphasenzaehler  :: 1,
+             werkstueckzaehler     :: 0,
+             bedienfehlerzaehler   :: 0,
+
+             korrekturzaehler      :: 0,
+             produktionsfehler,
+             cursorspalte relativ,
+             cursorzeile  relativ;
+    REAL VAR beginn der arbeitsphase,
+             beginn der bearbeitung,
+             arbeitsphasenlaenge,
+             arbeitsphasenueberziehung,
+             pausenueberziehung.
+  weise auf arbeitsbeginn hin:
+    page (fenster);
+    boxinfo (fenster, anwendungstext (252), 5, maxint);
+    clear buffer.
+  trage grunddaten in tabelle:
+    tab.datum               := date;
+
+    tab.uhrzeit             := time of day;
+    tab.breite              := breite;
+    tab.hoehe               := hoehe;
+    tab.kleinster code      := kleinster code;
+    tab.groesster code      := groesster code;
+    tab.anzahl aphasen      := anzahl aphasen;
+    tab.aphasendauer        := aphasendauer;
+    tab.pausendauer         := pausendauer;
+    tab.fehlerzeichen       := fehlerzeichen;
+    tab.nach rechts         := nach rechts;
+    tab.nach links          := nach links;
+    tab.nach oben           := nach oben;
+
+    tab.nach unten          := nach unten;
+    tab.ausbesserung        := ausbesserung;
+    tab.naechstes           := naechstes;
+    tab.inversdarstellung   := inversdarstellung;
+    tab.bewertung           := bewertung;
+    eintragzaehler          := 1.
+  simuliere:
+    REP
+      gib holehinweis;
+      hole werkstueck  (werkstueck, produktionsfehler);
+      zeige werkstueck (werkstueck, fenster);
+      lasse werkstueck bearbeiten
+    UNTIL simulationsende erreicht PER.
+  gib holehinweis:
+
+    page (fenster);
+    cursor (fenster, 2, 3); out (fenster, anwendungstext (253)).
+  lasse werkstueck bearbeiten:
+    initialisiere den relativcursor;
+    setze cursor;
+    clear buffer;
+    bearbeite das werkstueck.
+  initialisiere den relativcursor:
+    cursorspalte relativ := 1;
+    cursorzeile relativ  := 1.
+  setze cursor:
+    IF inversdarstellung
+       THEN cursor (fenster, eckspalte + cursorspalte relativ,
+                             eckzeile  + cursorzeile  relativ - 1);
+
+       ELSE cursor (fenster, eckspalte + cursorspalte relativ - 1,
+                             eckzeile  + cursorzeile  relativ - 1);
+    FI.
+  bearbeite das werkstueck:
+    BOOL VAR werkstueck voll bearbeitet :: FALSE;
+    REP
+      hole eingabe und werte aus
+    UNTIL werkstueck voll bearbeitet PER.
+  hole eingabe und werte aus:
+    TEXT VAR eingabezeichen := incharety (100);
+    SELECT eingabezeichenposition OF
+      CASE 1: wenn moeglich nach rechts
+      CASE 2: wenn moeglich nach links
+
+      CASE 3: wenn moeglich nach oben
+      CASE 4: wenn moeglich nach unten
+      CASE 5: wenn moeglich ausbessern
+      CASE 6: beende werkstueckbearbeitung
+      OTHERWISE entscheide ob gepiepst wird
+    END SELECT.
+  eingabezeichenposition:
+    pos (moegliche eingabezeichen, eingabezeichen).
+  wenn moeglich nach rechts:
+    IF cursorspalte relativ < breite
+       THEN cursorspalte relativ INCR 1;
+            setze cursor
+       ELSE registriere bedienfehler
+    FI.
+  wenn moeglich nach links:
+
+    IF cursorspalte relativ > 1
+       THEN cursorspalte relativ DECR 1;
+            setze cursor
+       ELSE registriere bedienfehler
+    FI.
+  wenn moeglich nach oben:
+    IF cursorzeile relativ > 1
+       THEN cursorzeile relativ DECR 1;
+            setze cursor
+       ELSE registriere bedienfehler
+    FI.
+  wenn moeglich nach unten:
+    IF cursorzeile relativ < hoehe
+       THEN cursorzeile relativ INCR 1;
+            setze cursor
+       ELSE registriere bedienfehler
+    FI.
+
+  wenn moeglich ausbessern:
+    IF werkstueck [cursorspalte relativ][cursorzeile relativ] = code (fehlerzeichen)
+       THEN werkstueck [cursorspalte relativ][cursorzeile relativ] := code (blank);
+            korrekturzaehler INCR 1;
+            get cursor (fenster, x, y);
+            out (fenster, blank);
+            cursor (fenster, x, y);
+       ELSE registriere bedienfehler
+    FI.
+  registriere bedienfehler:
+    piepse; bedienfehlerzaehler INCR 1.
+  entscheide ob gepiepst wird:
+    IF eingabezeichen <> "" THEN piepse FI.
+
+  beende werkstueckbearbeitung:
+    IF   simulationsende erreicht
+         THEN trage simulationsende in tabelle ein
+    ELIF arbeitsphasenende erreicht
+         THEN trage werkstueckdaten in tabelle ein;
+              ermittle ueberziehung der arbeitsphase;
+              lege eine pause ein
+    ELSE trage werkstueckdaten in tabelle ein
+    FI;
+    werkstueck voll bearbeitet := TRUE.
+  lege eine pause ein:
+    nimm pausendaten;
+    weise auf pausenanfang hin;
+    pausiere;
+    weise auf pausenende hin;
+
+    registriere pausenueberziehung.
+  nimm pausendaten:
+    REAL VAR pausenanfang :: clock (1),
+             pausenende   :: pausenanfang + real (pausendauer * 60);.
+  weise auf pausenanfang hin:
+    page (fenster);
+    boxnotice (fenster, anwendungstext (255), 5, x, y, xsize, ysize).
+  pausiere:
+    REP
+      pause (int ((pausenende - clock (1)) * 10.0))
+    UNTIL clock (1) >= pausenende PER.
+  weise auf pausenende hin:
+    page (fenster);
+    pausenanfang := clock (1);
+    piepse;
+
+    clear buffer;
+    boxinfo (fenster, anwendungstext (256), 5, maxint);
+    pausenende   := clock (1).
+  registriere pausenueberziehung:
+    pausenueberziehung := pausenende - pausenanfang;
+    trage pausenueberziehung in tabelle ein.
+  trage werkstueckdaten in tabelle ein:
+    REAL VAR bearbeitungsende :: clock (1);
+    tab.tabelle [eintragzaehler].eintragskennung    := werkstueckendekennung;
+    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;
+    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;
+
+    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;
+    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;
+    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;
+    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;
+    erhoehe eintragzaehler;
+    beginn der bearbeitung := clock (1);
+    werkstueckzaehler INCR 1;
+    bedienfehlerzaehler := 0;
+    korrekturzaehler    := 0.
+  trage pausenueberziehung in tabelle ein:
+
+    tab.tabelle [eintragzaehler].eintragskennung    := pausenendekennung;
+    tab.tabelle [eintragzaehler].produktionsfehler  := 0;
+    tab.tabelle [eintragzaehler].anzahl korrekturen := 0;
+    tab.tabelle [eintragzaehler].anzahl bedienfehler:= 0;
+    tab.tabelle [eintragzaehler].anfang             := pausenanfang;
+    tab.tabelle [eintragzaehler].ende               := pausenende;
+    tab.tabelle [eintragzaehler].differenz          := pausenueberziehung;
+    erhoehe eintragzaehler;
+    arbeitsphasenzaehler    INCR 1;
+
+    beginn der bearbeitung  := clock (1);
+    beginn der arbeitsphase := clock (1);
+    bearbeitungslaenge bestimmen.
+  trage simulationsende in tabelle ein:
+    bearbeitungsende := clock (1);
+    tab.tabelle [eintragzaehler].eintragskennung    := simulationsendekennung;
+    tab.tabelle [eintragzaehler].produktionsfehler  := produktionsfehler;
+    tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;
+    tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;
+
+    tab.tabelle [eintragzaehler].anfang             := beginn der bearbeitung;
+    tab.tabelle [eintragzaehler].ende               := bearbeitungsende;
+    tab.tabelle [eintragzaehler].differenz          := bearbeitungszeit;
+    tab.letzter eintrag                             := eintragzaehler.
+  bearbeitungszeit:
+    bearbeitungsende - beginn der bearbeitung.
+  erhoehe eintragzaehler:
+    IF eintragzaehler < maxeintraege
+       THEN eintragzaehler INCR 1
+       ELSE trage simulationsende in tabelle ein;
+
+            errorstop (anwendungstext (254))
+    FI.
+  ermittle ueberziehung der arbeitsphase:
+    arbeitsphasenueberziehung := clock (1) - beginn der arbeitsphase
+                                           - arbeitsphasenlaenge.
+  bearbeitungslaenge bestimmen:
+    arbeitsphasenlaenge := real (aphasendauer * 60)
+                                - arbeitsphasenueberziehung
+                                - pausenueberziehung.
+  arbeitsphasenende erreicht:
+    clock (1) - beginn der arbeitsphase >= arbeitsphasenlaenge.
+
+  simulationsende erreicht:
+    arbeitsphasenzaehler = anzahl aphasen AND arbeitsphasenende erreicht.
+END PROC fuehre simulation durch;
+PROC gib bedieninformationen aus (INT CONST zeile):
+  WINDOW VAR f1 :: window ( 2, zeile, 35, 6),
+             f2 :: window (40, zeile, 39, 6);
+  show (f1); show (f2);
+  cursor (f1, 2, 1); out (f1, anwendungstext (11));
+                     out (f1, tastenbezeichnung ( nach rechts));
+  cursor (f1, 2, 2); out (f1, anwendungstext (12));
+                     out (f1, tastenbezeichnung ( nach links));
+
+  cursor (f1, 2, 3); out (f1, anwendungstext (13));
+                     out (f1, tastenbezeichnung ( nach oben));
+  cursor (f1, 2, 4); out (f1, anwendungstext (14));
+                     out (f1, tastenbezeichnung ( nach unten));
+  cursor (f1, 2, 5); out (f1, anwendungstext (15));
+                     out (f1, tastenbezeichnung ( ausbesserung));
+  cursor (f1, 2, 6); out (f1, anwendungstext (16));
+                     out (f1, tastenbezeichnung ( naechstes));
+  cursor (f2, 2, 1); out (f2, anwendungstext (17));
+
+                     out (f2, text (anzahl aphasen, 4));
+  cursor (f2, 2, 2); out (f2, anwendungstext (18));
+                     out (f2, text (aphasendauer,   4));
+                     out (f2, anwendungstext (51));
+  cursor (f2, 2, 3); out (f2, anwendungstext (19));
+                     out (f2, text (pausendauer,    4));
+                     out (f2, anwendungstext (51));
+  cursor (f2, 2, 4); out (f2, anwendungstext ( 5));
+                     out (f2, text (gesamtzeit,      4));
+                     out (f2, anwendungstext (51));
+
+  cursor (f2, 2, 6); out (f2, anwendungstext (251));
+                     out (f2, 3 * blank);
+                     out (f2, fehlerzeichen).
+END PROC gib bedieninformationen aus;
+INT PROC gesamtzeit:
+  anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer
+END PROC gesamtzeit;
+PROC hole werkstueck (WERKSTUECK VAR w, INT VAR anzahl fehler):
+  INT VAR spaltenzaehler, zeilenzaehler;
+  anzahl fehler := 0;
+  FOR zeilenzaehler FROM 1 UPTO hoehe REP
+    ermittle eine zeile
+  PER.
+
+  ermittle eine zeile:
+    FOR spaltenzaehler FROM 1 UPTO breite REP
+      ermittle eine position;
+      ggf fehler registrieren
+    PER.
+  ermittle eine position:
+    w [spaltenzaehler][zeilenzaehler] := zufallscode.
+  zufallscode:
+    random (kleinster code, groesster code).
+  ggf fehler registrieren:
+    IF w [spaltenzaehler][zeilenzaehler] = code (fehlerzeichen)
+       THEN anzahl fehler INCR 1
+    FI.
+END PROC hole werkstueck;
+PROC zeige werkstueck (WERKSTUECK CONST w, WINDOW VAR f):
+
+  INT VAR spaltenzaehler, zeilenzaehler;
+  page (f);
+  FOR zeilenzaehler FROM 1 UPTO hoehe REP
+    zeige eine zeile
+  PER.
+  zeige eine zeile:
+    cursor (f, eckspalte, eckzeile + zeilenzaehler - 1);
+    ggf invers einschalten;
+    FOR spaltenzaehler FROM 1 UPTO breite REP
+      out (f, code (w [spaltenzaehler][zeilenzaehler]))
+    PER;
+    ggf invers ausschalten.
+  ggf invers einschalten:
+    IF inversdarstellung THEN out (f, markierung ein) FI.
+  ggf invers ausschalten:
+    IF inversdarstellung THEN out (f, markierung aus) FI.
+
+END PROC zeige werkstueck;
+PROC kurzauswertung auf bildschirm (TEXT CONST dateiname):
+  WINDOW VAR fenster :: window (  2, 10, 77, 13);
+  show (fenster);
+  clear buffer;
+  notiere ueberschrift;
+  notiere ergebnis.
+  notiere ueberschrift:
+    cursor (fenster, 1, 1);
+    out (fenster, center (fenster, anwendungstext (275)));
+    cursor (fenster, 1, 2);
+    out (fenster, center (fenster, anwendungstext (276))).
+  notiere ergebnis:
+    BOUND KONTROLLTABELLE CONST k := old (dateiname);
+    ermittle die simulationsdaten;
+
+    notiere gesamtzahl werkstuecke;
+    notiere zeichengesamtzahl;
+    notiere bedienfehler;
+    notiere benoetigte zeit;
+    notiere gesamtausbesserungsrate;
+    notiere gesamtbewertungsfaktor;
+    notiere gesamtbewertungszahl mit pausenueberziehung;
+    cursor (1, 24); out (anwendungstext (2));
+    pause.
+  ermittle die simulationsdaten:
+    INT  VAR z, anzahl zeichen pro werkstueck,
+             anzahl werkstuecke        ::   0,
+             anzahl bedienfehler       ::   0,
+             anzahl produktionsfehler  ::   0,
+
+             anzahl korrekturen        ::   0;
+    REAL VAR gesamtzahl zeichen, anteil korrekturen,
+             gesamtzeit                :: 0.0,
+             pausenueberzug            :: 0.0;
+    FOR z FROM 1 UPTO k.letzter eintrag REP
+      IF   k.tabelle [z].eintragskennung = werkstueckendekennung
+           THEN anzahl werkstuecke       INCR 1;
+                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;
+                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;
+
+                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;
+                gesamtzeit               INCR k.tabelle [z].differenz;
+      ELIF k.tabelle [z].eintragskennung = pausenendekennung
+           THEN pausenueberzug           INCR k.tabelle [z].differenz;
+      FI
+    PER;
+    anzahl zeichen pro werkstueck := k.breite * k.hoehe;
+    gesamtzahl zeichen            :=   real (anzahl werkstuecke)
+                                     * real (anzahl zeichen pro werkstueck);
+
+    IF anzahl produktionsfehler = 0
+       THEN anteil korrekturen    := 1.0
+       ELSE anteil korrekturen    :=   real (anzahl korrekturen)
+                                     / real (anzahl produktionsfehler)
+    FI.
+  notiere gesamtzahl werkstuecke:
+    cursor (fenster, 12, 4); out (fenster, anwendungstext (277));
+                             out (fenster, text (anzahl werkstuecke, 8)).
+  notiere zeichengesamtzahl:
+    cursor (fenster, 12, 5); out (fenster, anwendungstext (278));
+                             out (fenster, zahl aus zeichenkette).
+
+  zahl aus zeichenkette:
+    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).
+  notiere bedienfehler:
+    cursor (fenster, 12, 6); out (fenster, anwendungstext (279));
+                             out (fenster, text (anzahl bedienfehler, 8)).
+  notiere benoetigte zeit:
+    cursor (fenster, 12, 7); out (fenster, anwendungstext (280));
+                             out (fenster, text (gesamtzeit,         8, 2)).
+  notiere gesamtausbesserungsrate:
+    cursor (fenster, 12, 9); out (fenster, anwendungstext (281));
+
+                             out (fenster, text (anteil korrekturen, 8, 2)).
+  notiere gesamtbewertungsfaktor:
+    cursor (fenster, 12,10); out (fenster, anwendungstext (282));
+                             out (fenster, text (bewertungsfaktor, 8, 2)).
+  bewertungsfaktor:
+    bewertungsmasszahl (anteil korrekturen).
+  notiere gesamtbewertungszahl mit pausenueberziehung:
+    cursor (fenster, 12, 12); out (fenster, (anwendungstext (283)));
+                              out (fenster, text (gesamtwertung,   8, 2));
+
+    cursor (fenster, 12, 13); out (fenster, (anwendungstext (284)));
+                              out (fenster, 8 * "=").
+  gesamtwertung:
+    IF gesamtzeit = 0.0
+       THEN 0.0
+       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug)
+                               * bewertungsfaktor
+    FI.
+END PROC kurzauswertung auf bildschirm;
+PROC simulationsauswertung (TEXT CONST dateiname, BOOL CONST mit zeigen):
+  TEXT CONST auswertdatei :: dateiname + auswertdateipostfix;
+  ermittle die kenndaten aus der protokolldatei (dateiname);
+
+  notiere ueberschrift 1               (auswertdatei);
+  notiere die kenndaten der simulation (auswertdatei);
+  notiere die werkstueckkenndaten      (auswertdatei);
+  notiere ein beispielwerkstueck       (auswertdatei);
+  notiere ueberschrift 2               (auswertdatei);
+  notiere gesamtergebnisse             (auswertdatei, dateiname);
+  notiere ueberschrift 3               (auswertdatei);
+  notiere tabellenkopf                 (auswertdatei);
+  notiere einzelne werkstueckdaten     (auswertdatei, dateiname);
+
+  notiere ggf die anmerkungen;
+  zeige ggf auswertung auf bildschirm.
+  notiere ggf die anmerkungen:
+    IF mit anmerkungen
+       THEN notiere anmerkungen        (auswertdatei);
+    FI.
+  zeige ggf auswertung auf bildschirm:
+    IF mit zeigen
+       THEN cursor on; show (auswertdatei); cursor off
+    FI.
+END PROC simulationsauswertung;
+PROC ermittle die kenndaten aus der protokolldatei (TEXT CONST dateiname):
+  BOUND KONTROLLTABELLE CONST k := old (dateiname);
+  breite                    := k.breite;
+
+  hoehe                     := k.hoehe;
+  kleinster code            := k.kleinster code;
+  groesster code            := k.groesster code;
+  fehlerzeichen             := k.fehlerzeichen;
+  inversdarstellung         := k.inversdarstellung;
+  nach rechts               := k.nach rechts;
+  nach links                := k.nach links;
+  nach oben                 := k.nach oben;
+  nach unten                := k.nach unten;
+  ausbesserung              := k.ausbesserung;
+  naechstes                 := k.naechstes;
+
+  anzahl aphasen            := k.anzahl aphasen;
+  aphasendauer              := k.aphasendauer;
+  pausendauer               := k.pausendauer;
+  datum                     := k.datum;
+  uhrzeit                   := k.uhrzeit;
+  bewertung                 := k.bewertung;
+END PROC ermittle die kenndaten aus der protokolldatei;
+PROC notiere ueberschrift 1 (TEXT CONST auswertdatei):
+  IF exists (auswertdatei)
+     THEN forget (auswertdatei, quiet)
+  FI;
+  FILE VAR f :: sequential file (output, auswertdatei);
+
+  IF auswertung geht zum drucker
+     THEN schreibe druckeranweisungen
+  FI;
+  putline (f, center (auswertdatei));
+  putline (f, center (length (auswertdatei) * "="));
+  put (f, anwendungstext (272)); put (f, datum); put (f, 26 * blank);
+  put (f, anwendungstext (273)); putline (f, uhrzeit);
+  line (f);
+  putline (f, center (anwendungstext (291)));
+  putline (f, center (length (anwendungstext (291)) * "=")).
+  schreibe druckeranweisungen:
+    write (f, "#type (""");
+    write (f, protokollschrifttyp);
+
+    write (f, """)##limit (");
+    write (f, text (schreibfeldbreite));
+    write (f, ")##pagelength (");
+    write (f, text (schreibfeldlaenge));
+    write (f, ")##start (");
+    write (f, text (xstart));
+    write (f, ",");
+    write (f, text (ystart));
+    write (f, ")#"); line (f).
+END PROC notiere ueberschrift 1;
+PROC notiere ueberschrift 2 (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+  putline (f, center (anwendungstext (285)));
+  putline (f, center (length (anwendungstext (285)) * "="))
+
+END PROC notiere ueberschrift 2;
+PROC notiere ueberschrift 3 (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+  line (f, 2);
+  putline (f, center (anwendungstext (311)));
+  putline (f, center (length (anwendungstext (311)) * "="));
+  line (f)
+END PROC notiere ueberschrift 3;
+PROC notiere die kenndaten der simulation (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+  ROW 6 TEXT VAR ausgabe;
+  bestuecke ausgabezeilen;
+  schreibe ausgabezeilen.
+
+  bestuecke ausgabezeilen:
+    ausgabe [1] :=   anwendungstext (11)
+                   + gleichlang (tastenbezeichnung (nach rechts ), 23)
+                   + anwendungstext (17)
+                   + text (anzahl aphasen,   4);
+    ausgabe [2] :=   anwendungstext (12)
+                   + gleichlang (tastenbezeichnung (nach links  ), 23)
+                   + anwendungstext (18)
+                   + text (aphasendauer,     4) + anwendungstext (51);
+    ausgabe [3] :=   anwendungstext (13)
+
+                   + gleichlang (tastenbezeichnung (nach oben   ), 23)
+                   + anwendungstext (19)
+                   + text (pausendauer,      4) + anwendungstext (51);
+    ausgabe [4] :=   anwendungstext (14)
+                   + gleichlang (tastenbezeichnung (nach unten  ), 23)
+                   + anwendungstext ( 5)
+                   + text (simulationsdauer, 4) + anwendungstext (51);
+    ausgabe [5] :=   anwendungstext (15)
+                   + gleichlang (tastenbezeichnung (ausbesserung), 23);
+
+    ausgabe [6] :=   anwendungstext (16)
+                   + gleichlang (tastenbezeichnung (naechstes   ), 23)
+                   + anwendungstext (251)
+                   + (3 * blank) + fehlerzeichen.
+  simulationsdauer:
+    anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer.
+  schreibe ausgabezeilen:
+    INT VAR i;
+    FOR i FROM 1 UPTO 6 REP
+      putline (f, ausgabe [i])
+    PER;
+    line (f).
+END PROC notiere die kenndaten der simulation;
+PROC notiere die werkstueckkenndaten (TEXT CONST auswertdatei):
+
+  FILE VAR f :: sequential file (output, auswertdatei);
+  ROW 4 TEXT VAR ausgabe;
+  bestuecke ausgabezeilen;
+  schreibe ausgabezeilen.
+  bestuecke ausgabezeilen:
+    ausgabe [1] :=  anwendungstext (292) + text (breite,        4) +
+                    anwendungstext (296);
+    ausgabe [2] :=  anwendungstext (293) + text (hoehe,          4) +
+                    anwendungstext (296);
+    ausgabe [3] :=  anwendungstext (294) + text (breite * hoehe, 4) +
+                    anwendungstext (296);
+
+    ausgabe [4] :=  anwendungstext (295) + zeichenumfang.
+  zeichenumfang:
+    " " + code (kleinster code) + " ... " + code (groesster code) +
+    " (" + text (groesster code - kleinster code + 1, 3) +
+    anwendungstext (296) + ")".
+  schreibe ausgabezeilen:
+    INT VAR i;
+    FOR i FROM 1 UPTO 4 REP putline (f, ausgabe [i]) PER;
+    line (f).
+END PROC notiere die werkstueckkenndaten;
+PROC notiere ein beispielwerkstueck (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+
+  WERKSTUECK VAR beispiel;
+  INT VAR beispielfehler;
+  hole werkstueck (beispiel, beispielfehler);
+  notiere ueberschrift;
+  notiere werkstueckzeilen;
+  notiere werkstueckleerzeilen.
+  notiere ueberschrift:
+    putline (f, center (anwendungstext (297)));
+    putline (f, center (length (anwendungstext (297)) * "-")).
+  notiere werkstueckzeilen:
+    INT VAR bs, bz;
+    FOR bz FROM 1 UPTO hoehe REP
+      notiere eine zeile
+    PER.
+  notiere eine zeile:
+    TEXT VAR beispielzeile :: "";
+
+    konstruiere beispielzeile;
+    gib beispielzeile aus.
+  konstruiere beispielzeile:
+    beispielzeile CAT (((80 - breite) DIV 2) * blank);
+    FOR bs FROM 1 UPTO breite REP
+      beispielzeile CAT code (beispiel [bs][bz])
+    PER.
+  gib beispielzeile aus:
+    putline (f, beispielzeile).
+  notiere werkstueckleerzeilen:
+    line (f, maxzeilen - hoehe + 1).
+END PROC notiere ein beispielwerkstueck;
+PROC notiere gesamtergebnisse (TEXT CONST auswertdatei, protokolldatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+
+  BOUND KONTROLLTABELLE CONST k :: old (protokolldatei);
+  ermittle die simulationsdaten;
+    notiere gesamtzahl werkstuecke;
+    notiere anzahl zeichen pro werkstueck;
+    notiere zeichengesamtzahl;
+    notiere bedienfehler;
+    notiere produktionsfehlerzahl;
+    notiere fehlerkorrekturen;
+    notiere gesamtzeit mit pausenueberziehung;
+    notiere zeichenzahl pro sekunde mit;
+    notiere gesamtausbesserungsrate;
+    notiere gesamtbewertungsfaktor  mit;
+    notiere gesamtbewertungszahl    mit;
+
+    notiere gesamtzeit ohne pausenueberziehung;
+    notiere zeichenzahl pro sekunde ohne;
+    notiere gesamtbewertungszahl    ohne.
+  ermittle die simulationsdaten:
+    INT  VAR z, anzahl zeichen pro werkstueck,
+             anzahl werkstuecke        ::   0,
+             anzahl bedienfehler       ::   0,
+             anzahl produktionsfehler  ::   0,
+             anzahl korrekturen        ::   0;
+    REAL VAR gesamtzahl zeichen, anteil korrekturen,
+             gesamtzeit                :: 0.0,
+
+             pausenueberzug            :: 0.0;
+    FOR z FROM 1 UPTO k.letzter eintrag REP
+      IF   k.tabelle [z].eintragskennung = werkstueckendekennung
+           THEN anzahl werkstuecke       INCR 1;
+                anzahl bedienfehler      INCR k.tabelle [z].anzahl bedienfehler;
+                anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;
+                anzahl korrekturen       INCR k.tabelle [z].anzahl korrekturen;
+                gesamtzeit               INCR k.tabelle [z].differenz;
+
+      ELIF k.tabelle [z].eintragskennung = pausenendekennung
+           THEN pausenueberzug           INCR k.tabelle [z].differenz;
+      FI
+    PER;
+    anzahl zeichen pro werkstueck := k.breite * k.hoehe;
+    gesamtzahl zeichen            :=   real (anzahl werkstuecke)
+                                     * real (anzahl zeichen pro werkstueck);
+    IF anzahl produktionsfehler = 0
+       THEN anteil korrekturen    := 1.0
+       ELSE anteil korrekturen    :=   real (anzahl korrekturen)
+
+                                     / real (anzahl produktionsfehler)
+    FI.
+  notiere gesamtzahl werkstuecke:
+    put (f, anwendungstext (277)); putline (f, text (anzahl werkstuecke, 8)).
+  notiere anzahl zeichen pro werkstueck:
+    put (f, anwendungstext (286)); putline (f, text (breite * hoehe,     8)).
+  notiere zeichengesamtzahl:
+    put (f, anwendungstext (278)); putline (f, zahl aus zeichenkette);
+    line (f).
+  zahl aus zeichenkette:
+    subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).
+
+  notiere produktionsfehlerzahl:
+    put (f, anwendungstext (287)); putline (f, text (anzahl produktionsfehler, 8)).
+  notiere fehlerkorrekturen:
+    put (f, anwendungstext (288)); putline (f, text (anzahl korrekturen, 8)).
+  notiere bedienfehler:
+    put (f, anwendungstext (279)); putline (f, text (anzahl bedienfehler,8));
+    line (f).
+  notiere gesamtzeit mit pausenueberziehung:
+    put (f, anwendungstext (301)); put (f, text (gesamtzeit mit, 8, 1));
+    putline (f, anwendungstext (300)).
+
+  gesamtzeit mit:
+    gesamtzeit + pausenueberzug.
+  notiere zeichenzahl pro sekunde mit:
+    put (f, anwendungstext (302));
+    putline (f, text (zeichenpro sec mit, 8, 1));
+    line (f).
+  zeichen pro sec mit:
+    IF gesamtzeit + pausenueberzug > 0.0
+       THEN gesamtzahl zeichen / (gesamtzeit + pausenueberzug)
+       ELSE 0.0
+    FI.
+  notiere gesamtausbesserungsrate:
+    put (f, anwendungstext (281)); putline (f, text (anteil korrekturen, 8, 1)).
+  notiere gesamtbewertungsfaktor mit:
+
+    put (f, anwendungstext (282)); putline (f, text (bewertungsfaktor, 8, 1));
+    line (f).
+  bewertungsfaktor:
+    bewertungsmasszahl (anteil korrekturen).
+  notiere gesamtbewertungszahl mit:
+    put (f, (anwendungstext (283))); putline (f, text (gesamtwertung mit,   8, 1));
+    put (f, (anwendungstext (284))); putline (f, 8 * "=").
+  gesamtwertung mit:
+    IF gesamtzeit = 0.0
+       THEN 0.0
+       ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug)
+                               * bewertungsfaktor
+
+    FI.
+  notiere gesamtzeit ohne pausenueberziehung:
+    put (f, anwendungstext (303)); put (f, text (gesamtzeit, 8, 1));
+    putline (f, anwendungstext (300)).
+  notiere zeichenzahl pro sekunde ohne:
+    put (f, anwendungstext (302));
+    putline (f, text (zeichenpro sec ohne, 8, 1)).
+  zeichen pro sec ohne:
+    IF gesamtzeit > 0.0
+       THEN gesamtzahl zeichen / gesamtzeit
+       ELSE 0.0
+    FI.
+  notiere gesamtbewertungszahl ohne:
+    put (f, (anwendungstext (304))); putline (f, text (gesamtwertung ohne,   8, 1));
+
+    put (f, (anwendungstext (284))); putline (f, 8 * "=").
+  gesamtwertung ohne:
+    IF gesamtzeit = 0.0
+       THEN 0.0
+       ELSE gesamtzahl zeichen / gesamtzeit * bewertungsfaktor
+    FI.
+END PROC notiere gesamtergebnisse;
+PROC notiere tabellenkopf (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+  putline (f, anwendungstext (312));
+  putline (f, anwendungstext (313));
+  putline (f, anwendungstext (314));
+  putline (f, anwendungstext (315));
+  putline (f, anwendungstext (316));
+
+  putline (f, anwendungstext (317));
+  putline (f, anwendungstext (318));
+END PROC notiere tabellenkopf;
+PROC notiere einzelne werkstueckdaten (TEXT CONST auswertdatei, dateiname):
+  BOUND KONTROLLTABELLE CONST k :: old (dateiname);
+  FILE VAR f :: sequential file (output, auswertdatei);
+  INT  VAR zeiger, werkstuecknummer :: 0;
+  TEXT VAR ausgabezeile :: "";
+  FOR zeiger FROM 1 UPTO k.letzter eintrag REP
+   notiere bearbeitungszeile
+  PER.
+  notiere bearbeitungszeile:
+    IF   k.tabelle [zeiger].eintragskennung = werkstueckendekennung
+
+         THEN werkstuecknummer INCR 1;
+              schreibe werkstueckzeile
+    ELIF k.tabelle [zeiger].eintragskennung = pausenendekennung
+         THEN schreibe pausenzeile
+    ELIF k.tabelle [zeiger].eintragskennung = simulationsendekennung
+         THEN werkstuecknummer INCR 1;
+              schreibe abschluss
+    ELSE putline (f, 75 * "?")
+    FI.
+  schreibe werkstueckzeile:
+    konstruiere ausgabezeile;
+    putline (f, ausgabezeile).
+  konstruiere ausgabezeile:
+    ausgabezeile := "";
+
+    ausgabezeile CAT text (werkstuecknummer, 5);
+    ausgabezeile CAT 2 * blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (k.tabelle [zeiger].anzahl bedienfehler, 5);
+    ausgabezeile CAT 3 * blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (k.tabelle [zeiger].produktionsfehler,   6);
+    ausgabezeile CAT 2 * blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (k.tabelle [zeiger].anzahl korrekturen,  6);
+    ausgabezeile CAT 2 * blank;
+    ausgabezeile CAT trenn;
+
+    ausgabezeile CAT text (k.tabelle [zeiger].differenz,  6, 1);
+    ausgabezeile CAT blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (zeichen pro zeiteinheit,  6, 1);
+    ausgabezeile CAT blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (einzelausbesserungsrate,  6, 1);
+    ausgabezeile CAT blank;
+    ausgabezeile CAT trenn;
+    ausgabezeile CAT text (bewertungsmasszahl (einzelausbesserungsrate), 6, 1);
+    ausgabezeile CAT blank;
+    ausgabezeile CAT trenn;
+
+    ausgabezeile CAT text (endbewertungszahl, 6, 1);
+    ausgabezeile CAT blank.
+  zeichen pro zeiteinheit:
+    real (breite * hoehe) / k.tabelle [zeiger].differenz.
+  einzelausbesserungsrate:
+    IF k.tabelle [zeiger].produktionsfehler = 0
+       THEN 0.0
+       ELSE   real (k.tabelle [zeiger].anzahl korrekturen)
+            / real (k.tabelle [zeiger].produktionsfehler )
+    FI.
+  endbewertungszahl:
+    real (breite * hoehe) / k.tabelle [zeiger].differenz
+                          * bewertungsmasszahl (einzelausbesserungsrate).
+
+  schreibe pausenzeile:
+    line (f);
+    put     (f, anwendungstext (320));
+    put     (f, text (k.tabelle [zeiger].differenz, 6, 1));
+    putline (f, anwendungstext (300));
+    line (f).
+  schreibe abschluss:
+    putline (f, anwendungstext (318));
+    putline (f, anwendungstext (319));
+    line (f);
+    konstruiere ausgabezeile;
+    ausgabezeile := "(" +
+                    subtext (ausgabezeile, 2, length (ausgabezeile) - 1) +
+                    ")";
+    putline (f, ausgabezeile).
+
+END PROC notiere einzelne werkstueckdaten;
+PROC notiere anmerkungen (TEXT CONST auswertdatei):
+  FILE VAR f :: sequential file (output, auswertdatei);
+  line (f);
+  schreibe kopf;
+  schreibe hinweis auf letztes werkstueck;
+  schreibe hinweis auf bedienfehler;
+  erlaeutere bewertungsschluessel;
+  stelle bewertungsschluessel graphisch dar;
+  schreibe rest.
+  schreibe kopf:
+    putline (f, center (anwendungstext (325)));
+    putline (f, center (length (anwendungstext (325)) * "="));
+    line (f).
+
+  schreibe hinweis auf letztes werkstueck:
+    INT VAR i;
+    FOR i FROM 326 UPTO 337 REP
+      putline (f, anwendungstext (i))
+    PER;
+    line (f).
+  schreibe hinweis auf bedienfehler:
+    FOR i FROM 339 UPTO 341 REP
+      putline (f, anwendungstext (i))
+    PER;
+    line (f).
+  erlaeutere bewertungsschluessel:
+    FOR i FROM 343 UPTO 372 REP
+      putline (f, anwendungstext (i))
+    PER.
+  stelle bewertungsschluessel graphisch dar:
+    putline (f, anwendungstext (374));
+    putline (f, anwendungstext (375));
+
+    ermittle die startposition;
+    zeichne diagramm;
+    trage werte ein.
+  ermittle die startposition:
+    modify (f);
+    INT VAR zeilenpos :: lines (f) + 2, spaltenpos :: 18.
+  zeichne diagramm:
+    cursor (f, spaltenpos, zeilenpos     , anwendungstext (20));
+    cursor (f, spaltenpos, zeilenpos +  1, anwendungstext (21));
+    cursor (f, spaltenpos, zeilenpos +  3, anwendungstext (23));
+    cursor (f, spaltenpos, zeilenpos +  4, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos +  5, anwendungstext (22));
+
+    cursor (f, spaltenpos, zeilenpos +  6, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos +  7, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos +  8, anwendungstext (24));
+    cursor (f, spaltenpos, zeilenpos +  9, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos + 10, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos + 11, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos + 12, anwendungstext (22));
+    cursor (f, spaltenpos, zeilenpos + 13, anwendungstext (25));
+
+    cursor (f, spaltenpos, zeilenpos + 14, anwendungstext (26));
+    cursor (f, spaltenpos, zeilenpos + 15, anwendungstext (27)).
+  trage werte ein:
+    zeilenpos INCR 13;
+    INT VAR bwzeiger;
+    FOR bwzeiger FROM 1 UPTO 11 REP
+      cursor (f, spaltenpos + 3 * bwzeiger, zeilenpos - konkreter wert, "+")
+    PER.
+  konkreter wert:
+    int (bewertung [bwzeiger] * 10.0).
+  schreibe rest:
+    output (f);
+    line (f, 2);
+    FOR i FROM 377 UPTO 387 REP
+      putline (f, anwendungstext (i))
+
+    PER;
+    haenge an jede zeile ein blank an.
+  haenge an jede zeile ein blank an:
+    TEXT VAR inhalt;
+    INT  VAR zeilenzeiger;
+    modify (f);
+    FOR zeilenzeiger FROM 1 UPTO lines (f) REP
+      to line (f, zeilenzeiger);
+      read record (f, inhalt);
+      inhalt CAT blank;
+      write record (f, inhalt)
+    PER;
+    to line (f,1).
+END PROC notiere anmerkungen;
+PROC cursor (FILE VAR f, INT CONST spa, zei, TEXT CONST text):
+  positioniere an zeile;
+  positioniere an spalte;
+
+  gib text an position aus.
+  positioniere an zeile:
+    IF zeile noch nicht vorhanden
+       THEN schaffe zeile und gehe dorthin
+       ELSE to line (f,zei)
+    FI.
+  zeile noch nicht vorhanden:
+    zei > lines (f).
+  schaffe zeile und gehe dorthin:
+    INT VAR zaehler 1;
+    IF lines (f) = 0
+       THEN to line (f,lines (f));
+            insert record (f);
+    FI;
+    FOR zaehler 1 FROM lines (f)  UPTO zei REP
+      to line (f,lines (f));
+      down (f);insert record (f)
+    PER;
+
+    to line(f,zei).
+  positioniere an spalte:
+    TEXT VAR alter satz :: "", neuer satz :: "", restsatz ::"";
+    INT VAR satzlaenge;
+    read record (f,alter satz);
+    satzlaenge := length (alter satz);
+    IF satzlaenge = 0
+       THEN neuer satz CAT (spa -1) * " "
+    ELIF satzlaenge >= spa
+       THEN neuer satz := subtext(alter satz,1,spa-1);
+            restsatz   := subtext(alter satz, spa + length (text));
+       ELSE neuer satz := alter satz;
+            neuer satz CAT (spa - satzlaenge - 1) * " "
+
+    FI.
+  gib text an position aus:
+   neuer satz CAT text;
+   IF restsatz <> ""
+      THEN neuer satz CAT restsatz
+   FI;
+   write record(f,neuer satz).
+ END PROC cursor;
+TEXT PROC gleichlang (TEXT CONST text, INT CONST laenge):
+  TEXT VAR intern :: compress (text);
+  INT  VAR anzahl :: laenge - length (intern);
+  IF anzahl < 0
+     THEN subtext (intern, 1, laenge)
+     ELSE intern + (anzahl * blank)
+  FI
+END PROC gleichlang;
+REAL PROC bewertungsmasszahl (REAL CONST wert):
+  REAL VAR interner wert := round (wert, 1);
+
+  IF interner wert > wert
+     THEN interner wert DECR 0.1
+  FI;
+  interpoliere.
+  interpoliere:
+    REAL VAR unterer wert, oberer wert;
+    unterer wert := interner wert;
+    IF unterer wert = 1.0
+       THEN oberer wert := 1.0
+       ELSE oberer  wert := unterer wert + 0.1
+    FI;
+    unterer wert := bewertung (int (unterer wert * 10.0) + 1);
+    oberer  wert := bewertung (int (oberer  wert * 10.0) + 1);
+    unterer wert + (oberer wert - unterer wert) * faktor.
+  faktor:
+    frac (wert * 10.0).
+
+END PROC bewertungsmasszahl;
+PROC zeige aktuellen protokollumfang an:
+  WINDOW VAR w :: window (2, 2, 34,  5);
+  show (w);
+  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));
+  IF mit anmerkungen
+     THEN cursor (w, 2, 4); out (w, anwendungstext (432))
+     ELSE cursor (w, 2, 4); out (w, anwendungstext (433));
+  FI.
+END PROC zeige aktuellen protokollumfang an;
+PROC gib erlaeuterungen zum protokollumfang:
+  WINDOW VAR f :: window ( 2, 9, 77, 15);
+  show (f);
+  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (434))));
+
+  cursor (f, 5, 3); out (f, anwendungstext (435));
+  cursor (f, 5, 4); out (f, anwendungstext (436));
+  cursor (f, 5, 5); out (f, anwendungstext (437));
+  cursor (f, 5, 6); out (f, anwendungstext (438));
+  cursor (f, 5, 8); out (f, anwendungstext (439));
+  cursor (f, 5, 9); out (f, anwendungstext (440));
+  cursor (f, 5,10); out (f, anwendungstext (441));
+  cursor (f, 5,11); out (f, anwendungstext (442));
+  cursor (f, 5,13); out (f, anwendungstext (443));
+  cursor (f, 5,14); out (f, anwendungstext (444));
+
+END PROC gib erlaeuterungen zum protokollumfang;
+PROC frage nach umfangsaenderung:
+  WINDOW VAR fenster :: window (38, 2, 41, 5);
+  show (fenster);
+  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (451))));
+  cursor (fenster, 4, 3); out (fenster, anwendungstext (452));
+  cursor (fenster, 4, 4);
+  IF yes (fenster, anwendungstext (453))
+     THEN  mit anmerkungen := NOT mit anmerkungen
+  FI.
+END PROC frage nach umfangsaenderung;
+PROC zeige aktuelle kurzauswertungseinstellung an:
+
+  WINDOW VAR w :: window ( 2, 2, 34,  5);
+  show (w);
+  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));
+  IF mit kurzprotokoll
+     THEN cursor (w, 7, 4); out (w, anwendungstext (461));
+     ELSE cursor (w, 7, 4); out (w, anwendungstext (462));
+  FI.
+END PROC zeige aktuelle kurzauswertungseinstellung an;
+PROC gib erlaeuterungen zur kurzauswertung:
+  WINDOW VAR f :: window ( 2, 9, 77, 15);
+  show (f);
+  cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (463))));
+
+  cursor (f, 5, 3); out (f, anwendungstext (464));
+  cursor (f, 5, 4); out (f, anwendungstext (465));
+  cursor (f, 5, 5); out (f, anwendungstext (466));
+  cursor (f, 5, 6); out (f, anwendungstext (467));
+  cursor (f, 5, 8); out (f, anwendungstext (468));
+  cursor (f, 5, 9); out (f, anwendungstext (469));
+  cursor (f, 5,10); out (f, anwendungstext (470));
+  cursor (f, 5,11); out (f, anwendungstext (471));
+  cursor (f, 5,13); out (f, anwendungstext (472));
+  cursor (f, 5,14); out (f, anwendungstext (473));
+
+END PROC gib erlaeuterungen zur kurzauswertung;
+PROC frage nach kurzauswertungsaenderung:
+  WINDOW VAR fenster :: window (38, 2, 41, 5);
+  show (fenster);
+  cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (481))));
+  cursor (fenster, 5, 3); out (fenster, anwendungstext (482));
+  cursor (fenster, 5, 4);
+  IF yes (fenster, anwendungstext (483))
+     THEN  mit kurzprotokoll := NOT mit kurzprotokoll
+  FI.
+END PROC frage nach kurzauswertungsaenderung;
+END PACKET ls mp bap 2;
+
 
diff --git a/mp-bap/ls-MP BAP-gen b/mp-bap/ls-MP BAP-gen
index 26a84c3..40df0b4 100644
--- a/mp-bap/ls-MP BAP-gen
+++ b/mp-bap/ls-MP BAP-gen
@@ -22,9 +22,79 @@ END PROC stelle existenz des mm sicher;
  
 PROC vom archiv (TEXT CONST datei): 
   cursor (1,5); out (""4""); 
-  out ("  """); out (datei); putline (""" wird geholt.");{}  fetch (datei, archive){}END PROC vom archiv;{}PROC hole (TEXT CONST datei):{}  IF NOT exists (datei) THEN vom archiv (datei) FI{}END PROC hole;{}PROC in (TEXT CONST datei):{}  hole (datei);{}  cursor (1, 5); out (""4"");{}  out ("  """); out (datei); out (""" wird übersetzt: ");{}  insert (datei);{}  forget (datei, quiet);{}END PROC in;{}PROC schicke (TEXT CONST datei):{}  cursor (1, 5); out (""4"");{}  out ("  """); out(datei);{}  out (""" wird zum MENUKARTEN-MANAGER geschickt!");{}
-  command dialogue (FALSE);{}  save (datei, task (mm taskname));{}  command dialogue (TRUE);{}  forget (datei, quiet){}END PROC schicke;{}INT VAR size, used;{}BOOL VAR einzeln;{}storage (size, used);{}einzeln := size - used < 500;{}forget (eigener name, quiet);{}wirf kopfzeile aus;{}stelle existenz des mm sicher;{}hole die dateien;{}insertiere die dateien;{}mache global manager aus der task.{}wirf kopfzeile aus:{}  page;{}  putline ("                  "15"ls-MP BAP  -  Automatische Generierung "14"").{}
-hole die dateien:{}  IF     NOT exists (datei 1){}     COR NOT exists (datei 2){}     COR NOT exists (menukarte){}     THEN hole dateien vom archiv; LEAVE hole die dateien{}  FI.{}hole dateien vom archiv:{}  cursor (1,3); out (""4"");{}  IF yes ("Ist das Archiv angemeldet und die Diskette eingelegt"){}     THEN lese ein{}     ELSE line (2);{}          errorstop ("Ohne die Diskette kann ich das System nicht generieren!"){}  FI.{}lese ein:{}  cursor (1, 3); out (""4"");{}  out ("                   "15"Bitte die Diskette eingelegt lassen! "14"");{}
-  IF NOT einzeln{}     THEN  hole (datei 1);{}           hole (datei 2);{}           hole (menukarte);{}           cursor (1, 3); out(""4"");{}           out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");{}           release (archive){}  FI.{}insertiere die dateien:{}  check off;{}  cursor (1, 3); out(""4"");{}  out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");{}  in (datei 1);{}  in (datei 2);{}  schicke (menukarte);{}  IF einzeln THEN release (archive) FI;{}
-  check on.{}mache global manager aus der task:{}  global manager.{}
+  out ("  """); out (datei); putline (""" wird geholt.");
+  fetch (datei, archive)
+END PROC vom archiv;
+PROC hole (TEXT CONST datei):
+  IF NOT exists (datei) THEN vom archiv (datei) FI
+END PROC hole;
+PROC in (TEXT CONST datei):
+  hole (datei);
+  cursor (1, 5); out (""4"");
+  out ("  """); out (datei); out (""" wird übersetzt: ");
+  insert (datei);
+  forget (datei, quiet);
+END PROC in;
+PROC schicke (TEXT CONST datei):
+  cursor (1, 5); out (""4"");
+  out ("  """); out(datei);
+  out (""" wird zum MENUKARTEN-MANAGER geschickt!");
+
+  command dialogue (FALSE);
+  save (datei, task (mm taskname));
+  command dialogue (TRUE);
+  forget (datei, quiet)
+END PROC schicke;
+INT VAR size, used;
+BOOL VAR einzeln;
+storage (size, used);
+einzeln := size - used < 500;
+forget (eigener name, quiet);
+wirf kopfzeile aus;
+stelle existenz des mm sicher;
+hole die dateien;
+insertiere die dateien;
+mache global manager aus der task.
+wirf kopfzeile aus:
+  page;
+  putline ("                  "15"ls-MP BAP  -  Automatische Generierung "14"").
+
+hole die dateien:
+  IF     NOT exists (datei 1)
+     COR NOT exists (datei 2)
+     COR NOT exists (menukarte)
+     THEN hole dateien vom archiv; LEAVE hole die dateien
+  FI.
+hole dateien vom archiv:
+  cursor (1,3); out (""4"");
+  IF yes ("Ist das Archiv angemeldet und die Diskette eingelegt")
+     THEN lese ein
+     ELSE line (2);
+          errorstop ("Ohne die Diskette kann ich das System nicht generieren!")
+  FI.
+lese ein:
+  cursor (1, 3); out (""4"");
+  out ("                   "15"Bitte die Diskette eingelegt lassen! "14"");
+
+  IF NOT einzeln
+     THEN  hole (datei 1);
+           hole (datei 2);
+           hole (menukarte);
+           cursor (1, 3); out(""4"");
+           out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");
+           release (archive)
+  FI.
+insertiere die dateien:
+  check off;
+  cursor (1, 3); out(""4"");
+  out ("                  "15"Die Diskette wird nicht mehr benötigt! "14"");
+  in (datei 1);
+  in (datei 2);
+  schicke (menukarte);
+  IF einzeln THEN release (archive) FI;
+
+  check on.
+mache global manager aus der task:
+  global manager.
+