Program HelloWorld(output);


type
   arrayType = array[1..100, 1..100] of integer;
   arrayOneRow = array[1..10000] of integer;

procedure prepareArray(var ext_array:arrayType; ext_ArraySize, ext_randomInterval:integer;
    ext_NegativeNumbersAllowed: boolean);
   var i,j: integer;
begin
    for  i:=1 to  ext_ArraySize do
        for j:=1 to ext_ArraySize do
            begin
                if ext_NegativeNumbersAllowed then
                    ext_array[i,j]:= Random(2 * ext_randomInterval) - ext_randomInterval
                else
                    ext_array[i,j]:=Random(ext_randomInterval);
            end;
end;

procedure outputArray(ext_array:arrayType; ext_ArraySize:integer);
var i,j: integer;
begin
    for  i:=1 to ext_ArraySize do
    begin
        for j:=1 to ext_ArraySize do
            write(ext_array[i,j],' ');
        writeln('');
    end;
end;

procedure getMaxElementFromArray(ext_array:arrayType; ext_ArraySize:integer; var ext_max: integer);
var i,j: integer;
begin
    ext_max := -99999;
    for  i:=1 to ext_ArraySize do
    begin
        for j:=1 to ext_ArraySize do
            if ext_array[i,j]> ext_max then ext_max:=ext_array[i,j];
    end;
end;

procedure getItemRepeatCount(ext_array:arrayType; ext_ArraySize, ext_item:integer; var ext_count : integer);
var i,j: integer;
begin
    ext_count:= 0;
    for  i:=1 to ext_ArraySize do
    begin
        for j:=1 to ext_ArraySize do
            if ext_array[i,j] = ext_item then ext_count := ext_count+1;
    end;
end;

procedure qSort(ext_arrayLength: integer; var ar: array of integer);
  procedure sort(var ar: array of integer; low, high: integer);
  var i, j, m, wsp: integer;
  begin
      i:=low; j:=high; m:=ar[(i+j) div 2];
      repeat
        while ar[i]<m do Inc(i);
        while ar[j]>m do Dec(j);
        if i<=j then begin
          wsp:=ar[i]; ar[i]:=ar[j]; ar[j]:=wsp;
          Inc(i); Dec(j);
         end;
      until i>j;
      if low<j then sort(ar, low, j);
      if i<high then sort(ar, i, high);
  end;
begin
  sort(ar, 0, ext_arrayLength);
end;

procedure getMaxElementWithOffset(ext_array:arrayType; ext_ArraySize, ext_offset:integer; var ext_item : integer);
var i,j,counter: integer;
var arrayUnited: array[1..10000] of integer;
begin
    ext_item:= -9999;
    counter:=1;
    for i:=1 to ext_ArraySize do
    begin
        for j:=1 to ext_ArraySize do
        begin
            arrayUnited[counter]:=ext_array[i,j];
            counter := counter+1;
        end;
    end;
    qSort(counter-2,arrayUnited);
    ext_item:=arrayUnited[counter-ext_offset-1];
end;

procedure getMaxElementThatAlsoBelongsToAnotherArray(ext_arrayOne, ext_arrayTwo:arrayType; ext_ArraySize:integer; var ext_item:integer; var ext_success: boolean);
var i,j, offset, maxElement,repeatCount: integer;
begin
    offset:=0;
    repeat
        getMaxElementWithOffset(ext_arrayOne, ext_ArraySize, offset, maxElement);
        getItemRepeatCount(ext_arrayTwo, ext_ArraySize, maxElement, repeatCount);
        if (repeatCount > 0) then
        begin
            ext_item := maxElement;
            ext_success := true;
        end
        else inc(offset);
        if offset > ext_arraySize then
        begin
            writeln('Item not found!');
            ext_success := false;
        end;
    until (repeatCount > 0) or (offset > ext_ArraySize);
end;

var matrixSize, randomInterval, dummyWhatever, maxElement, maxElementB, repeatCount, highestInFirst, highestInSecond :integer;
var negativeNumbersAllowed, itemFound :boolean;
var arrayOne, arrayTwo: arrayType;

begin
    Randomize;
    matrixSize := 0;
    while (matrixSize < 1) or (matrixSize > 100) do
    begin
        write('set matrix size M=');
        readln(matrixSize);
    end;
    writeln(matrixSize);

    randomInterval := 0;
    while (randomInterval < 1) or (randomInterval > 100) do
    begin
        write('set randomInterval rINT=');
        readln(randomInterval);
    end;
    writeln(randomInterval);

    dummyWhatever := 0;
    write('1 for negative numbers allowed, non-1 - not allowed: ');
    readln(dummyWhatever);
    if (dummyWhatever = 1) then
        negativeNumbersAllowed := true
    else negativeNumbersAllowed := false;
    writeln(negativeNumbersAllowed);

    prepareArray(arrayOne, matrixSize, randomInterval, negativeNumbersAllowed);
    writeln('first array');
    outputArray(arrayOne, matrixSize);

    prepareArray(arrayTwo, matrixSize, randomInterval, negativeNumbersAllowed);
    writeln('second array');
    outputArray(arrayTwo, matrixSize);

    writeln('SEPARATE MAX');

    getMaxElementFromArray(arrayOne, matrixSize, maxElement);
    writeln('maximum element for first matrix: ', maxElement);
    getItemRepeatCount(arrayOne, matrixSize, maxElement, repeatCount);
    writeln('item repeat count for first matrix: ', repeatCount);
    getMaxElementFromArray(arrayTwo, matrixSize, maxElement);
    writeln('maximum element for second matrix: ', maxElement);
    getItemRepeatCount(arrayTwo, matrixSize, maxElement, repeatCount);
    writeln('item repeat count for first matrix: ', repeatCount);

    writeln('MAX OVERALL/OUTER JOIN');

    getMaxElementFromArray(arrayOne, matrixSize, maxElement);
    writeln('maximum element for first matrix: ', maxElement);
    getMaxElementFromArray(arrayTwo, matrixSize, maxElementB);
    writeln('maximum element for second matrix: ', maxElementB);
    if (maxElement<maxElementB) then maxElement := maxElementB;
    writeln('maximum element for both arrays: ', maxElement);
    getItemRepeatCount(arrayOne, matrixSize, maxElement, repeatCount);
    writeln('item repeat count for first matrix: ', repeatCount);
    getItemRepeatCount(arrayTwo, matrixSize, maxElement, repeatCount);
    writeln('item repeat count for first matrix: ', repeatCount);

    writeln('MAX INNER JOIN');
    getMaxElementThatAlsoBelongsToAnotherArray(arrayOne, arrayTwo, matrixSize, highestInFirst, itemFound);
    if (itemFound) then
    begin
        getMaxElementThatAlsoBelongsToAnotherArray(arrayTwo, arrayOne, matrixSize, highestInSecond, itemFound);
        writeln('Maximum element that belongs to both arrays is ', highestInFirst);
        getItemRepeatCount(arrayOne, matrixSize, highestInFirst, repeatCount);
        writeln('Repeat count for first matrix: ', repeatCount);
        getItemRepeatCount(arrayTwo, matrixSize, highestInFirst, repeatCount);
        write('Repeat count for first matrix: ', repeatCount);
    end;
end.