#line 1
#include <perms.h>

//          Edinburgh IMP77 Compiler - Version 8.4
//
//     1  ! File of externals followed by a main program.
//     2
//     3  %recordformat rf ( %integer i, %real r, %record (rf) %name next)  ;! Are record format vars in a sub-scope?  Or is it just that formats are in a different name space?

#line 3 "test-new/bigtest.imp"
struct RF {
  union {
    struct {
#line 3 "test-new/bigtest.imp"
      int I;
#line 3 "test-new/bigtest.imp"
      float R;
#line 3 "test-new/bigtest.imp"
      struct RF *NEXT;
#line 3 "test-new/bigtest.imp"
    };
  };
};

//     4
//     5  ! owns and externals are simpler declarations
//     6  %externalinteger xi1

#line 6 "test-new/bigtest.imp"
int XI1;

//     7  %externalintegername xin1

#line 7 "test-new/bigtest.imp"
int *XIN1;

//     8  %externalreal xr1

#line 8 "test-new/bigtest.imp"
float XR1;

//     9  %externalinteger xi2,xi3

#line 9 "test-new/bigtest.imp"
int XI2;
#line 9 "test-new/bigtest.imp"
int XI3;

//    10  %externalreal xcr1 = 3.1415

#line 10 "test-new/bigtest.imp"
float XCR1 = 3.1415;

//    11  %externalrealarray xra1(0:9)

#line 11 "test-new/bigtest.imp"
float XRA1[10];

//    12  %externalrealarrayname xran1

#line 12 "test-new/bigtest.imp"
float *XRAN1;

//    13  %externallongreal xclr1 = 3.1415

#line 13 "test-new/bigtest.imp"
double XCLR1 = 3.1415;

//    14  %externallongrealarray xlra1(0:9)

#line 14 "test-new/bigtest.imp"
double XLRA1[10];

//    15  %externallongrealarrayname xlran1

#line 15 "test-new/bigtest.imp"
double *XLRAN1;

//    16  %externalintegernamearray xina1(0:9)

#line 16 "test-new/bigtest.imp"
int *XINA1[10];

//    17  %externalintegernamearrayname xinan1

#line 17 "test-new/bigtest.imp"
int **XINAN1;

//    18  %externalstring(82) xs1

#line 18 "test-new/bigtest.imp"
_imp_string82 XS1;

//    19  %externalstring(82)%name xsn1

#line 19 "test-new/bigtest.imp"
_imp_string82 *XSN1;

//    20  %externalstring(82)%array xsa1(4:7)

#line 20 "test-new/bigtest.imp"
_imp_string82 XSA1[4];

//    21  %externalstring(82)%arrayname xsan1

#line 21 "test-new/bigtest.imp"
_imp_string82 *XSAN1;

//    22  %externalstring(82)%namearray xsna1(4:7)

#line 22 "test-new/bigtest.imp"
_imp_string82 *XSNA1[4];

//    23  %externalstring(82)%namearrayname xsnan1

#line 23 "test-new/bigtest.imp"
_imp_string82 **XSNAN1;

//    24  %externalrecord (rf) xrec1

#line 24 "test-new/bigtest.imp"
struct RF XREC1;

//    25  %externalrecord (rf) %name xrecn1

#line 25 "test-new/bigtest.imp"
struct RF *XRECN1;

//    26  %externalrecord (rf) %array xreca1(2:3)

#line 26 "test-new/bigtest.imp"
struct RF XRECA1[2];

//    27  %externalrecord (rf) %array %name xrecan1

#line 27 "test-new/bigtest.imp"
struct RF *XRECAN1;

//    28  %externalrecord (rf) %name %array xrecna1(2:3)

#line 28 "test-new/bigtest.imp"
struct RF *XRECNA1[2];

//    29  %externalrecord (rf) %name %array %name xrecnan1

#line 29 "test-new/bigtest.imp"
struct RF **XRECNAN1;

//    30
//    31  %externalintegerfn ifn1

#line 31 "test-new/bigtest.imp"
int IFN1(void) {
  //    32    %result = xi1

#line 32 "test-new/bigtest.imp"
  return XI1;

  //    33  %end

#line 33 "test-new/bigtest.imp"
} /* end of IFN1 */

//    34
//    35  %externalintegermap imap1

#line 35 "test-new/bigtest.imp"
int *IMAP1(void)
#line 35 "test-new/bigtest.imp"
{

  //    36    %result == xi1

#line 36 "test-new/bigtest.imp"
  return /*?*/ &XI1;

  //    37  %end

#line 37 "test-new/bigtest.imp"
} /* end of IMAP1 */

//    38
//    39  %externalroutine rt1

#line 39 "test-new/bigtest.imp"
void RT1(void) {
  //    40    %integer i1

#line 40 "test-new/bigtest.imp"
  int I1;

  //    41    %routine rt1

#line 41 "test-new/bigtest.imp"
  void RT1(void) {
    //    42    %end

#line 42 "test-new/bigtest.imp"
    return;
#line 42 "test-new/bigtest.imp"
  } /* end of RT1 */

  //    43  %end

#line 43 "test-new/bigtest.imp"
  return;
#line 43 "test-new/bigtest.imp"
} /* end of RT1 */

