function naive( M, N, K, alpha, A, strideA1, strideA2, offsetA, B, strideB1, strideB2, offsetB, C, strideC1, strideC2, offsetC ) {
	var da0;
	var db0;
	var dc0;
	var dc1;
	var S0;
	var S1;
	var i0;
	var i1;
	var ia;
	var ib;
	var ic;

	// Note on variable naming convention: S#, da#, db#, dc#, i# where # corresponds to the loop number, with `0` being the innermost loop...

	S0 = N;
	S1 = M;
	da0 = strideA2;
	db0 = strideB1;
	dc0 = strideC2;                   // offset increment for innermost loop
	dc1 = strideC1 - ( S0*strideC2 ); // offset increment for outermost loop

	ic = offsetC;
	for ( i1 = 0; i1 < S1; i1++ ) {
		ia = offsetA + ( i1*strideA1 );
		for ( i0 = 0; i0 < S0; i0++ ) {
			ib = offsetB + ( i0*strideB2 );
			C[ ic ] += f32( alpha * sdot( K, A, da0, ia, B, db0, ib ) );
			ic += dc0;
		}
		ic += dc1;
	}
	return C;
}
Performs matrix multiplication using a naive algorithm which is cache-optimal when `A` is row-major and `B` is column-major.

@private
@param {NonNegativeInteger} M - number of rows in the matrix `op(A)` and in the matrix `C`
@param {NonNegativeInteger} N - number of columns in the matrix `op(B)` and in the matrix `C`
@param {NonNegativeInteger} K - number of columns in the matrix `op(A)` and number of rows in the matrix `op(B)`
@param {number} alpha - scalar constant
@param {Float32Array} A - first matrix
@param {integer} strideA1 - stride of the first dimension of `A`
@param {integer} strideA2 - stride of the second dimension of `A`
@param {NonNegativeInteger} offsetA - starting index for `A`
@param {Float32Array} B - second matrix
@param {integer} strideB1 - stride of the first dimension of `B`
@param {integer} strideB2 - stride of the second dimension of `B`
@param {NonNegativeInteger} offsetB - starting index for `B`
@param {Float32Array} C - third matrix
@param {integer} strideC1 - stride of the first dimension of `C`
@param {integer} strideC2 - stride of the second dimension of `C`
@param {NonNegativeInteger} offsetC - starting index for `C`
@returns {Float32Array} `C`

@example
var Float32Array = require( '@stdlib/array/float32' );

var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );
var B = new Float32Array( [ 1.0, 1.0, 0.0, 1.0 ] );
var C = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] );

naive( 2, 2, 2, 1.0, A, 2, 1, 0, B, 2, 1, 0, C, 2, 1, 0 );
// C => <Float32Array>[ 2.0, 5.0, 6.0, 11.0 ]