program pptest2;

  var
    a: array [0 .. 2] of integer;
    b: array [1 .. 2] of integer;
    c: array [-1 .. 2] of integer;
    d: array [32000 .. 32002] of integer;
    e,
    f: array [0 .. 2, 1 .. 2] of integer;
    i: integer;
    r1,
    r2: record
          firstfield: integer;
          secondfield: integer;
          a: array [0 .. 3] of
               record
                 firstfield: integer;
                 secondfield: integer
               end;
          case s: boolean of
            false: (s1: integer);
            true: (s2: integer)
        end;

  begin
  { array base 0 }
    a[0] := 0; { compile time evaluation }
    a[i] := 0; { simple adjustment }
    a[0] := a[1]; { as for simple assignment }
    a[2] := a[1]; { optimization }
    a[i] := a[0]; { " }
    a[i] := a[1]; { contents forgotten }
    a[i] := i; { optimization }
    i := a[i]; { " }
    a[i] := -a[i]; { " }

    { deeply nested references }

    a[a[a[a[a[a[a[a[a[a[i]]]]]]]]]] := 0;
    i := a[a[a[a[a[a[a[a[a[a[i]]]]]]]]]];

    { array bases other than 0 }
    b[i] := 0; { array base 1 }
    c[i] := 0; { array base -1 }
    d[i] := 0; { large adjustment }

    { 2D arrays }

    e[0, 1] := 0;
    e[0, i] := 0;
    e[i, i] := 0;

    { optimization on first index - second forgotten }
    i := e[1, 1];
    i := e[2, 1];
    e[2, 1] := 0;
    i := e[1, 1];
    i := e[2, 1];
    e := f; { whole array assignment }
    i := e[2, 1]; { contents forgotten }

    { records }

    { simple addressing }

    r1.firstfield := 0;
    r1.secondfield := 0;
    i := r1.firstfield;
    i := r1.secondfield;
    r1 := r2; { whole record assignment }
    i := r1.firstfield;

    { variant records }
    r1.s1 := 24;
    r1.s2 := 23; { same location }
    i := r1.s1; { contents remembered }
    i := r1.s2; { contents forgotten }

   { mixed structures }

    r1.a[1].firstfield := 0;
    r1.a[i].firstfield := 0;
    r1.a[i].secondfield := 0;
    i := r1.a[i].firstfield
  end { pptest2 }.