Program HelloWorld(output);

type
   arrayType = array[1..100, 1..100] of real;
   arrayOneRow = array[1..5000] of real;


procedure inputSomething(var ext_size: integer; ext_text:string);
begin
    ext_size := 0;
    while (ext_size < 1) or (ext_size > 100) do
    begin
        write(ext_text);
        readln(ext_size);
    end;
    writeln(ext_size);
end;

procedure prepareArray(var ext_array:arrayType; ext_ArraySize, ext_randomInterval:integer);
   var i,j: integer;
begin
    for  i:=1 to  ext_ArraySize do
        for j:=1 to ext_ArraySize do
            ext_array[i,j]:= random * 2 * ext_randomInterval - ext_randomInterval;
end;

procedure outputMatrix(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]:3:2,' ');
            writeln('');
    end;
end;

procedure getShitHigherThanIncidentalDiagonal(var ext_output: arrayOneRow; var ext_outputArraySize:integer; ext_array:arrayType; ext_arraySize:integer);
var i,j: integer;
begin
    ext_outputArraySize := 0;
    for  i:=1 to ext_ArraySize do
        for j:=1 to ext_ArraySize do
            if i <= ext_ArraySize-j then
            begin
                inc(ext_outputArraySize);
                ext_output[ext_outputArraySize] := ext_array[i,j];
            end;
end;

procedure getArithmeticalMeanOfNegativeElementsOfArray(var ext_output: real; ext_array: arrayOneRow; ext_arraySize:integer);
var i,counter:integer;
var sum:real;
begin
    ext_output:=0;
    sum:=0;
    counter:=0;
    for  i:=1 to ext_ArraySize do
        if ext_array[i]<0 then
        begin
            inc(counter);
            sum := sum+ext_array[i];
        end;
    if counter>0 then
        ext_output:=sum/counter;
end;

var matrixOneSize, matrixTwoSize, randomInterval, lenghtOfArrayOnesElements, lenghtOfArrayTwosElements, repeatCount, highestInFirst, highestInSecond :integer;
var negativeNumbersAllowed, itemFound :boolean;
var arrayOne, arrayTwo: arrayType;
var elementsOfFirstArrayThatHigherThanIncidentionalDiagonal, elementsOfSecondArrayThatHigherThanIncidentionalDiagonal: arrayOneRow;
var arithmeticalMean:real;
begin
    Randomize;
    inputSomething(matrixOneSize, 'set matrix one size M1s= ');
    inputSomething(matrixTwoSize, 'set matrix two size M2s= ');
    inputSomething(randomInterval, 'set randomInterval rINT= ');

    prepareArray(arrayOne, matrixOneSize, randomInterval);
    writeln('first array');
    outputMatrix(arrayOne, matrixOneSize);
    getShitHigherThanIncidentalDiagonal(elementsOfFirstArrayThatHigherThanIncidentionalDiagonal,
        lenghtOfArrayOnesElements, arrayOne, matrixOneSize);
    write('arithmetical mean of negative elements of array that located higher than incidental diagonal is ');
    getArithmeticalMeanOfNegativeElementsOfArray(arithmeticalMean,
        elementsOfFirstArrayThatHigherThanIncidentionalDiagonal,lenghtOfArrayOnesElements);
    writeln(arithmeticalMean:2:2);

    prepareArray(arrayTwo, matrixTwoSize, randomInterval);
    writeln('second array');
    outputMatrix(arrayTwo, matrixTwoSize);
    getShitHigherThanIncidentalDiagonal(elementsOfSecondArrayThatHigherThanIncidentionalDiagonal,
        lenghtOfArrayTwosElements, arrayTwo, matrixTwoSize);
    write('arithmetical mean of negative elements of array that located higher than incidental diagonal is ');
    getArithmeticalMeanOfNegativeElementsOfArray(arithmeticalMean,
        elementsOfSecondArrayThatHigherThanIncidentionalDiagonal,lenghtOfArrayTwosElements);
    writeln(arithmeticalMean:2:2);
end.