Type
  TType = Double;
  PTRows = ^TRows;
  TRows = Array[1 .. (2 * maxInt) Div SizeOf(TType)] Of TType;

  PTCol = ^TCol;
  TCol = Array[1 .. (2 * maxInt) Div SizeOf(PTRows)] Of PTRows;

  PTMatrix = ^TMatrix;
  TMatrix =
    Record
      nRow, nCol: Integer;
      matrix: PTCol;
    End;

Function mxCreate(Var mx: TMatrix;
         pRows, pCols: Integer): Boolean;
Var
  i, j: Integer;
Begin
  GetMem(mx.matrix, pRows*SizeOf(PTRows));
  For i := 1 To pRows Do Begin
    GetMem(mx.matrix^[i], pCols*SizeOf(TType));
    For j := 1 To pCols Do mx.matrix^[i]^[j] := 0
  End;

  mx.nRow := pRows;
  mx.nCol := pCols;

  mxCreate := True
End;
Procedure mxDispose(Var mx: TMatrix);
Var
  i, j: Integer;
Begin
  For i := 1 To mx.nRow Do
    FreeMem(mx.matrix^[i], mx.nCol*SizeOf(TType));
  FreeMem(mx.matrix, mx.nRow*SizeOf(PTRows));
End;

Procedure mxInput(Var mx: TMatrix);
Var
  i, j: Integer;
Begin
  For i := 1 To mx.nRow Do Begin
    WriteLn('Entering row #', i);
    For j := 1 To mx.nCol Do Begin
      Write('matrix[', i, ',', j,'] = ');
      ReadLn(mx.matrix^[i]^[j]);
    End
  End;
  WriteLn
End;


Procedure mxPrint(mx: TMatrix);
Var
  i, j: Integer;
Begin
  For i := 1 To mx.nRow Do Begin
    For j := 1 To mx.nCol Do
      Write(mx.matrix^[i]^[j]:6:2);
    WriteLn
  End;
  WriteLn
End;


(* determinant calculations *)
Function matrixDet(mx: TMatrix): Double;
Const
  Eps = 1.0E-10;
Var
  i, j, k: Integer;
  T: Double;
Begin
  matrixDet := 0.0;
  If mx.nRow <> mx.nCol Then Exit;

  For i := 1 To Pred(mx.nRow) Do Begin
    matrixDet := 0.0;
    If Abs(mx.matrix^[i]^[i]) < Eps Then Exit;

    For j := Succ(i) To mx.nRow Do Begin
      T := mx.matrix^[j]^[i] / mx.matrix^[i]^[i];
      For k := i To mx.nRow Do
        mx.matrix^[j]^[k] := mx.matrix^[j]^[k] -
          T * mx.matrix^[i]^[k]
    End
  End;

  T := 1.0;
  For i := 1 To mx.nRow Do
    T := T * mx.matrix^[i]^[i];
  matrixDet := T
End;

(* matrix scaling *)
Function matrixScale(Var T: TMatrix;
         mx: TMatrix; f: Double): Boolean;
Var
  i, j: Integer;
Begin
  mxCreate(T, mx.nRow, mx.nCol);

  For i := 1 To mx.nRow Do
    For j := 1 To mx.nCol Do
      T.matrix^[i]^[j] := mx.matrix^[i]^[j] * f;
  matrixScale := True
End;


Function matrixTranspose(Var T: TMatrix;
         mx: TMatrix): Boolean;
Var
  i, j: Integer;
Begin
  mxCreate(T, mx.nCol, mx.nRow);

  For i := 1 To mx.nRow Do
    For j := 1 To mx.nCol Do
      T.matrix^[j]^[i] := mx.matrix^[i]^[j];

  matrixTranspose := True
End;


(* Square matrix inversion *)
Function matrixInvert(Var T: TMatrix;
         mx: TMatrix): Boolean;
Var
  mxNew, mmNew: TMatrix;
  i, j, ii, jj, iPos, jPos: Integer;
Begin
  matrixInvert := False;
  If mx.nRow <> mx.nCol Then Exit;

  mxCreate(mxNew, mx.nRow, mx.nCol);
  For i := 1 To mx.nRow Do
    For j := 1 To mx.nCol Do Begin
      mxCreate(mmNew, mx.nRow - 1, mx.nCol - 1);
      iPos := 1;
      For ii := 1 To mx.nRow Do
        If ii <> i Then Begin
          jPos := 1;
          For jj := 1 To mx.nCol Do
            If jj <> j Then Begin
              mmNew.matrix^[iPos]^[jPos] := mx.matrix^[ii]^[jj];
              Inc(jPos)
            End;
          Inc(iPos)
        End;
      mxNew.matrix^[i]^[j] :=
        (1 - (2*(Byte(Odd(i + j))))) * matrixDet(mmNew);
      mxDispose(mmNew)
    End;

  matrixTranspose(mmNew, mxNew);
  matrixScale(T, mmNew, 1 / matrixDet(mx));
  mxDispose(mmNew);
  mxDispose(mxNew)
End;

var
  a, Inv: TMatrix;
  size: byte;

begin
  write('Enter the matrix size: '); readln(size);
  mxCreate(A, size, size);
  mxInput(A); mxPrint(A);

  matrixInvert(Inv, A);
  mxPrint(Inv);

  mxDispose(Inv);
  mxDispose(A)
end.