#include <perms.h>

                                                                //      1  %external %record (*) %name Null == 0
#line 1 "dhry_1.imp"
 void /*name*/*NULL = { 0 } /* Initialise all fields of a record to 0. */;
                                                                //      2  
                                                                //      3  %external %routine %spec Proc 6 (%integer {Enumeration} Enum Val Par, %integer {Enumeration} %name Enum Ref Par)
#line 3 "dhry_1.imp"
extern void PROC6( int ENUMVALPAR, int /*name*/*ENUMREFPAR );
                                                                //      4  %external %routine %spec Proc 7 (%integer {One Fifty} Int 1 Par Val,
#line 4 "dhry_1.imp"
extern void PROC7( int INT1PARVAL, int INT2PARVAL, int /*name*/*INTPARREF );
                                                                //      5                                   %integer {One Fifty} Int 2 Par Val,
                                                                //      6                                   %integer {One Fifty} %name Int Par Ref)
                                                                //      7  %external %routine %spec Proc 8 (%integer %array %name Arr 1 Par Ref {(0:49)},
#line 7 "dhry_1.imp"
extern void PROC8( int /*arrayname*/*ARR1PARREF, int /*arrayname*/*ARR2PARREF, int INT1PARVAL, int INT2PARVAL );
                                                                //      8                                   %integer %array %name Arr 2 Par Ref {(0:50*50-1)} {(0:49, 0:49)},
                                                                //      9                                   %integer Int 1 Par Val,
                                                                //     10                                   %integer Int 2 Par Val)
                                                                //     11  %external %integer {Enumeration} %fn %spec Func 1 (%integer {Capital Letter} Ch 1 Par Val,
#line 11 "dhry_1.imp"
extern int FUNC1( int CH1PARVAL, int CH2PARVAL );
                                                                //     12                                                     %integer {Capital Letter} Ch 2 Par Val)
                                                                //     13  %external %predicate %spec Func 2 (%string (30) %name Str 1 Par Ref, %string (30) %name Str 2 Par Ref)
#line 13 "dhry_1.imp"
extern int /*Boolean*/ FUNC2( _imp_string /*%string(30)*/ /*name*/*STR1PARREF, _imp_string /*%string(30)*/ /*name*/*STR2PARREF );
                                                                //     14  %external %predicate %spec Func 3 (%integer {Enumeration} Enum Par Val)
#line 14 "dhry_1.imp"
extern int /*Boolean*/ FUNC3( int ENUMPARVAL );
                                                                //     15  
                                                                //     16  ! ****************************************************************************
                                                                //     17  ! *
                                                                //     18  ! *                   "DHRYSTONE" Benchmark Program
                                                                //     19  ! *                   -----------------------------
                                                                //     20  ! *                                                                            
                                                                //     21  ! *  Version:    Imp, Version 2.1
                                                                //     22  ! *                                                                            
                                                                //     23  ! *  File:       dhry_1.c (part 2 of 3)
                                                                //     24  ! *
                                                                //     25  ! *  Date:       May 25, 1988 & Mar 30, 2026
                                                                //     26  ! *
                                                                //     27  ! *  Author:     Reinhold P. Weicker, translated from C to Imp by Graham Toal
                                                                //     28  ! *
                                                                //     29  ! ****************************************************************************
                                                                //     30  
                                                                //     31  %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
                                                                //     32  
                                                                //     33  %const %integer DHRY ITERS = 100000
                                                                //     34  
                                                                //     35  { Global Variables: }
                                                                //     36  
                                                                //     37  %external %record (Rec Type fm) %name  Ptr Glob,
#line 37 "dhry_1.imp"
 RECTYPEFM /*name*/*PTRGLOB;
#line 37 "dhry_1.imp"
 RECTYPEFM /*name*/*NEXTPTRGLOB;
                                                                //     38                                         Next Ptr Glob
                                                                //     39  %external %integer                     Int Glob
#line 39 "dhry_1.imp"
int INTGLOB;
                                                                //     40  %external %integer {Boolean}           Bool Glob
#line 40 "dhry_1.imp"
int BOOLGLOB;
                                                                //     41  %external %byte %integer               Ch 1 Glob,
#line 41 "dhry_1.imp"
unsigned char CH1GLOB;
#line 41 "dhry_1.imp"
unsigned char CH2GLOB;
                                                                //     42                                         Ch 2 Glob
                                                                //     43  %external %integer %array              Arr 1 Glob (0:49)
#line 43 "dhry_1.imp"
int ARR1GLOB[50];
                                                                //     44  
                                                                //     45  !!! PROBLEM! Imp77 doesn't allow N-D external arrays, only local ones!
                                                                //     46  %external %integer %array              Arr 2 Glob (0:50*50-1) {(0:49, 0:49)}
#line 46 "dhry_1.imp"
int ARR2GLOB[2500];
                                                                //     47  
                                                                //     48  !extern char     *malloc ()
                                                                //     49  !!%external %integer {Enumeration} %fn %spec     Func 1
                                                                //     50    { forward declaration necessary since Enumeration may not simply be int }
                                                                //     51  
                                                                //     52  !#ifndef REG
                                                                //     53  %external %integer {Boolean} Reg = false
