#include <perms.h>

                                                                //      1  %external %routine %spec Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par)
#line 1 "dhry_2.imp"
extern void PROC6( int ENUMVALPAR, int /*name*/*ENUMREFPAR );
                                                                //      2  %external %routine %spec Proc 7 (%integer {One Fifty} Int 1 Par Val,
#line 2 "dhry_2.imp"
extern void PROC7( int INT1PARVAL, int INT2PARVAL, int /*name*/*INTPARREF );
                                                                //      3                                   %integer {One Fifty} Int 2 Par Val,
                                                                //      4                                   %integer {One Fifty} %name Int Par Ref)
                                                                //      5  %external %routine %spec Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)},
#line 5 "dhry_2.imp"
extern void PROC8( int /*arrayname*/*ARR1PARREF, int /*arrayname*/*ARR2PARREF, int INT1PARVAL, int INT2PARVAL );
                                                                //      6                                   %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)},
                                                                //      7                                   %integer Int 1 Par Val,
                                                                //      8                                   %integer Int 2 Par Val)
                                                                //      9  %external %integer {Enumeration} %fn %spec Func 1 (%integer {Capital Letter} Ch 1 Par Val,
#line 9 "dhry_2.imp"
extern int FUNC1( int CH1PARVAL, int CH2PARVAL );
                                                                //     10                                                     %integer {Capital Letter} Ch 2 Par Val)
                                                                //     11  %external %predicate %spec Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref)
#line 11 "dhry_2.imp"
extern int /*Boolean*/ FUNC2( _imp_string /*%string(30)*/ /*name*/*STR1PARREF, _imp_string /*%string(30)*/ /*name*/*STR2PARREF );
                                                                //     12  %external %predicate %spec Func 3 (%integer {Enumeration} Enum Par Val)
