program bank22;
begin
pref IIUWGraph BLOCK
(* SYMULACJA PRACY BANKU *)
(* dolaczone funkcje graficzne *)

(****************************************************************************)

unit kasa:procedure(nr:integer);
var i:integer;
begin
i:=71+(nr-1)*56;
call move(10,i);
call draw(10,i+36);
call draw(56,i+36);
call draw(56,i);
call draw(10,i);
(*call vfill(i+36);
call hfill(46);
call move(10,i+36);
call hfill(46);
call move(46,i);
call vfill(i+36);*)
call move(13,i+7);
call outstring("Desk");
call move(13,i+21);
call outstring("No");
call move(38,i+18);
(* call hascii(0); *)
 call hascii(nr+48);
end kasa;

(****************************************************************************)

unit klient:procedure(nr,kasa:integer;inout kl:integer);
var i,j,k,p:integer;
begin
kl:=kl+1;
j:=85+(kasa-1)*56;
i:=54+(nr-1)*26;
call move(i,j-4);
call hfill(i+24);
call vfill(j+12);
call move(i,j+12);
call hfill(i+24);
call move(i+24,j-4);
call vfill(j+12);
call move(i+4,j);
k:=kl div 10; p:=kl mod 10;
if k>0 then
(* call hascii(0); *)
 call hascii(k+48);
call move(i+12,j);
(* call hascii(0); *) 
call hascii(p+48);
else
call move(i+8,j);
(* call hascii(0); *)
call hascii(p+48);
fi;
end klient;

(****************************************************************************)

unit obsluzony:procedure(nr,kasa:integer);
var j:integer,pom:arrayof integer;
begin
j:=85+(kasa-1)*56;
call move(80,j-5);
pom:=getmap(199,j+14);
call xormap(pom);
call move(54,j-5);
call putmap(pom);
kill(pom);
end obsluzony;


(****************************************************************************)

unit ramka:procedure;
var i:integer;
begin
call move(0,0);
call vfill(347);
call hfill(719);
call move(719,0);
call vfill(347);
call move(0,347);
call hfill(719);
call move(0,63);
call hfill(719);
call move(200,63);
call vfill(347);
call move(200,337);
call hfill(719);
call move(195,4);
call outstring("       SIMULATION PROGRAM  - BANK        ");
call move(0,14);
call hfill(719);
for i:=1 to 5 do
   call kasa(i) od ;
call move(5,19);
call outstring("This program simulates a bank department with 5 desks ");
 call outstring("served by 5 cashiers "); 
call move(5,29);

call outstring("Customers arrive at random. The service time is also random ");

call move(5,39);
call outstring("as well as its account and the sum to be paid ");
call move(5,49);
end ramka;

(****************************************************************************)

unit zwieksz:procedure(inout linia:integer);
var pom:arrayof integer;
begin
linia:=linia+10;
if linia>=326 then
call move(205,65);
pom:=getmap(718,325);
call xormap(pom);
linia:=66;
fi;
kill(pom);
end zwieksz;

(****************************************************************************)

unit piszczas:procedure(t:real);
var d,p,i:integer,r,x:real;
begin
x:=inxpos+16;
p:=entier(t);
for i:=1 to 3 do
d:=p mod 10;
call move(x,inypos);
call hascii(0);call hascii(d+48);
x:=x-8;
p:=p div 10;
if p=0 then exit fi;
od;
x:=x+(i+1)*8;
call move(x,inypos);
call hascii(0);call hascii(ord('.'));
r:=t*1000;
r:=r-(p*1000);
p:=entier(r);
x:=x+24;
call move(x,inypos);
for i:=1 to 3 do
d:=p mod 10;
call move(x,inypos);
call hascii(0); call hascii(d+48);
x:=x-8;
p:=p div 10;
od;
call move(x+32,inypos);
end piszczas;

(****************************************************************************)


