public void Execute()
            {
                int  i_nextBestUniqueKeyIndex = i_eltiesCount - 1;
                bool canCheckForElite         = i_nextBestUniqueKeyIndex >= 0 ? true : false;
                int  i_eliteIndex             = 0;
                bool isNextUniqueKey          = true;

                EntityIndex parentEntityScore       = default;
                NativeMultiHashMapIterator <int> it = default;

                while (canCheckForElite)
                {
                    if (!isNextUniqueKey && nmhm_entitiesScore.TryGetNextValue(out parentEntityScore, ref it))
                    {
// Debug.Log ( "try get nexxt value: " + parent.entity + "; " + parent.i_index ) ;
                    }
                    else
                    {
// Debug.LogWarning ( "try get but NO MORE." ) ;
                        isNextUniqueKey = true;
                    }

                    if (isNextUniqueKey && nmhm_entitiesScore.TryGetFirstValue(na_currentSortedKeysWithDuplicates [i_nextBestUniqueKeyIndex], out parentEntityScore, out it))
                    {
// Debug.LogWarning ( "try get first value: " + parent.entity + "; " + parent.i_index ) ;

                        i_nextBestUniqueKeyIndex--;
                        isNextUniqueKey = false;
                    }

                    na_elities [i_eliteIndex] = parentEntityScore;
                    i_eliteIndex++;

                    if (i_eliteIndex >= i_eltiesCount)
                    {
                        // Stop lookup.
                        canCheckForElite = false;
                    }
                } // while
            }
            public void Execute( )
            {
                NativeHashMap <int, bool> nhm_checkedEliteEntities = new NativeHashMap <int, bool> (na_elities.Length, Allocator.Temp);

                int  i_parentUniqueKeyIndex = 0;
                bool isNextParentUniqueKey  = true;

                NativeMultiHashMapIterator <int> it = default;

                for (int i_eliteIndex = 0; i_eliteIndex < na_elities.Length; i_eliteIndex++)
                {
                    EntityIndex currentEntityIndex = na_elities [i_eliteIndex];
                    Entity      currentEliteEntity = currentEntityIndex.entity;

                    // Check if this entity has not been tested already.
                    if (nhm_checkedEliteEntities.TryAdd(currentEliteEntity.Index, true))
                    {
                        int i_currentEntityIndex          = currentEntityIndex.i_index;
                        int i_currentPopulationBrainScore = a_brainScore [currentEliteEntity].i;

// Debug.Log ( "* Inject Elite: " + i_eliteIndex + " / " + na_currentEliteIndexProbability.Length + "; " + currentEliteEntity + "; with current score: " + i_currentPopulationBrainScore ) ;
// Debug.Log ( "* Inject Elite: " + i_probablity + " / " + i_perentageOfElites + "; " + eliteEntity + "; with current score: " + i_currentPopulationBrainScore ) ;

                        EntityIndex parentIndex = default;

                        // Look up through parents' scores, starting from lowest score ascending.
                        if (!isNextParentUniqueKey && nmhm_parentEntitiesScore.TryGetNextValue(out parentIndex, ref it))
                        {
// Debug.Log ( "try get next value: " + parentIndex.entity + "; " + parentIndex.i_index ) ;
                        }
                        else
                        {
// Debug.LogWarning ( "try get but NO MORE." ) ;
                            isNextParentUniqueKey = true;
                        }

                        if (isNextParentUniqueKey && nmhm_parentEntitiesScore.TryGetFirstValue(na_parentKeysWithDuplicates [i_parentUniqueKeyIndex], out parentIndex, out it))
                        {
// Debug.LogWarning ( "try get first value: " + parentIndex.entity + "; " + parentIndex.i_index ) ;

                            i_parentUniqueKeyIndex++;
                            isNextParentUniqueKey = false;
                        }


                        // Parent is valid.
                        if (!isNextParentUniqueKey && parentIndex.entity.Version > 0)
                        {
                            int i_parentPopulationBrainScore = a_brainScore [parentIndex.entity].i;

// Debug.Log ( "score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore ) ;

                            if (i_currentPopulationBrainScore > i_parentPopulationBrainScore)
                            {
                                // isBetterScore = true ;

                                na_parentPopulationEntities [parentIndex.i_index] = currentEliteEntity;

// Debug.LogWarning ( "Parent index: " + parentIndex.i_index + " / " + na_parentPopulationEntities.Length + "; inject : " + currentEliteEntity + "; for: " + parentIndex.entity + "; score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore ) ;
// Debug.LogWarning ( "Parent index: " + parent.i_index + " / " + na_parentPopulationEntities.Length + "; inject : " + eliteEntity + "; for: " + parent.entity + "; score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore + "; index prob: " + i_indexProbability ) ;

                                // Swap entities.

                                na_currentPopulationEntities [i_currentEntityIndex] = parentIndex.entity;
                                // na_elities [i_eliteIndex] = parent.entity ;
                                // na_currentPopulationEntities [i_indexProbability] = parent.entity ;
                            }
                        }

                        if (isNextParentUniqueKey || i_parentUniqueKeyIndex >= na_parentKeysWithDuplicates.Length)
                        {
// Debug.LogError ( "No more parent entities." ) ;
                            break;  // No more parent entities.
                        }
                    }
                } // for

                nhm_checkedEliteEntities.Dispose();
                // na_currentPopulationEntitiesCopy.Dispose () ;
            }