//
// Template class for square NxN matrices with elements of type T.
// This is just for demonstration purposes.  
//
template<class T, int N> class GenericMatrix {
private:
    T data[N][N];
public:
    T& operator()( int i, int j ) {return data[i][j];}
    const T& operator()( int i, int j ) const {return data[i][j];}
    
    // GenericMatrix addition - except for very small N, the execution time
    // will dominate the overhead for calling it and thus declaring
    // it inline is probably counterproductive.
    friend GenericMatrix operator+( const GenericMatrix& A, const GenericMatrix& B ) {
	GenericMatrix result;
	for( int i=0; i<N; i++ )
	    for( int j=0; j<N; j++ )
		result(i,j) = A(i,j)+B(i,j);
	return result;
    }

    // GenericMatrix multiplication - except for very small N, the execution time
    // will dominate the overhead for calling it and thus declaring
    // it inline is probably counterproductive.
    friend GenericMatrix operator*( const GenericMatrix& A, const GenericMatrix& B ) {
	GenericMatrix result;
	for( int i=0; i<N; i++ )
	    for( int j=0; j<N; j++ )
		result(i,j) = 0;
	for( int i=0; i<N; i++ )
	    for( int k=0; k<N; k++ ) {
		T temp = A(i,k);
	        for( int j=0; j<N; j++ )
		    result(i,j) += temp * B(k,j);
	    }	
	return result;
    }

};

typedef GenericMatrix<double,100> Matrix;

Matrix Calculation( 
    const Matrix& a, 
    const Matrix& b, 
    const Matrix& c, 
    const Matrix& d, 
    const Matrix& e 
) {
    // At optimization level +K1 and higher, without 
    // --inline_keyword_space_time=8, KCC will relentlessly 
    // inline all the calls to operator* and operator+ below.
    return a*b + c*d + e;
}

main() {
    // Dummy main provided so that example compiles.
}