UNIT PRIORITYQUEUE: CLASS;
  (* HEAP AS BINARY LINKED TREE WITH FATHER LINK*)



     UNIT QUEUEHEAD: CLASS;
        (* HEAP ACCESING MODULE *)
             VAR LAST,ROOT:NODE;

             UNIT MIN: FUNCTION: ELEM;
                  BEGIN
                IF ROOT=/= NONE THEN RESULT:=ROOT.EL FI;
                 END MIN;

             UNIT INSERT: PROCEDURE(R:ELEM);
               (* INSERTION INTO HEAP *)
                   VAR X,Z:NODE;
                 BEGIN
                       X:= R.LAB;
                       IF LAST=NONE THEN
                         ROOT:=X;
                         ROOT.LEFT,ROOT.RIGHT,LAST:=ROOT
                       ELSE
                         IF LAST.NS=0 THEN
                           LAST.NS:=1;
                           Z:=LAST.LEFT;
                           LAST.LEFT:=X;
                           X.UP:=LAST;
                           X.LEFT:=Z;
                           Z.RIGHT:=X;
                         ELSE
                           LAST.NS:=2;
                           Z:=LAST.RIGHT;
                           LAST.RIGHT:=X;
                           X.RIGHT:=Z;
                           X.UP:=LAST;
                           Z.LEFT:=X;
                           LAST.LEFT.RIGHT:=X;
                           X.LEFT:=LAST.LEFT;
                           LAST:=Z;
                         FI
                       FI;
                       CALL CORRECT(R,FALSE)
                       END INSERT;

UNIT DELETE: PROCEDURE(R: ELEM);
     VAR X,Y,Z:NODE;
     BEGIN
     X:=R.LAB;
     Z:=LAST.LEFT;
     IF LAST.NS =0 THEN
           Y:= Z.UP;
           Y.RIGHT:= LAST;
           LAST.LEFT:=Y;
           LAST:=Y;
                   ELSE
           Y:= Z.LEFT;
           Y.RIGHT:= LAST;
            LAST.LEFT:= Y;
                    FI;
       Z.EL.LAB:=X;
       X.EL:= Z.EL;
       LAST.NS:= LAST.NS-1;
       R.LAB:=Z;
       Z.EL:=R;
       IF X.LESS(X.UP) THEN CALL CORRECT(X.EL,FALSE)
                       ELSE CALL CORRECT(X.EL,TRUE) FI;
     END DELETE;

UNIT CORRECT: PROCEDURE(R:ELEM,DOWN:BOOLEAN);
   (* CORRECTION OF THE HEAP WITH STRUCTURE BROKEN BY R *)
     VAR X,Z:NODE,T:ELEM,FIN,LOG:BOOLEAN;
     BEGIN
     Z:=R.LAB;
     IF DOWN THEN
          WHILE NOT FIN DO
                 IF Z.NS =0 THEN FIN:=TRUE ELSE
                      IF Z.NS=1 THEN X:=Z.LEFT ELSE
                      IF Z.LEFT.LESS(Z.RIGHT) THEN X:=Z.LEFT ELSE X:=Z.RIGHT
                       FI; FI;
                      IF Z.LESS(X) THEN FIN:=TRUE ELSE
                            T:=X.EL;
                            X.EL:=Z.EL;
                            Z.EL:=T;
                            Z.EL.LAB:=Z;
                           X.EL.LAB:=X
                      FI; FI;
                 Z:=X;
                       OD
              ELSE
    X:=Z.UP;
    IF X=NONE THEN LOG:=TRUE ELSE LOG:=X.LESS(Z); FI;
    WHILE NOT LOG DO
          T:=Z.EL;
          Z.EL:=X.EL;
           X.EL:=T;
          X.EL.LAB:=X;
          Z.EL.LAB:=Z;
          Z:=X;
          X:=Z.UP;
           IF X=NONE THEN LOG:=TRUE ELSE LOG:=X.LESS(Z);
            FI;
                OD
     FI;
 END CORRECT;

END QUEUEHEAD;


