//D contains 12 determinants of 2x2 submatrices of A chosen by convenience
    //C contains the (+/-)determinants of 3x3 submatrices created by elimination of given row and column from A
    static void Cofactor(float* C, const float* A)
    {
        float D[12] = {
            /* 0*/  A[ 0]*A[ 5] - A[ 4]*A[ 1],
            /* 1*/  A[ 0]*A[ 6] - A[ 4]*A[ 2],
            /* 2*/  A[ 0]*A[ 7] - A[ 4]*A[ 3],
            /* 3*/  A[ 1]*A[ 6] - A[ 5]*A[ 2],
            /* 4*/  A[ 1]*A[ 7] - A[ 5]*A[ 3],
            /* 5*/  A[ 2]*A[ 7] - A[ 6]*A[ 3],
            /* 6*/  A[ 8]*A[13] - A[12]*A[ 9],
            /* 7*/  A[ 8]*A[14] - A[12]*A[10],
            /* 8*/  A[ 8]*A[15] - A[12]*A[11],
            /* 9*/  A[ 9]*A[14] - A[13]*A[10],
            /*10*/  A[ 9]*A[15] - A[13]*A[11],
            /*11*/  A[10]*A[15] - A[14]*A[11]
        };

        C[ 0] = + A[ 5]*D[11] - A[ 6]*D[10] + A[ 7]*D[ 9];
        C[ 1] = - A[ 4]*D[11] + A[ 6]*D[ 8] - A[ 7]*D[ 7];
        C[ 2] = + A[ 4]*D[10] - A[ 5]*D[ 8] + A[ 7]*D[ 6];
        C[ 3] = - A[ 4]*D[ 9] + A[ 5]*D[ 7] - A[ 6]*D[ 6];
        C[ 4] = - A[ 1]*D[11] + A[ 2]*D[10] - A[ 3]*D[ 9];
        C[ 5] = + A[ 0]*D[11] - A[ 2]*D[ 8] + A[ 3]*D[ 7];
        C[ 6] = - A[ 0]*D[10] + A[ 1]*D[ 8] - A[ 3]*D[ 6];
        C[ 7] = + A[ 0]*D[ 9] - A[ 1]*D[ 7] + A[ 2]*D[ 6];
        C[ 8] = + A[13]*D[ 5] - A[14]*D[ 4] + A[15]*D[ 3];
        C[ 9] = - A[12]*D[ 5] + A[14]*D[ 2] - A[15]*D[ 1];
        C[10] = + A[12]*D[ 4] - A[13]*D[ 2] + A[15]*D[ 0];
        C[11] = - A[12]*D[ 3] + A[13]*D[ 1] - A[14]*D[ 0];
        C[12] = - A[ 9]*D[ 5] + A[10]*D[ 4] - A[11]*D[ 3];
        C[13] = + A[ 8]*D[ 5] - A[10]*D[ 2] + A[11]*D[ 1];
        C[14] = - A[ 8]*D[ 4] + A[ 9]*D[ 2] - A[11]*D[ 0];
        C[15] = + A[ 8]*D[ 3] - A[ 9]*D[ 1] + A[10]*D[ 0];
    }

    // Invert(A, A) is alright
    static bool Invert(float* R, const float* A)
    {
        float C[16];
        float D;

        Cofactor(C, A);

        D = A[0]*C[0] + A[1]*C[1] + A[2]*C[2] + A[3]*C[3];

        if(D != 0.0f)
        {
            Transpose(R, C);                // Copies the adjacent matrix of A to R
            MultScalar(R, 1.0f / D);        // Divides R by the det(A)

            return true;
        }

        return false;
    }