#line 53 "dhry_1.imp"
int REG = 0;
                                                                //     54  !#define REG
                                                                //     55          { REG becomes defined as empty }
                                                                //     56          { i.e. no register variables   }
                                                                //     57  !#else
                                                                //     58  !        %integer {Boolean} Reg = true
                                                                //     59  !#endif
                                                                //     60  
                                                                //     61  { variables for time measurement: }
                                                                //     62  
                                                                //     63  !#ifdef TIMES
                                                                //     64  !struct tms      time info
                                                                //     65  !extern  int     times ()
                                                                //     66  !                { see library function "times" }
                                                                //     67  !#define Too Small Time (2*HZ)
                                                                //     68  !                { Measurements should last at least about 2 seconds }
                                                                //     69  !#endif
                                                                //     70  !#ifdef TIME
                                                                //     71  !extern long     time()
                                                                //     72  !                { see library function "time"  }
                                                                //     73  !#define Too Small Time 2
                                                                //     74  !                { Measurements should last at least 2 seconds }
                                                                //     75  !#endif
                                                                //     76  !#ifdef MSC CLOCK
                                                                //     77  !extern clock t	clock()
                                                                //     78  !#define Too Small Time (2*HZ)
                                                                //     79  !#endif
                                                                //     80  
                                                                //     81  %const %integer           Too Small Time = 2 * 1000000  {must run at least 2 seconds}
                                                                //     82  
                                                                //     83  %external {%long} %integer  Begin Time, %c
#line 83 "dhry_1.imp"
int BEGINTIME;
#line 83 "dhry_1.imp"
int ENDTIME;
#line 83 "dhry_1.imp"
int USERTIME;
                                                                //     84                            End Time, %c
                                                                //     85                            User Time
                                                                //     86                            
                                                                //     87  %external %real           Microseconds, %c
#line 87 "dhry_1.imp"
float MICROSECONDS;
#line 87 "dhry_1.imp"
float DHRYSTONESPERSECOND;
                                                                //     88                            Dhrystones Per Second
                                                                //     89  
                                                                //     90  { end of variables for time measurement }
                                                                //     91  
                                                                //     92  
                                                                //     93  %begin
#line 93 "dhry_1.imp"
int main(int argc, char **argv) {
  _imp_initialise(argc, argv);
                                                                //     94  {***}
                                                                //     95    %routinespec Proc 1 (%record (Rec Type fm) %name Ptr Val Par)
#line 95 "dhry_1.imp"
auto void PROC1(  RECTYPEFM /*name*/*PTRVALPAR );
                                                                //     96    %routinespec Proc 2 (%integer {One Fifty} %name  Int Par Ref)
#line 96 "dhry_1.imp"
auto void PROC2( int /*name*/*INTPARREF );
                                                                //     97    %routinespec Proc 3 (%record (Rec Type fm) %name Ptr Ref Par)
#line 97 "dhry_1.imp"
auto void PROC3(  RECTYPEFM /*name*/*PTRREFPAR );
                                                                //     98    %routinespec Proc 4
#line 98 "dhry_1.imp"
auto void PROC4( void );
                                                                //     99    %routinespec Proc 5
#line 99 "dhry_1.imp"
auto void PROC5( void );
                                                                //    100  
                                                                //    101    { main program, corresponds to procedures        }
                                                                //    102    { Main and Proc 0 in the Ada version             }
                                                                //    103    
                                                                //    104    %integer {One Fifty}   Int 1 Loc
#line 104 "dhry_1.imp"
int INT1LOC;
                                                                //    105    %integer {One Fifty}   Int 2 Loc
#line 105 "dhry_1.imp"
int INT2LOC;
                                                                //    106    %integer {One Fifty}   Int 3 Loc
#line 106 "dhry_1.imp"
int INT3LOC;
                                                                //    107    %byte %integer         Ch Index
#line 107 "dhry_1.imp"
unsigned char CHINDEX;
                                                                //    108    %integer {Enumeration} Enum Loc
#line 108 "dhry_1.imp"
int ENUMLOC;
                                                                //    109    %string (30)           Str 1 Loc
#line 109 "dhry_1.imp"
_imp_string /*%string(30)*/ STR1LOC;
                                                                //    110    %string (30)           Str 2 Loc
#line 110 "dhry_1.imp"
_imp_string /*%string(30)*/ STR2LOC;
                                                                //    111    %integer               Run Index
#line 111 "dhry_1.imp"
int RUNINDEX;
                                                                //    112    %integer               Number Of Runs
#line 112 "dhry_1.imp"
int NUMBEROFRUNS;
                                                                //    113  
                                                                //    114    { Initializations }
                                                                //    115  
                                                                //    116    %record (Rec Type fm) Next Ptr Glob
#line 116 "dhry_1.imp"
 RECTYPEFM NEXTPTRGLOB;
                                                                //    117    %record (Rec Type fm) Ptr Glob {= (Rec Pointer) malloc (sizeof (Rec Type))}
#line 117 "dhry_1.imp"
 RECTYPEFM PTRGLOB;
                                                                //    118  
                                                                //    119    Ptr Glob_Ptr Comp                    == Next Ptr Glob
#line 119 "dhry_1.imp"
PTRGLOB.PTRCOMP = &NEXTPTRGLOB;
                                                                //    120    Ptr Glob_Discr                       = Ident 1
#line 120 "dhry_1.imp"
PTRGLOB.DISCR = 0;
                                                                //    121    Ptr Glob_variant_var 1_Enum Comp     = Ident 3
#line 121 "dhry_1.imp"
PTRGLOB.VARIANT.VAR1.ENUMCOMP = 2;
                                                                //    122    Ptr Glob_variant_var 1_Int Comp      = 40
#line 122 "dhry_1.imp"
PTRGLOB.VARIANT.VAR1.INTCOMP = 40;
                                                                //    123    Ptr Glob_variant_var 1_Str Comp = "DHRYSTONE PROGRAM, SOME STRING"
#line 123 "dhry_1.imp"
PTRGLOB.VARIANT.VAR1.STRCOMP = _imp_str_literal("DHRYSTONE PROGRAM, SOME STRING");
                                                                //    124    Str 1 Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
#line 124 "dhry_1.imp"
STR1LOC = _imp_str_literal("DHRYSTONE PROGRAM, 1'ST STRING");
                                                                //    125  
                                                                //    126    Arr 2 Glob (8*50+7){(8,7)} = 10
#line 126 "dhry_1.imp"
ARR2GLOB[(((int)((((int)(8)) * (50)))) + (7))] = 10;
                                                                //    127          { Was missing in published program. Without this statement,    }
                                                                //    128          { Arr 2 Glob [8][7] would have an undefined value.             }
                                                                //    129          { Warning: With 16-Bit processors and Number Of Runs > 32000,  }
                                                                //    130          { overflow may occur for this array element.                   }
                                                                //    131  
                                                                //    132    newline
#line 132 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    133    printstring ("Dhrystone Benchmark, Version 2.1 (Language: Imp)")
#line 133 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Dhrystone Benchmark, Version 2.1 (Language: Imp)"));
                                                                //    134    newlines(2)
#line 134 "dhry_1.imp"
_imp_NEWLINES(2);
                                                                //    135    
                                                                //    136    %if Reg # 0 %start
#line 136 "dhry_1.imp"
if (((REG) == (0))) goto L_0002;
                                                                //    137      printstring ("Program compiled with 'register' attribute")
#line 137 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Program compiled with 'register' attribute"));
                                                                //    138      newlines(2)
#line 138 "dhry_1.imp"
_imp_NEWLINES(2);
                                                                //    139    %else
#line 139 "dhry_1.imp"
goto L_0003;
#line 139 "dhry_1.imp"
L_0002:;
                                                                //    140      printstring ("Program compiled without 'register' attribute")
#line 140 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Program compiled without 'register' attribute"));
                                                                //    141      newlines(2)
#line 141 "dhry_1.imp"
_imp_NEWLINES(2);
                                                                //    142    %finish
#line 142 "dhry_1.imp"
L_0003:;
                                                                //    143  
                                                                //    144    Number Of Runs = DHRY ITERS
#line 144 "dhry_1.imp"
NUMBEROFRUNS = 100000;
                                                                //    145  
                                                                //    146  !  printstring ("Please give the number of runs through the benchmark: ")
                                                                //    147  !  %begin
                                                                //    148  !    %integer n
                                                                //    149  !    read(n)
                                                                //    150  !    Number Of Runs = n
                                                                //    151  !  %end
                                                                //    152  !  newline
                                                                //    153  
                                                                //    154    printstring ("Execution starts, ")
#line 154 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Execution starts, "));
                                                                //    155    write(Number Of Runs, -1)
#line 155 "dhry_1.imp"
_imp_WRITE(NUMBEROFRUNS, (-1));
                                                                //    156    printstring (" runs through Dhrystone")
#line 156 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal(" runs through Dhrystone"));
                                                                //    157    newline
#line 157 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    158  
                                                                //    159    {*************}
                                                                //    160    { Start timer }
                                                                //    161    {*************}
                                                                //    162   
                                                                //    163  !#ifdef TIMES
                                                                //    164  !  times (&time info)
                                                                //    165  !  Begin Time = (long) time info.tms utime
                                                                //    166  !#endif
                                                                //    167  !#ifdef TIME
                                                                //    168  !  Begin Time = time ( (long *) 0)
                                                                //    169  !#endif
                                                                //    170  !#ifdef MSC CLOCK
                                                                //    171  !  Begin Time = clock()
                                                                //    172  !#endif
                                                                //    173  
                                                                //    174    Begin Time = cpu time
#line 174 "dhry_1.imp"
BEGINTIME = _imp_CPUTIME();
                                                                //    175  
                                                                //    176    %for Run Index = 1, 1, Number Of Runs %cycle
#line 176 "dhry_1.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = NUMBEROFRUNS; RUNINDEX = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle RUNINDEX = 1, 1, NUMBEROFRUNS");
RUNINDEX -= _increment; _control -= _increment;
L_0004:;
if (RUNINDEX == _final) goto L_0005;
RUNINDEX += _increment; _control += _increment;
if (RUNINDEX != _control) _imp_signal(4,2,0,"Corrupt control variable RUNINDEX"); /* FOR loop control variable corrupted */
}
                                                                //    177  
                                                                //    178      Proc 5