UNIT NODE: CLASS (EL:ELEM);
  (* ELEMENT OF THE HEAP *)
      VAR LEFT,RIGHT,UP: NODE, NS:INTEGER;
      UNIT LESS: FUNCTION(X:NODE): BOOLEAN;
          BEGIN
          IF X= NONE THEN RESULT:=FALSE
                    ELSE RESULT:=EL.LESS(X.EL) FI;
          END LESS;
     END NODE;

 
UNIT ELEM: CLASS(PRIOR:REAL);
  (* PREFIX OF INFORMATION TO BE STORED IN NODE *)
   VAR LAB: NODE;
   UNIT VIRTUAL LESS: FUNCTION(X:ELEM):BOOLEAN;
            BEGIN
            IF X=NONE THEN RESULT:= FALSE ELSE
                           RESULT:= PRIOR< X.PRIOR FI;
            END LESS;
    BEGIN
    LAB:= NEW NODE(THIS ELEM);
    END ELEM;


END PRIORITYQUEUE;


 
UNIT SIMULATION: PRIORITYQUEUE CLASS;
(* THE LANGUAGE FOR SIMULATION PURPOSES *)
 
  VAR CURR: SIMPROCESS,  (*ACTIVE PROCESS *)
      PQ:QUEUEHEAD,  (* THE TIME AXIS *)
       MAINPR: MAINPROGRAM;


      UNIT SIMPROCESS: COROUTINE;
        (* USER PROCESS PREFIX *)
             VAR EVENT,  (* ACTIVATION MOMENT NOTICE *)
                 EVENTAUX: EVENTNOTICE,
                 (* THIS IS FOR AVOIDING MANY NEW CALLS AS AN RESULT OF *)
                 (* SUBSEQUENT PASSIVATIONS AND ACTIVATIONS             *)
                 FINISH: BOOLEAN;
 
             UNIT IDLE: FUNCTION: BOOLEAN;
                   BEGIN
                   RESULT:= EVENT= NONE;
                   END IDLE;

             UNIT TERMINATED: FUNCTION :BOOLEAN;
                   BEGIN
                  RESULT:= FINISH;
                   END TERMINATED;

             UNIT EVTIME: FUNCTION: REAL;
             (* TIME OF ACTIVATION *)
                  BEGIN
                  IF IDLE THEN CALL ERROR1;
                                           FI;
                  RESULT:= EVENT.EVENTTIME;
                  END EVTIME;

    UNIT ERROR1:PROCEDURE;
                BEGIN
                ATTACH(MAIN);
                call groff;
                WRITELN(" AN ATTEMPT TO ACCESS AN IDLE PROCESS TIME");
                END ERROR1;

     UNIT ERROR2:PROCEDURE;
                 BEGIN
                 ATTACH(MAIN);
                 call groff;
                 WRITELN(" AN ATTEMPT TO ACCESS A TERMINATED PROCESS TIME");
                 END ERROR2;
             BEGIN

             RETURN;
             INNER;
             FINISH:=TRUE;
              CALL PASSIVATE;
             CALL ERROR2;
          END SIMPROCESS;


UNIT EVENTNOTICE: ELEM CLASS;
  (* A PROCESS ACTIVATION NOTICE TO BE PLACED ONTO THE TIME AXIS PQ *)
      VAR EVENTTIME: REAL, PROC: SIMPROCESS;

      UNIT VIRTUAL LESS: FUNCTION(X: EVENTNOTICE):BOOLEAN;
       (* OVERWRITE THE FORMER VERSION CONSIDERING EVENTTIME *)
                  BEGIN
                  IF X=NONE THEN RESULT:= FALSE ELSE
                  RESULT:= EVENTTIME< X.EVENTTIME OR
                  (EVENTTIME=X.EVENTTIME AND PRIOR< X.PRIOR); FI;

               END LESS;
    END EVENTNOTICE;
 

UNIT MAINPROGRAM: SIMPROCESS CLASS;
 (* IMPLEMENTING MASTER PROGRAM AS A PROCESS *)
      BEGIN
      DO ATTACH(MAIN) OD;
      END MAINPROGRAM;
 
