procedure TArrayEx<T>.SetLengthFast(NewValue: integer);
const
  GrowLimit = 64;
begin
  if NewValue<=0 then begin
    FCapacity:=0;
    SetLength(Items,0);
  end else begin
    if (NewValue>FCapacity) or (NewValue shl 1<FCapacity) then begin
      FCapacity:=Min(NewValue shl 1,NewValue+GrowLimit);
      SetLength(Items,FCapacity);
      FArrayCount:=PNativeInt(NativeInt(@Items[0])-SizeOf(NativeInt));
    end;
    FArrayCount^:=NewValue;
  end;
end;

type
  ArrayEx<T> = record
    v: array of T;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength: Integer;
begin
  MaxLength := Length(v);
  if CurrentLength >= MaxLength then
    SetLength(v, MaxLength + Plus);

  v[CurrentLength] := Value;
  inc(CurrentLength);
end;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  ArrayEx<T> = record
    v: array of T;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength: Integer;
begin
  if PDynArrayRec(v) = nil then
    MaxLength := 0
  else
    MaxLength := PDynArrayRec(NativeUInt(v) - SizeOf(TDynArrayRec)).Length;

  if CurrentLength >= MaxLength then
    SetLength(v, MaxLength + Plus);
  v[CurrentLength] := Value;
  inc(CurrentLength);
end;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  PDynArrayTypeInfo = ^TDynArrayTypeInfo;

  TDynArrayTypeInfo = packed record
    kind: TTypeKind;
    name: Byte; { string[0]; }
    elSize: Integer;
    elType: ^PDynArrayTypeInfo;
    varType: Integer;
  end;

  ArrayEx<T> = record
    v: TArray<T>;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

procedure ArrayOfPointerSetLength(ptr: PPointer; const NewLength: NativeInt);
  procedure ArrayOfPointerClear(const ptr: PPointer);
    function __DynArrayRefCnt(const A: Pointer): Integer; inline;
    begin
      Result := PDynArrayRec(PByte(A) - SizeOf(TDynArrayRec))^.RefCnt;
    end;

  var
    p: Pointer;
  begin
    p := ptr^;
    if p <> nil then
    begin
      ptr^ := nil;
      if __DynArrayRefCnt(p) > 0 then
      begin
        if AtomicDecrement(PDynArrayRec(PByte(p) - SizeOf(TDynArrayRec))
          ^.RefCnt) = 0 then
        begin
          Dec(PByte(p), SizeOf(TDynArrayRec));
          SysFreeMem(p);
        end;
      end;
    end;
  end;

const
  elSize = SizeOf(Pointer);
var
  oldLength, minLength: NativeInt;
  neededSize: NativeInt;
  p: Pointer;
begin
  p := ptr^;
  neededSize := NewLength * elSize + SizeOf(TDynArrayRec);
  if p = nil then
    p := SysAllocMem(neededSize)
  else
  begin
    Dec(PByte(p), SizeOf(TDynArrayRec));
    oldLength := PDynArrayRec(p).Length;

    if PDynArrayRec(p).RefCnt = 1 then
      p := SysReallocMem(p, neededSize)
    else
    begin
      p := SysGetMem(neededSize);
      minLength := oldLength;
      if minLength > NewLength then
        minLength := NewLength;
      Move(PByte(ptr^)^, (PByte(p) + SizeOf(TDynArrayRec))^,
        minLength * elSize);
      ArrayOfPointerClear(ptr^);
    end;
    if NewLength > oldLength then
      FillChar((PByte(p) + SizeOf(TDynArrayRec) + elSize * oldLength)^,
        elSize * (NewLength - oldLength), 0);
  end;

  PDynArrayRec(p).RefCnt := 1;
  PDynArrayRec(p).Length := NewLength;
  Inc(PByte(p), SizeOf(TDynArrayRec));

  ptr^ := p;
end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength, NewLength: Integer;
  typeInfo, pv: Pointer;
  pv2: PPointer;
begin
  if PDynArrayRec(v) = nil then
    MaxLength := 0
  else
    MaxLength := PDynArrayRec(NativeUInt(v) - SizeOf(TDynArrayRec)).Length;

  if CurrentLength >= MaxLength then
    ArrayOfPointerSetLength(Pointer(@v), MaxLength + Plus);

  v[CurrentLength] := Value;
  Inc(CurrentLength);
end;

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  PDynArrayTypeInfo = ^TDynArrayTypeInfo;

  TDynArrayTypeInfo = packed record
    kind: TTypeKind;
    name: Byte; { string[0]; }
    elSize: Integer;
    elType: ^PDynArrayTypeInfo;
    varType: Integer;
  end;

  ArrayEx<T> = record
    v: TArray<T>;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