#line 178 "dhry_1.imp"
PROC5();
                                                                //    179      Proc 4
#line 179 "dhry_1.imp"
PROC4();
                                                                //    180        { Ch 1 Glob == 'A', Ch 2 Glob == 'B', Bool Glob == true }
                                                                //    181      Int 1 Loc = 2
#line 181 "dhry_1.imp"
INT1LOC = 2;
                                                                //    182      Int 2 Loc = 3
#line 182 "dhry_1.imp"
INT2LOC = 3;
                                                                //    183      Str 2 Loc = "DHRYSTONE PROGRAM, 2'ND STRING"
#line 183 "dhry_1.imp"
STR2LOC = _imp_str_literal("DHRYSTONE PROGRAM, 2'ND STRING");
                                                                //    184      Enum Loc = Ident 2
#line 184 "dhry_1.imp"
ENUMLOC = 1;
                                                                //    185      %if %not Func 2 (Str 1 Loc, Str 2 Loc) %then Bool Glob = false %else Bool Glob = true
#line 185 "dhry_1.imp"
if (FUNC2(&STR1LOC, &STR2LOC)) goto L_0007;
#line 185 "dhry_1.imp"
BOOLGLOB = 0;
#line 185 "dhry_1.imp"
goto L_0008;
#line 185 "dhry_1.imp"
L_0007:;
#line 185 "dhry_1.imp"
BOOLGLOB = 1;
#line 185 "dhry_1.imp"
L_0008:;
                                                                //    186        { Bool Glob == 1 }
                                                                //    187      %while Int 1 Loc < Int 2 Loc %cycle { loop body executed once }
#line 187 "dhry_1.imp"
L_0009:;
#line 187 "dhry_1.imp"
if (((INT1LOC) >= (INT2LOC))) goto L_000a;
                                                                //    188        Int 3 Loc = 5 * Int 1 Loc - Int 2 Loc
