DOOM-3-BFG

Snapshot.cpp (40758B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 #pragma hdrstop
 #include "../idlib/precompiled.h"
 
 idCVar net_verboseSnapshot( "net_verboseSnapshot", "0", CVAR_INTEGER|CVAR_NOCHEAT, "Verbose snapshot code to help debug snapshot problems. Greater the number greater the spam" );
 idCVar net_verboseSnapshotCompression( "net_verboseSnapshotCompression", "0", CVAR_INTEGER|CVAR_NOCHEAT, "Verbose snapshot code to help debug snapshot problems. Greater the number greater the spam" );
 idCVar net_verboseSnapshotReport( "net_verboseSnapshotReport", "0", CVAR_INTEGER|CVAR_NOCHEAT, "Verbose snapshot code to help debug snapshot problems. Greater the number greater the spam" );
 
 idCVar net_ssTemplateDebug( "net_ssTemplateDebug", "0", CVAR_BOOL, "Debug snapshot template states" );
 idCVar net_ssTemplateDebug_len( "net_ssTemplateDebug_len", "32", CVAR_INTEGER, "Offset to start template state debugging" );
 idCVar net_ssTemplateDebug_start( "net_ssTemplateDebug_start", "0", CVAR_INTEGER, "length of template state to print in debugging" );
 
 /*
 ========================
 InDebugRange
 Helper function for net_ssTemplateDebug debugging
 ========================
 */
 bool InDebugRange( int i ) {
 	return ( i >= net_ssTemplateDebug_start.GetInteger() && i < net_ssTemplateDebug_start.GetInteger() + net_ssTemplateDebug_len.GetInteger() );
 }
 /*
 ========================
 PrintAlign
 Helper function for net_ssTemplateDebug debugging
 ========================
 */
 void PrintAlign( const char * text ) {
 	idLib::Printf( "%25s: 0x", text );
 }
 
 /*
 ========================
 idSnapShot::objectState_t::Print
 Helper function for net_ssTemplateDebug debugging
 ========================
 */
 void idSnapShot::objectState_t::Print( const char * name ) {
 
 	unsigned int start = (unsigned int)net_ssTemplateDebug_start.GetInteger();
 	unsigned int end = Min( (unsigned int)buffer.Size(), start + net_ssTemplateDebug_len.GetInteger() );
 
 	PrintAlign( va( "%s: [sz %d]", name, buffer.Size() ) );
 
 	for ( unsigned int i = start; i < end; i++ ) {
 		idLib::Printf( "%02X", buffer[i] );
 	}
 	idLib::Printf("\n");
 }
 
 /*
 ========================
 idSnapShot::objectBuffer_t::Alloc
 ========================
 */
 void idSnapShot::objectBuffer_t::Alloc( int s ) {
 	//assert( mem.IsMapHeap() );
 	if ( !verify( s < SIZE_NOT_STALE ) ) {
 		idLib::FatalError( "s >= SIZE_NOT_STALE" );
 	}
 	_Release();
 	data = (byte *)Mem_Alloc( s + 1, TAG_NETWORKING );
 	size = s;
 	data[size] = 1;
 }
 
 /*
 ========================
 idSnapShot::objectBuffer_t::AddRef
 ========================
 */
 void idSnapShot::objectBuffer_t::_AddRef() {
 	if ( data != NULL ) {
 		assert( size > 0 );
 		assert( data[size] < 255 );
 		data[size]++;
 	}
 }
 
 /*
 ========================
 idSnapShot::objectBuffer_t::Release
 ========================
 */
 void idSnapShot::objectBuffer_t::_Release() {
 	//assert( mem.IsMapHeap() );
 	if ( data != NULL ) {
 		assert( size > 0 );
 		if ( --data[size] == 0 ) {
 			Mem_Free( data );
 		}
 		data = NULL;
 		size = 0;
 	}
 }
 
 /*
 ========================
 idSnapShot::objectBuffer_t::operator=
 ========================
 */
 void idSnapShot::objectBuffer_t::operator=( const idSnapShot::objectBuffer_t & other ) {
 	//assert( mem.IsMapHeap() );
 	if ( this != &other ) {
 		_Release();
 		data = other.data;
 		size = other.size;
 		_AddRef();
 	}
 }
 
 /*
 ========================
 idSnapShot::idSnapShot
 ========================
 */
 idSnapShot::idSnapShot() :
 	time( 0 ),
 	recvTime( 0 )
 {
 }
 
 /*
 ========================
 idSnapShot::idSnapShot
 ========================
 */
 idSnapShot::idSnapShot( const idSnapShot & other ) : time( 0 ), recvTime(0) {
 	*this = other;
 }
 
 /*
 ========================
 idSnapShot::~idSnapShot
 ========================
 */
 idSnapShot::~idSnapShot() {
 	Clear();
 }
 
 /*
 ========================
 idSnapShot::Clear
 ========================
 */
 void idSnapShot::Clear() {
 	time = 0;
 	recvTime = 0;
 	for ( int i = 0; i < objectStates.Num(); i++ ) {
 		FreeObjectState( i );
 	}
 	objectStates.Clear();
 	allocatedObjs.Shutdown();
 }
 
 /*
 ========================
 idSnapShot::operator=
 ========================
 */
 void idSnapShot::operator=( const idSnapShot & other ) {
 	//assert( mem.IsMapHeap() );
 
 	if ( this != &other ) {
 		for ( int i = other.objectStates.Num(); i < objectStates.Num(); i++ ) {
 			FreeObjectState( i );
 		}
 		objectStates.AssureSize( other.objectStates.Num(), NULL );
 		for ( int i = 0; i < objectStates.Num(); i++ ) {
 			const objectState_t & otherState = *other.objectStates[i];
 			if ( objectStates[i] == NULL ) {
 				objectStates[i] = allocatedObjs.Alloc();
 			}
 			objectState_t & state = *objectStates[i];
 			state.objectNum		= otherState.objectNum;
 			state.buffer		= otherState.buffer;
 			state.visMask		= otherState.visMask;
 			state.stale			= otherState.stale;
 			state.deleted		= otherState.deleted;
 			state.changedCount	= otherState.changedCount;
 			state.expectedSequence = otherState.expectedSequence;
 			state.createdFromTemplate = otherState.createdFromTemplate;
 		}
 		time = other.time;
 		recvTime = other.recvTime;
 	}
 }
 
 /*
 ========================
 idSnapShot::PeekDeltaSequence
 ========================
 */
 void idSnapShot::PeekDeltaSequence( const char * deltaMem, int deltaSize, int & sequence, int & baseSequence ) {
 	lzwCompressionData_t	lzwData;
 	idLZWCompressor			lzwCompressor( &lzwData );
 	
 	lzwCompressor.Start( (uint8*)deltaMem, deltaSize );	
 	lzwCompressor.ReadAgnostic( sequence );
 	lzwCompressor.ReadAgnostic( baseSequence );
 }
 
 /*
 ========================
 idSnapShot::ReadDeltaForJob
 ========================
 */
 bool idSnapShot::ReadDeltaForJob( const char * deltaMem, int deltaSize, int visIndex, idSnapShot * templateStates ) {
 
 	bool report = net_verboseSnapshotReport.GetBool();
 	net_verboseSnapshotReport.SetBool( false );
 
 	lzwCompressionData_t		lzwData;
 	idZeroRunLengthCompressor	rleCompressor;
 	idLZWCompressor				lzwCompressor( &lzwData );
 	int bytesRead = 0; // how many uncompressed bytes we read in. Used to figure out compression ratio
 
 	lzwCompressor.Start( (uint8*)deltaMem, deltaSize );
 
 	// Skip past sequence and baseSequence
 	int sequence		= 0;
 	int baseSequence	= 0;
 
 	lzwCompressor.ReadAgnostic( sequence );
 	lzwCompressor.ReadAgnostic( baseSequence );
 	lzwCompressor.ReadAgnostic( time );
 	bytesRead += sizeof( int ) * 3;
 
 	int objectNum = 0;
 	uint16 delta = 0;
 	
 
 	while ( lzwCompressor.ReadAgnostic( delta, true ) == sizeof( delta ) ) {
 		bytesRead += sizeof( delta );
 
 		objectNum += delta;
 		if ( objectNum >= 0xFFFF ) {
 			// full delta
 			if ( net_verboseSnapshotCompression.GetBool() ) {
 				float compRatio = static_cast<float>( deltaSize ) / static_cast<float>( bytesRead );
 				idLib::Printf( "Snapshot (%d/%d). ReadSize: %d DeltaSize: %d Ratio: %.3f\n", sequence, baseSequence, bytesRead, deltaSize, compRatio );
 			}
 			return true;
 		}
 
 		objectState_t & state = FindOrCreateObjectByID( objectNum );
 		
 		objectSize_t newsize = 0;
 		lzwCompressor.ReadAgnostic( newsize );
 		bytesRead += sizeof( newsize );
 
 		if ( newsize == SIZE_STALE ) {
 			NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d goes stale\n", objectNum );
 			// sanity
 			bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
 			if ( !oldVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected already stale\n" );
 			}
 			state.visMask &= ~( 1 << visIndex );
 			state.stale = true;
 			// We need to make sure we haven't freed stale objects.
 			assert( state.buffer.Size() > 0 );
 			// no more data
 			continue;
 		} else if ( newsize == SIZE_NOT_STALE ) {
 			NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d no longer stale\n", objectNum );
 			// sanity
 			bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
 			if ( oldVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected not stale\n" );
 			}
 			state.visMask |= ( 1 << visIndex );
 			state.stale = false;
 			// the latest state is packed in, get the new size and continue reading the new state
 			lzwCompressor.ReadAgnostic( newsize );
 			bytesRead += sizeof( newsize );
 		}
 
 		objectState_t *	objTemplateState = templateStates->FindObjectByID( objectNum );
 
 		if ( newsize == 0 ) {
 			// object deleted: reset state now so next one to use it doesn't have old data
 			state.deleted = false;
 			state.stale = false;
 			state.changedCount = 0;
 			state.expectedSequence = 0;
 			state.visMask = 0;
 			state.buffer._Release();
 			state.createdFromTemplate = false;
 
 			if ( objTemplateState != NULL && objTemplateState->buffer.Size() && objTemplateState->expectedSequence < baseSequence ) {
 				idLib::PrintfIf( net_ssTemplateDebug.GetBool(), "Clearing old template state[%d] [%d<%d]\n", objectNum, objTemplateState->expectedSequence, baseSequence );
 				objTemplateState->deleted = false;
 				objTemplateState->stale = false;
 				objTemplateState->changedCount = 0;
 				objTemplateState->expectedSequence = 0;
 				objTemplateState->visMask = 0;
 				objTemplateState->buffer._Release();
 			}
 
 		} else {
 
 			// new state?
 			bool debug = false;
 			if ( state.buffer.Size() == 0 ) {
 				state.createdFromTemplate = true;
 				// Brand new state
 				if ( objTemplateState != NULL && objTemplateState->buffer.Size() > 0 && sequence >= objTemplateState->expectedSequence ) {
 					idLib::PrintfIf( net_ssTemplateDebug.GetBool(), "\nAdding basestate for new object %d (for SS %d/%d. obj base created in ss %d) deltaSize: %d\n", objectNum, sequence, baseSequence, objTemplateState->expectedSequence, deltaSize );
 					state.buffer = objTemplateState->buffer;
 
 					if ( net_ssTemplateDebug.GetBool() ) {
 						state.Print( "SPAWN STATE" );
 						debug = true;
 						PrintAlign( "DELTA STATE" );
 					}
 				} else if ( net_ssTemplateDebug.GetBool() ) {
 					idLib::Printf("\nNew snapobject[%d] in snapshot %d/%d but no basestate found locally so creating new\n", objectNum, sequence, baseSequence );
 				}
 			} else {
 				state.createdFromTemplate = false;
 			}
 
 			// the buffer shrank or stayed the same
 			objectBuffer_t newbuffer( newsize );
 			rleCompressor.Start( NULL, &lzwCompressor, newsize );
 			objectSize_t compareSize = Min( state.buffer.Size(), newsize );
 			for ( objectSize_t i = 0; i < compareSize; i++ ) {
 				byte b = rleCompressor.ReadByte();
 				newbuffer[i] = state.buffer[i] + b;
 
 				if ( debug && InDebugRange( i ) ) {
 					idLib::Printf( "%02X", b );
 				}
 			}
 			// Catch leftover
 			if ( newsize > compareSize ) {
 				rleCompressor.ReadBytes( newbuffer.Ptr() + compareSize, newsize - compareSize );
 
 				if ( debug ) {
 					for ( objectSize_t i = compareSize; i < newsize; i++ ) {
 						if ( InDebugRange( i ) ) {
 							idLib::Printf( "%02X", newbuffer[i] );
 						}
 					}
 				}
 
 			}
 			state.buffer = newbuffer;
 			state.changedCount = sequence;
 			bytesRead += sizeof( byte ) * newsize;
 			if ( debug ) {
 				idLib::Printf( "\n" );
 				state.Print( "NEW STATE" );	
 			}
 
 			if ( report ) {
 				idLib::Printf( "    Obj %d Compressed: Size %d \n", objectNum, rleCompressor.CompressedSize() );
 			}
 		}
 #ifdef SNAPSHOT_CHECKSUMS
 		extern uint32 SnapObjChecksum( const uint8 * data, int length );
 		if ( state.buffer.Size() > 0 ) {
 			uint32 checksum = 0;
 			lzwCompressor.ReadAgnostic( checksum );
 			bytesRead += sizeof( checksum );
 			if ( !verify( checksum == SnapObjChecksum( state.buffer.Ptr(), state.buffer.Size() ) ) ) {
 				idLib::Error(" Invalid snapshot checksum" );
 			}
 		}
 #endif
 	}
 	// partial delta
 	return false;
 }
 
 /*
 ========================
 idSnapShot::SubmitObjectJob
 ========================
 */
 
 void idSnapShot::SubmitObjectJob(	const submitDeltaJobsInfo_t &	submitDeltaJobsInfo,
 									objectState_t *					newState, 
 									objectState_t *					oldState, 
 									objParms_t *&					baseObjParm, 
 									objParms_t *&					curObjParm, 
 									objHeader_t *&					curHeader,
 									uint8 *&						curObjDest,
 									lzwParm_t *&					curlzwParm 
 ) {
 	assert( newState != NULL || oldState != NULL );
 	assert_16_byte_aligned( curHeader );
 	assert_16_byte_aligned( curObjDest );
 			
 	int32 dataSize = newState != NULL ? newState->buffer.Size() : 0;
 	int totalSize = OBJ_DEST_SIZE_ALIGN16( dataSize );
 	
 	if ( curObjParm - submitDeltaJobsInfo.objParms >= submitDeltaJobsInfo.maxObjParms ) {
 		idLib::Error( "Out of parms for snapshot jobs.\n");
 	}
 	
 	// Check to see if we are out of dest write space, and need to flush the jobs
 	bool needToSubmit = ( curObjDest - submitDeltaJobsInfo.objMemory ) + totalSize >= submitDeltaJobsInfo.maxObjMemory;
 	needToSubmit |= ( curHeader - submitDeltaJobsInfo.headers >= submitDeltaJobsInfo.maxHeaders );
 	
 	if ( needToSubmit ) {
 		// If this obj will put us over the limit, then submit the jobs now, and start over re-using the same buffers
 		SubmitLZWJob( submitDeltaJobsInfo, baseObjParm, curObjParm, curlzwParm, true );
 		curHeader	= submitDeltaJobsInfo.headers;
 		curObjDest	= submitDeltaJobsInfo.objMemory;
 	}
 
 	// Setup obj parms
 	assert( submitDeltaJobsInfo.visIndex < 256 );
 	curObjParm->visIndex	= submitDeltaJobsInfo.visIndex;
 	curObjParm->destHeader	= curHeader;
 	curObjParm->dest		= curObjDest;
 
 	memset( &curObjParm->newState, 0, sizeof( curObjParm->newState ) );
 	memset( &curObjParm->oldState, 0, sizeof( curObjParm->oldState ) );
 	
 	if ( newState != NULL ) {
 		assert( newState->buffer.Size() <= 65535 );
 				
 		curObjParm->newState.valid		= 1;
 		curObjParm->newState.data		= newState->buffer.Ptr();
 		curObjParm->newState.size		= newState->buffer.Size();
 		curObjParm->newState.objectNum	= newState->objectNum;
 		curObjParm->newState.visMask	= newState->visMask;
 	}
 	
 	if ( oldState != NULL ) {
 		assert( oldState->buffer.Size() <= 65535 );
 
 		curObjParm->oldState.valid		= 1;
 		curObjParm->oldState.data		= oldState->buffer.Ptr();
 		curObjParm->oldState.size		= oldState->buffer.Size();
 		curObjParm->oldState.objectNum	= oldState->objectNum;
 		curObjParm->oldState.visMask	= oldState->visMask;
 	}
 
 	assert_16_byte_aligned( curObjParm );
 	assert_16_byte_aligned( curObjParm->newState.data );
 	assert_16_byte_aligned( curObjParm->oldState.data );
 	
 	SnapshotObjectJob( curObjParm );
 
 	// Advance past header + data
 	curObjDest += totalSize;
 
 	// Advance parm pointer
 	curObjParm++;		
 	
 	// Advance header pointer
 	curHeader++;
 }
 
 /*
 ========================
 idSnapShot::SubmitLZWJob
 Take the current list of delta'd + zlre processed objects, and write them to the lzw stream.
 ========================
 */
 void idSnapShot::SubmitLZWJob( 
 	const submitDeltaJobsInfo_t &	writeDeltaInfo, 
 	objParms_t *&					baseObjParm,		// Pointer to the first obj parm for the current stream
 	objParms_t *&					curObjParm,			// Current obj parm
 	lzwParm_t *&					curlzwParm,			// Current delta parm
 	bool							saveDictionary
 ) {
 	int numObjects = curObjParm - baseObjParm;
 	
 	if ( numObjects == 0 ) {
 		return;		// Nothing to do
 	}
 			
 	if ( curlzwParm - writeDeltaInfo.lzwParms >= writeDeltaInfo.maxDeltaParms ) {
 		idLib::Error( "SubmitLZWJob: Not enough lzwParams.\n" );
 		return;		// Can't do anymore
 	}
 
 	curlzwParm->numObjects		= numObjects;
 	curlzwParm->headers			= writeDeltaInfo.headers;		// We always start grabbing from the beggining of the memory (it's reused, with fences to protect memory sharing)
 	curlzwParm->curTime			= this->GetTime();
 	curlzwParm->baseTime		= writeDeltaInfo.oldSnap->GetTime();
 	curlzwParm->baseSequence	= writeDeltaInfo.baseSequence;
 	curlzwParm->fragmented		= ( curlzwParm != writeDeltaInfo.lzwParms );
 	curlzwParm->saveDictionary	= saveDictionary;
 	
 	curlzwParm->ioData			= writeDeltaInfo.lzwInOutData;
 
 	LZWJob( curlzwParm );
 	
 	curlzwParm++;
 	
 	// Set base so it now points to where the parms start for the new stream
 	baseObjParm = curObjParm;
 }
 
 /*
 ========================
 idSnapShot::GetTemplateState
 Helper function for getting template objectState.
 newState parameter is optional and is just used for debugging/printf comparison of the template and actual state
 ========================
 */
 idSnapShot::objectState_t * idSnapShot::GetTemplateState( int objNum, idSnapShot * templateStates, idSnapShot::objectState_t * newState /*=NULL*/ ) {
 	objectState_t * oldState = NULL;
 	int spawnedStateIndex = templateStates->FindObjectIndexByID( objNum );
 	if ( spawnedStateIndex >= 0 ) {
 		oldState = templateStates->objectStates[ spawnedStateIndex ];
 		
 		if ( net_ssTemplateDebug.GetBool() ) {
 			idLib::Printf( "\nGetTemplateState[%d]\n", objNum );
 			oldState->Print( "SPAWN STATE" );
 			if ( newState != NULL ) {
 				newState->Print( "CUR STATE" );
 			}
 		}
 	}
 	return oldState;
 }
 
 /*
 ========================
 idSnapShot::SubmitWriteDeltaToJobs
 ========================
 */
 void idSnapShot::SubmitWriteDeltaToJobs( const submitDeltaJobsInfo_t & submitDeltaJobInfo ) {
 	objParms_t *	curObjParms		= submitDeltaJobInfo.objParms;
 	objParms_t *	baseObjParms	= submitDeltaJobInfo.objParms;
 	lzwParm_t *		curlzwParms		= submitDeltaJobInfo.lzwParms;
 	objHeader_t *	curHeader		= submitDeltaJobInfo.headers;
 	uint8 *			curObjMemory	= submitDeltaJobInfo.objMemory;
 	
 	submitDeltaJobInfo.lzwInOutData->numlzwDeltas	= 0;
 	submitDeltaJobInfo.lzwInOutData->lzwBytes		= 0;
 	submitDeltaJobInfo.lzwInOutData->fullSnap		= false;
 
 	int j = 0;
 	
 	int numOldStates = submitDeltaJobInfo.oldSnap->objectStates.Num();
 	
 	for ( int i = 0; i < objectStates.Num(); i++ ) {
 		objectState_t & newState = *objectStates[i];
 		if ( !verify( newState.buffer.Size() > 0 ) ) {
 			// you CANNOT have a valid ss obj state w/ size = 0: this will be interpreted as a delete in ::ReadDelta and this will completely throw
 			// off delta compression, eventually resulting in a checksum error that is a pain to track down.
 			idLib::Warning( "Snap obj [%d] state.size <= 0... skipping ", newState.objectNum );
 			continue;
 		}
 		
 		if ( j >= numOldStates ) {
 			// We no longer have old objects to compare to.
 			// All objects are new from this point on.
 
 			objectState_t * oldState = GetTemplateState( newState.objectNum, submitDeltaJobInfo.templateStates, &newState );
 			SubmitObjectJob( submitDeltaJobInfo, &newState, oldState, baseObjParms, curObjParms, curHeader, curObjMemory, curlzwParms );
 			continue;
 		}
 
 		// write any deleted entities up to this one
 		for ( ; j < numOldStates && newState.objectNum > submitDeltaJobInfo.oldSnap->objectStates[j]->objectNum; j++ ) {
 			objectState_t & oldState = *submitDeltaJobInfo.oldSnap->objectStates[j];
 
 			if ( ( oldState.stale && !oldState.deleted ) || oldState.buffer.Size() <= 0 ) {
 				continue;		// Don't delete objects that are stale and not marked as deleted
 			}
 
 			SubmitObjectJob( submitDeltaJobInfo, NULL, &oldState, baseObjParms, curObjParms, curHeader, curObjMemory, curlzwParms );
 		}
 		
 		if ( j >= numOldStates ) {
 			continue;	// Went past end of old list deleting objects
 		}
 		
 		// Beyond this point, we may have old state to compare against
 		objectState_t & submittedOldState = *submitDeltaJobInfo.oldSnap->objectStates[j];
 		objectState_t * oldState = &submittedOldState;
 	
 		if ( newState.objectNum == oldState->objectNum ) {
 			if ( oldState->buffer.Size() == 0 ) {
 				// New state (even though snapObj existed, its size was zero)
 				oldState = GetTemplateState( newState.objectNum, submitDeltaJobInfo.templateStates, &newState );
 			}
 
 			SubmitObjectJob( submitDeltaJobInfo, &newState, oldState, baseObjParms, curObjParms, curHeader, curObjMemory, curlzwParms );
 			j++;
 		} else {
 			// Different object, this one is new, 
 			// Spawned
 			oldState = GetTemplateState( newState.objectNum, submitDeltaJobInfo.templateStates, &newState );
 			SubmitObjectJob( submitDeltaJobInfo, &newState, oldState, baseObjParms, curObjParms, curHeader, curObjMemory, curlzwParms );
 		}
 	}
 	// Finally, remove any entities at the end
 	for ( ; j < submitDeltaJobInfo.oldSnap->objectStates.Num(); j++ ) {
 		objectState_t & oldState = *submitDeltaJobInfo.oldSnap->objectStates[j];
 
 		if ( ( oldState.stale && !oldState.deleted ) || oldState.buffer.Size() <= 0 ) {
 			continue;		// Don't delete objects that are stale and not marked as deleted
 		}
 
 		SubmitObjectJob( submitDeltaJobInfo, NULL, &oldState, baseObjParms, curObjParms, curHeader, curObjMemory, curlzwParms );
 	}
 				
 	// Submit any objects that are left over (will be all if they all fit up to this point)
 	SubmitLZWJob( submitDeltaJobInfo, baseObjParms, curObjParms, curlzwParms, false );
 }
 
 /*
 ========================
 idSnapShot::ReadDelta
 ========================
 */
 bool idSnapShot::ReadDelta( idFile * file, int visIndex ) {
 
 	file->ReadBig( time );
 
 	int objectNum = 0;
 	uint16 delta = 0;
 	while ( file->ReadBig( delta ) == sizeof( delta ) ) {	
 		objectNum += delta;
 		if ( objectNum >= 0xFFFF ) {
 			// full delta
 			return true;
 		}
 		objectState_t & state = FindOrCreateObjectByID( objectNum );
 		objectSize_t newsize = 0;
 		file->ReadBig( newsize );
 
 		if ( newsize == SIZE_STALE ) {
 			NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d goes stale\n", objectNum );
 			// sanity
 			bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
 			if ( !oldVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected already stale\n" );
 			}
 			state.visMask &= ~( 1 << visIndex );
 			state.stale = true;
 			// We need to make sure we haven't freed stale objects.
 			assert( state.buffer.Size() > 0 );
 			// no more data
 			continue;
 		} else if ( newsize == SIZE_NOT_STALE ) {
 			NET_VERBOSESNAPSHOT_PRINT( "read delta: object %d no longer stale\n", objectNum );
 			// sanity
 			bool oldVisible = ( state.visMask & ( 1 << visIndex ) ) != 0;
 			if ( oldVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "ERROR: unexpected not stale\n" );
 			}
 			state.visMask |= ( 1 << visIndex );
 			state.stale = false;
 			// the latest state is packed in, get the new size and continue reading the new state
 			file->ReadBig( newsize );
 		}
 		
 		if ( newsize == 0 ) {
 			// object deleted
 			state.buffer._Release();
 		} else {						
 			objectBuffer_t newbuffer( newsize );
 			objectSize_t compareSize = Min( newsize, state.buffer.Size() );
 
 			for ( objectSize_t i = 0; i < compareSize; i++ ) {
 				uint8 delta = 0;
 				file->ReadBig<byte>( delta );
 				newbuffer[i] = state.buffer[i] + delta;
 			}
 			
 			if ( newsize > compareSize ) {
 				file->Read( newbuffer.Ptr() + compareSize, newsize - compareSize );	
 			}
 			
 			state.buffer = newbuffer;			
 			state.changedCount++;
 		}
 		
 #ifdef SNAPSHOT_CHECKSUMS
 		if ( state.buffer.Size() > 0 ) {
 			unsigned int checksum = 0;
 			file->ReadBig( checksum );
 			assert( checksum == MD5_BlockChecksum( state.buffer.Ptr(), state.buffer.Size() ) );
 		}
 #endif		
 	}
 		
 	// partial delta
 	return false;
 }
 
 /*
 ========================
 idSnapShot::WriteObject
 ========================
 */
 void idSnapShot::WriteObject( idFile * file, int visIndex, objectState_t * newState, objectState_t * oldState, int & lastobjectNum ) {
 	assert( newState != NULL || oldState != NULL );
 		
 	bool visChange		= false; // visibility changes will be signified with a 0xffff state size
 	bool visSendState	= false; // the state is sent when an entity is no longer stale
 
 	// Compute visibility changes 
 	// (we need to do this before writing out object id, because we may not need to write out the id if we early out)
 	// (when we don't write out the id, we assume this is an "ack" when we deserialize the objects)
 	if ( newState != NULL && oldState != NULL ) {
 		// Check visibility
 		assert( newState->objectNum == oldState->objectNum );
 		
 		if ( visIndex > 0 ) {
 			bool oldVisible = ( oldState->visMask & ( 1 << visIndex ) ) != 0;
 			bool newVisible = ( newState->visMask & ( 1 << visIndex ) ) != 0;
 			
 			// Force visible if we need to either create or destroy this object
 			newVisible |= ( newState->buffer.Size() == 0 ) != ( oldState->buffer.Size() == 0 );	
 			
 			if ( !oldVisible && !newVisible ) {
 				// object is stale and ack'ed for this client, write nothing (see 'same object' below)					
 				return;
 			} else if ( oldVisible && !newVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "object %d to client %d goes stale\n", newState->objectNum, visIndex );
 				visChange = true;
 				visSendState = false;
 			} else if ( !oldVisible && newVisible ) {
 				NET_VERBOSESNAPSHOT_PRINT( "object %d to client %d no longer stale\n", newState->objectNum, visIndex );
 				visChange = true;
 				visSendState = true;
 			}				
 		}
 		
 		// Same object, write a delta (never early out during vis changes)
 		if ( !visChange && newState->buffer.Size() == oldState->buffer.Size() &&
 			( ( newState->buffer.Ptr() == oldState->buffer.Ptr() ) || memcmp( newState->buffer.Ptr(), oldState->buffer.Ptr(), newState->buffer.Size() ) == 0 ) ) {
 			// same state, write nothing
 			return;
 		}
 	}
 		
 	// Get the id of the object we are writing out
 	uint16 objectNum;
 	if ( newState != NULL ) {
 		objectNum = newState->objectNum;
 	} else if ( oldState != NULL ) {
 		objectNum = oldState->objectNum;
 	} else {
 		objectNum = 0;
 	}
 	
 	assert( objectNum == 0 || objectNum > lastobjectNum );
 		
 	// Write out object id (using delta)
 	uint16 objectDelta = objectNum - lastobjectNum;
 	file->WriteBig( objectDelta );
 	lastobjectNum = objectNum;
 
 	if ( newState == NULL ) {
 		// Deleted, write 0 size
 		assert( oldState != NULL );
 		file->WriteBig<objectSize_t>( 0 );
 	} else if ( oldState == NULL ) {
 		// New object, write out full state
 		assert( newState != NULL );
 		// delta against an empty snap
 		file->WriteBig( newState->buffer.Size() );
 		file->Write( newState->buffer.Ptr(), newState->buffer.Size() );
 	} else {
 		// Compare to last object
 		assert( newState != NULL && oldState != NULL );
 		assert( newState->objectNum == oldState->objectNum );
 		
 		if ( visChange ) {
 			// fake size indicates vis state change
 			// NOTE: we may still send a real size and a state below, for 'no longer stale' transitions
 			// TMP: send 0xFFFF for going stale and 0xFFFF - 1 for no longer stale
 			file->WriteBig<objectSize_t>( visSendState ? SIZE_NOT_STALE : SIZE_STALE );
 		}
 		if ( !visChange || visSendState ) {
 			
 			objectSize_t compareSize = Min( newState->buffer.Size(), oldState->buffer.Size() );		// Get the number of bytes that overlap
 			
 			file->WriteBig( newState->buffer.Size() );										// Write new size
 			
 			// Compare bytes that overlap
 			for ( objectSize_t b = 0; b < compareSize; b++ ) {
 				file->WriteBig<byte>( ( 0xFF + 1 + newState->buffer[b] - oldState->buffer[b] ) & 0xFF );
 			}
 			
 			// Write leftover
 			if ( newState->buffer.Size() > compareSize ) {
 				file->Write( newState->buffer.Ptr() + oldState->buffer.Size(), newState->buffer.Size() - compareSize );
 			}
 		}
 	}
 
 #ifdef SNAPSHOT_CHECKSUMS
 	if ( ( !visChange || visSendState ) && newState != NULL ) {
 		assert( newState->buffer.Size() > 0 );
 		unsigned int checksum = MD5_BlockChecksum( newState->buffer.Ptr(), newState->buffer.Size() );
 		file->WriteBig( checksum );
 	}
 #endif
 }
 
 /*
 ========================
 idSnapShot::PrintReport
 ========================
 */
 void idSnapShot::PrintReport() {
 }
 
 /*
 ========================
 idSnapShot::WriteDelta
 ========================
 */
 bool idSnapShot::WriteDelta( idSnapShot & old, int visIndex, idFile * file, int maxLength, int optimalLength ) {
 	file->WriteBig( time );
 
 	int objectHeaderSize = sizeof( uint16 ) + sizeof( objectSize_t );
 #ifdef SNAPSHOT_CHECKSUMS
 	objectHeaderSize += sizeof( unsigned int );
 #endif
 
 	int lastobjectNum = 0;
 	int j = 0;
 	
 	for ( int i = 0; i < objectStates.Num(); i++ ) {
 		objectState_t & newState = *objectStates[i];
 
 		if ( optimalLength > 0 && file->Length() >= optimalLength ) {
 			return false;
 		}
 
 		if ( !verify( newState.buffer.Size() < maxLength ) ) {
 			// If the new state's size is > the max packet size, we'll never be able to send it!
 			idLib::Warning( "Snap obj [%d] state.size > max packet length. Skipping... ", newState.objectNum );
 			continue;
 		} else if ( !verify( newState.buffer.Size() > 0 ) ) {
 			// you CANNOT have a valid ss obj state w/ size = 0: this will be interpreted as a delete in ::ReadDelta and this will completely throw
 			// off delta compression, eventually resulting in a checksum error that is a pain to track down.
 			idLib::Warning( "Snap obj [%d] state.size <= 0... skipping ", newState.objectNum );
 			continue;
 		}
 
 		if ( file->Length() + objectHeaderSize + newState.buffer.Size() >= maxLength ) {
 			return false;
 		}
 		
 		if ( j >= old.objectStates.Num() ) {
 			// delta against an empty snap
 			WriteObject( file, visIndex, &newState, NULL, lastobjectNum );
 			continue;
 		}
 
 		// write any deleted entities up to this one
 		for ( ; newState.objectNum > old.objectStates[j]->objectNum; j++ ) {
 			if ( file->Length() + objectHeaderSize >= maxLength ) {
 				return false;
 			}
 			objectState_t & oldState = *old.objectStates[j];
 			WriteObject( file, visIndex, NULL, &oldState, lastobjectNum );
 		}
 		
 		// Beyond this point, we have old state to compare against
 		objectState_t & oldState = *old.objectStates[j];
 
 		if ( newState.objectNum == oldState.objectNum ) {
 			// FIXME: We don't need to early out if WriteObject determines that we won't send the object due to being stale
 			if ( file->Length() + objectHeaderSize + newState.buffer.Size() >= maxLength ) {
 				return false;
 			}
 			WriteObject( file, visIndex, &newState, &oldState, lastobjectNum );
 			j++;
 		} else {
 			if ( file->Length() + objectHeaderSize + newState.buffer.Size() >= maxLength ) {
 				return false;
 			}
 
 			// Different object, this one is new, write the full state
 			WriteObject( file, visIndex, &newState, NULL, lastobjectNum );
 		}
 	}
 	// Finally, remove any entities at the end
 	for ( ; j < old.objectStates.Num(); j++ ) {
 		if ( file->Length() + objectHeaderSize >= maxLength ) {
 			return false;
 		}
 
 		if ( optimalLength > 0 && file->Length() >= optimalLength ) {
 			return false;
 		}
 
 		objectState_t & oldState = *old.objectStates[j];
 		WriteObject( file, visIndex, NULL, &oldState, lastobjectNum );
 	}
 	if ( file->Length() + 2 >= maxLength ) {
 		return false;
 	}
 	uint16 objectDelta = 0xFFFF - lastobjectNum;
 	file->WriteBig( objectDelta );
 
 	return true;
 }
 
 /*
 ========================
 idSnapShot::AddObject
 ========================
 */
 idSnapShot::objectState_t * idSnapShot::S_AddObject( int objectNum, uint32 visMask, const char * data, int _size, const char * tag ) {
 	objectSize_t size = _size;
 	objectState_t & state = FindOrCreateObjectByID( objectNum );
 	state.visMask = visMask;
 	if ( state.buffer.Size() == size && state.buffer.NumRefs() == 1 ) {
 		// re-use the same buffer
 		memcpy( state.buffer.Ptr(), data, size );
 	} else {
 		objectBuffer_t buffer( size );
 		memcpy( buffer.Ptr(), data, size );
 		state.buffer = buffer;
 	}
 	return &state;
 }
 
 /*
 ========================
 idSnapShot::CopyObject
 ========================
 */
 
 bool idSnapShot::CopyObject( const idSnapShot & oldss, int objectNum, bool forceStale ) {	
 
 	int oldIndex = oldss.FindObjectIndexByID( objectNum );
 	if ( oldIndex == -1 ) {
 		return false;
 	}
 
 	const objectState_t & oldState = *oldss.objectStates[oldIndex];
 	objectState_t & newState = FindOrCreateObjectByID( objectNum );
 
 	newState.buffer			= oldState.buffer;
 	newState.visMask		= oldState.visMask;
 	newState.stale			= oldState.stale;
 	newState.deleted		= oldState.deleted;
 	newState.changedCount	= oldState.changedCount;
 	newState.expectedSequence = oldState.expectedSequence;
 	newState.createdFromTemplate = oldState.createdFromTemplate;
 
 	if ( forceStale ) {
 		newState.visMask = 0;
 	}
 
 	return true;
 }
 
 /*
 ========================
 idSnapShot::CompareObject
 start, end, and oldStart can optionally be passed in to compare subsections of the object
 default parameters will compare entire object
 ========================
 */
 int idSnapShot::CompareObject( const idSnapShot * oldss, int objectNum, int start, int end, int oldStart ) {
 	if ( oldss == NULL ) {
 		return 0;
 	}
 	
 	assert( FindObjectIndexByID( objectNum ) >= 0 );
 
 	objectState_t & newState = FindOrCreateObjectByID( objectNum );
 
 	int oldIndex = oldss->FindObjectIndexByID( objectNum );
 	if ( oldIndex == -1 ) {
 		return ( end == 0 ? newState.buffer.Size() : end - start );	// Didn't exist in the old state, so we take the hit on the entire size
 	}
 
 	objectState_t & oldState = const_cast< objectState_t & >( *oldss->objectStates[oldIndex] );
 
 	int bytes = 0;
 
 	int oldOffset = oldStart - start;
 	int commonSize = ( newState.buffer.Size() <= oldState.buffer.Size() - oldOffset ) ? newState.buffer.Size() : oldState.buffer.Size() - oldOffset;
 	if ( end == 0 ) {
 		// default 0 means compare the whole thing
 		end = commonSize;
 		
 		// Get leftover (if any)
 		bytes = ( newState.buffer.Size() > oldState.buffer.Size() ) ? ( newState.buffer.Size() - oldState.buffer.Size() ) : 0;
 	} else {
 
 		// else only compare up to end or the max buffer and dont include leftover
 		end = Min( commonSize, end );
 	}
 
 	for ( int b = start; b < end; b++ ) {
 		if ( verify( b >= 0 && b < (int)newState.buffer.Size() && b + oldOffset >= 0 && b + oldOffset < (int)oldState.buffer.Size() ) ) {
 			bytes += ( newState.buffer[b] != oldState.buffer[b + oldOffset] ) ? 1 : 0;
 		}
 	}
 
 	return bytes;
 }
 
 /*
 ========================
 idSnapShot::GetObjectMsgByIndex
 ========================
 */
 int idSnapShot::GetObjectMsgByIndex( int i, idBitMsg & msg, bool ignoreIfStale ) const {
 	if ( i < 0 || i >= objectStates.Num() ) {
 		return -1;
 	}
 	objectState_t & state = *objectStates[i];
 	if ( state.stale && ignoreIfStale ) {
 		return -1;
 	}
 	msg.InitRead( state.buffer.Ptr(), state.buffer.Size() );
 	return state.objectNum;
 }
 
 /*
 ========================
 idSnapShot::ObjectIsStaleByIndex
 ========================
 */
 bool idSnapShot::ObjectIsStaleByIndex( int i ) const {
 	if ( i < 0 || i >= objectStates.Num() ) {
 		return false;
 	}
 	return objectStates[i]->stale;
 }
 
 /*
 ========================
 idSnapShot::ObjectChangedCountByIndex
 ========================
 */
 int idSnapShot::ObjectChangedCountByIndex( int i ) const {
 	if ( i < 0 || i >= objectStates.Num() ) {
 		return false;
 	}
 	return objectStates[i]->changedCount;
 }
 
 /*
 ========================
 idSnapShot::FindObjectIndexByID
 ========================
 */
 int idSnapShot::FindObjectIndexByID( int objectNum ) const {
 	int i = BinarySearch( objectNum );
 	if ( i >= 0 && i < objectStates.Num() && objectStates[i]->objectNum == objectNum ) {
 		return i;
 	}
 	return -1;
 }
 
 /*
 ========================
 idSnapShot::BinarySearch
 ========================
 */
 int idSnapShot::BinarySearch( int objectNum ) const {
 	int lo = 0;
 	int hi = objectStates.Num();
 	while ( hi != lo ) {
 		int mid = ( hi + lo ) >> 1;
 
 		if ( objectStates[mid]->objectNum == objectNum ) {
 			return mid;		// Early out if we can
 		}
 
 		if ( objectStates[mid]->objectNum < objectNum ) {
 			lo = mid + 1;
 		} else {
 			hi = mid;
 		}
 	}
 	return hi;
 }
 
 /*
 ========================
 idSnapShot::FindOrCreateObjectByID
 ========================
 */
 idSnapShot::objectState_t & idSnapShot::FindOrCreateObjectByID( int objectNum ) {
 	//assert( mem.IsMapHeap() );
 
 	int i = BinarySearch( objectNum );
 
 	if ( i >= 0 && i < objectStates.Num() && objectStates[i]->objectNum == objectNum ) {
 		return *objectStates[i];
 	}
 
 	objectState_t * newstate = allocatedObjs.Alloc();
 	newstate->objectNum = objectNum;
 
 	objectStates.Insert( newstate, i );
 
 	return *objectStates[i];
 }
 
 /*
 ========================
 idSnapShot::FindObjectByID
 ========================
 */
 idSnapShot::objectState_t * idSnapShot::FindObjectByID( int objectNum ) const {
 
 	//assert( mem.IsMapHeap() );
 
 	int i = BinarySearch( objectNum );
 
 	if ( i >= 0 && i < objectStates.Num() && objectStates[i]->objectNum == objectNum ) {
 		return objectStates[i];
 	}
 
 	return NULL;
 }
 
 /*
 ========================
 idSnapShot::CleanupEmptyStates
 ========================
 */
 void idSnapShot::CleanupEmptyStates() {
 	for ( int i = objectStates.Num() - 1; i >= 0 ; i-- ) {
 		if ( objectStates[i]->buffer.Size() == 0 ) {
 			FreeObjectState( i );
 			objectStates.RemoveIndex(i);
 		}
 	}
 }
 
 /*
 ========================
 idSnapShot::UpdateExpectedSeq
 ========================
 */
 void idSnapShot::UpdateExpectedSeq( int newSeq ) {
 	for ( int i = 0; i < objectStates.Num(); i++ ) {
 		if ( objectStates[i]->expectedSequence == -2 ) {
 			objectStates[i]->expectedSequence = newSeq;
 		}
 	}
 }
 
 /*
 ========================
 idSnapShot::FreeObjectState
 ========================
 */
 void idSnapShot::FreeObjectState( int index ) {
 	assert( objectStates[index] != NULL );
 	//assert( mem.IsMapHeap() );
 	objectStates[index]->buffer._Release();
 	allocatedObjs.Free( objectStates[index] );
 	objectStates[index] = NULL;
 }
 
 /*
 ========================
 idSnapShot::ApplyToExistingState
 Take uncompressed state in msg and add it to existing state
 ========================
 */
 void idSnapShot::ApplyToExistingState( int objId, idBitMsg & msg ) {
 	objectState_t *	objectState = FindObjectByID( objId );
 	if ( !verify( objectState != NULL ) ) {
 		return;	
 	}
 
 	if ( !objectState->createdFromTemplate ) {
 		// We were created this from a template, so we shouldn't be applying it again
 		if ( net_ssTemplateDebug.GetBool() ) {
 			idLib::Printf( "NOT ApplyToExistingState[%d] because object was created from existing base state. %d\n", objId, objectState->expectedSequence  );
 			objectState->Print( "SS STATE" );
 		}
 		return;
 	}
 
 	// Debug print the template (spawn) and delta state
 	if ( net_ssTemplateDebug.GetBool() ) {
 		idLib::Printf( "\nApplyToExistingState[%d]. buffer size: %d msg size: %d\n", objId, objectState->buffer.Size(), msg.GetSize() );
 		objectState->Print( "DELTA STATE" );
 		
 		PrintAlign( "SPAWN STATE" );
 		for ( int i = 0; i < msg.GetSize(); i++ ) {
 			if ( InDebugRange( i ) ) {
 				idLib::Printf( "%02X", msg.GetReadData()[i] );
 			}
 		}
 		idLib::Printf( "\n" );
 	}
 
 	// Actually apply it
 	for ( objectSize_t i = 0; i < Min( objectState->buffer.Size(), msg.GetSize() ); i++ ) {
 		objectState->buffer[i] += msg.GetReadData()[i];
 	}
 
 	// Debug print the final state
 	if ( net_ssTemplateDebug.GetBool() ) {
 		objectState->Print( "NEW STATE" );
 		idLib::Printf( "\n" );
 	}
 }
 
 #if 0
 CONSOLE_COMMAND( serializeQTest, "Serialization Sanity Test", 0 ) {
 
 	byte buffer[1024];
 	memset( buffer, 0, sizeof( buffer ) );	
 
 	float values[] = { 0.0001f, 0.001f, 0.01f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.999f, 
 							1.0f, 1.01f, 1.1f, 10.0f, 10.1f, 10.101f, 100.0f, 101.0f, 101.1f, 101.101f };
 	int num = sizeof(values) / sizeof(float);
 
 	idLib::Printf("\n^3Testing SerializeQ and SerializeUQ \n");
 
 	{
 		idBitMsg writeBitMsg;
 		writeBitMsg.InitWrite( buffer, sizeof(buffer) );
 		idSerializer writeSerializer( writeBitMsg, true );
 
 		for( int i = 0; i < num; i++ ) {
 			writeSerializer.SerializeUQ( values[i], 255.0f, 16 );
 			writeSerializer.SerializeQ( values[i], 128.0f, 16 );
 		}
 	}
 
 	{
 		idBitMsg readBitMsg;
 		readBitMsg.InitRead( buffer, sizeof( buffer ) );
 		idSerializer readSerializer( readBitMsg, false );
 
 		for( int i = 0; i < num; i++ ) {
 
 			float resultUQ = -999.0f;
 			float resultQ  = -999.0f;
 
 			readSerializer.SerializeUQ( resultUQ, 255.0f, 16 );
 			readSerializer.SerializeQ( resultQ, 128.0f, 16 );
 
 			float errorUQ = idMath::Fabs( (resultUQ - values[i]) ) / values[i];
 			float errorQ  = idMath::Fabs( (resultQ - values[i]) ) / values[i];
 
 			idLib::Printf( "%s%f SerializeUQ: %f. Error: %f \n", errorUQ > 0.1f ? "^1": "", values[i], resultUQ, errorUQ );			
 			idLib::Printf( "%s%f SerializeQ: %f. Error: %f \n",   errorQ > 0.1f ? "^1": "", values[i], resultQ, errorQ );
 		}
 	}
 }
 #endif