UNIT TIME:FUNCTION:REAL;
 (* CURRENT VALUE OF SIMULATION TIME *)
     BEGIN
     RESULT:=CURRENT.EVTIME
     END TIME;

UNIT CURRENT: FUNCTION: SIMPROCESS;
   (* THE FIRST PROCESS ON THE TIME AXIS *)
     BEGIN
     RESULT:=CURR;
     END CURRENT;
 
UNIT SCHEDULE: PROCEDURE(P:SIMPROCESS,T:REAL);
 (* ACTIVATION OF PROCESS P AT TIME T AND DEFINITION OF "PRIOR"- PRIORITY *)
 (* WITHIN TIME MOMENT T                                                  *)
      BEGIN
      IF T<TIME THEN T:= TIME FI;
      IF P=CURRENT THEN CALL HOLD(T-TIME) ELSE
      IF P.IDLE AND P.EVENTAUX=NONE THEN (* HAS NOT BEEN SCHEDULED YET*)
                P.EVENT,P.EVENTAUX:= NEW EVENTNOTICE(RANDOM);
                P.EVENT.PROC:= P;
                                      ELSE
       IF P.IDLE (* P HAS ALREADY BEEN SCHEDULED *) THEN
               P.EVENT:= P.EVENTAUX;
               P.EVENT.PRIOR:=RANDOM;
                                          ELSE
   (* NEW SCHEDULING *)
               P.EVENT.PRIOR:=RANDOM;
               CALL PQ.DELETE(P.EVENT)
                                FI; FI;
      P.EVENT.EVENTTIME:= T;
      CALL PQ.INSERT(P.EVENT) FI;
END SCHEDULE;

UNIT HOLD:PROCEDURE(T:REAL);
 (* MOVE THE ACTIVE PROCESS T MINUTES BACK ALONG PQ *)
 (* REDEFINE PRIOR                                  *)
     BEGIN
     CALL PQ.DELETE(CURRENT.EVENT);
     CURRENT.EVENT.PRIOR:=RANDOM;
     IF T<0 THEN T:=0; FI;
      CURRENT.EVENT.EVENTTIME:=TIME+T;
     CALL PQ.INSERT(CURRENT.EVENT);
     CALL CHOICEPROCESS;
     END HOLD;
 
UNIT PASSIVATE: PROCEDURE;
  (* REMOVE THE ACTVE PROCESS FROM PQ AND ACTIVATE THE NEXT ONE *)
     BEGIN
      CALL PQ.DELETE(CURRENT.EVENT);
      CURRENT.EVENT:=NONE;
      CALL CHOICEPROCESS
     END PASSIVATE;

UNIT RUN: PROCEDURE(P:SIMPROCESS);
 (* ACTIVATE P IMMEDIATELY AND DELAY THE FORMER FIRST PROCESS BY REDEFINING*)
 (* PRIOR                                                              *)
     BEGIN
     CURRENT.EVENT.PRIOR:=RANDOM;
     IF NOT P.IDLE THEN
            P.EVENT.PRIOR:=0;
            P.EVENT.EVENTTIME:=TIME;
            CALL PQ.CORRECT(P.EVENT,FALSE)
                    ELSE
      IF P.EVENTAUX=NONE THEN
            P.EVENT,P.EVENTAUX:=NEW EVENTNOTICE(0);
            P.EVENT.EVENTTIME:=TIME;
            P.EVENT.PROC:=P;
            CALL PQ.INSERT(P.EVENT)
                        ELSE
             P.EVENT:=P.EVENTAUX;
             P.EVENT.PRIOR:=0;
             P.EVENT.EVENTTIME:=TIME;
             P.EVENT.PROC:=P;
             CALL PQ.INSERT(P.EVENT);
                          FI;FI;
      CALL CHOICEPROCESS;
END RUN;

