function resolveCallback( table, t1, t2, t3 ) {
	// The following branches attempt to follow type promotion rules; however, some accommodations are made for completeness...

	// Signature: ??_z
	if ( t3 === C128 ) {
		// c?_z
		if ( t1 === C64 ) {
			// cz_z or cc_z
			if ( t2 === C128 || t2 === C64 ) {
				return table[ C128 ]; // Signature: cz_z_as_zz_z or cc_z_as_zz_z
			}
			// cd_z
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: cd_z_as_zz_z
		}
		// z?_z
		if ( t1 === C128 ) {
			// zz_z or zc_z
			if ( t2 === C128 || t2 === C64 ) {
				return table[ C128 ]; // Signature: zz_z or zc_z_as_zz_z
			}
			// zd_z
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_z_as_zz_z
		}
		// dc_z, dz_z, or dd_z
		return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: dc_z_as_zz_z, dz_z_as_zz_z, or dd_z_as_zz_z
	}
	// Signature: ??_c
	if ( t3 === C64 ) {
		// z?_c
		if ( t1 === C128 ) {
			// zc_c or zz_c (note: according to type promotion rules `zz_c` should not happen, as `z` does not promote to `c`, but we accommodate here anyway)
			if ( t2 === C64 || t2 === C128 ) {
				return table[ C128 ]; // Signature: zc_c_as_zz_z or zz_c_as_zz_z
			}
			// zd_c (note: according to type promotion rules `zd_c` should not happen, as neither `z` nor `d` promote to `c`, but we accommodate here anyway)
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_c_as_zz_z
		}
		// c?_c
		if ( t1 === C64 ) {
			// cz_c (note: according to type promotion rules `cz_c` should not happen, as `z` does not promote to `c`, but we accommodate here anyway)
			if ( t2 === C128 ) {
				return table[ C128 ]; // Signature: cz_c_as_zz_z
			}
			// cc_c
			if ( t2 === C64 ) {
				return table[ C64 ]; // Signature: cc_c
			}
			// cd_c (note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `cd_c` should not happen, as `d` does not promote to `c`, but `cf_c` can happen)
			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: cd_c_as_cc_c (cf_c_as_cc_c)
		}
		// dz_c
		if ( t2 === C128 ) {
			// Note: according to type promotion rules `dz_c` should not happen, as neither `z` nor `d` promote to `c`, but we accommodate here anyway
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_c_as_zz_z
		}
		// dc_c
		if ( t2 === C64 ) {
			// Note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `dc_c` should not happen, as `d` does not promote to `c`, but `fc_c` can happen
			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dc_c_as_cc_c (fc_c_as_cc_c)
		}
		// dd_c (note: in JavaScript, real values are double-precision, but we downcast `d` to `c`, as, according to type promotion rules `dd_c` should not happen, as `d` does not promote to `c`, but `ff_c` can happen)
		return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dd_c_as_cc_c (ff_c_as_cc_c)
	}
	// Signature: ??_o
	if ( t3 === 'generic' ) {
		// z?_o
		if ( t1 === C128 ) {
			// zz_o or zc_o
			if ( t2 === C128 || t2 === C64 ) {
				return table[ C128 ]; // Signature: zz_o_as_zz_z or zc_o_as_zz_z
			}
			// zd_o
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: zd_o_as_zz_z
		}
		// c?_o
		if ( t1 === C64 ) {
			// cc_o
			if ( t2 === C64 ) {
				return table[ C64 ]; // Signature: cc_o_as_cc_c
			}
			// cz_o
			if ( t2 === C128 ) {
				return table[ C128 ]; // Signature: cz_o_as_zz_z
			}
			// cd_o
			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: cd_o_as_cc_c
		}
		// dz_o
		if ( t2 === C128 ) {
			return wrap( table[ C128 ], 2, CTORS[ C128 ] ); // Signature: dz_o_as_zz_z
		}
		// dc_o
		if ( t2 === C64 ) {
			return wrap( table[ C64 ], 2, CTORS[ C64 ] ); // Signature: dc_o_as_cc_c
		}
		// dd_o
		return table.default;
	}
	return table.default;
}
Resolves a callback based on provided dtypes.

@private
@param {Object} table - callback table
@param {Function} table.default - default callback
@param {Function} table.complex64 - callback for single-precision complex floating-point numbers
@param {Function} table.complex128 - callback for double-precision complex floating-point numbers
@param {string} t1 - dtype for first argument
@param {string} t2 - dtype for second argument
@param {string} t3 - dtype for return value
@returns {Function} callback