// ?RT1 unused
// ?I1 unused
//    44
//    45  %externalpredicate test1

#line 45 "test-new/bigtest.imp"
int TEST1(void) {
  //    46    %true

#line 46 "test-new/bigtest.imp"
  return 1 /*TRUE*/;

  //    47  %end

#line 47 "test-new/bigtest.imp"
} /* end of TEST1 */

//    48
//    49  %externalroutine xrt1(%integer p1)

#line 49 "test-new/bigtest.imp"
void XRT1(int P1) {
  //    50    %real r1

#line 50 "test-new/bigtest.imp"
  float R1;

  //    51  %end

#line 51 "test-new/bigtest.imp"
  return;
#line 51 "test-new/bigtest.imp"
} /* end of XRT1 */

// ?R1 unused
// ?P1 unused
//    52
//    53  %externalroutine xr2(%integer p1, p2, p3, p4)

#line 53 "test-new/bigtest.imp"
void XR2(int P1, int P2, int P3, int P4) {
  //    54    %real r1

#line 54 "test-new/bigtest.imp"
  float R1;

  //    55  %end

#line 55 "test-new/bigtest.imp"
  return;
#line 55 "test-new/bigtest.imp"
} /* end of XR2 */

// ?R1 unused
// ?P4 unused
// ?P3 unused
// ?P2 unused
// ?P1 unused
//    56
//    57  %externalroutine xr3(%integer p1, p2, %real r1, r2)

#line 57 "test-new/bigtest.imp"
void XR3(int P1, int P2, float R1, float R2) {
  //    58    %real r3

#line 58 "test-new/bigtest.imp"
  float R3;

  //    59  %end

#line 59 "test-new/bigtest.imp"
  return;
#line 59 "test-new/bigtest.imp"
} /* end of XR3 */

// ?R3 unused
// ?R2 unused
// ?R1 unused
// ?P2 unused
// ?P1 unused
//    60
//    61  %begin

