function blocked( 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 oa1;
	var ob0;
	var oc0;
	var oc1;
	var S0;
	var S1;
	var s0;
	var s1;
	var sk;
	var i0;
	var i1;
	var j0;
	var j1;
	var ia;
	var ib;
	var ic;
	var oa;
	var ob;
	var k;

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

	S0 = N;
	S1 = M;

	// Define increments for the innermost loop:
	da0 = strideA2;
	db0 = strideB1;
	dc0 = strideC2;

	// Iterate over blocks...
	for ( j1 = S1; j1 > 0; ) {
		if ( j1 < bsize ) {
			s1 = j1;
			j1 = 0;
		} else {
			s1 = bsize;
			j1 -= bsize;
		}
		oa1 = offsetA + ( j1*strideA1 );
		oc1 = offsetC + ( j1*strideC1 );
		for ( j0 = S0; j0 > 0; ) {
			if ( j0 < bsize ) {
				s0 = j0;
				j0 = 0;
			} else {
				s0 = bsize;
				j0 -= bsize;
			}
			ob0 = offsetB + ( j0*strideB2 );
			oc0 = oc1 + ( j0*strideC2 );      // index offset for `C` for the current block
			dc1 = strideC1 - ( s0*strideC2 ); // loop offset increment for `C`
			for ( k = K; k > 0; ) {
				if ( k < bsize ) {
					sk = k;
					k = 0;
				} else {
					sk = bsize;
					k -= bsize;
				}
				oa = oa1 + ( k*strideA2 );
				ob = ob0 + ( k*strideB1 );
				ic = oc0;
				for ( i1 = 0; i1 < s1; i1++ ) {
					ia = oa + ( i1*strideA1 );
					for ( i0 = 0; i0 < s0; i0++ ) {
						ib = ob + ( i0*strideB2 );
						C[ ic ] += alpha * ddot( sk, A, da0, ia, B, db0, ib );
						ic += dc0;
					}
					ic += dc1;
				}
			}
		}
	}
	return C;
}
Performs matrix multiplication using loop tiling.

@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 {Float64Array} 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 {Float64Array} 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 {Float64Array} 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 {Float64Array} `C`

@example
var Float64Array = require( '@stdlib/array/float64' );

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

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