#line 188 "dhry_1.imp"
INT3LOC = (((int)((((int)(5)) * (INT1LOC)))) - (INT2LOC));
                                                                //    189          { Int 3 Loc == 7 }
                                                                //    190        Proc 7 (Int 1 Loc, Int 2 Loc, Int 3 Loc)
#line 190 "dhry_1.imp"
PROC7(INT1LOC, INT2LOC, &INT3LOC);
                                                                //    191          { Int 3 Loc == 7 }
                                                                //    192        Int 1 Loc = Int 1 Loc + 1
#line 192 "dhry_1.imp"
INT1LOC = (((int)(INT1LOC)) + (1));
                                                                //    193      %repeat { while }
#line 193 "dhry_1.imp"
goto L_0009;
#line 193 "dhry_1.imp"
L_000a:;
                                                                //    194        { Int 1 Loc == 3, Int 2 Loc == 3, Int 3 Loc == 7 }
                                                                //    195      Proc 8 (Arr 1 Glob, Arr 2 Glob, Int 1 Loc, Int 3 Loc)
#line 195 "dhry_1.imp"
PROC8(&ARR1GLOB[0], &ARR2GLOB[0], INT1LOC, INT3LOC);
                                                                //    196        { Int Glob == 5 }
                                                                //    197      Proc 1 (Ptr Glob)
#line 197 "dhry_1.imp"
PROC1(&PTRGLOB);
                                                                //    198      %for Ch Index = 'A', 1,  Ch 2 Glob %cycle
#line 198 "dhry_1.imp"
{static int _initial, _increment, _final, _control;
_initial = 65; _increment = 1; _final = CH2GLOB; CHINDEX = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle CHINDEX = 65, 1, CH2GLOB");
CHINDEX -= _increment; _control -= _increment;
L_000c:;
if (CHINDEX == _final) goto L_000d;
CHINDEX += _increment; _control += _increment;
if (CHINDEX != _control) _imp_signal(4,2,0,"Corrupt control variable CHINDEX"); /* FOR loop control variable corrupted */
}
                                                                //    199                               { loop body executed twice }
                                                                //    200        %if Enum Loc = Func 1 (Ch Index, 'C') %start
#line 200 "dhry_1.imp"
if (((ENUMLOC) != (FUNC1(CHINDEX, 67)))) goto L_000f;
                                                                //    201            { then, not executed }
                                                                //    202          Proc 6 (Ident 1, Enum Loc)
#line 202 "dhry_1.imp"
PROC6(0, &ENUMLOC);
                                                                //    203          Str 2 Loc = "DHRYSTONE PROGRAM, 3'RD STRING"
#line 203 "dhry_1.imp"
STR2LOC = _imp_str_literal("DHRYSTONE PROGRAM, 3'RD STRING");
                                                                //    204          Int 2 Loc = Run Index
#line 204 "dhry_1.imp"
INT2LOC = RUNINDEX;
                                                                //    205          Int Glob = Run Index
#line 205 "dhry_1.imp"
INTGLOB = RUNINDEX;
                                                                //    206        %finish
#line 206 "dhry_1.imp"
L_000f:;
                                                                //    207      %repeat
#line 207 "dhry_1.imp"
goto L_000c;
#line 207 "dhry_1.imp"
L_000d:;
                                                                //    208        { Int 1 Loc == 3, Int 2 Loc == 3, Int 3 Loc == 7 }
                                                                //    209      Int 2 Loc = Int 2 Loc * Int 1 Loc
#line 209 "dhry_1.imp"
INT2LOC = (((int)(INT2LOC)) * (INT1LOC));
                                                                //    210      Int 1 Loc = Int 2 Loc // Int 3 Loc
#line 210 "dhry_1.imp"
INT1LOC = (long)((long)((int)(INT2LOC)) / (long)((int)(_Z(INT3LOC))));
                                                                //    211      Int 2 Loc = 7 * (Int 2 Loc - Int 3 Loc) - Int 1 Loc
#line 211 "dhry_1.imp"
INT2LOC = (((int)(((7) * ((int)((((int)(INT2LOC)) - (INT3LOC))))))) - (INT1LOC));
                                                                //    212        { Int 1 Loc == 1, Int 2 Loc == 13, Int 3 Loc == 7 }
                                                                //    213      Proc 2 (Int 1 Loc)
#line 213 "dhry_1.imp"
PROC2(&INT1LOC);
                                                                //    214        { Int 1 Loc == 5 }
                                                                //    215  
                                                                //    216    %repeat { loop "for Run Index" }
#line 216 "dhry_1.imp"
goto L_0004;
#line 216 "dhry_1.imp"
L_0005:;
                                                                //    217  
                                                                //    218    {************}
                                                                //    219    { Stop timer }
                                                                //    220    {************}
                                                                //    221    
                                                                //    222  !#ifdef TIMES
                                                                //    223  !  times (&time info)
                                                                //    224  !  End Time = (long) time info.tms utime
                                                                //    225  !#endif
                                                                //    226  !#ifdef TIME
                                                                //    227  !  End Time = time ( (long *) 0)
                                                                //    228  !#endif
                                                                //    229  !#ifdef MSC CLOCK
                                                                //    230  !  End Time = clock()
                                                                //    231  !#endif
                                                                //    232  
                                                                //    233    End Time = cpu time
#line 233 "dhry_1.imp"
ENDTIME = _imp_CPUTIME();
                                                                //    234  
                                                                //    235    printstring ("Execution ends"); newline
