function log10( x ) {
	var valHi;
	var valLo;
	var hfsq;
	var hi;
	var lo;
	var hx;
	var lx;
	var y2;
	var f;
	var R;
	var w;
	var y;
	var i;
	var k;

	if ( isnan( x ) || x < 0.0 ) {
		return NaN;
	}
	toWords.assign( x, WORDS, 1, 0 );
	hx = WORDS[ 0 ] | 0; // asm type annotation
	lx = WORDS[ 1 ];
	k = 0|0; // asm type annotation

	if ( hx < HIGH_MIN_NORMAL_EXP ) {
		// Case: x < 2**-1022
		if ( ( ( hx & ABS_MASK ) | lx ) === 0 ) {
			return NINF;
		}
		k -= 54|0; // asm type annotation

		// Subnormal number, scale up x:
		x *= TWO54;
		hx = getHighWord( x ) | 0; // asm type annotation
	}
	if ( hx >= HIGH_MAX_NORMAL_EXP ) {
		return x + x;
	}
	// Case: log(1) = +0
	if ( hx === HIGH_BIASED_EXP_0 && lx === 0 ) {
		return 0.0;
	}
	k += ( ( hx >> 20 ) - BIAS )|0; // asm type annotation
	hx &= HIGH_SIGNIFICAND_MASK;
	i = ( ( hx + 0x95f64 ) & HIGH_MIN_NORMAL_EXP )|0; // asm type annotation

	// Normalize `x` or `x/2`...
	x = setHighWord( x, hx | ( i ^ HIGH_BIASED_EXP_0 ) );
	k += ( i >> 20 )|0; // asm type annotation
	y = k;
	f = x - 1.0;
	hfsq = 0.5 * f * f;
	R = kernelLog1p( f );

	/*
	* Notes:
	*
	* -   `f-hfsq` must (for args near `1`) be evaluated in extra precision to avoid a large cancellation when `x` is near `sqrt(2)` or `1/sqrt(2)`. This is fairly efficient since `f-hfsq` only depends on `f`, so can be evaluated in parallel with `R`. Not combining `hfsq` with `R` also keeps `R` small (though not as small as a true `lo` term would be), so that extra precision is not needed for terms involving `R`.
	* -   When implemented in C, compiler bugs involving extra precision used to break Dekker's theorem for spitting `f-hfsq` as `hi+lo`. These problems are now automatically avoided as a side effect of the optimization of combining the Dekker splitting step with the clear-low-bits step.
	* -   This implementation uses Dekker's theorem to normalize `y+val_hi`, so, when implemented in C, compiler bugs may reappear in some configurations.
	* -   The multi-precision calculations for the multiplications are routine.
	*/
	hi = f - hfsq;
	hi = setLowWord( hi, 0 );
	lo = ( f - hi ) - hfsq + R;
	valHi = hi * IVLN10HI;
	y2 = y * LOG10_2HI;
	valLo = ( y * LOG10_2LO ) + ( ( lo + hi ) * IVLN10LO ) + ( lo * IVLN10HI );

	/*
	* Note:
	*
	* -   Extra precision for adding `y*log10_2hi` is not strictly needed since there is no very large cancellation near `x = sqrt(2)` or `x = 1/sqrt(2)`, but we do it anyway since it costs little on CPUs with some parallelism and it reduces the error for many args.
	*/
	w = y2 + valHi;
	valLo += ( y2 - w ) + valHi;
	valHi = w;

	return valLo + valHi;
}
Evaluates the common logarithm (base ten).

@param {NonNegativeNumber} x - input value
@returns {number} function value

@example
var v = log10( 4.0 );
// returns ~0.602

@example
var v = log10( 8.0 );
// returns ~0.903

@example
var v = log10( 0.0 );
// returns -Infinity

@example
var v = log10( Infinity );
// returns Infinity

@example
var v = log10( NaN );
// returns NaN

@example
var v = log10( -4.0 );
// returns NaN