#line 12 "dhry_2.imp"
extern int /*Boolean*/ FUNC3( int ENUMPARVAL );
                                                                //     13  
                                                                //     14  ! ****************************************************************************
                                                                //     15  ! *
                                                                //     16  ! *                   "DHRYSTONE" Benchmark Program
                                                                //     17  ! *                   -----------------------------
                                                                //     18  ! *                                                                            
                                                                //     19  ! *  Version:    Imp, Version 2.1
                                                                //     20  ! *                                                                            
                                                                //     21  ! *  File:       dhry_2.c (part 3 of 3)
                                                                //     22  ! *
                                                                //     23  ! *  Date:       May 25, 1988 & Mar 30, 2026
                                                                //     24  ! *
                                                                //     25  ! *  Author:     Reinhold P. Weicker, translated from C to Imp by Graham Toal
                                                                //     26  ! *
                                                                //     27  ! ****************************************************************************
                                                                //     28  
                                                                //     29  %include "dhry.inc"
                                                                //      1  ! This translation to Imp derived from https://github.com/sifive/benchmark-dhrystone/
                                                                //      2  
                                                                //      3  !  ***************************************************************************
                                                                //      4  !  
                                                                //      5  !                     "DHRYSTONE" Benchmark Program
                                                                //      6  !                     -----------------------------
                                                                //      7  !                                                                              
                                                                //      8  !    Version:    C, Version 2.1
                                                                //      9  !                                                                              
                                                                //     10  !    File:       dhry.h (part 1 of 3)
                                                                //     11  !  
                                                                //     12  !    Date:       May 25, 1988
                                                                //     13  !  
                                                                //     14  !    Author:     Reinhold P. Weicker
                                                                //     15  !                        Siemens AG, E STE 35
                                                                //     16  !                        Postfach 3240
                                                                //     17  !                        8520 Erlangen
                                                                //     18  !                        Germany (West)
                                                                //     19  !                                Phone:  [xxx-49]-9131-7-20330
                                                                //     20  !                                        (8-17 Central European Time)
                                                                //     21  !                                Usenet: ..!mcvax!unido!estevax!weicker
                                                                //     22  !  
                                                                //     23  !                Original Version (in Ada) published in
                                                                //     24  !                "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
                                                                //     25  !                pp. 1013 - 1030, together with the statistics
                                                                //     26  !                on which the distribution of statements etc. is based.
                                                                //     27  !  
                                                                //     28  !                In this C version, the following C library functions are used:
                                                                //     29  !                - strcpy, strcmp (inside the measurement loop)
                                                                //     30  !                - printf, scanf (outside the measurement loop)
                                                                //     31  !                In addition, Berkeley UNIX system calls "times ()" or "time ()"
                                                                //     32  !                are used for execution time measurement. For measurements
                                                                //     33  !                on other systems, these calls have to be changed.
                                                                //     34  !  
                                                                //     35  !    Collection of Results:
                                                                //     36  !                Reinhold Weicker (address see above) and
                                                                //     37  !                
                                                                //     38  !                Rick Richardson
                                                                //     39  !                PC Research. Inc.
                                                                //     40  !                94 Apple Orchard Drive
                                                                //     41  !                Tinton Falls, NJ 07724
                                                                //     42  !                        Phone:  (201) 389-8963 (9-17 EST)               
                                                                //     43  !                        Usenet: ...!uunet!pcrat!rick
                                                                //     44  !  
                                                                //     45  !        Please send results to Rick Richardson and/or Reinhold Weicker.
                                                                //     46  !        Complete information should be given on hardware and software used.
                                                                //     47  !        Hardware information includes: Machine type, CPU, type and size
                                                                //     48  !        of caches; for microprocessors: clock frequency, memory speed
                                                                //     49  !        (number of wait states).
                                                                //     50  !        Software information includes: Compiler (and runtime library)
                                                                //     51  !        manufacturer and version, compilation switches, OS version.
                                                                //     52  !        The Operating System version may give an indication about the
                                                                //     53  !        compiler; Dhrystone itself performs no OS calls in the measurement loop.
                                                                //     54  !  
                                                                //     55  !        The complete output generated by the program should be mailed
                                                                //     56  !        such that at least some checks for correctness can be made.
                                                                //     57  !  
                                                                //     58  !  **************************************************************************
                                                                //     59  !  
                                                                //     60  !    History:    This version C/2.1 has been made for two reasons:
                                                                //     61  !  
                                                                //     62  !                1) There is an obvious need for a common C version of
                                                                //     63  !                Dhrystone, since C is at present the most popular system
                                                                //     64  !                programming language for the class of processors
                                                                //     65  !                (microcomputers, minicomputers) where Dhrystone is used most.
                                                                //     66  !                There should be, as far as possible, only one C version of
                                                                //     67  !                Dhrystone such that results can be compared without
                                                                //     68  !                restrictions. In the past, the C versions distributed
                                                                //     69  !                by Rick Richardson (Version 1.1) and by Reinhold Weicker
                                                                //     70  !                had small (though not significant) differences.
                                                                //     71  !  
                                                                //     72  !                2) As far as it is possible without changes to the Dhrystone
                                                                //     73  !                statistics, optimizing compilers should be prevented from
                                                                //     74  !                removing significant statements.
                                                                //     75  !  
                                                                //     76  !                This C version has been developed in cooperation with
                                                                //     77  !                Rick Richardson (Tinton Falls, NJ), it incorporates many
                                                                //     78  !                ideas from the "Version 1.1" distributed previously by
                                                                //     79  !                him over the UNIX network Usenet.
                                                                //     80  !                I also thank Chaim Benedelac (National Semiconductor),
                                                                //     81  !                David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
                                                                //     82  !                Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
                                                                //     83  !                for their help with comments on earlier versions of the
                                                                //     84  !                benchmark.
                                                                //     85  !  
                                                                //     86  !    Changes:    In the initialization part, this version follows mostly
                                                                //     87  !                Rick Richardson's version distributed via Usenet, not the
                                                                //     88  !                version distributed earlier via floppy disk by Reinhold Weicker.
                                                                //     89  !                As a concession to older compilers, names have been made
                                                                //     90  !                unique within the first 8 characters.
                                                                //     91  !                Inside the measurement loop, this version follows the
                                                                //     92  !                version previously distributed by Reinhold Weicker.
                                                                //     93  !  
                                                                //     94  !                At several places in the benchmark, code has been added,
                                                                //     95  !                but within the measurement loop only in branches that 
                                                                //     96  !                are not executed. The intention is that optimizing compilers
                                                                //     97  !                should be prevented from moving code out of the measurement
                                                                //     98  !                loop, or from removing code altogether. Since the statements
                                                                //     99  !                that are executed within the measurement loop have NOT been
                                                                //    100  !                changed, the numbers defining the "Dhrystone distribution"
                                                                //    101  !                (distribution of statements, operand types and locality)
                                                                //    102  !                still hold. Except for sophisticated optimizing compilers,
                                                                //    103  !                execution times for this version should be the same as
                                                                //    104  !                for previous versions.
                                                                //    105  !                
                                                                //    106  !                Since it has proven difficult to subtract the time for the
                                                                //    107  !                measurement loop overhead in a correct way, the loop check
                                                                //    108  !                has been made a part of the benchmark. This does have
                                                                //    109  !                an impact - though a very minor one - on the distribution
                                                                //    110  !                statistics which have been updated for this version.
                                                                //    111  !  
                                                                //    112  !                All changes within the measurement loop are described
                                                                //    113  !                and discussed in the companion paper "Rationale for
                                                                //    114  !                Dhrystone version 2".
                                                                //    115  !  
                                                                //    116  !                Because of the self-imposed limitation that the order and
                                                                //    117  !                distribution of the executed statements should not be
                                                                //    118  !                changed, there are still cases where optimizing compilers
                                                                //    119  !                may not generate code for some statements. To a certain
                                                                //    120  !                degree, this is unavoidable for small synthetic benchmarks.
                                                                //    121  !                Users of the benchmark are advised to check code listings
                                                                //    122  !                whether code is generated for all statements of Dhrystone.
                                                                //    123  !  
                                                                //    124  !                Version 2.1 is identical to version 2.0 distributed via
                                                                //    125  !                the UNIX network Usenet in March 1988 except that it corrects
                                                                //    126  !                some minor deficiencies that were found by users of version 2.0.
                                                                //    127  !                The only change within the measurement loop is that a
                                                                //    128  !                non-executed "else" part was added to the "if" statement in
                                                                //    129  !                Func_3, and a non-executed "else" part removed from Proc_3.
                                                                //    130  !  
                                                                //    131  !  **************************************************************************
                                                                //    132  !  
                                                                //    133  !   Defines:     The following "Defines" are possible:
                                                                //    134  !                -DREG=register          (default: Not defined)
                                                                //    135  !                        As an approximation to what an average C programmer
                                                                //    136  !                        might do, the "register" storage class is applied
                                                                //    137  !                        (if enabled by -DREG=register)
                                                                //    138  !                        - for local variables, if they are used (dynamically)
                                                                //    139  !                          five or more times
                                                                //    140  !                        - for parameters if they are used (dynamically)
                                                                //    141  !                          six or more times
                                                                //    142  !                        Note that an optimal "register" strategy is
                                                                //    143  !                        compiler-dependent, and that "register" declarations
                                                                //    144  !                        do not necessarily lead to faster execution.
                                                                //    145  !                -DNOSTRUCTASSIGN        (default: Not defined)
                                                                //    146  !                        Define if the C compiler does not support
                                                                //    147  !                        assignment of structures.
                                                                //    148  !                -DNOENUMS               (default: Not defined)
                                                                //    149  !                        Define if the C compiler does not support
                                                                //    150  !                        enumeration types.
                                                                //    151  !                -DTIMES                 (default)
                                                                //    152  !                -DTIME
                                                                //    153  !                        The "times" function of UNIX (returning process times)
                                                                //    154  !                        or the "time" function (returning wallclock time)
                                                                //    155  !                        is used for measurement. 
                                                                //    156  !                        For single user machines, "time ()" is adequate. For
                                                                //    157  !                        multi-user machines where you cannot get single-user
                                                                //    158  !                        access, use the "times ()" function. If you have
                                                                //    159  !                        neither, use a stopwatch in the dead of night.
                                                                //    160  !                        "printf"s are provided marking the points "Start Timer"
                                                                //    161  !                        and "Stop Timer". DO NOT use the UNIX "time(1)"
                                                                //    162  !                        command, as this will measure the total time to
                                                                //    163  !                        run this program, which will (erroneously) include
                                                                //    164  !                        the time to allocate storage (malloc) and to perform
                                                                //    165  !                        the initialization.
                                                                //    166  !                -DHZ=nnn
                                                                //    167  !                        In Berkeley UNIX, the function "times" returns process
                                                                //    168  !                        time in 1/HZ seconds, with HZ = 60 for most systems.
                                                                //    169  !                        CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
                                                                //    170  !                        A VALUE.
                                                                //    171  !  
                                                                //    172  !  **************************************************************************
                                                                //    173  !  
                                                                //    174  !    Compilation model and measurement (IMPORTANT):
                                                                //    175  !  
                                                                //    176  !    This C version of Dhrystone consists of three files:
                                                                //    177  !    - dhry.h (this file, containing global definitions and comments)
                                                                //    178  !    - dhry_1.c (containing the code corresponding to Ada package Pack_1)
                                                                //    179  !    - dhry_2.c (containing the code corresponding to Ada package Pack_2)
                                                                //    180  !  
                                                                //    181  !    The following "ground rules" apply for measurements:
                                                                //    182  !    - Separate compilation
                                                                //    183  !    - No procedure merging
                                                                //    184  !    - Otherwise, compiler optimizations are allowed but should be indicated
                                                                //    185  !    - Default results are those without register declarations
                                                                //    186  !    See the companion paper "Rationale for Dhrystone Version 2" for a more
                                                                //    187  !    detailed discussion of these ground rules.
                                                                //    188  !  
                                                                //    189  !    For 16-Bit processors (e.g. 80186, 80286), times for all compilation
                                                                //    190  !    models ("small", "medium", "large" etc.) should be given if possible,
                                                                //    191  !    together with a definition of these models for the compiler system used.
                                                                //    192  !  
                                                                //    193  !  *************************************************************************
                                                                //    194  !  
                                                                //    195  !    Dhrystone (C version) statistics:
                                                                //    196  !  
                                                                //    197  !    [Comment from the first distribution, updated for version 2.
                                                                //    198  !     Note that because of language differences, the numbers are slightly
                                                                //    199  !     different from the Ada version.]
                                                                //    200  !  
                                                                //    201  !    The following program contains statements of a high level programming
                                                                //    202  !    language (here: C) in a distribution considered representative:           
                                                                //    203  !  
                                                                //    204  !      assignments                  52 (51.0 %)
                                                                //    205  !      control statements           33 (32.4 %)
                                                                //    206  !      procedure, function calls    17 (16.7 %)
                                                                //    207  !  
                                                                //    208  !    103 statements are dynamically executed. The program is balanced with
                                                                //    209  !    respect to the three aspects:                                             
                                                                //    210  !  
                                                                //    211  !      - statement type
                                                                //    212  !      - operand type
                                                                //    213  !      - operand locality
                                                                //    214  !           operand global, local, parameter, or constant.                     
                                                                //    215  !  
                                                                //    216  !    The combination of these three aspects is balanced only approximately.    
                                                                //    217  !  
                                                                //    218  !    1. Statement Type:                                                        
                                                                //    219  !    -----------------             number
                                                                //    220  !  
                                                                //    221  !       V1 = V2                     9
                                                                //    222  !         (incl. V1 = F(..)
                                                                //    223  !       V = Constant               12
                                                                //    224  !       Assignment,                 7
                                                                //    225  !         with array element
                                                                //    226  !       Assignment,                 6
                                                                //    227  !         with record component
                                                                //    228  !                                  --
                                                                //    229  !                                  34       34
                                                                //    230  !  
                                                                //    231  !       X = Y +|-|"&&"|"|" Z        5
                                                                //    232  !       X = Y +|-|"==" Constant     6
                                                                //    233  !       X = X +|- 1                 3
                                                                //    234  !       X = Y *|/ Z                 2
                                                                //    235  !       X = Expression,             1
                                                                //    236  !             two operators
                                                                //    237  !       X = Expression,             1
                                                                //    238  !             three operators
                                                                //    239  !                                  --
                                                                //    240  !                                  18       18
                                                                //    241  !  
                                                                //    242  !       if ....                    14
                                                                //    243  !         with "else"      7
                                                                //    244  !         without "else"   7
                                                                //    245  !             executed        3
                                                                //    246  !             not executed    4
                                                                //    247  !       for ...                     7  |  counted every time
                                                                //    248  !       while ...                   4  |  the loop condition
                                                                //    249  !       do ... while                1  |  is evaluated
                                                                //    250  !       switch ...                  1
                                                                //    251  !       break                       1
                                                                //    252  !       declaration with            1
                                                                //    253  !         initialization
                                                                //    254  !                                  --
                                                                //    255  !                                  34       34
                                                                //    256  !  
                                                                //    257  !       P (...)  procedure call    11
                                                                //    258  !         user procedure      10
                                                                //    259  !         library procedure    1
                                                                //    260  !       X = F (...)
                                                                //    261  !               function  call      6
                                                                //    262  !         user function        5                                         
                                                                //    263  !         library function     1                                               
                                                                //    264  !                                  --                                          
                                                                //    265  !                                  17       17
                                                                //    266  !                                          ---
                                                                //    267  !                                          103
                                                                //    268  !  
                                                                //    269  !      The average number of parameters in procedure or function calls
                                                                //    270  !      is 1.82 (not counting the function values aX *
                                                                //    271  !  
                                                                //    272  !    2. Operators
                                                                //    273  !    ------------
                                                                //    274  !                            number    approximate
                                                                //    275  !                                      percentage
                                                                //    276  !  
                                                                //    277  !      Arithmetic             32          50.8                                 
                                                                //    278  !  
                                                                //    279  !         +                     21          33.3                              
                                                                //    280  !         -                      7          11.1                              
                                                                //    281  !         *                      3           4.8
                                                                //    282  !         / (int div)            1           1.6
                                                                //    283  !  
                                                                //    284  !      Comparison             27           42.8
                                                                //    285  !  
                                                                //    286  !         ==                     9           14.3
                                                                //    287  !         /=                     4            6.3
                                                                //    288  !         >                      1            1.6
                                                                //    289  !         <                      3            4.8
                                                                //    290  !         >=                     1            1.6
                                                                //    291  !         <=                     9           14.3
                                                                //    292  !  
                                                                //    293  !      Logic                   4            6.3
                                                                //    294  !  
                                                                //    295  !         && (AND-THEN)          1            1.6
                                                                //    296  !         |  (OR)                1            1.6
                                                                //    297  !         !  (NOT)               2            3.2
                                                                //    298  !   
                                                                //    299  !                             --          -----
                                                                //    300  !                             63          100.1
                                                                //    301  !  
                                                                //    302  !  
                                                                //    303  !    3. Operand Type (counted once per operand reference):
                                                                //    304  !    ---------------
                                                                //    305  !                            number    approximate
                                                                //    306  !                                      percentage
                                                                //    307  !  
                                                                //    308  !       Integer               175        72.3 %
                                                                //    309  !       Character              45        18.6 %
                                                                //    310  !       Pointer                12         5.0 %
                                                                //    311  !       String30                6         2.5 %
                                                                //    312  !       Array                   2         0.8 %
                                                                //    313  !       Record                  2         0.8 %
                                                                //    314  !                             ---       -------
                                                                //    315  !                             242       100.0 %
                                                                //    316  !  
                                                                //    317  !    When there is an access path leading to the final operand (e.g. a record
                                                                //    318  !    component), only the final data type on the access path is counted.       
                                                                //    319  !  
                                                                //    320  !  
                                                                //    321  !    4. Operand Locality:                                                      
                                                                //    322  !    -------------------
                                                                //    323  !                                  number    approximate
                                                                //    324  !                                            percentage
                                                                //    325  !  
                                                                //    326  !       local variable              114        47.1 %
                                                                //    327  !       global variable              22         9.1 %
                                                                //    328  !       parameter                    45        18.6 %
                                                                //    329  !          value                        23         9.5 %
                                                                //    330  !          reference                    22         9.1 %
                                                                //    331  !       function result               6         2.5 %
                                                                //    332  !       constant                     55        22.7 %
                                                                //    333  !                                   ---       -------
                                                                //    334  !                                   242       100.0 %
                                                                //    335  !  
                                                                //    336  !  
                                                                //    337  !    The program does not compute anything meaningful, but it is syntactically
                                                                //    338  !    and semantically correct. All variables have a value assigned to them
                                                                //    339  !    before they are used as a source operand.
                                                                //    340  !  
                                                                //    341  !    There has been no explicit effort to account for the effects of a
                                                                //    342  !    cache, or to balance the use of long or short displacements for code or
                                                                //    343  !    data.
                                                                //    344  !  
                                                                //    345  !  **************************************************************************
                                                                //    346  
                                                                //    347  { Compiler and system dependent definitions: }
                                                                //    348  
                                                                //    349  { Use times(2) time function unless    }
                                                                //    350  { explicitly defined otherwise         }
                                                                //    351  
                                                                //    352  { Use Microsoft C hi-res clock }
                                                                //    353  
                                                                //    354  %const %integer Mic secs Per Second     = 1000000       { Berkeley UNIX C returns process times in seconds/HZ }
                                                                //    355  
                                                                //    356  !! If using gtcpp:
                                                                //    357  !!   $define structassign(d, s)      d = s
                                                                //    358  
                                                                //    359  %const %integer Ident 1 = 0
                                                                //    360  %const %integer Ident 2 = 1
                                                                //    361  %const %integer Ident 3 = 2
                                                                //    362  %const %integer Ident 4 = 3
                                                                //    363  %const %integer Ident 5 = 4
                                                                //    364  ! typedef int   Enumeration;
                                                                //    365  
                                                                //    366  { for boolean and enumeration types in Ada, Pascal }
                                                                //    367  
                                                                //    368  { General definitions: }
                                                                //    369  
                                                                //    370  { Value of a Null pointer }
                                                                //    371  !!%external %record (*) %name %spec Null
                                                                //    372  %const %integer true  = 1
                                                                //    373  %const %integer false = 0
                                                                //    374  
                                                                //    375  ! typedef int     One Thirty;
                                                                //    376  ! typedef int     One Fifty;
                                                                //    377  ! typedef char    Capital Letter;
                                                                //    378  ! typedef int     Boolean;
                                                                //    379  ! typedef char    Str 30 [31];
                                                                //    380  ! typedef int     Arr 1 Dim [50];
                                                                //    381  ! typedef int     Arr 2 Dim [50] [50];
                                                                //    382  
                                                                //    383  
                                                                //    384  %recordformat var 1 fm    (%integer {Enumeration} Enum Comp, %integer     Int Comp, %string (30) Str Comp)