#line 235 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Execution ends"));
#line 235 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    236    printstring (""); newline
#line 236 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal(""));
#line 236 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    237    printstring ("Final values of the variables used in the benchmark:"); newline
#line 237 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Final values of the variables used in the benchmark:"));
#line 237 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    238    printstring (""); newline
#line 238 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal(""));
#line 238 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    239    printstring ("Int_Glob:            "); write( Int Glob, -1); newline
#line 239 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Int_Glob:            "));
#line 239 "dhry_1.imp"
_imp_WRITE(INTGLOB, (-1));
#line 239 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    240    printstring ("        should be:   "); write( 5, -1); newline
#line 240 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 240 "dhry_1.imp"
_imp_WRITE(5, (-1));
#line 240 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    241    printstring ("Bool_Glob:           "); write( Bool Glob, -1); newline
#line 241 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Bool_Glob:           "));
#line 241 "dhry_1.imp"
_imp_WRITE(BOOLGLOB, (-1));
#line 241 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    242    printstring ("        should be:   "); write( 1, -1); newline
#line 242 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 242 "dhry_1.imp"
_imp_WRITE(1, (-1));
#line 242 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    243    printstring ("Ch_1_Glob:           "); print symbol(Ch 1 Glob); newline
#line 243 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Ch_1_Glob:           "));
#line 243 "dhry_1.imp"
_imp_PRINTSYMBOL(CH1GLOB);
#line 243 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    244    printstring ("        should be:   "); print symbol('A'); newline
#line 244 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 244 "dhry_1.imp"
_imp_PRINTSYMBOL(65);
#line 244 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    245    printstring ("Ch_2_Glob:           "); print symbol(Ch 2 Glob); newline
#line 245 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Ch_2_Glob:           "));
#line 245 "dhry_1.imp"
_imp_PRINTSYMBOL(CH2GLOB);
#line 245 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    246    printstring ("        should be:   "); print symbol('B'); newline
#line 246 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 246 "dhry_1.imp"
_imp_PRINTSYMBOL(66);
#line 246 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    247    printstring ("Arr_1_Glob[8]:       "); write( Arr 1 Glob(8), -1); newline
#line 247 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Arr_1_Glob[8]:       "));
#line 247 "dhry_1.imp"
_imp_WRITE(ARR1GLOB[8], (-1));
#line 247 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    248    printstring ("        should be:   "); write( 7, -1); newline
#line 248 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 248 "dhry_1.imp"
_imp_WRITE(7, (-1));
#line 248 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    249    printstring ("Arr_2_Glob[8][7]:    "); write( Arr 2 Glob(8*50+7){(8,7)}, -1); newline
#line 249 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Arr_2_Glob[8][7]:    "));
#line 249 "dhry_1.imp"
_imp_WRITE(ARR2GLOB[(((int)((((int)(8)) * (50)))) + (7))], (-1));
#line 249 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    250    printstring ("        should be:   Number_Of_Runs + 10"); newline
#line 250 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   Number_Of_Runs + 10"));
#line 250 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    251    printstring ("Ptr_Glob->"); newline
#line 251 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Ptr_Glob->"));
#line 251 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    252    printstring ("  Ptr_Comp:          "); write(ADDR(Ptr Glob_Ptr Comp), -1); newline
#line 252 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Ptr_Comp:          "));
#line 252 "dhry_1.imp"
_imp_WRITE(_imp_ADDR(PTRGLOB.PTRCOMP), (-1));
#line 252 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    253    printstring ("        should be:   (implementation-dependent)"); newline
#line 253 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   (implementation-dependent)"));
#line 253 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    254    printstring ("  Discr:             "); write( Ptr Glob_Discr, -1); newline
#line 254 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Discr:             "));
#line 254 "dhry_1.imp"
_imp_WRITE(PTRGLOB.DISCR, (-1));
#line 254 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    255    printstring ("        should be:   "); write( 0, -1); newline
#line 255 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 255 "dhry_1.imp"
_imp_WRITE(0, (-1));
#line 255 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    256    printstring ("  Enum_Comp:         "); write( Ptr Glob_variant_var 1_Enum Comp, -1); newline
#line 256 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Enum_Comp:         "));
#line 256 "dhry_1.imp"
_imp_WRITE(PTRGLOB.VARIANT.VAR1.ENUMCOMP, (-1));
#line 256 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    257    printstring ("        should be:   "); write( 2, -1); newline
#line 257 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 257 "dhry_1.imp"
_imp_WRITE(2, (-1));
#line 257 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    258    printstring ("  Int_Comp:          "); write( Ptr Glob_variant_var 1_Int Comp, -1); newline
#line 258 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Int_Comp:          "));
#line 258 "dhry_1.imp"
_imp_WRITE(PTRGLOB.VARIANT.VAR1.INTCOMP, (-1));
#line 258 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    259    printstring ("        should be:   "); write( 17, -1); newline
#line 259 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 259 "dhry_1.imp"
_imp_WRITE(17, (-1));
#line 259 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    260    printstring ("  Str_Comp:          "); print string(Ptr Glob_variant_var 1_Str Comp); newline
#line 260 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Str_Comp:          "));
#line 260 "dhry_1.imp"
_imp_PRINTSTRING(PTRGLOB.VARIANT.VAR1.STRCOMP);
#line 260 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    261    printstring ("        should be:   DHRYSTONE PROGRAM, SOME STRING"); newline
#line 261 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   DHRYSTONE PROGRAM, SOME STRING"));
#line 261 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    262    printstring ("Next_Ptr_Glob->"); newline
#line 262 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Next_Ptr_Glob->"));
#line 262 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    263    printstring ("  Ptr_Comp:          "); write(ADDR(Next Ptr Glob_Ptr Comp), -1); newline
#line 263 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Ptr_Comp:          "));
#line 263 "dhry_1.imp"
_imp_WRITE(_imp_ADDR(NEXTPTRGLOB.PTRCOMP), (-1));
#line 263 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    264    printstring ("        should be:   (implementation-dependent), same as above"); newline
#line 264 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   (implementation-dependent), same as above"));
#line 264 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    265    printstring ("  Discr:             "); write( Next Ptr Glob_Discr, -1); newline
#line 265 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Discr:             "));
#line 265 "dhry_1.imp"
_imp_WRITE(NEXTPTRGLOB.DISCR, (-1));
#line 265 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    266    printstring ("        should be:   "); write( 0, -1); newline
#line 266 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 266 "dhry_1.imp"
_imp_WRITE(0, (-1));
#line 266 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    267    printstring ("  Enum_Comp:         "); write( Next Ptr Glob_variant_var 1_Enum Comp, -1); newline
#line 267 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Enum_Comp:         "));
#line 267 "dhry_1.imp"
_imp_WRITE(NEXTPTRGLOB.VARIANT.VAR1.ENUMCOMP, (-1));
#line 267 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    268    printstring ("        should be:   "); write( 1, -1); newline
#line 268 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 268 "dhry_1.imp"
_imp_WRITE(1, (-1));
#line 268 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    269    printstring ("  Int_Comp:          "); write( Next Ptr Glob_variant_var 1_Int Comp, -1); newline
#line 269 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Int_Comp:          "));
#line 269 "dhry_1.imp"
_imp_WRITE(NEXTPTRGLOB.VARIANT.VAR1.INTCOMP, (-1));
#line 269 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    270    printstring ("        should be:   "); write( 18, -1); newline
#line 270 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 270 "dhry_1.imp"
_imp_WRITE(18, (-1));
#line 270 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    271    printstring ("  Str_Comp:          "); print string(Next Ptr Glob_variant_var 1_Str Comp); newline
#line 271 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("  Str_Comp:          "));
#line 271 "dhry_1.imp"
_imp_PRINTSTRING(NEXTPTRGLOB.VARIANT.VAR1.STRCOMP);
#line 271 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    272    printstring ("        should be:   DHRYSTONE PROGRAM, SOME STRING"); newline
#line 272 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   DHRYSTONE PROGRAM, SOME STRING"));
#line 272 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    273    printstring ("Int_1_Loc:           "); write( Int 1 Loc, -1); newline
#line 273 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Int_1_Loc:           "));
#line 273 "dhry_1.imp"
_imp_WRITE(INT1LOC, (-1));
#line 273 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    274    printstring ("        should be:   "); write( 5, -1); newline
#line 274 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 274 "dhry_1.imp"
_imp_WRITE(5, (-1));
#line 274 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    275    printstring ("Int_2_Loc:           "); write( Int 2 Loc, -1); newline
#line 275 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Int_2_Loc:           "));
#line 275 "dhry_1.imp"
_imp_WRITE(INT2LOC, (-1));
#line 275 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    276    printstring ("        should be:   "); write( 13, -1); newline
#line 276 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 276 "dhry_1.imp"
_imp_WRITE(13, (-1));
#line 276 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    277    printstring ("Int_3_Loc:           "); write( Int 3 Loc, -1); newline
#line 277 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Int_3_Loc:           "));
#line 277 "dhry_1.imp"
_imp_WRITE(INT3LOC, (-1));
#line 277 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    278    printstring ("        should be:   "); write( 7, -1); newline
#line 278 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 278 "dhry_1.imp"
_imp_WRITE(7, (-1));
#line 278 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    279    printstring ("Enum_Loc:            "); write( Enum Loc, -1); newline
#line 279 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Enum_Loc:            "));
#line 279 "dhry_1.imp"
_imp_WRITE(ENUMLOC, (-1));
#line 279 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    280    printstring ("        should be:   "); write( 1, -1); newline
#line 280 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   "));
#line 280 "dhry_1.imp"
_imp_WRITE(1, (-1));
#line 280 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    281    printstring ("Str_1_Loc:           "); print string(Str 1 Loc); newline
#line 281 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Str_1_Loc:           "));
#line 281 "dhry_1.imp"
_imp_PRINTSTRING(STR1LOC);
#line 281 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    282    printstring ("        should be:   DHRYSTONE PROGRAM, 1'ST STRING"); newline
#line 282 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   DHRYSTONE PROGRAM, 1'ST STRING"));
#line 282 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    283    printstring ("Str_2_Loc:           "); print string(Str 2 Loc); newline
#line 283 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Str_2_Loc:           "));
#line 283 "dhry_1.imp"
_imp_PRINTSTRING(STR2LOC);
#line 283 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    284    printstring ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING"); newline
#line 284 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("        should be:   DHRYSTONE PROGRAM, 2'ND STRING"));
#line 284 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    285    newline
#line 285 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    286  
                                                                //    287    User Time = End Time - Begin Time
