#include <perms.h>

//          Edinburgh IMP77 Compiler - Version 8.4
//
//     1  %begin

int main(int argc, char **argv) { /*%begin*/
  _imp_initialise(argc, argv);

  //     2
  //     3    %integer i

  int I;

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

  struct RF {
    union {
      struct {
        struct RF *NEXT;
        int I;
      };
    };
  };

  //     5
  //     6
  //     7
  //     8    %record (rf) rec

  struct RF REC;

  //     9    %record (rf) %name recn

  struct RF *RECN;

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

  struct RF RA[11];

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

  struct RF *RNA[11];

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

  struct RF **RNAN;

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

  struct RF *RM(int I)
  {

    return /*?*/ &REC;
  } /* end of RM */

  // ?I unused
  //    14    %integer x

  int X;

  //    15    x = rec_i

  X = REC.I;

  //    16    x = rec_next_i

  X = REC.NEXT->I;

  //    17    x = rec_next_next_i

  X = REC.NEXT->NEXT->I;

  //    18    recn == ra(i)

  RECN = (struct RF *)/*?*/ &RA[I];

  //    19    recn == ra(i)_next

  RECN = (struct RF *)RA[I].NEXT;

  //    20    recn == ra(i)_next_next

  RECN = (struct RF *)RA[I].NEXT->NEXT;

  //    21    ra(i) = rec

  RA[I] = REC;

  //    22    ra(i)_i = i

  RA[I].I = I;

  //    23    ra(i)_next = rec

  *RA[I].NEXT = REC;

  //    24    ra(i)_next = recn

  *RA[I].NEXT = *RECN;

  //    25    ra(i)_next_i = i

  RA[I].NEXT->I = I;

  //    26    ra(i)_next_next = rec

  *RA[I].NEXT->NEXT = REC;

  //    27    ra(i)_next_next = recn

  *RA[I].NEXT->NEXT = *RECN;

  //    28    ra(i)_next_next_i = i

  RA[I].NEXT->NEXT->I = I;

  //    29    x = ra(i)_i

  X = RA[I].I;

  //    30    x = ra(i)_next_i

  X = RA[I].NEXT->I;

  //    31    x = ra(i)_next_next_i

  X = RA[I].NEXT->NEXT->I;

  //    32    recn == rec

  RECN = (struct RF *)/*?*/ &REC;

  //    33    x = recn_i

  X = RECN->I;

  //    34    x = recn_next_i

  X = RECN->NEXT->I;

  //    35    x = recn_next_next_i

  X = RECN->NEXT->NEXT->I;

  //    36    recn = rec

  *RECN = REC;

  //    37    recn_i = i

  RECN->I = I;

  //    38    recn_next = rec

  *RECN->NEXT = REC;

  //    39    recn_next_i = i

  RECN->NEXT->I = I;

  //    40    recn_next_next = rec

  *RECN->NEXT->NEXT = REC;

  //    41    recn_next_next = recn

  *RECN->NEXT->NEXT = *RECN;

  //    42    recn_next_next_i = i

  RECN->NEXT->NEXT->I = I;

  //    43    recn == rna(i)

  RECN = (struct RF *)RNA[I];

  //    44    recn == rna(i)_next

  RECN = (struct RF *)RNA[I]->NEXT;

  //    45    recn == rna(i)_next_next

  RECN = (struct RF *)RNA[I]->NEXT->NEXT;

  //    46    rec = rna(i)

  REC = *RNA[I];

  //    47    rec = rna(i)_next

  REC = *RNA[I]->NEXT;

  //    48    rec = rna(i)_next_next

  REC = *RNA[I]->NEXT->NEXT;

  //    49    x = rna(i)_i

  X = RNA[I]->I;

  //    50    x = rna(i)_next_i

  X = RNA[I]->NEXT->I;

  //    51    x = rna(i)_next_next_i

  X = RNA[I]->NEXT->NEXT->I;

  //    52    rnan == rna

  RNAN = (struct RF *)RNA;

  //    53    recn == rnan(i)

  RECN = (struct RF *)[/*BUG*/ 0];

  //    54    recn == rnan(i)_next

  RECN = (struct RF *)[/*BUG*/ 0]->NEXT;

  //    55    recn == rnan(i)_next

  RECN = (struct RF *)[/*BUG*/ 0]->NEXT;

  //    56    rec  = rnan(i)

  REC = *[/*BUG*/ 0];

  //    57    rec  = rnan(i)_next

  REC = *[/*BUG*/ 0] -> NEXT;

  //    58    rec  = rnan(i)_next

  REC = *[/*BUG*/ 0] -> NEXT;

  //    59    x = rnan(i)_i

  X = [/*BUG*/ 0] -> I;

  //    60    x = rnan(i)_next_i

  X = [/*BUG*/ 0] -> NEXT -> I;

  //    61    x = rnan(i)_next_next_i

  X = [/*BUG*/ 0] -> NEXT -> NEXT -> I;

  //    62    rnan(i)_i = x

  [/*BUG*/ 0] -> I = X;

  //    63    rnan(i)_next = rec

  *[/*BUG*/ 0] -> NEXT = REC;

  //    64    rnan(i)_next == recn

  [/*BUG*/ 0] -> NEXT = (struct RF *)RECN;

  //    65    rnan(i)_next_i = x

  [/*BUG*/ 0] -> NEXT -> I = X;

  //    66    rnan(i)_next_next = rec

  *[/*BUG*/ 0] -> NEXT -> NEXT = REC;

  //    67    rnan(i)_next_next == recn

  [/*BUG*/ 0] -> NEXT -> NEXT = (struct RF *)RECN;

  //    68    rnan(i)_next_next_i = x

  [/*BUG*/ 0] -> NEXT -> NEXT -> I = X;

  //    69    recn == rm(i)

  RECN = (struct RF *)RM(I);

  //    70    recn == rm(i)_next

  RECN = (struct RF *)RM(I)->NEXT;

  //    71    recn == rm(i)_next_next

  RECN = (struct RF *)RM(I)->NEXT->NEXT;

  //    72    recn_i = rm(i)_i

  RECN->I = RM(I)->I;

  //    73    recn_i = rm(i)_next_i

  RECN->I = RM(I)->NEXT->I;

  //    74    recn_i = rm(i)_next_next_i

  RECN->I = RM(I)->NEXT->NEXT->I;

  //    75    rm(i) = rec

  *RM(I) = REC;

  //    76    rm(i)_next = rec

  *RM(I)->NEXT = REC;

  //    77    rm(i)_next_i = x

  RM(I)->NEXT->I = X;

  //    78    rm(i)_next == recn

  RM(I)->NEXT = (struct RF *)RECN;

  //    79    rm(i)_next_next = rec

  *RM(I)->NEXT->NEXT = REC;

  //    80    rm(i)_next_next_i = x

  RM(I)->NEXT->NEXT->I = X;

  //    81    rm(i)_next_next == recn

  RM(I)->NEXT->NEXT = (struct RF *)RECN;

  //    82    x = rm(i)_i

  X = RM(I)->I;

  //    83    x = rm(i)_next_i

  X = RM(I)->NEXT->I;

  //    84    x = rm(i)_next_next_i

  X = RM(I)->NEXT->NEXT->I;

  //    85    rm(i)_i = x

  RM(I)->I = X;

  //    86    rm(i)_next = rec

  *RM(I)->NEXT = REC;

  //    87    rm(i)_next = recn

  *RM(I)->NEXT = *RECN;

  //    88    rm(i)_next_i = x

  RM(I)->NEXT->I = X;

  //    89    rm(i)_next_next = rec

  *RM(I)->NEXT->NEXT = REC;

  //    90    rm(i)_next_next = recn

  *RM(I)->NEXT->NEXT = *RECN;

  //    91    rm(i)_next_next_i = x

  RM(I)->NEXT->NEXT->I = X;

  //    92  %endofprogram

  _imp_stop(0);
  return 0;
end_0:;
}