#line 384 "dhry.inc"
typedef struct VAR1FM VAR1FM;
struct VAR1FM {
  int ENUMCOMP;
  int INTCOMP;
  _imp_string /*%string(30)*/ STRCOMP;
};
                                                                //    385  %recordformat var 2 fm    (%integer {Enumeration} E Comp 2, %string (30) Str 2 Comp)
#line 385 "dhry.inc"
typedef struct VAR2FM VAR2FM;
struct VAR2FM {
  int ECOMP2;
  _imp_string /*%string(30)*/ STR2COMP;
};
                                                                //    386  %recordformat var 3 fm    (%byteinteger Ch 1 Comp, %byteinteger Ch 2 Comp)
#line 386 "dhry.inc"
typedef struct VAR3FM VAR3FM;
struct VAR3FM {
  unsigned char CH1COMP;
  unsigned char CH2COMP;
};
                                                                //    387  %recordformat variant fm  (%record (var 1 fm) var 1 %or %record (var 2 fm) var 2 %or %record (var 3 fm) var 3)
#line 387 "dhry.inc"
typedef struct VARIANTFM VARIANTFM;
struct VARIANTFM {
   VAR1FM VAR1;
   VAR2FM VAR2;
   VAR3FM VAR3;
};
                                                                //    388  %recordformat Rec Type fm (%record (Rec Type fm) %name Ptr Comp,