#line 287 "dhry_1.imp"
USERTIME = (((int)(ENDTIME)) - (BEGINTIME));
                                                                //    288  
                                                                //    289  !!  %if User Time < Too Small Time %start
                                                                //    290  !!    printf ("Measured time too small to obtain meaningful results"); newline
                                                                //    291  !!    printf ("Please increase number of runs"); newline
                                                                //    292  !!    newline
                                                                //    293  !!  %else
                                                                //    294  !#ifdef TIME
                                                                //    295  !    Microseconds = (float) User Time * Mic secs Per Second 
                                                                //    296  !                        / (float) Number Of Runs
                                                                //    297  !    Dhrystones Per Second = (float) Number Of Runs / (float) User Time
                                                                //    298  !#else
                                                                //    299  !    Microseconds = (float) User Time * Mic secs Per Second 
                                                                //    300  !                        / ((float) HZ * ((float) Number Of Runs))
                                                                //    301  !    Dhrystones Per Second = ((float) HZ * (float) Number Of Runs)
                                                                //    302  !                        / (float) User Time
                                                                //    303  !#endif
                                                                //    304  
                                                                //    305      Microseconds = User Time / Number Of Runs  {CPU TIME function has been adjusted to return microseconds!}
#line 305 "dhry_1.imp"
MICROSECONDS = (double)((double)((float)(USERTIME)) / (double)((float)(NUMBEROFRUNS)));
/*promote*/                                                                //    306      Dhrystones Per Second = (Number Of Runs * 1000000.0) / User Time  {need to scale down by 1000 to fit in 32-bit %integer}
#line 306 "dhry_1.imp"
DHRYSTONESPERSECOND = (double)((double)(((((double)(NUMBEROFRUNS)) * (1000000.0)))) / (double)((float)(USERTIME)));
                                                                //    307  
                                                                //    308      printstring ("Microseconds for one run through Dhrystone: ")