procedure ArrayOfPointerSetLength(ptr: PPointer; const NewLength: NativeInt);
  procedure ArrayOfPointerClear(const ptr: PPointer);
    function __DynArrayRefCnt(const A: Pointer): Integer; inline;
    begin
      Result := PDynArrayRec(PByte(A) - SizeOf(TDynArrayRec))^.RefCnt;
    end;

  var
    p: Pointer;
  begin
    p := ptr^;
    if p <> nil then
    begin
      ptr^ := nil;
      if __DynArrayRefCnt(p) > 0 then
      begin
        if AtomicDecrement(PDynArrayRec(PByte(p) - SizeOf(TDynArrayRec))
          ^.RefCnt) = 0 then
        begin
          Dec(PByte(p), SizeOf(TDynArrayRec));
          SysFreeMem(p);
        end;
      end;
    end;
  end;

const
  elSize = SizeOf(Pointer);
var
  oldLength, minLength: NativeInt;
  neededSize: NativeInt;
  p: Pointer;
begin
  p := ptr^;
  neededSize := NewLength * elSize + SizeOf(TDynArrayRec);
  if p = nil then
    p := SysAllocMem(neededSize)
  else
  begin
    Dec(PByte(p), SizeOf(TDynArrayRec));
    oldLength := PDynArrayRec(p).Length;

    if PDynArrayRec(p).RefCnt = 1 then
      p := SysReallocMem(p, neededSize)
    else
    begin
      p := SysGetMem(neededSize);
      minLength := oldLength;
      if minLength > NewLength then
        minLength := NewLength;
      Move(PByte(ptr^)^, (PByte(p) + SizeOf(TDynArrayRec))^,
        minLength * elSize);
      ArrayOfPointerClear(ptr^);
    end;
    if NewLength > oldLength then
      FillChar((PByte(p) + SizeOf(TDynArrayRec) + elSize * oldLength)^,
        elSize * (NewLength - oldLength), 0);
  end;

  PDynArrayRec(p).RefCnt := 1;
  PDynArrayRec(p).Length := NewLength;
  Inc(PByte(p), SizeOf(TDynArrayRec));

  ptr^ := p;
end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength, NewLength: Integer;
  typeInfo, pv: Pointer;
  pv2: PPointer;
begin
  if PDynArrayRec(v) = nil then
    MaxLength := 0
  else
    MaxLength := PDynArrayRec(NativeUInt(v) - SizeOf(TDynArrayRec)).Length;

  if CurrentLength >= MaxLength then
    ArrayOfPointerSetLength(Pointer(@v), MaxLength + Plus);

  v[CurrentLength] := Value;
  Inc(CurrentLength);
end;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: ArrayEx<Integer>;
  i: Integer;
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(i);

    Writeln(PrintTime(T));

    for i := 0 to 50000000 do
      if arr.v[i] <> i then
        Writeln('Faild!!: ' + i.ToString);

    Writeln('End');

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  ArrayEx<T> = record
    v: array of T;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength: Integer;
begin
  MaxLength := Length(v);
  if CurrentLength >= MaxLength then
    SetLength(v, MaxLength + Plus);

  v[CurrentLength] := Value;
  inc(CurrentLength);
end;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: ArrayEx<Integer>;
  i: Integer;
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(i);

    Writeln(PrintTime(T));

    for i := 0 to 50000000 do
      if arr.v[i] <> i then
        Writeln('Faild!!: ' + i.ToString);

    Writeln('End');

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  ArrayEx<T> = record
    v: array of T;
    CurrentLength: NativeUInt;
    function add(Value: T): NativeUInt;
  end;

function ArrayEx<T>.add(Value: T): NativeUInt;
const
  Plus = 16; // 32
var
  MaxLength: Integer;
begin
  if PDynArrayRec(v) = nil then
    MaxLength := 0
  else
    MaxLength := PDynArrayRec(NativeUInt(v) - SizeOf(TDynArrayRec)).Length;

  if CurrentLength >= MaxLength then
    SetLength(v, MaxLength + Plus);
  v[CurrentLength] := Value;
  inc(CurrentLength);
end;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: ArrayEx<Integer>;
  i: Integer;
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(i);

    Writeln(PrintTime(T));

    for i := 0 to 50000000 do
      if arr.v[i] <> i then
        Writeln('Faild!!: ' + i.ToString);

    Writeln('End');

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils, classes;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: TList;
  i: Integer;
  T: Int64;

begin
  try
    arr := TList.Create;
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(Pointer(i));

    Writeln(PrintTime(T));

    Writeln('End');

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  PDynArrayTypeInfo = ^TDynArrayTypeInfo;

  TDynArrayTypeInfo = packed record
    kind: TTypeKind;
    name: Byte; { string[0]; }
    elSize: Integer;
    elType: ^PDynArrayTypeInfo;
    varType: Integer;
  end;

  ArrayEx<T> = record
    v: TArray<T>;
    CurrentLength: Integer;
    procedure add(Value: T);
  end;