#line 388 "dhry.inc"
typedef struct RECTYPEFM RECTYPEFM;
struct RECTYPEFM {
   RECTYPEFM /*name*/*PTRCOMP;
  int DISCR;
   VARIANTFM VARIANT;
};
                                                                //    389                             %integer {Enumeration} Discr,
                                                                //    390                             %record (variant fm) variant)
                                                                //    391  
                                                                //    392  %external %record (Rec Type fm) %spec        Rec Type
#line 392 "dhry.inc"
extern  RECTYPEFM RECTYPE;
                                                                //    393  %external %record (Rec Type fm) %name %spec  Rec Pointer;
#line 393 "dhry.inc"
extern  RECTYPEFM /*name*/*RECPOINTER;
                                                                //    394  
                                                                //    395  %endoffile
                                                                //     30  
                                                                //     31  %external %integer %spec        Int Glob
#line 31 "dhry_2.imp"
extern int INTGLOB;
                                                                //     32  %external %byte %integer %spec  Ch 1 Glob
#line 32 "dhry_2.imp"
extern unsigned char CH1GLOB;
                                                                //     33  
                                                                //     34  
                                                                //     35  %external %routine Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par)
#line 35 "dhry_2.imp"
void PROC6( int ENUMVALPAR, int /*name*/*ENUMREFPAR )
#line 35 "dhry_2.imp"
{
                                                                //     36  {*******************************}
                                                                //     37      { executed once }
                                                                //     38      { Enum Val Par == Ident 3, Enum Ref Par becomes Ident 2 }
                                                                //     39    %switch EV(Ident 1:Ident 5)
#line 39 "dhry_2.imp"
static int sw1_EV_idx;
static const void * /*SWITCH*/ sw1_EV[5] = { &&sw1_EV_0, &&sw1_EV_1, &&sw1_EV_2, &&sw1_EV_3, &&sw1_EV_4,  };
                                                                //     40    
                                                                //     41    Enum Ref Par = Enum Val Par
#line 41 "dhry_2.imp"
*ENUMREFPAR = ENUMVALPAR;
                                                                //     42    Enum Ref Par = Ident 4 %if %not Func 3 (Enum Val Par)    { then, not executed }
#line 42 "dhry_2.imp"
if (FUNC3(ENUMVALPAR)) goto L_0002;
#line 42 "dhry_2.imp"
*ENUMREFPAR = 3;
#line 42 "dhry_2.imp"
L_0002:;
                                                                //     43  
                                                                //     44    ->EV(Enum Val Par)
#line 44 "dhry_2.imp"
sw1_EV_idx = ENUMVALPAR; if ((0 <= sw1_EV_idx) && (sw1_EV_idx <= 4)) goto *sw1_EV[sw1_EV_idx]; else {
   /*_imp_signal(8, 2, sw1_EV_idx);*/
   fprintf(stderr, "%%SWITCH index EV(%d) not in range 0:4 at %s:%d\n",
           sw1_EV_idx, (_imp_current_file != 0 ? _imp_current_file : __FILE__),
           (_imp_current_line != 0 ? _imp_current_line : __LINE__));
           exit(1);
}
                                                                //     45    
                                                                //     46      EV(Ident 1): 
#line 46 "dhry_2.imp"
sw1_EV_0:;
                                                                //     47        Enum Ref Par = Ident 1
#line 47 "dhry_2.imp"
*ENUMREFPAR = 0;
                                                                //     48        ->end
#line 48 "dhry_2.imp"
goto U_1000;
                                                                //     49        
                                                                //     50      EV(Ident 2): 
#line 50 "dhry_2.imp"
sw1_EV_1:;
                                                                //     51        %if Int Glob > 100 %then Enum Ref Par = Ident 1 %c
#line 51 "dhry_2.imp"
if (((INTGLOB) <= (100))) goto L_0003;
#line 51 "dhry_2.imp"
*ENUMREFPAR = 0;
#line 51 "dhry_2.imp"
goto L_0004;
#line 51 "dhry_2.imp"
L_0003:;
#line 51 "dhry_2.imp"
*ENUMREFPAR = 3;
#line 51 "dhry_2.imp"
L_0004:;
                                                                //     52        %else Enum Ref Par = Ident 4
                                                                //     53        ->end
#line 53 "dhry_2.imp"
goto U_1000;
                                                                //     54        
                                                                //     55      EV(Ident 3): { executed }
#line 55 "dhry_2.imp"
sw1_EV_2:;
                                                                //     56        Enum Ref Par = Ident 2
#line 56 "dhry_2.imp"
*ENUMREFPAR = 1;
                                                                //     57        ->end
#line 57 "dhry_2.imp"
goto U_1000;
                                                                //     58        
                                                                //     59      EV(Ident 4): ->end
#line 59 "dhry_2.imp"
sw1_EV_3:;
#line 59 "dhry_2.imp"
goto U_1000;
                                                                //     60      
                                                                //     61      EV(Ident 5): 
#line 61 "dhry_2.imp"
sw1_EV_4:;
                                                                //     62        Enum Ref Par = Ident 3
#line 62 "dhry_2.imp"
*ENUMREFPAR = 2;
                                                                //     63        ->end
#line 63 "dhry_2.imp"
goto U_1000;
                                                                //     64  
                                                                //     65    end: { switch }
#line 65 "dhry_2.imp"
U_1000:;
                                                                //     66  %end { Proc 6 }
#line 66 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC6 at level 1
                                                                //     67  
                                                                //     68  
                                                                //     69  %external %routine Proc 7 (%integer {One Fifty} Int 1 Par Val,
#line 69 "dhry_2.imp"
void PROC7( int INT1PARVAL, int INT2PARVAL, int /*name*/*INTPARREF )
#line 69 "dhry_2.imp"
{
                                                                //     70                             %integer {One Fifty} Int 2 Par Val,
                                                                //     71                             %integer {One Fifty} %name Int Par Ref)
                                                                //     72  {********************************************}
                                                                //     73      { executed three times                                      } 
                                                                //     74      { first call:      Int 1 Par Val == 2, Int 2 Par Val == 3,  }
                                                                //     75      {                  Int Par Ref becomes 7                    }
                                                                //     76      { second call:     Int 1 Par Val == 10, Int 2 Par Val == 5, }
                                                                //     77      {                  Int Par Ref becomes 17                   }
                                                                //     78      { third call:      Int 1 Par Val == 6, Int 2 Par Val == 10, }
                                                                //     79      {                  Int Par Ref becomes 18                   }
                                                                //     80    %integer {One Fifty} Int Loc
#line 80 "dhry_2.imp"
int INTLOC;
                                                                //     81  
                                                                //     82    Int Loc = Int 1 Par Val + 2
#line 82 "dhry_2.imp"
INTLOC = (((int)(INT1PARVAL)) + (2));
                                                                //     83    Int Par Ref = Int 2 Par Val + Int Loc
#line 83 "dhry_2.imp"
*INTPARREF = (((int)(INT2PARVAL)) + (INTLOC));
                                                                //     84  %end { Proc 7 }
#line 84 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC7 at level 1
                                                                //     85  
                                                                //     86  
                                                                //     87  %external %routine Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)},
#line 87 "dhry_2.imp"
void PROC8( int /*arrayname*/*ARR1PARREF, int /*arrayname*/*ARR2PARREF, int INT1PARVAL, int INT2PARVAL )
#line 87 "dhry_2.imp"
{
                                                                //     88                             %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)},
                                                                //     89                             %integer Int 1 Par Val,
                                                                //     90                             %integer Int 2 Par Val)
                                                                //     91  {*******************************************************************}
                                                                //     92      { executed once      }
                                                                //     93      { Int Par Val 1 == 3 }
                                                                //     94      { Int Par Val 2 == 7 }
                                                                //     95    %integer {One Fifty} Int Index
#line 95 "dhry_2.imp"
int INTINDEX;
                                                                //     96    %integer {One Fifty} Int Loc
#line 96 "dhry_2.imp"
int INTLOC;
                                                                //     97  
                                                                //     98    Int Loc = Int 1 Par Val + 5
#line 98 "dhry_2.imp"
INTLOC = (((int)(INT1PARVAL)) + (5));
                                                                //     99    Arr 1 Par Ref (Int Loc) = Int 2 Par Val
#line 99 "dhry_2.imp"
ARR1PARREF[INTLOC] = INT2PARVAL;
                                                                //    100    Arr 1 Par Ref (Int Loc+1) = Arr 1 Par Ref (Int Loc)
#line 100 "dhry_2.imp"
ARR1PARREF[(((int)(INTLOC)) + (1))] = ARR1PARREF[INTLOC];
                                                                //    101    Arr 1 Par Ref (Int Loc+30) = Int Loc
#line 101 "dhry_2.imp"
ARR1PARREF[(((int)(INTLOC)) + (30))] = INTLOC;
                                                                //    102    Arr 2 Par Ref (Int Loc*50 + Int Index) {(Int Loc, Int Index)} = Int Loc %for Int Index = Int Loc, 1, Int Loc+1
#line 102 "dhry_2.imp"
{static int _initial, _increment, _final, _control;
_initial = INTLOC; _increment = 1; _final = (((int)(INTLOC)) + (1)); INTINDEX = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle INTINDEX = INTLOC, 1, (((int)(INTLOC)) + (1))");
INTINDEX -= _increment; _control -= _increment;
L_0005:;
if (INTINDEX == _final) goto L_0006;
INTINDEX += _increment; _control += _increment;
if (INTINDEX != _control) _imp_signal(4,2,0,"Corrupt control variable INTINDEX"); /* FOR loop control variable corrupted */
}
#line 102 "dhry_2.imp"
ARR2PARREF[(((int)((((int)(INTLOC)) * (50)))) + (INTINDEX))] = INTLOC;
#line 102 "dhry_2.imp"
goto L_0005;
#line 102 "dhry_2.imp"
L_0006:;
                                                                //    103    Arr 2 Par Ref (Int Loc*50 + Int Loc-1) {(Int Loc, Int Loc-1)} = Arr 2 Par Ref (Int Loc*50 + Int Loc-1){(Int Loc, Int Loc-1)} + 1
#line 103 "dhry_2.imp"
ARR2PARREF[(((int)((((int)((((int)(INTLOC)) * (50)))) + (INTLOC)))) - (1))] = (((int)(ARR2PARREF[(((int)((((int)((((int)(INTLOC)) * (50)))) + (INTLOC)))) - (1))])) + (1));
                                                                //    104    Arr 2 Par Ref ((Int Loc+20)*50 + Int Loc) {(Int Loc+20, Int Loc)} = Arr 1 Par Ref (Int Loc)
#line 104 "dhry_2.imp"
ARR2PARREF[(((int)((((int)((((int)(INTLOC)) + (20)))) * (50)))) + (INTLOC))] = ARR1PARREF[INTLOC];
                                                                //    105    Int Glob = 5
#line 105 "dhry_2.imp"
INTGLOB = 5;
                                                                //    106  %end { Proc 8 }
#line 106 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC8 at level 1
                                                                //    107  
                                                                //    108  
                                                                //    109  %external %integer {Enumeration} %fn Func 1 (%integer {Capital Letter} Ch 1 Par Val,
#line 109 "dhry_2.imp"
int FUNC1( int CH1PARVAL, int CH2PARVAL )
#line 109 "dhry_2.imp"
{
                                                                //    110                                               %integer {Capital Letter} Ch 2 Par Val)
                                                                //    111  {***********************************************}
                                                                //    112      { executed three times                                         }
                                                                //    113      { first call:      Ch 1 Par Val == 'H', Ch 2 Par Val == 'R'    }
                                                                //    114      { second call:     Ch 1 Par Val == 'A', Ch 2 Par Val == 'C'    }
                                                                //    115      { third call:      Ch 1 Par Val == 'B', Ch 2 Par Val == 'C'    }
                                                                //    116  
                                                                //    117    %integer {Capital Letter}        Ch 1 Loc
#line 117 "dhry_2.imp"
int CH1LOC;
                                                                //    118    %integer {Capital Letter}        Ch 2 Loc
#line 118 "dhry_2.imp"
int CH2LOC;
                                                                //    119  
                                                                //    120    Ch 1 Loc = Ch 1 Par Val
#line 120 "dhry_2.imp"
CH1LOC = CH1PARVAL;
                                                                //    121    Ch 2 Loc = Ch 1 Loc
#line 121 "dhry_2.imp"
CH2LOC = CH1LOC;
                                                                //    122    %if Ch 2 Loc # Ch 2 Par Val %start
#line 122 "dhry_2.imp"
if (((CH2LOC) == (CH2PARVAL))) goto L_0008;
                                                                //    123      { then, executed }
                                                                //    124      %result = Ident 1
#line 124 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 0;
                                                                //    125    %else  { not executed }
#line 125 "dhry_2.imp"
L_0008:;
                                                                //    126      Ch 1 Glob = Ch 1 Loc
#line 126 "dhry_2.imp"
CH1GLOB = CH1LOC;
                                                                //    127      %result = Ident 2
#line 127 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 1;
                                                                //    128    %finish
                                                                //    129  %end { Func 1 }
#line 129 "dhry_2.imp"
} // End of block FUNC1 at level 1
                                                                //    130  
                                                                //    131  
                                                                //    132  %external %predicate Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref)
#line 132 "dhry_2.imp"
int /*Boolean*/ FUNC2( _imp_string /*%string(30)*/ /*name*/*STR1PARREF, _imp_string /*%string(30)*/ /*name*/*STR2PARREF )
#line 132 "dhry_2.imp"
{
                                                                //    133  {***********************************************}
                                                                //    134      { executed once }
                                                                //    135      { Str 1 Par Ref == "DHRYSTONE PROGRAM, 1'ST STRING" }
                                                                //    136      { Str 2 Par Ref == "DHRYSTONE PROGRAM, 2'ND STRING" }
                                                                //    137  
                                                                //    138    %integer {One Thirty}        Int Loc
#line 138 "dhry_2.imp"
int INTLOC;
                                                                //    139    %integer {Capital Letter}    Ch Loc
#line 139 "dhry_2.imp"
int CHLOC;
                                                                //    140  
                                                                //    141    Int Loc = 2
#line 141 "dhry_2.imp"
INTLOC = 2;
                                                                //    142    %while Int Loc <= 2 %cycle { loop body executed once }
#line 142 "dhry_2.imp"
L_0009:;
#line 142 "dhry_2.imp"
if (((INTLOC) > (2))) goto L_000a;
                                                                //    143      %if Func 1 (CHARNO(Str 1 Par Ref, Int Loc),
#line 143 "dhry_2.imp"
if (((FUNC1(*_imp_CHARNO(STR1PARREF, INTLOC), *_imp_CHARNO(STR2PARREF, (((int)(INTLOC)) + (1))))) != (0))) goto L_000c;
                                                                //    144                  CHARNO(Str 2 Par Ref, Int Loc+1)) = Ident 1 %start { then, executed }
                                                                //    145        Ch Loc = 'A'
#line 145 "dhry_2.imp"
CHLOC = 65;
                                                                //    146        Int Loc = Int Loc + 1
#line 146 "dhry_2.imp"
INTLOC = (((int)(INTLOC)) + (1));
                                                                //    147      %finish { if }
#line 147 "dhry_2.imp"
L_000c:;
                                                                //    148    %repeat { while }
#line 148 "dhry_2.imp"
goto L_0009;
#line 148 "dhry_2.imp"
L_000a:;
                                                                //    149    Int Loc = 7 %if 'W' <= Ch Loc < 'Z'    { then, not executed }
#line 149 "dhry_2.imp"
if ((((87) > (CHLOC))) || (((CHLOC) >= (90)))) goto L_000d;
#line 149 "dhry_2.imp"
INTLOC = 7;
#line 149 "dhry_2.imp"
L_000d:;
                                                                //    150      
                                                                //    151    %true %if Ch Loc = 'R'                 { then, not executed }
#line 151 "dhry_2.imp"
if (((CHLOC) != (82))) goto L_000e;
#line 151 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 1;
#line 151 "dhry_2.imp"
L_000e:;
                                                                //    152  
                                                                //    153    { else executed }
                                                                //    154    %if Str 1 Par Ref > Str 2 Par Ref %start
#line 154 "dhry_2.imp"
if ((_imp_strcmp(*STR1PARREF, *STR2PARREF) <= 0)) goto L_000f;
                                                                //    155      { then, not executed }
                                                                //    156      Int Loc  = Int Loc + 7
#line 156 "dhry_2.imp"
INTLOC = (((int)(INTLOC)) + (7));
                                                                //    157      Int Glob = Int Loc
#line 157 "dhry_2.imp"
INTGLOB = INTLOC;
                                                                //    158      %true
#line 158 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 1;
                                                                //    159    %finish %else %false { executed }
#line 159 "dhry_2.imp"
L_000f:;
#line 159 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 0;
                                                                //    160    { if Ch Loc }
                                                                //    161  %end { Func 2 }
#line 161 "dhry_2.imp"
} // End of block FUNC2 at level 1
                                                                //    162  
                                                                //    163  
                                                                //    164  %external %predicate Func 3 (%integer {Enumeration} Enum Par Val)
#line 164 "dhry_2.imp"
int /*Boolean*/ FUNC3( int ENUMPARVAL )
#line 164 "dhry_2.imp"
{
                                                                //    165  {*************************}
                                                                //    166      { executed once        }
                                                                //    167      { Enum Par Val == Ident 3 }
                                                                //    168    %integer {Enumeration} Enum Loc
#line 168 "dhry_2.imp"
int ENUMLOC;
                                                                //    169    Enum Loc = Enum Par Val
#line 169 "dhry_2.imp"
ENUMLOC = ENUMPARVAL;
                                                                //    170    %true %if Enum Loc = Ident 3     { then, executed }
#line 170 "dhry_2.imp"
if (((ENUMLOC) != (2))) goto L_0010;
#line 170 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 1;
#line 170 "dhry_2.imp"
L_0010:;
                                                                //    171    %false                           { not executed }
#line 171 "dhry_2.imp"
/* Remove %on %event handler here if present for this block */
return 0;
                                                                //    172  %end { Func 3 }
#line 172 "dhry_2.imp"
} // End of block FUNC3 at level 1
                                                                //    173  
                                                                //    174  %end %of %file
#line 174 "dhry_2.imp"
// End of file
