home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / pascal / passrc / dhry.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-11-18  |  19.0 KB  |  496 lines
  1. { -----------------------------------------------------------------------------
  2.  
  3.                                  NOTICE:
  4.  
  5.       THESE MATERIALS are UNSUPPORTED by OSS!  If you do not understand how to
  6.       use them do not contact OSS for help!  We will not teach you how to 
  7.       program in Pascal.  If you find an error in these materials, feel free
  8.       to SEND US A LETTER explaining the error, and how to fix it.
  9.  
  10.       THE BOTTOM LINE:
  11.  
  12.          Use it, enjoy it, but you are on your own when using these materials!
  13.  
  14.  
  15.                                DISCLAIMER:
  16.  
  17.       OSS makes no representations or warranties with respect to the contents
  18.       hereof and specifically disclaim all warranties of merchantability or
  19.       fitness for any particular purpose.   This document is subject to change
  20.       without notice.
  21.       
  22.       OSS provides these materials for use with Personal Pascal.  Use them in
  23.       any way you wish.
  24.  
  25.    -------------------------------------------------------------------------- }
  26.  
  27.  
  28. PROGRAM Dhrystone( output );
  29. (*
  30.  *      "DHRYSTONE" Benchmark Program
  31.  *
  32.  *      Version:        C/1
  33.  *      Date:           12/01/84, RESULTS updated 10/22/85
  34.  *      Author:         Reinhold P. Weicker, CACM Vol 27, No 10, 10/84 pg. 1013
  35.  
  36.  *                      Translated from ADA by Rick Richardson
  37.  *                      Every method to preserve ADA-likeness has been used,
  38.  *                      at the expense of C-ness.
  39.  *      Compile:        cc -O dry.c -o drynr                    : No registers
  40.  *                      cc -O -DREG=register dry.c -o dryr      : Registers
  41.  *      Defines:        Defines are provided for old C compiler's
  42.  *                      which don't have enums, and can't assign structures.
  43.  *                      The time(2) function is library dependant; One is
  44.  *                      provided for CI-C86.  Your compiler may be different.
  45.  *                      The LOOPS define is initially set for 50000 loops.
  46.  *                      If you have a machine with large integers and is
  47.  *                      very fast, please change this number to 500000 to
  48.  *                      get better accuracy.  Please select the way to
  49.  *                      measure the execution time using the TIME define.
  50.  *                      For single user machines, time(2) is adequate. For
  51.  *                      multi-user machines where you cannot get single-user
  52.  *                      access, use the times(2) function.  If you have
  53.  *                      neither, use a stopwatch in the dead of night.
  54.  *                      Use a "printf" at the point marked "start timer"
  55.  *                      to begin your timings. DO NOT use the UNIX "time(1)"
  56.  *                      command, as this will measure the total time to
  57.  *                      run this program, which will (erroneously) include
  58.  *                      the time to malloc(3) storage and to compute the
  59.  *                      time it takes to do nothing.
  60.  *      Run:            drynr; dryr
  61.  *
  62.  *      Results:        If you get any new machine/OS results, please send to:
  63.  *                      BEGINihnp4,vax135,..END!houxm!vaximile!rer
  64.  *                      and thanks to all that do.  Space prevents listing
  65.  *                      the names of those who have provided some of these
  66.  *                      results.
  67.  *      Note:           I order the list in increasing performance of the
  68.  *                      "with registers" benchmark.  If the compiler doesn't
  69.  *                      provide register variables, then the benchmark
  70.  *                      is the same for both REG and NOREG.  I'm not going
  71.  *                      to list a compiler in a better place because if it
  72.  *                      had register variables it might do better. No
  73.  *                      register variables is a big loss in my book.
  74.  *      PLEASE:         Send complete information about the machine type,
  75.  *                      clock speed, OS and C manufacturer/version.  If
  76.  *                      the machine is modified, tell me what was done.
  77.  *                      Otherwise, I won't include it in this list.  My
  78.  *                      favorite flame on this subject was a machine that
  79.  *                      was listed as an IBM PC/XT 8086-9.54Mhz.  That must
  80.  *                      have been some kind of co-processor board that ran
  81.  *                      the benchmark, not the XT.  Tell me what it was!
  82.  *
  83.  * MACHINE      MICROPROCESSOR  OPERATING       COMPILER        DHRYSTONES/SEC.
  84.  * TYPE                         SYSTEM                          NO REG  REGS
  85.  * --------------------------   ------------    -----------     ---------------
  86.  * IBM PC/XT    8088-4.77Mhz    PC/IX           cc               257     287
  87.  * Cosmos       68000-8Mhz      UniSoft         cc               305     322
  88.  * IBM PC/XT    8088-4.77Mhz    VENIX/86 2.0    cc               297     324
  89.  * IBM PC       8088-4.77Mhz    MSDOS 2.0       b16cc 2.0        310     340
  90.  * IBM PC       8088-4.77Mhz    MSDOS 2.0       CI-C86 2.20M     390     390
  91.  * IBM PC/XT    8088-4.77Mhz    PCDOS 2.1       Lattice 2.15     403      -  @
  92.  * PDP-11/34    -               UNIX V7M        cc               387     438
  93.  * Onyx C8002   Z8000-4Mhz      IS/1 1.1 (V7)   cc               476     511
  94.  * ATT PC6300   8086-8Mhz       MSDOS 2.11      b16cc 2.0        632     684
  95.  * IBM PC/AT    80286-6Mhz      PCDOS 3.0       CI-C86 2.1       666     684
  96.  * Macintosh    68000-7.8Mhz 2M Mac Rom         Mac C 32 bit int 694     704
  97.  * Macintosh    68000-7.7Mhz    -               MegaMax C 2.0    661     709
  98.  * NEC PC9801F  8086-8Mhz       PCDOS 2.11      Lattice 2.15     768      -  @
  99.  * ATT PC6300   8086-8Mhz       MSDOS 2.11      CI-C86 2.20M     769     769
  100.  * ATT 3B2/300  WE32000-?Mhz    UNIX 5.0.2      cc               735     806
  101.  * IBM PC/AT    80286-6Mhz      PCDOS 3.0       MS 3.0(large)    833     847 LM
  102.  * VAX 11/750   -               Unix 4.2bsd     cc               862     877
  103.  * Fast Mac     68000-7.7Mhz    -               MegaMax C 2.0    839     904 +
  104.  * Macintosh    68000-7.8Mhz 2M Mac Rom         Mac C 16 bit int 877     909 S
  105.  * IRIS-1400    68010-10Mhz     Unix System V   cc               909    1000
  106.  * IBM PC/AT    80286-6Mhz      VENIX/86 2.1    cc               961    1000
  107.  * IBM PC/AT    80286-6Mhz      PCDOS 3.0       b16cc 2.0        943    1063
  108.  * IBM PC/AT    80286-6Mhz      PCDOS 3.0       MS 3.0(small)   1063    1086
  109.  * VAX 11/750   -               VMS             VAX-11 C 2.0     958    1091
  110.  * ATT PC7300   68010-10Mhz     UNIX 5.2        cc              1041    1111
  111.  * ATT PC6300+  80286-6Mhz      MSDOS 3.1       b16cc 2.0       1111    1219
  112.  * Sun2/120     68010-10Mhz     Sun 4.2BSD      cc              1136    1219
  113.  * IBM PC/AT    80286-6Mhz      PCDOS 3.0       CI-C86 2.20M    1219    1219
  114.  * MASSCOMP 500 68010-10MHz     RTU V3.0        cc (V3.2)       1156    1238
  115.  * Cyb DataMate 68010-12.5Mhz   Uniplus 5.0     Unisoft cc      1162    1250
  116.  * PDP 11/70    -               UNIX 5.2        cc              1162    1250
  117.  * IBM PC/AT    80286-6Mhz      PCDOS 3.1       Lattice 2.15    1250      -  @
  118.  * IBM PC/AT    80286-7.5Mhz    VENIX/86 2.1    cc              1190    1315 *
  119.  * Sun2/120     68010-10Mhz     Standalone      cc              1219    1315
  120.  * ATT 3B2/400  WE32100-?Mhz    UNIX 5.2        cc              1315    1315
  121.  * HP-110       8086-5.33Mhz    MSDOS 2.11      Aztec-C         1282    1351 ?
  122.  * IBM PC/AT    80286-6Mhz      ?               ?               1250    1388 ?
  123.  * ATT PC6300+  80286-6Mhz      MSDOS 3.1       CI-C86 2.20M    1428    1428
  124.  * Cyb DataMate 68010-12.5Mhz   Uniplus 5.0     Unisoft cc      1470    1562 S
  125.  * VAX 11/780   -               UNIX 5.2        cc              1515    1562
  126.  * MicroVAX-II  -               -               -               1562    1612
  127.  * ATT 3B20     -               UNIX 5.2        cc              1515    1724
  128.  * HP9000-500   B series CPU    HP-UX 4.02      cc              1724    -
  129.  * IBM PC/STD   80286-8Mhz      ?               ?               1724    1785
  130.  * Gould PN6005 -               UTX 1.1(4.2BSD) cc              1675    1964
  131.  * VAX 11/785   -               UNIX 5.2        cc              2083    2083
  132.  * VAX 11/785   -               VMS             VAX-11 C 2.0    2083    2083
  133.  * Pyramid 90x  -               OSx 2.3         cc              2272    2272
  134.  * Pyramid 90x  -               OSx 2.5         cc              3125    3125
  135.  * SUN 3/75     68020-16.67Mhz  SUN 4.2 V3      cc              3333    3571
  136.  * Sun 3/180    68020-16.67Mhz  Sun 4.2         cc              3333    3846
  137.  * MC 5400      68020-16.67MHz  RTU V3.0        cc (V4.0)       3952    4054
  138.  * SUN-3/160C   68020-16.67Mhz  Sun3.0ALPHA1 Un*x               3333    4166
  139.  * Gould PN9080 -               UTX-32 1.1c     cc              -       4629
  140.  * MC 5600/5700 68020-16.67MHz  RTU V3.0        cc (V4.0)       4504    4746 %
  141.  * VAX 8600     -               VMS             VAX-11 C 2.0    7142    7142
  142.  * Amdahl 470 V/8               ?               ?               -      15015
  143.  * Amdahl 580   -               UTS 5.0 Rel 1.2 cc Ver. 1.5    23076   23076
  144.  * Amdahl 5860                  ?               ?               -      28355
  145.  *
  146.  *   *  15Mhz crystal substituted for original 12Mhz;
  147.  *   +  This Macintosh was upgraded from 128K to 512K in such a way that
  148.  *      the new 384K of memory is not slowed down by video generator accesses.
  149.  *   %  Single processor; MC == MASSCOMP
  150.  *   &  Seattle Telecom STD-286 board
  151.  *   @  vanilla Lattice compiler used with MicroPro standard library
  152.  *   S  Shorts used instead of ints
  153.  *   LM Large Memory Model. (Otherwise, all 80x8x results are small model)
  154.  *   ?  I don't trust results marked with '?'.  These were sent to me with
  155.  *      either incomplete information, or with times that just don't make sense.
  156.  
  157.  *      If anybody can confirm these figures, please respond.
  158.  *
  159.  **************************************************************************
  160.  *
  161.  *      The following program contains statements of a high-level programming
  162.  *      language (C) in a distribution considered representative:
  163.  *
  164.  *      assignments                     53%
  165.  *      control statements              32%
  166.  *      procedure, function calls       15%
  167.  *
  168.  *      100 statements are dynamically executed.  The program is balanced with
  169.  *      respect to the three aspects:
  170.  *              - statement type
  171.  *              - operand type (for simple data types)
  172.  *              - operand access
  173.  *                      operand global, local, parameter, or constant.
  174.  *
  175.  *      The combination of these three aspects is balanced only approximately.
  176.  *
  177.  *      The program does not compute anything meaningfull, but it is
  178.  *      syntactically and semantically correct.
  179.  *
  180.  *)
  181.  
  182.   CONST
  183. (* Accuracy of timings and human fatigue controlled by next two lines *)
  184.     LOOPS = 50000;          (* Use this for slow or 16 bit machines *)
  185. (*    LOOPS = 500000;         (* Use this for faster machines *)
  186.  
  187. (* We assume that the Pascal compiler can assign records *)
  188.  
  189. (* define the granularity of your times(2) function (when used) *)
  190. (*  HZ = 60;                (* times(2) returns 1/60 second (most) *)
  191. (*  HZ = 100;               (* times(2) returns 1/100 second (WECo) *)
  192.     HZ = 200;               (* ST is different -gdf-        *)
  193.  
  194.   TYPE
  195.     Enumeration = ( Ident1, Ident2, Ident3, Ident4, Ident5 );
  196.  
  197.     OneToThirty = 1..30;
  198.     OneToFifty  = 1..50;
  199.     CapitalLetter = char;
  200.     String30 = PACKED ARRAY[ OneToThirty ] OF char;
  201.     Array1Dim = ARRAY[ OneToFifty ] OF integer;
  202.     Array2Dim = ARRAY[ OneToFifty ] OF Array1Dim;
  203.  
  204.     RecordPtr = ^RecordType;
  205.     RecordType = RECORD
  206.                    PtrComp: RecordPtr;
  207.                    Discr: Enumeration;
  208.                    EnumComp: Enumeration;
  209.                    IntComp: OneToFifty;
  210.                    StringComp: String30;
  211.                  END;
  212.  
  213. (*
  214.  * Package 1
  215.  *)
  216.  
  217.   VAR { Global variables }
  218.     ssp: long_integer;
  219.  
  220.     IntGlob: integer;
  221.     BoolGlob: boolean;
  222.     Char1Glob: CapitalLetter;
  223.     Char2Glob: CapitalLetter;
  224.     Array1Glob: Array1Dim;
  225.     Array2Glob: Array2Dim;
  226.     PtrGlb: RecordPtr;
  227.     PtrGlbNext: RecordPtr;
  228.  
  229.   FUNCTION time: long_integer;
  230.  
  231.     TYPE
  232.       long_pointer = ^long_integer;
  233.  
  234.     VAR
  235.       hz_200: RECORD
  236.                 CASE boolean OF
  237.                   true: ( l: long_integer );
  238.                   false: ( p: long_pointer );
  239.               END;
  240.  
  241.     BEGIN
  242.       hz_200.l := $4ba;
  243. (*$P-*)
  244.       time := hz_200.p^;
  245. (*$P=*)
  246.     END;
  247.  
  248.   PROCEDURE Proc2( VAR IntParIO: OneToFifty );
  249.  
  250.     VAR
  251.       IntLoc: OneToFifty;
  252.       EnumLoc: Enumeration;
  253.  
  254.     BEGIN { Proc2 }
  255.       IntLoc := IntParIO + 10;
  256.       REPEAT
  257.         IF Char1Glob = 'A' THEN
  258.           BEGIN
  259.             IntLoc := IntLoc - 1;
  260.             IntParIO := IntLoc - IntGlob;
  261.             EnumLoc := Ident1;
  262.           END
  263.       UNTIL EnumLoc = Ident1;
  264.     END; { Proc2 }
  265.  
  266.   PROCEDURE Proc7( IntParI1, IntParI2: OneToFifty; VAR IntParOut: OneToFifty );
  267.  
  268.     VAR
  269.       IntLoc: OneToFifty;
  270.  
  271.     BEGIN { Proc7 }
  272.       IntLoc := IntParI1 + 2;
  273.       IntParOut := IntParI2 + IntLoc;
  274.     END; { Proc7 }
  275.  
  276.   PROCEDURE Proc3( VAR PtrParOut: RecordPtr );
  277.  
  278.     BEGIN { Proc3 }
  279.       IF PtrGlb <> nil THEN
  280.         PtrParOut := PtrGlb^.PtrComp
  281.       ELSE
  282.         IntGlob := 100;
  283.       Proc7( 10, IntGlob, PtrGlb^.IntComp );
  284.     END; { Proc3 }
  285.  
  286.   PROCEDURE Proc4;
  287.  
  288.     VAR
  289.       BoolLoc: boolean;
  290.  
  291.     BEGIN { Proc4 }
  292.       BoolLoc := (Char1Glob = 'A');
  293.       BoolLoc := BoolLoc OR BoolGlob;
  294.       Char2Glob := 'B';
  295.     END; { Proc4 }
  296.  
  297.   PROCEDURE Proc5;
  298.  
  299.     BEGIN { Proc5 }
  300.       Char1Glob := 'A';
  301.       BoolGlob := false;
  302.     END; { Proc5 }
  303.  
  304.   FUNCTION Func1( CharPar1, CharPar2: CapitalLetter ): Enumeration;
  305.  
  306.     VAR
  307.       CharLoc1,
  308.       CharLoc2: CapitalLetter;
  309.  
  310.     BEGIN { Func1 }
  311.       CharLoc1 := CharPar1;
  312.       CharLoc2 := CharLoc1;
  313.       IF CharLoc2 <> CharPar2 THEN
  314.         Func1 := Ident1
  315.       ELSE
  316.         Func1 := Ident2;
  317.     END; { Func1 }
  318.  
  319.   FUNCTION Func2( VAR StrParI1, StrParI2: String30 ): boolean;
  320.  
  321.     VAR
  322.       IntLoc: OneToThirty;
  323.       CharLoc: CapitalLetter;
  324.  
  325.     BEGIN { Func2 }
  326.       IntLoc := 1;
  327.       WHILE IntLoc <= 1 DO
  328.         IF Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) = Ident1 THEN
  329.           BEGIN
  330.             CharLoc := 'A';
  331.             IntLoc := IntLoc + 1;
  332.           END;
  333.       IF (CharLoc >= 'W') AND (CharLoc <= 'Z') THEN
  334.         IntLoc := 7;
  335.       IF CharLoc = 'X' THEN
  336.         Func2 := true
  337.       ELSE
  338.         BEGIN
  339.           IF StrParI1 > StrParI2 THEN
  340.             BEGIN
  341.               IntLoc := IntLoc + 7;
  342.               Func2 := true;
  343.             END
  344.           ELSE
  345.             Func2 := false;
  346.         END
  347.     END; { Func2 }
  348.  
  349.   FUNCTION Func3( EnumParIn: Enumeration ): boolean;
  350.  
  351.     VAR
  352.       EnumLoc: Enumeration;
  353.  
  354.     BEGIN
  355.       EnumLoc := EnumParIn;
  356.       Func3 := (EnumLoc = Ident3);
  357.     END; { Func3 }
  358.  
  359.   PROCEDURE Proc6( EnumParIn: Enumeration; VAR EnumParOut: Enumeration );
  360.  
  361.     BEGIN
  362.       EnumParOut := EnumParIn;
  363.       IF NOT Func3(EnumParIn) THEN
  364.         EnumParOut := Ident4;
  365.       CASE EnumParIn OF
  366.         Ident1:    EnumParOut := Ident1;
  367.         Ident2:    IF IntGlob > 100 THEN
  368.                      EnumParOut := Ident1
  369.                    ELSE
  370.                      EnumParOut := Ident4;
  371.         Ident3:    EnumParOut := Ident2;
  372.         Ident4:    ;
  373.         Ident5:    EnumParOut := Ident3;
  374.       END; { CASE }
  375.     END; { Proc6 }
  376.  
  377.   PROCEDURE Proc8( VAR Array1Par: Array1Dim; VAR Array2Par: Array2Dim;
  378.                      IntParI1, IntParI2: OneToFifty );
  379.  
  380.     VAR
  381.       IntLoc: OneToFifty;
  382.       IntIndex: OneToFifty;
  383.  
  384.     BEGIN { Proc8 }
  385.       IntLoc := IntParI1 + 5;
  386.       Array1Par[IntLoc] := IntParI2;
  387.       Array1Par[IntLoc+1] := Array1Par[IntLoc];
  388.       Array1Par[IntLoc+30] := IntLoc;
  389.       FOR IntIndex := IntLoc TO IntLoc+1 DO
  390.         Array2Par[IntLoc][IntIndex] := IntLoc;
  391.       Array2Par[IntLoc][IntLoc-1] := Array2Par[IntLoc][IntLoc-1] + 1;
  392.       Array2Par[IntLoc+20][IntLoc] := Array1Par[IntLoc];
  393.       IntGlob := 5;
  394.     END; { Proc8 }
  395.  
  396.   PROCEDURE Proc1( PtrParIn: RecordPtr );
  397.  
  398.     BEGIN
  399.       PtrParIn^.PtrComp^ := PtrGlb^;
  400.       PtrParIn^.IntComp := 5;
  401.       PtrParIn^.PtrComp^.IntComp := PtrParIn^.IntComp;
  402.       PtrParIn^.PtrComp^.PtrComp := PtrParIn^.PtrComp;
  403.       Proc3( PtrParIn^.PtrComp^.PtrComp );
  404.       IF PtrParIn^.PtrComp^.Discr = Ident1 THEN
  405.         BEGIN
  406.           PtrParIn^.PtrComp^.IntComp := 6;
  407.           Proc6( PtrParIn^.EnumComp, PtrParIn^.PtrComp^.EnumComp );
  408.           PtrParIn^.PtrComp^.PtrComp := PtrGlb^.PtrComp;
  409.           Proc7( PtrParIn^.PtrComp^.IntComp, 10, PtrParIn^.PtrComp^.IntComp );
  410.         END
  411.       ELSE
  412.         PtrParIn^ := PtrParIn^.PtrComp^;
  413.     END; { Proc1 }
  414.  
  415.   PROCEDURE Proc0;
  416.  
  417.     VAR
  418.       IntLoc1: OneToFifty;
  419.       IntLoc2: OneToFifty;
  420.       IntLoc3: OneToFifty;
  421.       CharLoc: CapitalLetter;
  422.       CharIndex: CapitalLetter;
  423.       EnumLoc: Enumeration;
  424.       String1Loc: String30;
  425.       String2Loc: String30;
  426.  
  427.       starttime,
  428.       benchtime,
  429.       nulltime: long_integer;
  430.       i: long_integer;
  431.  
  432.     BEGIN
  433.       starttime := time;
  434.       i := 0;
  435.       WHILE i < LOOPS DO
  436.         i := i + 1;
  437.       nulltime := time - starttime; (* Computes overhead of looping *)
  438.  
  439.       new( PtrGlbNext );
  440.       new( PtrGlb );
  441.       PtrGlb^.PtrComp := PtrGlbNext;
  442.       PtrGlb^.Discr := Ident1;
  443.       PtrGlb^.EnumComp := Ident3;
  444.       PtrGlb^.IntComp := 40;
  445.       PtrGlb^.StringComp := 'DHRYSTONE PROGRAM, SOME STRING';
  446.  
  447. (*****************
  448. -- Start Timer --
  449. *****************)
  450.       starttime := time;
  451.       i := 0;
  452.       WHILE i < LOOPS DO
  453.         BEGIN
  454.           Proc5;
  455.           Proc4;
  456.           IntLoc1 := 2;
  457.           IntLoc2 := 3;
  458.           String2Loc := 'DHRYSTONE PROGRAM, 2''ND STRING';
  459.           EnumLoc := Ident2;
  460.           BoolGlob := NOT Func2(String1Loc, String2Loc);
  461.           WHILE IntLoc1 < IntLoc2 DO
  462.             BEGIN
  463.               IntLoc3 := 5 * IntLoc1 - IntLoc2;
  464.               Proc7( IntLoc1, IntLoc2, IntLoc3 );
  465.               IntLoc1 := IntLoc1 + 1;
  466.             END;
  467.           Proc8( Array1Glob, Array2Glob, IntLoc1, IntLoc3 );
  468.           Proc1( PtrGlb );
  469.           FOR CharIndex := 'A' TO Char2Glob DO
  470.             IF EnumLoc = Func1(CharIndex, 'C') THEN
  471.               Proc6(Ident1, EnumLoc);
  472.           IntLoc3 := IntLoc2 * IntLoc1;
  473.           IntLoc2 := IntLoc3 DIV IntLoc1;
  474.           IntLoc2 := 7 * (IntLoc3 - IntLoc2) - IntLoc1;
  475.           Proc2( IntLoc1 );
  476.  
  477.           i := i + 1;
  478.         END;
  479. (*****************
  480. -- Stop Timer --
  481. *****************)
  482.       benchtime := time - starttime - nulltime;
  483.       writeln( 'Dhrystone time for ', LOOPS, ' passes :=', benchtime/HZ:15:2 );
  484.       writeln( 'This machine benchmarks at ', LOOPS*(HZ/benchtime):15:2,
  485.                         ' dhrystones/second' );
  486.     END; { Proc0 }
  487.  
  488.   FUNCTION Super( x: long_integer ): long_integer;
  489.     GEMDOS( $20 );
  490.  
  491.   BEGIN { Main routine }
  492.     ssp := Super( 0 );
  493.     Proc0;
  494.     ssp := Super( ssp );
  495.   END.
  496.