procedure ArrayOfPointerSetLength(ptr: PPointer; const NewLength: NativeInt);
  procedure ArrayOfPointerClear(const ptr: PPointer);
    function __DynArrayRefCnt(const A: Pointer): Integer; inline;
    begin
      Result := PDynArrayRec(PByte(A) - SizeOf(TDynArrayRec))^.RefCnt;
    end;

  var
    p: Pointer;
  begin
    p := ptr^;
    if p <> nil then
    begin
      ptr^ := nil;
      if __DynArrayRefCnt(p) > 0 then
      begin
        if AtomicDecrement(PDynArrayRec(PByte(p) - SizeOf(TDynArrayRec))
          ^.RefCnt) = 0 then
        begin
          Dec(PByte(p), SizeOf(TDynArrayRec));
          SysFreeMem(p);
        end;
      end;
    end;
  end;

const
  elSize = SizeOf(Pointer);
var
  oldLength, minLength: NativeInt;
  neededSize: NativeInt;
  p: Pointer;
begin
  p := ptr^;
  neededSize := NewLength * elSize + SizeOf(TDynArrayRec);
  if p = nil then
    p := SysAllocMem(neededSize)
  else
  begin
    Dec(PByte(p), SizeOf(TDynArrayRec));
    oldLength := PDynArrayRec(p).Length;

    if PDynArrayRec(p).RefCnt = 1 then
      p := SysReallocMem(p, neededSize)
    else
    begin
      p := SysGetMem(neededSize);
      minLength := oldLength;
      if minLength > NewLength then
        minLength := NewLength;
      Move(PByte(ptr^)^, (PByte(p) + SizeOf(TDynArrayRec))^,
        minLength * elSize);
      ArrayOfPointerClear(ptr^);
    end;
    if NewLength > oldLength then
      FillChar((PByte(p) + SizeOf(TDynArrayRec) + elSize * oldLength)^,
        elSize * (NewLength - oldLength), 0);
  end;

  PDynArrayRec(p).RefCnt := 1;
  PDynArrayRec(p).Length := NewLength;
  Inc(PByte(p), SizeOf(TDynArrayRec));

  ptr^ := p;
end;

procedure ArrayEx<T>.add(Value: T);
const
  Plus = 21; // 32
var
  MaxLength: Integer;
begin
  if PDynArrayRec(v) = nil then
    MaxLength := 0
  else
    MaxLength := PDynArrayRec(NativeUInt(v) - SizeOf(TDynArrayRec)).Length;

  if CurrentLength >= MaxLength then
    ArrayOfPointerSetLength(Pointer(@v), MaxLength + Plus);

  v[CurrentLength] := Value;
  Inc(CurrentLength);
end;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: ArrayEx<Integer>;
  i: Integer;
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(i);

    Writeln(PrintTime(T));

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  ArrayEx<T> = record
    v: Pointer;
    CurrentLength, MaxLength: Integer;
    temp: TArray<T>;
    procedure add(Value: T);
    function GetIndex(i: Integer): T;
    function GetIndex2(i: Integer): T;
  end;

procedure ArrayEx<T>.add(Value: T);
type
  Test = array of T;
const
  elSize = SizeOf(Pointer);
  Plus = 48;
begin
  if MaxLength < CurrentLength then
  begin
    Inc(MaxLength, Plus);
    Dec(PByte(v), SizeOf(TDynArrayRec));
    v := SysReallocMem(v, MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));
  end
  else if v = nil then
  begin
    MaxLength := Plus;
    v := SysGetMem(MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));
  end;

  Test(v)[CurrentLength] := Value;

  Inc(CurrentLength);

  PPointer(@temp)^ := v;
  PDynArrayRec(NativeUInt(temp) - SizeOf(TDynArrayRec)).Length := CurrentLength;
end;

function ArrayEx<T>.GetIndex(i: Integer): T;
begin
  if (i >= MaxLength) and (i <= CurrentLength) then
    Result := GetIndex2(i);
end;

function ArrayEx<T>.GetIndex2(i: Integer): T;
type
  Test = array of T;
begin
  Result := Test(v)[i];
end;

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

var
  arr: ArrayEx<Integer>;
  i: Integer;
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);

    for i := 0 to 50000000 do
      arr.add(i);

    Writeln(PrintTime(T));

    for i := 0 to 100 do
      Writeln(arr.GetIndex2(i));

    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  ArrayEx<T> = record
    v: Pointer;
    CurrentLength, MaxLength: Integer;
    temp: TArray<T>;
    procedure init;
    procedure add(Value: T);
    function GetIndex(i: Integer): T;
    function GetIndex2(i: Integer): T;
  end;