UNIT CANCEL:PROCEDURE(P: SIMPROCESS);
 (* REMOVE PROCESS P FROM PQ AND CONTINUE SIMULATION *)
   BEGIN
   IF P= CURRENT THEN CALL PASSIVATE ELSE
    CALL PQ.DELETE(P.EVENT);
    P.EVENT:=NONE;  FI;
 END CANCEL;

UNIT CHOICEPROCESS:PROCEDURE;
 (* CHOOSE THE FIRST PROCESS FROM PQ TO BE ACTIVATED *)
   VAR P:SIMPROCESS;
   BEGIN
   P:=CURR;
   CURR:= PQ.MIN QUA EVENTNOTICE.PROC;
    IF CURR=NONE THEN
    call groff;
     WRITE(" ERROR IN THE HEAP"); WRITELN;
                      ATTACH(MAIN);
                 ELSE ATTACH(CURR); FI;
END CHOICEPROCESS;

BEGIN
  PQ:=NEW QUEUEHEAD;  (* SIMULATION TIME AXIS*)
  CURR,MAINPR:=NEW MAINPROGRAM;
  MAINPR.EVENT,MAINPR.EVENTAUX:=NEW EVENTNOTICE(0);
  MAINPR.EVENT.EVENTTIME:=0;
  MAINPR.EVENT.PROC:=MAINPR;
  CALL PQ.INSERT(MAINPR.EVENT);
  (* THE FIRST PROCESS TO BE ACTIVATED IS MAIN PROGRAM *)
  INNER;
  PQ:=NONE;
END SIMULATION;


 
UNIT LISTS:SIMULATION CLASS;
 (* WE WISH TO USE LISTS FOR QUEUEING PROCESSES DURING SIMULATION*)

           UNIT LINKAGE:CLASS;
            (*WE WILL USE TWO WAY LISTS *)
                VAR SUC1,PRED1:LINKAGE;
                          END LINKAGE;
            UNIT HEAD:LINKAGE CLASS;
            (* EACH LIST WILL HAVE ONE ELEMENT ESTABLISHED *)
                      UNIT FIRST:FUNCTION:LINK;
                                 BEGIN
                             IF SUC1 IN LINK THEN RESULT:=SUC1
                                             ELSE RESULT:=NONE FI;
                                 END;
                      UNIT EMPTY:FUNCTION:BOOLEAN;
                                 BEGIN
                                 RESULT:=SUC1=THIS LINKAGE;
                                 END EMPTY;
                   BEGIN
                   SUC1,PRED1:=THIS LINKAGE;
                     END HEAD;

          UNIT LINK:LINKAGE CLASS;
           (* ORDINARY LIST ELEMENT PREFIX *)
                     UNIT OUT:PROCEDURE;
                              BEGIN
                              IF SUC1=/=NONE THEN
                                    SUC1.PRED1:=PRED1;
                                    PRED1.SUC1:=SUC1;
                                    SUC1,PRED1:=NONE FI;
                               END OUT;
                     UNIT INTO:PROCEDURE(S:HEAD);
                               BEGIN

                               CALL OUT;
                               IF S=/= NONE THEN
                                    IF S.SUC1=/=NONE THEN
                                            SUC1:=S;
                                            PRED1:=S.PRED1;
                                            PRED1.SUC1:=THIS LINKAGE;
                                            S.PRED1:=THIS LINKAGE;
                                                 FI FI;
                                  END INTO;
                  END LINK;

     UNIT ELEM:LINK CLASS(SPROCESS:SIMPROCESS);
     (* USER DEFINED  PROCESS WILL BE JOINED INTO LISTS  *)
                    END ELEM;

    END LISTS;

 



  (*poczatek symulacji pracy banku*)


  UNIT OFFICE:LISTS CLASS; (*AN OFFICE*)

     UNIT TILL:SIMPROCESS CLASS(QUEUE:HEAD);
     (* TELLER WITH CUSTOMERS QUEUEING UP *)
            UNIT VIRTUAL SERVICE:PROCEDURE;
             (* SERVICE OF THIS TELLER WILL BE PRECISED LATER *)
                                 END SERVICE;
              VAR CSTM:CUSTOMER,  (*THE CUSTOMER BEING SERVED*)
                  REST,PAUSE:REAL;

              BEGIN
              PAUSE:=TIME;
              DO
              REST:=REST+TIME-PAUSE;
              WHILE NOT QUEUE.EMPTY DO
               (* SERVE ALL QUEUE *)
                       CSTM:=QUEUE.FIRST QUA ELEM.SPROCESS;
                       CALL SERVICE;
                       CALL SCHEDULE(CSTM,TIME);
                                       OD;
              PAUSE:=TIME;
              CALL PASSIVATE
              OD;
     END TILL;

   UNIT CUSTOMER:SIMPROCESS CLASS;

              VAR ELLIST:ELEM, K:INTEGER;
              UNIT ARRIVAL:PROCEDURE(S:TILL);
              (* ATTACHING TELLER S *)
                        BEGIN
                        IF S=/=NONE THEN
                          ELLIST:=NEW ELEM(THIS CUSTOMER);
                          CALL ELLIST.INTO(S.QUEUE);
                          IF S.IDLE THEN CALL SCHEDULE(S,TIME) FI;
                          CALL PASSIVATE; FI;
                        END ARRIVAL;
       END CUSTOMER;

 END OFFICE;



