#include <perms.h>

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