procedure ArrayEx<T>.init;
begin
  v := nil;
  CurrentLength := 0;
  MaxLength := 0;
end;

procedure ArrayEx<T>.add(Value: T);
type
  Test = array of T;
const
  elSize = SizeOf(Pointer);
  Plus = 48;
begin
  if MaxLength < CurrentLength then
  begin
    Inc(MaxLength, Plus);
    Dec(PByte(v), SizeOf(TDynArrayRec));
    v := SysReallocMem(v, MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));

    PPointer(@temp)^ := v;
  end
  else if v = nil then
  begin
    MaxLength := Plus;
    v := SysGetMem(MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));

    PPointer(@temp)^ := v;
  end;

  Test(v)[CurrentLength] := Value;

  Inc(CurrentLength);

  PDynArrayRec(NativeUInt(temp) - SizeOf(TDynArrayRec)).Length := CurrentLength;
end;

function ArrayEx<T>.GetIndex(i: Integer): T;
begin
  if (i >= MaxLength) and (i <= CurrentLength) then
    Result := GetIndex2(i);
end;

function ArrayEx<T>.GetIndex2(i: Integer): T;
type
  Test = array of T;
begin
  Result := Test(v)[i];
end;

// -----------------------

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

procedure Test; // Роли не играло, вынеся  в отдельную процедуру 
var
  arr: ArrayEx<Integer>;
  i: Integer;
begin
  with arr do
  begin

    init;

    for i := 0 to 50000000 do
      add(i);

    // for i := 0 to 100 do
    // Writeln(GetIndex2(i));
  end;
end;

var
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);
    Test;
    Writeln(PrintTime(T));
    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  windows, System.SysUtils;

type
  PDynArrayRec = ^TDynArrayRec;

  TDynArrayRec = packed record
{$IFDEF CPU64BITS}
    _Padding: Integer; // Make 16 byte align for payload..
{$ENDIF}
    RefCnt: Integer;
    Length: NativeInt;
  end;

  ArrayEx<T> = record
    v: Pointer;
    CurrentLength, MaxLength: Integer;
    temp: TArray<T>;
    procedure init;
    procedure add(Value: T);
    function GetIndex(i: Integer): T;
    function GetIndex2(i: Integer): T;
    function Remove(i: Integer): T;

  type
    Test = array of T;

  const
    elSize = SizeOf(Pointer);
    Plus = 48;
  end;

procedure ArrayEx<T>.init;
begin
  v := nil;
  CurrentLength := 0;
  MaxLength := 0;
end;

procedure ArrayEx<T>.add(Value: T);
begin
  if MaxLength < CurrentLength then
  begin
    Inc(MaxLength, Plus);
    Dec(PByte(v), SizeOf(TDynArrayRec));
    v := SysReallocMem(v, MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));

    PPointer(@temp)^ := v;
  end
  else if v = nil then
  begin
    MaxLength := Plus;
    v := SysGetMem(MaxLength * elSize + SizeOf(TDynArrayRec));
    Inc(PByte(v), SizeOf(TDynArrayRec));

    PPointer(@temp)^ := v;
  end;

  Test(v)[CurrentLength] := Value;

  Inc(CurrentLength);

  PDynArrayRec(NativeUInt(temp) - SizeOf(TDynArrayRec)).Length := CurrentLength;
end;

function ArrayEx<T>.GetIndex(i: Integer): T;
begin
  if (i >= MaxLength) and (i <= CurrentLength) then
    Result := GetIndex2(i);
end;

function ArrayEx<T>.GetIndex2(i: Integer): T;
begin
  Result := Test(v)[i];
end;

function ArrayEx<T>.Remove(i: Integer): T;
begin
  Dec(MaxLength);
  System.Move(Test(v)[i + 1], Test(v)[i], (MaxLength - i) * SizeOf(elSize));

  Dec(CurrentLength);

  PDynArrayRec(NativeUInt(temp) - SizeOf(TDynArrayRec)).Length := CurrentLength;
end;

// -----------------------

function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';

function PrintTime(T: Int64): AnsiString;
var
  A, b: Int64;
begin
  Result := '';
  if QueryPerformanceCounter(A) and QueryPerformanceFrequency(b) then
  begin
    SetLength(Result, 25);
    SetLength(Result, sprintf(PAnsiChar(Result), '%f', single((A - T) / b)));
  end;
end;

procedure Test; // Роли не играло, вынеся  в отдельную процедуру
var
  arr: ArrayEx<Integer>;
  i: Integer;
begin
  with arr do
  begin

    init;

    for i := 0 to 50000000 do
      add(i);

    Remove(50000000 - 2);

    add(50000000 - 2);
  end;
end;

var
  T: Int64;

begin
  try
    QueryPerformanceCounter(T);
    Test;
    Writeln(PrintTime(T));
    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;

end.