#line 308 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Microseconds for one run through Dhrystone: "));
                                                                //    309      !write(INT(Microseconds), -1); space; newline
                                                                //    310      print fl(Microseconds, 6); space; newline
#line 310 "dhry_1.imp"
_imp_PRINTFL(MICROSECONDS, 6);
#line 310 "dhry_1.imp"
_imp_SPACE();
#line 310 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    311      printstring ("Dhrystones per Second:                      ")
#line 311 "dhry_1.imp"
_imp_PRINTSTRING(_imp_str_literal("Dhrystones per Second:                      "));
                                                                //    312      write(INT(Dhrystones Per Second), -1); space; newline
#line 312 "dhry_1.imp"
_imp_WRITE(_imp_INT(DHRYSTONESPERSECOND), (-1));
#line 312 "dhry_1.imp"
_imp_SPACE();
#line 312 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    313      newline
#line 313 "dhry_1.imp"
_imp_NEWLINE();
                                                                //    314  !!  %finish
                                                                //    315    
                                                                //    316  !%end
                                                                //    317  
                                                                //    318  
                                                                //    319  %routine Proc 1 (%record (Rec Type fm) %name Ptr Val Par)
#line 319 "dhry_1.imp"
void PROC1(  RECTYPEFM /*name*/*PTRVALPAR )
#line 319 "dhry_1.imp"
{
                                                                //    320  {****************}
                                                                //    321      { executed once }
                                                                //    322    %record (Rec Type fm) %name Next Record == Ptr Val Par_Ptr Comp   {or '='???}
#line 322 "dhry_1.imp"
 RECTYPEFM /*name*/*NEXTRECORD;
#line 322 "dhry_1.imp"
NEXTRECORD = PTRVALPAR->PTRCOMP;
                                                                //    323                                          { == Ptr Glob Next }
                                                                //    324    { Local variable, initialized with Ptr Val Par->Ptr Comp,    }
                                                                //    325    { corresponds to "rename" in Ada, "with" in Pascal           }
                                                                //    326    
                                                                //    327    {structassign} Ptr Val Par_Ptr Comp = Ptr Glob
#line 327 "dhry_1.imp"
*PTRVALPAR->PTRCOMP = PTRGLOB;
                                                                //    328    Ptr Val Par_variant_var 1_Int Comp = 5
#line 328 "dhry_1.imp"
PTRVALPAR->VARIANT.VAR1.INTCOMP = 5;
                                                                //    329    Next Record_variant_var 1_Int Comp = Ptr Val Par_variant_var 1_Int Comp
#line 329 "dhry_1.imp"
NEXTRECORD->VARIANT.VAR1.INTCOMP = PTRVALPAR->VARIANT.VAR1.INTCOMP;
                                                                //    330    Next Record_Ptr Comp = Ptr Val Par_Ptr Comp
#line 330 "dhry_1.imp"
*NEXTRECORD->PTRCOMP = *PTRVALPAR->PTRCOMP;
                                                                //    331    Proc 3 (Next Record_Ptr Comp)
#line 331 "dhry_1.imp"
PROC3(NEXTRECORD->PTRCOMP);
                                                                //    332      { Ptr Val Par_Ptr Comp_Ptr Comp = Ptr Glob_Ptr Comp }
                                                                //    333    %if Next Record_Discr = Ident 1 %start
#line 333 "dhry_1.imp"
if (((NEXTRECORD->DISCR) != (0))) goto L_0010;
                                                                //    334      { then, executed }
                                                                //    335      Next Record_variant_var 1_Int Comp = 6
#line 335 "dhry_1.imp"
NEXTRECORD->VARIANT.VAR1.INTCOMP = 6;
                                                                //    336      Proc 6 (Ptr Val Par_variant_var 1_Enum Comp, Next Record_variant_var 1_Enum Comp)
#line 336 "dhry_1.imp"
PROC6(PTRVALPAR->VARIANT.VAR1.ENUMCOMP, &NEXTRECORD->VARIANT.VAR1.ENUMCOMP);
                                                                //    337      Next Record_Ptr Comp = Ptr Glob_Ptr Comp
#line 337 "dhry_1.imp"
*NEXTRECORD->PTRCOMP = *PTRGLOB.PTRCOMP;
                                                                //    338      Proc 7 (Next Record_variant_var 1_Int Comp, 10, Next Record_variant_var 1_Int Comp)
#line 338 "dhry_1.imp"
PROC7(NEXTRECORD->VARIANT.VAR1.INTCOMP, 10, &NEXTRECORD->VARIANT.VAR1.INTCOMP);
                                                                //    339    %else { not executed }
#line 339 "dhry_1.imp"
goto L_0011;
#line 339 "dhry_1.imp"
L_0010:;
                                                                //    340      {structassign} Ptr Val Par = Ptr Val Par_Ptr Comp
#line 340 "dhry_1.imp"
*PTRVALPAR = *PTRVALPAR->PTRCOMP;
                                                                //    341    %finish
#line 341 "dhry_1.imp"
L_0011:;
                                                                //    342  %end { Proc 1 }
#line 342 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC1 at level 2
                                                                //    343  
                                                                //    344  
                                                                //    345  %routine Proc 2 (%integer {One Fifty} %name  Int Par Ref)
#line 345 "dhry_1.imp"
void PROC2( int /*name*/*INTPARREF )
#line 345 "dhry_1.imp"
{
                                                                //    346  {****************}
                                                                //    347      { executed once }
                                                                //    348      { *Int Par Ref == 1, becomes 4 }
                                                                //    349    %integer {One Fifty}     Int Loc
#line 349 "dhry_1.imp"
int INTLOC;
                                                                //    350    %integer {Enumeration}   Enum Loc
#line 350 "dhry_1.imp"
int ENUMLOC;
                                                                //    351  
                                                                //    352    Int Loc = Int Par Ref + 10
#line 352 "dhry_1.imp"
INTLOC = ((*(int *)(INTPARREF)) + (10));
                                                                //    353    %cycle { executed once }
#line 353 "dhry_1.imp"
L_0012:;
                                                                //    354      %if Ch 1 Glob = 'A' %start
#line 354 "dhry_1.imp"
if (((CH1GLOB) != (65))) goto L_0015;
                                                                //    355        { then, executed }
                                                                //    356        Int Loc = Int Loc - 1
#line 356 "dhry_1.imp"
INTLOC = (((int)(INTLOC)) - (1));
                                                                //    357        Int Par Ref = Int Loc - Int Glob
#line 357 "dhry_1.imp"
*INTPARREF = (((int)(INTLOC)) - (INTGLOB));
                                                                //    358        Enum Loc = Ident 1
#line 358 "dhry_1.imp"
ENUMLOC = 0;
                                                                //    359      %finish { if }
#line 359 "dhry_1.imp"
L_0015:;
                                                                //    360    %repeat %until Enum Loc = Ident 1 { true }
#line 360 "dhry_1.imp"
if (((ENUMLOC) == (0))) goto L_0013;
#line 360 "dhry_1.imp"
goto L_0012;
#line 360 "dhry_1.imp"
L_0013:;
                                                                //    361  %end { Proc 2 }
#line 361 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC2 at level 2
                                                                //    362  
                                                                //    363  
                                                                //    364  %routine Proc 3 (%record (Rec Type fm) %name Ptr Ref Par)
#line 364 "dhry_1.imp"
void PROC3(  RECTYPEFM /*name*/*PTRREFPAR )
#line 364 "dhry_1.imp"
{
                                                                //    365  {****************}
                                                                //    366      { executed once }
                                                                //    367      { Ptr Ref Par becomes Ptr Glob }
                                                                //    368  
                                                                //    369    %if Ptr Glob ## Null %then { then, executed } Ptr Ref Par == Ptr Glob_Ptr Comp
#line 369 "dhry_1.imp"
if (((&PTRGLOB) == (NULL))) goto L_0016;
#line 369 "dhry_1.imp"
PTRREFPAR = PTRGLOB.PTRCOMP;
#line 369 "dhry_1.imp"
L_0016:;
                                                                //    370    Proc 7 (10, Int Glob, Ptr Glob_variant_var 1_Int Comp)
#line 370 "dhry_1.imp"
PROC7(10, INTGLOB, &PTRGLOB.VARIANT.VAR1.INTCOMP);
                                                                //    371  %end { Proc 3 }
#line 371 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC3 at level 2
                                                                //    372  
                                                                //    373  
                                                                //    374  %routine Proc 4 { without parameters }
#line 374 "dhry_1.imp"
void PROC4( void )
#line 374 "dhry_1.imp"
{
                                                                //    375  {*****}
                                                                //    376      { executed once }
                                                                //    377    %integer {Boolean} Bool Loc
#line 377 "dhry_1.imp"
int BOOLLOC;
                                                                //    378  
                                                                //    379    %if Ch 1 Glob = 'A' %then Bool Loc = true %else Bool Loc = false
#line 379 "dhry_1.imp"
if (((CH1GLOB) != (65))) goto L_0017;
#line 379 "dhry_1.imp"
BOOLLOC = 1;
#line 379 "dhry_1.imp"
goto L_0018;
#line 379 "dhry_1.imp"
L_0017:;
#line 379 "dhry_1.imp"
BOOLLOC = 0;
#line 379 "dhry_1.imp"
L_0018:;
                                                                //    380    Bool Glob = Bool Loc ! Bool Glob
#line 380 "dhry_1.imp"
BOOLGLOB = ((BOOLLOC) | (BOOLGLOB));
                                                                //    381    Ch 2 Glob = 'B'
#line 381 "dhry_1.imp"
CH2GLOB = 66;
                                                                //    382  %end { Proc 4 }
#line 382 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC4 at level 2
                                                                //    383  
                                                                //    384  
                                                                //    385  %routine Proc 5 { without parameters }
#line 385 "dhry_1.imp"
void PROC5( void )
#line 385 "dhry_1.imp"
{
                                                                //    386  {*****}
                                                                //    387      { executed once }
                                                                //    388    Ch 1 Glob = 'A'
#line 388 "dhry_1.imp"
CH1GLOB = 65;
                                                                //    389    Bool Glob = false
#line 389 "dhry_1.imp"
BOOLGLOB = 0;
                                                                //    390  %end { Proc 5 }
#line 390 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PROC5 at level 2
                                                                //    391  
                                                                //    392  
                                                                //    393  { Procedure for the assignment of structures,          }
                                                                //    394  { if the C compiler doesn't support this feature       }
                                                                //    395  
                                                                //    396  %endofprogram
#line 396 "dhry_1.imp"
/* Remove %on %event handler here if present for this block */
return 0;
} // End of block _imp_main at level 1
#line 396 "dhry_1.imp"
// End of file
