uses crt;

type
  PT = ^T;
  T = integer;

  arrT =
    array[1 .. maxint div sizeOf(T)] of T;

  PTC_arr = ^TC_arr;
  TC_arr = arrT;

  PTColumn = ^TColumn;
  TColumn = object
    size: Word;
    constructor Create(const n, sz: Word);
    constructor CreateRandom(const sz: word);
    destructor done;

    function get(i: word): PT;
    procedure put(i: word; value: T);

    procedure print(px, py: integer);

    function has_negatives: boolean;
    function get_s: T;
  private
    vc: PTC_arr;
    procedure allocate(const sz: Word);
  end;

  PTmx_arr = ^Tmx_arr;
  Tmx_arr =
    array[1 .. maxInt div sizeof(PTColumn)] of PTColumn;

  Tmatrix = object
    num_cols: word;

    constructor Create(n_rows, n_cols: word);
    constructor Random(n_rows, n_cols: word);
    destructor done;

    function get_col_count: Word;
    function get_column(i: word): PTColumn;

    procedure print(px, py: integer);
    procedure process;
  private
    mx: PTmx_arr;
    procedure allocate(n_cols: word);
  end;

procedure TColumn.allocate(const sz: word);
begin
  size := sz;
  getmem(vc, size * sizeof(T));
end;

constructor TColumn.CreateRandom(const sz: word);
var i: integer;
begin
  allocate(sz);
  for i := 1 to size do begin
    vc^[i] := integer(random(20)) - 10;
  end;
end;

constructor TColumn.Create(const n, sz: word);
var i: integer;
begin
  allocate(sz);
  writeln('enter column #', n);
  for i := 1 to size do begin
    write('<', i:3, ', ', n:3, '> = '); readln(vc^[i]);
  end;
end;

destructor TColumn.done;
begin
  freemem(vc, size * sizeof(T));
end;

function TColumn.get(i: word): PT;
begin
  get := @(vc^[i]);
end;
procedure TColumn.put(i: word; value: T);
begin
  vc^[i] := value
end;

procedure TColumn.print(px, py: integer);
var i: word;
begin
  for i := 1 to size do begin
    GotoXY(px, py);
    writeln((get(i)^):3);
    inc(py);
  end;
end;

function TColumn.get_s: T;
var
  i: integer;
  s: T;
begin
  s := 0;
  for i := 1 to size do s := s + get(i)^;
  get_s := s;
end;

function TColumn.has_negatives: boolean;
var i: integer;
begin
  has_negatives := true;
  for i := 1 to size do if get(i)^ < 0 then exit;
  has_negatives := false;
end;



procedure tmatrix.allocate(n_cols: word);
var i: integer;
begin
  num_cols := n_cols;
  getmem(mx, num_cols * sizeof(PTColumn));
end;


constructor tmatrix.Create(n_rows, n_cols: word);
var i: word;
begin
  allocate(n_cols);
  for i := 1 to get_col_count do
    new(mx^[i], Create(i, n_rows));
end;
constructor tmatrix.Random(n_rows, n_cols: word);
var i: word;
begin
  allocate(n_cols);
  for i := 1 to get_col_count do
    new(mx^[i], CreateRandom(n_rows));
end;

destructor tmatrix.done;
var i: word;
begin
  for i := 1 to get_col_count do
    dispose(get_column(i), done);
  freemem(mx, get_col_count * sizeof(ptcolumn));
end;


function tmatrix.get_col_count: word;
begin
  get_col_count := num_cols
end;
function tmatrix.get_column(i: word): ptcolumn;
begin
  get_column := mx^[i]
end;

procedure tmatrix.print(px, py: integer);
var i: word;
begin
  writeln('mx <', get_column(1)^.size, ', ',
          get_col_count, '>');
  for i := 1 to get_col_count do begin
    get_column(i)^.print(px, py + 1); inc(px, 4);
  end;
end;

procedure tmatrix.process;
var i: integer;
begin
  for i := 1 to get_col_count do
    if not get_column(i)^.has_negatives then
      writeln('column #', i:3, ' : sum = ', get_column(i)^.get_s);
end;


var
  obj1, obj2, obj3: tmatrix;

begin
  clrscr;
  obj1.Random(5, 6);
  obj1.print(wherex, wherey);
  obj1.process;

  obj2.Create(3, 3);
  obj2.print(wherex, wherey);
  obj2.process;
end.