UNIT BANKDEPARTMENT:OFFICE CLASS;


    UNIT COUNTER:TILL CLASS;
              VAR PAYTIME:REAL; (*RANDOM SERVICE TIME*)
              UNIT VIRTUAL SERVICE:PROCEDURE;
                 BEGIN
                 call move(205,linia);
                 call outstring(" Customer No"); 
                 p1:=cstm.k div 10; p2:=cstm.k mod 10;
                 if p1>0 then
                 call hascii(0); call hascii(p1+48);
                 call hascii(0);call hascii(p2+48);
                 else
                  call hascii(0);call hascii(p2+48);
                 fi;
                 call outstring(" has payed at the desk at time: ");
                 call piszczas(time);
                 call zwieksz(linia);
                 CALL CSTM.ELLIST.OUT;
                 PAYTIME:=RANDOM*2+2;
                 CALL HOLD(PAYTIME);
                 END SERVICE;
    END COUNTER;


    UNIT TELLER:TILL CLASS(NUMBER:INTEGER);
              VAR SERVICETIME:REAL;
              UNIT VIRTUAL SERVICE:PROCEDURE;
                 VAR N:INTEGER;
                 BEGIN
                 call move(205,linia);
                 call outstring(" Cashier No ");
                 call hascii(0); call hascii(number+48);
                 call outstring(" was waiting a customer during  ");
                 call piszczas(REST);
                 call zwieksz(linia);
                 CALL CSTM.ELLIST.OUT;
                 N:=CSTM QUA BANKCUSTOMER.NO;
                 call move(205,linia);
                 call outstring(" Customer No ");
                 p1:=cstm.k div 10; p2:=cstm.k mod 10;
                 if p1>0 then
                 call hascii(0); call hascii(p1+48);
                 call hascii(0);call hascii(p2+48);
                 else
                   call hascii(0);call hascii(p2+48);
                  fi;
                  call outstring(" becomes to be served by cashier No ");
                  call hascii(0); call hascii(number+48);
                  call zwieksz(linia);
                  call move(205,linia);
                  call outstring(" at time ");
                  call piszczas(TIME);
                  call zwieksz(linia);
                  ACCOUNT(N):=ACCOUNT(N)+CSTM QUA BANKCUSTOMER.AMOUNT;
                  IF ACCOUNT(N)<0 THEN CALL CSTM.ARRIVAL(CONTROL);FI;
                  SERVICETIME:=RANDOM*7+3;
                  CALL HOLD(SERVICETIME);

                 END SERVICE;
          END TELLER;


    UNIT BANKCUSTOMER:CUSTOMER CLASS(NO:INTEGER,AMOUNT:REAL);
    (* BANK CUSTOMER. AMOUNT- THE MONEY TO BE PAID AT THE BANK *)
            VAR ARRIVALTIME,STAYTIME:REAL,CHOOSETELLER:INTEGER;
               BEGIN
               I:=I+1;
               K:=I;
               ARRIVALTIME:=TIME;
               call move(205,linia);
               call outstring(" Customer No ");
               p1:=k div 10; p2:=k mod 10;
               if p1>0 then
               call hascii(0); call hascii(p1+48);
               call hascii(0);call hascii(p2+48);
               else
                call hascii(0);call hascii(p2+48);
               fi;
               call outstring(" arrived at time ");
               call piszczas(TIME);
               call zwieksz(linia);
               CHOOSETELLER:=RANDOM*5+1;
               kasa(chooseteller):=kasa(chooseteller)+1;
               call klient(kasa(chooseteller),chooseteller,kl);
               CALL ARRIVAL(TELLERS(CHOOSETELLER));
               IF AMOUNT<0 THEN CALL ARRIVAL(CTR); FI;
               STAYTIME:=TIME-ARRIVALTIME;
               call move(205,linia);
               call outstring(" Customer No ");
               p1:=k div 10; p2:=k mod 10;
               if p1>0 then
               call hascii(0); call hascii(p1+48);
               call hascii(0);call hascii(p2+48);
               else
                call hascii(0);call hascii(p2+48);
               fi;
               call outstring(" left bank after ");
               call piszczas(STAYTIME); (*STAN KONTA ",ACCOUNT(NO):10:4); *)
               call zwieksz(linia);
               call obsluzony(kasa(chooseteller),chooseteller);
               kasa(chooseteller):=kasa(chooseteller)-1
            END BANKCUSTOMER;

  VAR TELLERS:ARRAYOF TELLER,ACCOUNT:ARRAYOF REAL;
  VAR CTR:COUNTER, CONTROL:TILL,I:INTEGER;
  var linia,p1,p2,kl:integer;
  var kasa:arrayof integer;

    BEGIN   (* NEW BANK DEPARTMENT GENERATION *)
    linia:=66;
    array kasa dim(1:5);
    CTR:=NEW COUNTER(NEW HEAD);
    ARRAY TELLERS DIM(1:5);  (* WE DEAL WITH 5 TELLES *)
    FOR I:=1 TO 5 DO  TELLERS(I):=NEW TELLER(NEW HEAD,I); OD;
    ARRAY ACCOUNT DIM(1:100);
    (* WE DEAL WITH 100 ACOUNTS IN THIS BANK DEPARTMENT *)
    FOR I:=1 TO 100 DO  ACCOUNT(I):=RANDOM*901+100; OD;
                  (* AN ACCOUNT VALUE CAN FLUCTUATE FROM 100 TO 1000$ *)
    I:=0;
 END BANKDEPARTMENT;



 BEGIN (* OF PROGRAM *)
   PREF BANKDEPARTMENT BLOCK
        UNIT GENERATOR:SIMPROCESS CLASS;
         (* CUSTOMERS GENERATION *)
              BEGIN
              DO
              CALL SCHEDULE(NEW BANKCUSTOMER(RANDOM*100+1,
                              RANDOM*9996+5),TIME);
              CALL HOLD(RANDOM*3);
              CALL SCHEDULE(NEW BANKCUSTOMER(RANDOM*100+1,
                          -(RANDOM*900+5)),TIME);
              CALL HOLD(RANDOM*2);
              OD
              END GENERATOR;
      BEGIN
      call hpage(1,0,0);
      call hpage(1,720,347); 

      call gron(1);
      call ramka;
      call move(300,339);
      call outstring("Click the mouse in order to start simulation");
    (*  call track(719,349); *)
      CALL SCHEDULE(NEW GENERATOR,TIME);
      CALL HOLD (135);
      call move(300,339);
      call outstring(" Click the mouse in order to finish   ");
      (* call track(719,349); *)
      call groff
       END
END
end
(****************************************************************************)