void GPPopulation::CrossOver(GPTreeData &CrossOver1, GPTreeData &CrossOver2)
{
	GPNode* Tree[2]={CrossOver1.Tree,CrossOver2.Tree};
	if(Tree[0]==NULL || Tree[1]==NULL)
	{
		Mutate(CrossOver1);
		Mutate(CrossOver2);
		return;
	}

	unsigned Choice[2];

	{
		unsigned NumNodes[2];
		unsigned DataTypes[2];
		DataType* DataTypeArray[2];
		for(unsigned J=0; J<2; J++)
		{
			unsigned Temp=0;
			NumNodes[J]=Tree[J]->Count();
			DataTypeArray[J]=new DataType[NumNodes[J]];
			DataTypes[J]=Tree[J]->NodeDataTypes(DataTypeArray[J],Temp);
		}
		unsigned AllDataTypes=DataTypes[0]&DataTypes[1];

		Choice[0]=GetChoice(DataTypeArray[0], NumNodes[0], AllDataTypes);
		Choice[1]=GetChoice(DataTypeArray[1], NumNodes[1], DataTypeArray[0][Choice[0]]);
		for(unsigned K=0; K<2; K++)
			delete [] DataTypeArray[K];//<-------Here is the offending statement
	}

	GPNode* Nodes[2];
	GPNode* Parents[2];
	for(unsigned J=0; J<2; J++)
	{
		Nodes[J]=Tree[J]->Find(Choice[J]);
		Parents[J]=Nodes[J]->GetParent();
	}
	for(unsigned K=0; K<2; K++)
		Parents[K]->SwitchChild(Nodes[K],Nodes[(K+1)%2]);
}

unsigned GPNode::NodeDataTypes(DataType* &DataTypeArray, unsigned &Index)
{
	unsigned Types=DataTypeArray[Index]=ReturnType;
	Index++;
	for(unsigned K=0; K<NumChildren; K++)
		Types|=Children[K]->NodeDataTypes(DataTypeArray,Index);
	return Types;
}

unsigned GPPopulation::GetChoice(DataType* DataTypeArray, unsigned ArrayLength, unsigned AcceptableDataTypes)
{
	unsigned NumAcceptable=0;
	for(unsigned J=0; J<ArrayLength; J++)
		if(DataTypeArray[J]&AcceptableDataTypes)
			NumAcceptable++;
	unsigned Choice=rand()%NumAcceptable;

	bool Found=false;
	unsigned Index=0;
	for(unsigned K=0; !Found; K++)
	{
		if(DataTypeArray[K]&AcceptableDataTypes)
		{
			if(Choice==Index)
			{
				Choice=K;
				Found=true;
			}
			Index++;
		}
	}
	return Choice;
}

_CRTIMP int __cdecl _CrtIsValidHeapPointer(
        const void * pUserData
        )
{
#ifndef WINHEAP
        int i;
        void * base;
#endif  /* WINHEAP */

        if (!pUserData)
            return FALSE;

        if (!_CrtIsValidPointer(pHdr(pUserData), sizeof(_CrtMemBlockHeader), FALSE))
            return FALSE;

#ifdef WINHEAP

#ifndef _WIN64
        if ( __active_heap == __V6_HEAP )
        {
            PHEADER     pHeader;
            if (pHeader = __sbh_find_block(pHdr(pUserData)))
            {
                return __sbh_verify_block(pHeader, pHdr(pUserData));
            }
            else if ( (_osver & 0x8000) != 0 )
                return TRUE;
            else
                return HeapValidate( _crtheap, 0, pHdr(pUserData) );
        }
#ifdef CRTDLL
        else if ( __active_heap == __V5_HEAP )
        {
            __old_sbh_region_t * preg;
            __old_sbh_page_t *   ppage;
            __old_page_map_t *   pmap;
            if ( (pmap = __old_sbh_find_block( pHdr(pUserData), &preg, &ppage )) !=
                 NULL )
            {
                if ( *pmap )
                    return TRUE;
                else
                    return FALSE;
            }
            else if ( (_osver & 0x8000) != 0 )
                return TRUE;
            else
                return HeapValidate( _crtheap, 0, pHdr(pUserData) );
        }
#endif  /* CRTDLL */
        else    //  __active_heap == _SYSTEM_HEAP
#endif  /* _WIN64 */
        {
            return HeapValidate( _crtheap, 0, pHdr(pUserData) );
        }

#else  /* WINHEAP */

        /*
         * Go through the heap regions and see if the pointer lies within one
         * of the regions of the local heap.
         *
         * Pointers from non-local heaps cannot be handled. For example, a
         * non-local pointer may come from a DLL that has the CRT linked-in.
         *
         */

        for (i = 0; (base = _heap_regions._regbase) != NULL &&
                i < _HEAP_REGIONMAX; i++)
        {
            if (pUserData >= base && pUserData <
                    (void *)(((char *)base)+_heap_regions._currsize))
                return TRUE;
        }

        return FALSE;

#endif  /* WINHEAP */
}

unsigned GPNode::Count(){	if(CountValid)		return ChildCount;	ChildCount=1;							// Set ChildCount to 1 to Count this Node	for(unsigned K=0; K<NumChildren; K++)	// For Each Child		ChildCount+=Children[K]->Count();	// Count Their Nodes	CountValid=true;	return ChildCount;}

void GPPopulation::Reproduce(){	if(NumSorted<NumTrees)		SortTrees();	for(unsigned J=NumTrees-1; J>=Rate.ToCopy; J--)						//	The Copying and Elimination Loop	{																	// Eliminate the Worst Trees, by Shifting The Trees up by the Copying Amount		if(J<NumTrees-Rate.ToCopy)										// If The Current Tree has been shifted,			Trees[J].Tree=NULL;											// Set it to NULL so that it doesn't delete		Trees[J]=Trees[J-Rate.ToCopy];									// Shift the Trees	}																	// Finished Shifting	const unsigned NonMutat=Rate.ToCopy+Rate.ToCross;					// The Amount that is Reproduced not by Mutation	for(unsigned K=NumTrees-1; K>=NonMutat; K--)						//	The Mutation Loop	{																	// This Loop Replaces the Worst Trees that are left by the Mutated Trees		delete Trees[K].Tree;											// Delete The Old Tree		unsigned Random=rand()%(NumTrees-1);							// Choose a Random Number		if(Random>=K)													// If the Random Number is More Than or Equal To this,			Random++;													// Increment the Random Number		Trees[K].Tree=new GPNode(NULL,Trees[Random].Tree);				// The Random Numbe is the Index of the Tree that will be Mutated,		Mutate(Trees[K]);												// And Mutate That Tree	}																	// Finished Mutating	for(unsigned L=0; L<(Rate.ToCross/2); L++)							//	The Cross Over Loop		CrossOver(Trees[L+Rate.ToCopy],Trees[NonMutat-(L+1)]);			// Cross Over The Trees that Are to be Crossed Over	ResetFitness();	NumSorted=Rate.ToCopy;	GenerationNum++;}