#line 61 "test-new/bigtest.imp"
int main(int argc, char **argv) { /*%begin*/
#line 61 "test-new/bigtest.imp"
  _imp_initialise(argc, argv);

  //    62
  //    63    %integerfn use pointer(%integername n)

#line 63 "test-new/bigtest.imp"
  int USEPOINTER(int *N) {
    //    64      %result = n

#line 64 "test-new/bigtest.imp"
    return *N;

    //    65    %end

#line 65 "test-new/bigtest.imp"
  } /* end of USEPOINTER */

  //    66
  //    67    %integerfn use scalar(%integer n)

#line 67 "test-new/bigtest.imp"
  int USESCALAR(int N) {
    //    68      %result = n

#line 68 "test-new/bigtest.imp"
    return N;

    //    69    %end

#line 69 "test-new/bigtest.imp"
  } /* end of USESCALAR */

  //    70
  //    71    %integermap map scalar(%integer n)

#line 71 "test-new/bigtest.imp"
  int *MAPSCALAR(int N)
#line 71 "test-new/bigtest.imp"
  {

    //    72      %owninteger local

#line 72 "test-new/bigtest.imp"
    static int LOCAL;

    //    73      local = n;

#line 73 "test-new/bigtest.imp"
    LOCAL = N;

    //    74      %result == local

#line 74 "test-new/bigtest.imp"
    return /*?*/ &LOCAL;

    //    75    %end

#line 75 "test-new/bigtest.imp"
  } /* end of MAPSCALAR */

  //    76
  //    77    %routine increment(%integername var)

#line 77 "test-new/bigtest.imp"
  void INCREMENT(int *VAR) {
    //    78      var = var + 1

#line 78 "test-new/bigtest.imp"
    *VAR = *VAR + 1;

    //    79    %end

#line 79 "test-new/bigtest.imp"
    return;
#line 79 "test-new/bigtest.imp"
  } /* end of INCREMENT */

  //    80
  //    81    %begin

#line 81 "test-new/bigtest.imp"
  { /*%begin*/

    //    82    %integer val

#line 82 "test-new/bigtest.imp"
    int VAL;

    //    83    %integername ptr

#line 83 "test-new/bigtest.imp"
    int *PTR;

    //    84    %integer i

#line 84 "test-new/bigtest.imp"
    int I;

    //    85    val = 17 ; i = 42 ; ptr == val

#line 85 "test-new/bigtest.imp"
    VAL = 17;
#line 85 "test-new/bigtest.imp"
    I = 42;
#line 85 "test-new/bigtest.imp"
    PTR = (int *)/*?*/ &VAL;

    //    86
    //    87    i = ptr

#line 87 "test-new/bigtest.imp"
    I = *PTR;

    //    88
    //    89    i = ptr+ptr

#line 89 "test-new/bigtest.imp"
    I = *PTR + *PTR;

    //    90
    //    91    i = use scalar(ptr)

#line 91 "test-new/bigtest.imp"
    I = USESCALAR(*PTR);

    //    92
    //    93    i = use scalar(ptr+ptr)

#line 93 "test-new/bigtest.imp"
    I = USESCALAR(*PTR + *PTR);

    //    94
    //    95    i = use scalar(ptr)+use scalar(ptr)

#line 95 "test-new/bigtest.imp"
    I = USESCALAR(*PTR) + USESCALAR(*PTR);

    //    96
    //    97    ptr = i

#line 97 "test-new/bigtest.imp"
    *PTR = I;

    //    98
    //    99    ptr = i+ptr

#line 99 "test-new/bigtest.imp"
    *PTR = I + *PTR;

    //   100
    //   101    ptr = use scalar(i)

#line 101 "test-new/bigtest.imp"
    *PTR = USESCALAR(I);

    //   102
    //   103    ptr = use scalar(ptr)

#line 103 "test-new/bigtest.imp"
    *PTR = USESCALAR(*PTR);

    //   104
    //   105    ptr = use scalar(ptr+ptr)

#line 105 "test-new/bigtest.imp"
    *PTR = USESCALAR(*PTR + *PTR);

    //   106
    //   107    ptr = -ptr

#line 107 "test-new/bigtest.imp"
    *PTR = -*PTR;

    //   108
    //   109    i = use pointer(ptr)

#line 109 "test-new/bigtest.imp"
    I = USEPOINTER(PTR);

    //   110
    //   111    i = use pointer(ptr)+use pointer(ptr)

#line 111 "test-new/bigtest.imp"
    I = USEPOINTER(PTR) + USEPOINTER(PTR);

    //   112
    //   113    ptr = use pointer(i)

#line 113 "test-new/bigtest.imp"
    *PTR = USEPOINTER(/*?*/ &I);

    //   114
    //   115    ptr = use pointer(ptr)

#line 115 "test-new/bigtest.imp"
    *PTR = USEPOINTER(PTR);

    //   116
    //   117    ->done %if ptr < ptr*ptr

#line 117 "test-new/bigtest.imp"
    if (*PTR >= *PTR * *PTR) goto L_0001;
#line 117 "test-new/bigtest.imp"
    goto U_1000;
#line 117 "test-new/bigtest.imp"
  L_0001:;

  //   118
  //   119    ->done %if ptr < i

#line 119 "test-new/bigtest.imp"
    if (*PTR >= I) goto L_0002;
#line 119 "test-new/bigtest.imp"
    goto U_1000;
#line 119 "test-new/bigtest.imp"
  L_0002:;

  //   120
  //   121    ->done %if ptr < use scalar(i)

#line 121 "test-new/bigtest.imp"
    if (*PTR >= USESCALAR(I)) goto L_0003;
#line 121 "test-new/bigtest.imp"
    goto U_1000;
#line 121 "test-new/bigtest.imp"
  L_0003:;

  //   122
  //   123    ->done %if ptr < use scalar(ptr)

#line 123 "test-new/bigtest.imp"
    if (*PTR >= USESCALAR(*PTR)) goto L_0004;
#line 123 "test-new/bigtest.imp"
    goto U_1000;
#line 123 "test-new/bigtest.imp"
  L_0004:;

  //   124
  //   125    ->done %if ptr < use pointer(ptr)

#line 125 "test-new/bigtest.imp"
    if (*PTR >= USEPOINTER(PTR)) goto L_0005;
#line 125 "test-new/bigtest.imp"
    goto U_1000;
#line 125 "test-new/bigtest.imp"
  L_0005:;

  //   126
  //   127    ->done %if i + ptr < i + use scalar(i)

#line 127 "test-new/bigtest.imp"
    if (I + *PTR >= I + USESCALAR(I)) goto L_0006;
#line 127 "test-new/bigtest.imp"
    goto U_1000;
#line 127 "test-new/bigtest.imp"
  L_0006:;

  //   128
  //   129    ->done %if i + ptr < i + use scalar(ptr)

#line 129 "test-new/bigtest.imp"
    if (I + *PTR >= I + USESCALAR(*PTR)) goto L_0007;
#line 129 "test-new/bigtest.imp"
    goto U_1000;
#line 129 "test-new/bigtest.imp"
  L_0007:;

  //   130
  //   131    ->done %if i + ptr < i + use pointer(ptr)

#line 131 "test-new/bigtest.imp"
    if (I + *PTR >= I + USEPOINTER(PTR)) goto L_0008;
#line 131 "test-new/bigtest.imp"
    goto U_1000;
#line 131 "test-new/bigtest.imp"
  L_0008:;

  //   132
  //   133    ->done %if use scalar(i) < use scalar(i)

#line 133 "test-new/bigtest.imp"
    if (USESCALAR(I) >= USESCALAR(I)) goto L_0009;
#line 133 "test-new/bigtest.imp"
    goto U_1000;
#line 133 "test-new/bigtest.imp"
  L_0009:;

  //   134
  //   135    ->done %if use scalar(i) < use pointer(i)

#line 135 "test-new/bigtest.imp"
    if (USESCALAR(I) >= USEPOINTER(/*?*/ &I)) goto L_000A;
#line 135 "test-new/bigtest.imp"
    goto U_1000;
#line 135 "test-new/bigtest.imp"
  L_000A:;

  //   136
  //   137    ->done %if use pointer(i) < use pointer(i)

#line 137 "test-new/bigtest.imp"
    if (USEPOINTER(/*?*/ &I) >= USEPOINTER(/*?*/ &I)) goto L_000B;
#line 137 "test-new/bigtest.imp"
    goto U_1000;
#line 137 "test-new/bigtest.imp"
  L_000B:;

  //   138
  //   139    ->done %if i + use scalar(i) < use scalar(i)

#line 139 "test-new/bigtest.imp"
    if (I + USESCALAR(I) >= USESCALAR(I)) goto L_000C;
#line 139 "test-new/bigtest.imp"
    goto U_1000;
#line 139 "test-new/bigtest.imp"
  L_000C:;

  //   140
  //   141    ->done %if i + use scalar(i) < use pointer(i)

#line 141 "test-new/bigtest.imp"
    if (I + USESCALAR(I) >= USEPOINTER(/*?*/ &I)) goto L_000D;
#line 141 "test-new/bigtest.imp"
    goto U_1000;
#line 141 "test-new/bigtest.imp"
  L_000D:;

  //   142
  //   143    ->done %if i + use pointer(i) < use pointer(i)

#line 143 "test-new/bigtest.imp"
    if (I + USEPOINTER(/*?*/ &I) >= USEPOINTER(/*?*/ &I)) goto L_000E;
#line 143 "test-new/bigtest.imp"
    goto U_1000;
#line 143 "test-new/bigtest.imp"
  L_000E:;

  //   144
  //   145    ->done %if ptr + use scalar(i) < use scalar(i)

#line 145 "test-new/bigtest.imp"
    if (*PTR + USESCALAR(I) >= USESCALAR(I)) goto L_000F;
#line 145 "test-new/bigtest.imp"
    goto U_1000;
#line 145 "test-new/bigtest.imp"
  L_000F:;

  //   146
  //   147    ->done %if ptr + use scalar(i) < use pointer(i)

#line 147 "test-new/bigtest.imp"
    if (*PTR + USESCALAR(I) >= USEPOINTER(/*?*/ &I)) goto L_0010;
#line 147 "test-new/bigtest.imp"
    goto U_1000;
#line 147 "test-new/bigtest.imp"
  L_0010:;

  //   148
  //   149    ->done %if ptr + use pointer(i) < use pointer(i)

#line 149 "test-new/bigtest.imp"
    if (*PTR + USEPOINTER(/*?*/ &I) >= USEPOINTER(/*?*/ &I)) goto L_0011;
#line 149 "test-new/bigtest.imp"
    goto U_1000;
#line 149 "test-new/bigtest.imp"
  L_0011:;

  //   150
  //   151    ->done %if i + ptr < i + map scalar(i)

#line 151 "test-new/bigtest.imp"
    if (I + *PTR >= I + *MAPSCALAR(I)) goto L_0012;
#line 151 "test-new/bigtest.imp"
    goto U_1000;
#line 151 "test-new/bigtest.imp"
  L_0012:;

  //   152
  //   153    ->done %if i + ptr < i + map scalar(ptr)

#line 153 "test-new/bigtest.imp"
    if (I + *PTR >= I + *MAPSCALAR(*PTR)) goto L_0013;
#line 153 "test-new/bigtest.imp"
    goto U_1000;
#line 153 "test-new/bigtest.imp"
  L_0013:;

  //   154
  //   155    map scalar(4) = i

#line 155 "test-new/bigtest.imp"
    *MAPSCALAR(4) = I;

    //   156
    //   157    map scalar(i) = i

#line 157 "test-new/bigtest.imp"
    *MAPSCALAR(I) = I;

    //   158
    //   159    map scalar(ptr) = i

#line 159 "test-new/bigtest.imp"
    *MAPSCALAR(*PTR) = I;

    //   160
    //   161    map scalar(i + ptr) = i

#line 161 "test-new/bigtest.imp"
    *MAPSCALAR(I + *PTR) = I;

    //   162
    //   163    increment(i)

#line 163 "test-new/bigtest.imp"
    INCREMENT(/*?*/ &I);

    //   164
    //   165    increment(ptr)

#line 165 "test-new/bigtest.imp"
    INCREMENT(PTR);

    //   166
    //   167    increment(map scalar(0))

#line 167 "test-new/bigtest.imp"
    INCREMENT(MAPSCALAR(0));

    //   168
    //   169    increment(map scalar(i))

#line 169 "test-new/bigtest.imp"
    INCREMENT(MAPSCALAR(I));

    //   170
    //   171    increment(map scalar(ptr))

#line 171 "test-new/bigtest.imp"
    INCREMENT(MAPSCALAR(*PTR));

    //   172
    //   173    increment(map scalar(map scalar(0)))

#line 173 "test-new/bigtest.imp"
    INCREMENT(MAPSCALAR(*MAPSCALAR(0)));

    //   174    done:

#line 174 "test-new/bigtest.imp"
  U_1000:;

  //   175    %end

#line 175 "test-new/bigtest.imp"
    goto end_1000;
#line 175 "test-new/bigtest.imp"
  end_1000:;
#line 175 "test-new/bigtest.imp"
  }
#line 175 "test-new/bigtest.imp"
  auto int *IMAP1(void)
#line 175 "test-new/bigtest.imp"
      ;

  //   176
  //   177    %integermapspec imap1
  //   178    %integer i1

#line 178 "test-new/bigtest.imp"
  int I1;

  //   179    %integername in1

#line 179 "test-new/bigtest.imp"
  int *IN1;

  //   180    %shortinteger si1

#line 180 "test-new/bigtest.imp"
  short int SI1;

  //   181    %shortintegername sin1

#line 181 "test-new/bigtest.imp"
  short int *SIN1;

  //   182    %byteinteger bi1

#line 182 "test-new/bigtest.imp"
  unsigned char BI1;

  //   183    %byteintegername bin1

#line 183 "test-new/bigtest.imp"
  unsigned char *BIN1;

  //   184    %real r1

#line 184 "test-new/bigtest.imp"
  float R1;

  //   185    %realslong
  //   186    %real qr1

#line 186 "test-new/bigtest.imp"
  double QR1;

  //   187    %realsnormal
  //   188    %constreal cr1 = 3.1415

#line 188 "test-new/bigtest.imp"
  const float CR1 = 3.1415;

  //   189    %longreal lr1

#line 189 "test-new/bigtest.imp"
  double LR1;

  //   190    %constlongreal clr1 = 3.1415

#line 190 "test-new/bigtest.imp"
  const double CLR1 = 3.1415;

  //   191    %integerfn ifn1

#line 191 "test-new/bigtest.imp"
  int IFN1(void) {
    //   192      %result = i1

#line 192 "test-new/bigtest.imp"
    return I1;

    //   193    %end

#line 193 "test-new/bigtest.imp"
  } /* end of IFN1 */

  //   194    %integermap imap1

#line 194 "test-new/bigtest.imp"
  int *IMAP1(void)
#line 194 "test-new/bigtest.imp"
  {

    //   195      %result == i1

#line 195 "test-new/bigtest.imp"
    return /*?*/ &I1;

    //   196    %end

#line 196 "test-new/bigtest.imp"
  } /* end of IMAP1 */

  //   197    %routine rt1

#line 197 "test-new/bigtest.imp"
  void RT1(void) {
    //   198      %integer i1

#line 198 "test-new/bigtest.imp"
    int I1;

    //   199      %integer local1

#line 199 "test-new/bigtest.imp"
    int LOCAL1;

    //   200      %routine rt1

#line 200 "test-new/bigtest.imp"
    void RT1(void) {
      //   201        %integer local1

#line 201 "test-new/bigtest.imp"
      int LOCAL1;

      //   202        local1 = 1

#line 202 "test-new/bigtest.imp"
      LOCAL1 = 1;

      //   203        i1 = 1

#line 203 "test-new/bigtest.imp"
      I1 = 1;

      //   204      %end

#line 204 "test-new/bigtest.imp"
      return;
#line 204 "test-new/bigtest.imp"
    } /* end of RT1 */

    //   205      local1 = 2

#line 205 "test-new/bigtest.imp"
    LOCAL1 = 2;

    //   206      i1 = 2

#line 206 "test-new/bigtest.imp"
    I1 = 2;

    //   207    %end

#line 207 "test-new/bigtest.imp"
    return;
#line 207 "test-new/bigtest.imp"
  } /* end of RT1 */

  // ?RT1 unused
  //   208
  //   209    %predicate test1

#line 209 "test-new/bigtest.imp"
  int TEST1(void) {
    //   210      %false

#line 210 "test-new/bigtest.imp"
    return 0 /*FALSE*/;

    //   211    %end

#line 211 "test-new/bigtest.imp"
  } /* end of TEST1 */

  //   212
  //   213    %realarray ra1, ra1b(0:9), ra2, ra2b(10:19)

#line 213 "test-new/bigtest.imp"
  float RA1[10];
#line 213 "test-new/bigtest.imp"
  float RA1B[10];
#line 213 "test-new/bigtest.imp"
  float RA2[10];
#line 213 "test-new/bigtest.imp"
  float RA2B[10];

  //   214    %realarrayname ran1, ran2

#line 214 "test-new/bigtest.imp"
  float *RAN1;
#line 214 "test-new/bigtest.imp"
  float *RAN2;

  //   215    %longrealarray lra1, lra1b(0:9), lra2, lra2b(10:19)

#line 215 "test-new/bigtest.imp"
  double LRA1[10];
#line 215 "test-new/bigtest.imp"
  double LRA1B[10];
#line 215 "test-new/bigtest.imp"
  double LRA2[10];
#line 215 "test-new/bigtest.imp"
  double LRA2B[10];

  //   216    %longrealarrayname lran1, lran2

#line 216 "test-new/bigtest.imp"
  double *LRAN1;
#line 216 "test-new/bigtest.imp"
  double *LRAN2;

  //   217    %integernamearray ina1, ina1b(0:9), ina2, ina2b(10:19)

#line 217 "test-new/bigtest.imp"
  int *INA1[10];
#line 217 "test-new/bigtest.imp"
  int *INA1B[10];
#line 217 "test-new/bigtest.imp"
  int *INA2[10];
#line 217 "test-new/bigtest.imp"
  int *INA2B[10];

  //   218    %integernamearrayname inan1, inan2

#line 218 "test-new/bigtest.imp"
  int **INAN1;
#line 218 "test-new/bigtest.imp"
  int **INAN2;

  //   219    %string(82) s1, s2

#line 219 "test-new/bigtest.imp"
  _imp_string82 S1;
#line 219 "test-new/bigtest.imp"
  _imp_string82 S2;

  //   220    %string(82)%name sn1, sn2

#line 220 "test-new/bigtest.imp"
  _imp_string82 *SN1;
#line 220 "test-new/bigtest.imp"
  _imp_string82 *SN2;

  //   221    %string(82)%array sa1, sa1b(4:7), sa2, sa2b(9:10), sa3(1:100)

#line 221 "test-new/bigtest.imp"
  _imp_string82 SA1[4];
#line 221 "test-new/bigtest.imp"
  _imp_string82 SA1B[4];
#line 221 "test-new/bigtest.imp"
  _imp_string82 SA2[2];
#line 221 "test-new/bigtest.imp"
  _imp_string82 SA2B[2];
#line 221 "test-new/bigtest.imp"
  _imp_string82 SA3[100];

  //   222    %string(82)%arrayname san1, san2, san3

#line 222 "test-new/bigtest.imp"
  _imp_string82 *SAN1;
#line 222 "test-new/bigtest.imp"
  _imp_string82 *SAN2;
#line 222 "test-new/bigtest.imp"
  _imp_string82 *SAN3;

  //   223    %string(82)%namearray sna1, sna2(4:7), sna3(1:2)

#line 223 "test-new/bigtest.imp"
  _imp_string82 *SNA1[4];
#line 223 "test-new/bigtest.imp"
  _imp_string82 *SNA2[4];
#line 223 "test-new/bigtest.imp"
  _imp_string82 *SNA3[2];

  //   224    %string(82)%namearrayname snan1, snan2

#line 224 "test-new/bigtest.imp"
  _imp_string82 **SNAN1;
#line 224 "test-new/bigtest.imp"
  _imp_string82 **SNAN2;

  //   225    %record (rf) rec1, rec2

#line 225 "test-new/bigtest.imp"
  struct RF REC1;
#line 225 "test-new/bigtest.imp"
  struct RF REC2;

  //   226    %record (rf) %name recn1, recn2

#line 226 "test-new/bigtest.imp"
  struct RF *RECN1;
#line 226 "test-new/bigtest.imp"
  struct RF *RECN2;

  //   227    %record (rf) %array reca1,reca2(2:3),reca3(4:5)

#line 227 "test-new/bigtest.imp"
  struct RF RECA1[2];
#line 227 "test-new/bigtest.imp"
  struct RF RECA2[2];
#line 227 "test-new/bigtest.imp"
  struct RF RECA3[2];

  //   228    %record (rf) %array %name recan1,recan2

#line 228 "test-new/bigtest.imp"
  struct RF *RECAN1;
#line 228 "test-new/bigtest.imp"
  struct RF *RECAN2;

  //   229    %record (rf) %name %array recna1,recna2(2:3),recna3(1:2)

#line 229 "test-new/bigtest.imp"
  struct RF *RECNA1[2];
#line 229 "test-new/bigtest.imp"
  struct RF *RECNA2[2];
#line 229 "test-new/bigtest.imp"
  struct RF *RECNA3[2];

  //   230    %record (rf) %name %array %name recnan1,recnan2

#line 230 "test-new/bigtest.imp"
  struct RF **RECNAN1;
#line 230 "test-new/bigtest.imp"
  struct RF **RECNAN2;

  //   231
  //   232    ! owns and externals are simpler declarations
  //   233    %owninteger oi1

#line 233 "test-new/bigtest.imp"
  static int OI1;

  //   234    %ownintegername oin1

#line 234 "test-new/bigtest.imp"
  static int *OIN1;

  //   235    %ownreal or1

#line 235 "test-new/bigtest.imp"
  static float OR1;

  //   236    %ownlongreal olr1

#line 236 "test-new/bigtest.imp"
  static double OLR1;

  //   237    %owninteger oi2,oi3

#line 237 "test-new/bigtest.imp"
  static int OI2;
#line 237 "test-new/bigtest.imp"
  static int OI3;

  //   238    %ownreal ocr1 = 3.1415

#line 238 "test-new/bigtest.imp"
  static float OCR1 = 3.1415;

  //   239    %ownlongreal oclr1 = 3.1415

#line 239 "test-new/bigtest.imp"
  static double OCLR1 = 3.1415;

  //   240    %ownrealarray ora1(0:9)

#line 240 "test-new/bigtest.imp"
  static float ORA1[10];

  //   241    %ownrealarrayname oran1

#line 241 "test-new/bigtest.imp"
  static float *ORAN1;

  //   242    %ownlongrealarray olra1(0:9)

#line 242 "test-new/bigtest.imp"
  static double OLRA1[10];

  //   243    %ownlongrealarrayname olran1

#line 243 "test-new/bigtest.imp"
  static double *OLRAN1;

  //   244    %ownintegernamearray oina1(0:9)

#line 244 "test-new/bigtest.imp"
  static int *OINA1[10];

  //   245    %ownintegernamearrayname oinan1

#line 245 "test-new/bigtest.imp"
  static int **OINAN1;

  //   246    %ownstring(82) os1

#line 246 "test-new/bigtest.imp"
  static _imp_string82 OS1;

  //   247    %ownstring(82)%name osn1

#line 247 "test-new/bigtest.imp"
  static _imp_string82 *OSN1;

  //   248    %ownstring(82)%array osa1(4:7)

#line 248 "test-new/bigtest.imp"
  static _imp_string82 OSA1[4];

  //   249    %ownstring(82)%arrayname osan1

#line 249 "test-new/bigtest.imp"
  static _imp_string82 *OSAN1;

  //   250    %ownstring(82)%namearray osna1(4:7)

#line 250 "test-new/bigtest.imp"
  static _imp_string82 *OSNA1[4];

  //   251    %ownstring(82)%namearrayname osnan1

#line 251 "test-new/bigtest.imp"
  static _imp_string82 **OSNAN1;

  //   252    %ownrecord (rf) orec1

#line 252 "test-new/bigtest.imp"
  static struct RF OREC1;

  //   253    %ownrecord (rf) %name orecn1

#line 253 "test-new/bigtest.imp"
  static struct RF *ORECN1;

  //   254    %ownrecord (rf) %array oreca1(2:3)

#line 254 "test-new/bigtest.imp"
  static struct RF ORECA1[2];

  //   255    %ownrecord (rf) %array %name orecan1

#line 255 "test-new/bigtest.imp"
  static struct RF *ORECAN1;

  //   256    %ownrecord (rf) %name %array orecna1(2:3)

#line 256 "test-new/bigtest.imp"
  static struct RF *ORECNA1[2];

  //   257    %ownrecord (rf) %name %array %name orecnan1

#line 257 "test-new/bigtest.imp"
  static struct RF **ORECNAN1;

  //   258
  //   259    %switch sw1(0:255), sw2('a':'z')

#line 259 "test-new/bigtest.imp"
  int SW1_index;
#line 259 "test-new/bigtest.imp"
  int SW1_line;
#line 259 "test-new/bigtest.imp"
  char *SW1_file;
#line 259 "test-new/bigtest.imp"
  static const void *SW1[256] = {
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing, &&case_SW1_missing,
      &&case_SW1_missing};

#line 259 "test-new/bigtest.imp"
  int SW2_index;
#line 259 "test-new/bigtest.imp"
  int SW2_line;
#line 259 "test-new/bigtest.imp"
  char *SW2_file;
#line 259 "test-new/bigtest.imp"
  static const void *SW2[26] = {&&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing, &&case_SW2_missing,
                                &&case_SW2_missing, &&case_SW2_missing};

  //   260
  //   261    %integer %array ia3, ia4(1:10), ia5(2:11,0:1,0:2)

#line 261 "test-new/bigtest.imp"
  int IA3[10];
#line 261 "test-new/bigtest.imp"
  int IA4[10];
#line 261 "test-new/bigtest.imp"
  int IA5[10][2][3];

  //   262
  //   263    %integernamearray in3a1(2:11,0:1,0:2)

#line 263 "test-new/bigtest.imp"
  int *IN3A1[10][2][3];

  //   264
  //   265    i1 = 1

#line 265 "test-new/bigtest.imp"
  I1 = 1;

  //   266
  //   267    !!!!!!!!!!!!!!!!!!!
  //   268
  //   269    xi1 = 1

#line 269 "test-new/bigtest.imp"
  XI1 = 1;

  //   270    xin1 == xi1

#line 270 "test-new/bigtest.imp"
  XIN1 = (int *)/*?*/ &XI1;

  //   271    xin1 = 1

#line 271 "test-new/bigtest.imp"
  *XIN1 = 1;

  //   272    xr1 = 3.1

#line 272 "test-new/bigtest.imp"
  XR1 = 3.1;

  //   273    xi2 = xi3

#line 273 "test-new/bigtest.imp"
  XI2 = XI3;

  //   274    xcr1 = 3.1415

#line 274 "test-new/bigtest.imp"
  XCR1 = 3.1415;

  //   275    xra1(5) = xcr1

#line 275 "test-new/bigtest.imp"
  XRA1[5] = XCR1;

  //   276    xran1 == xra1

#line 276 "test-new/bigtest.imp"
  XRAN1 = (float *)XRA1;

  //   277    xclr1 = 3.1415

#line 277 "test-new/bigtest.imp"
  XCLR1 = 3.1415;

  //   278    xlra1(2) = 3.1

#line 278 "test-new/bigtest.imp"
  XLRA1[2] = 3.1;

  //   279    xlran1 == xlra1

#line 279 "test-new/bigtest.imp"
  XLRAN1 = (double *)XLRA1;

  //   280    xlran1(2) = 3.2

#line 280 "test-new/bigtest.imp"
  [/*BUG*/ 0] = 3.2;

  //   281    xina1(9) == xi1

#line 281 "test-new/bigtest.imp"
  XINA1[9] = (int *)/*?*/ &XI1;

  //   282    xinan1 == xina1

#line 282 "test-new/bigtest.imp"
  XINAN1 = (int *)XINA1;

  //   283
  //   284    %integer i

#line 284 "test-new/bigtest.imp"
  int I;

  //   285    %real r

#line 285 "test-new/bigtest.imp"
  float R;

  //   286    %name fred

#line 286 "test-new/bigtest.imp"
  _imp_name *FRED;

  //   287    fred == i

#line 287 "test-new/bigtest.imp"
  FRED = (*)/*?*/ &I;

  //   288    fred == r

#line 288 "test-new/bigtest.imp"
  FRED = (*)/*?*/ &R;

  //   289
  //   290
  //   291    %begin

#line 291 "test-new/bigtest.imp"
  { /*%begin*/

    //   292
    //   293      %integer i

#line 293 "test-new/bigtest.imp"
    int I;

    //   294      %recordformat rf(%record (rf) %name next, %integer i)

#line 294 "test-new/bigtest.imp"
    struct RF {
      union {
        struct {
#line 294 "test-new/bigtest.imp"
          struct RF *NEXT;
#line 294 "test-new/bigtest.imp"
          int I;
#line 294 "test-new/bigtest.imp"
        };
      };
    };

    //   295
    //   296      %record (rf) rec, subrec, subsubrec

#line 296 "test-new/bigtest.imp"
    struct RF REC;
#line 296 "test-new/bigtest.imp"
    struct RF SUBREC;
#line 296 "test-new/bigtest.imp"
    struct RF SUBSUBREC;

    //   297      %record (rf) %name recn

#line 297 "test-new/bigtest.imp"
    struct RF *RECN;

    //   298      %record (rf) %array ra(0:10)

#line 298 "test-new/bigtest.imp"
    struct RF RA[11];

    //   299      %record (rf) %array %name ran

#line 299 "test-new/bigtest.imp"
    struct RF *RAN;

    //   300      %record (rf) %name %array rna(0:10)

#line 300 "test-new/bigtest.imp"
    struct RF *RNA[11];

    //   301      %record (rf) %name %array %name rnan

#line 301 "test-new/bigtest.imp"
    struct RF **RNAN;

    //   302      %record (rf) %map rm(%integer i);  %result == rec;  %end

#line 302 "test-new/bigtest.imp"
    struct RF *RM(int I)
#line 302 "test-new/bigtest.imp"
    {

#line 302 "test-new/bigtest.imp"
      return /*?*/ &REC;
#line 302 "test-new/bigtest.imp"
    } /* end of RM */

    // ?I unused
    //   303      %integer x

#line 303 "test-new/bigtest.imp"
    int X;

    //   304      rna(i) == ra(i) %for i = 0, 1, 10

#line 304 "test-new/bigtest.imp"
    // %for I = 0, 1, 10 %cycle
#line 304 "test-new/bigtest.imp"
    {
      int _control, _initial = 0, _increment = 1, _final = 10;
#line 304 "test-new/bigtest.imp"
      if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 10");
      _control = I = _initial - _increment;
#line 304 "test-new/bigtest.imp"
    L_0014:
#line 304 "test-new/bigtest.imp"
      if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 304 "test-new/bigtest.imp"
      if (I == _final) goto L_0015;
#line 304 "test-new/bigtest.imp"
      _control += _increment;
      I += _increment;
#line 304 "test-new/bigtest.imp"
      RNA[I] = (struct RF *)/*?*/ &RA[I];
#line 304 "test-new/bigtest.imp"
      goto L_0014;
#line 304 "test-new/bigtest.imp"
    }

#line 304 "test-new/bigtest.imp"
  L_0015:;

  //   305      i = 5

#line 305 "test-new/bigtest.imp"
    I = 5;

    //   306      subsubrec_i = 234; subsubrec_next == RECORD(0)

#line 306 "test-new/bigtest.imp"
    SUBSUBREC.X = 234;
#line 306 "test-new/bigtest.imp"
    SUBSUBREC.RA = (int *)_imp_RECORD(0);

    //   307      subrec_i = 234; subrec_next == subsubrec

#line 307 "test-new/bigtest.imp"
    SUBREC.X = 234;
#line 307 "test-new/bigtest.imp"
    SUBREC.RA = (int *)/*?*/ &SUBSUBREC;

    //   308      rec_i = 123; rec_next == subrec

#line 308 "test-new/bigtest.imp"
    REC.X = 123;
#line 308 "test-new/bigtest.imp"
    REC.RA = (int *)/*?*/ &SUBREC;

    //   309      ra(5)_next == subrec

#line 309 "test-new/bigtest.imp"
    RA[5].RA = (int *)/*?*/ &SUBREC;

    //   310
    //   311      x = rec_i

#line 311 "test-new/bigtest.imp"
    X = REC.X;

    //   312      x = rec_next_i

#line 312 "test-new/bigtest.imp"
    X = REC.