{

                Thread thr = new Thread(new ThreadStart(this.Generate));

                generatorThreads.Add(thr);

            }

            foreach (Thread thr in generatorThreads)

            {

                thr.Start();

            }

        }

        public void ResumeRecipeGeneration()

        {

            if (running)

            {

                // Already running - don't start again

                return;

            }

            this.running = true;

            requestCancel = false;

            for (int i = 0; i < costSortedReagents.Count; ++i)

            {

                Thread thr = new Thread(new ThreadStart(this.Generate));

                generatorThreads.Add(thr);

            }

            foreach (Thread thr in generatorThreads)

            {

                thr.Start();

            }

        }

        private void Generate()

        {

            SearchNode node;

            bool ok = true;

            do

            {

                lock (workerLock)

                {

                    ok = searchQueue.TryDequeue(out node);

                }

                if (ok)

                {

                    uint targetQuantity = node.MaxQuantity + 1;

                    do {

                        --targetQuantity;

                        node.InitForQuantity(targetQuantity);

                    } while (targetQuantity > 10 && (node.CurrentTargetQuantity != node.UsedQuantity));

                    while (ok = Iterate(node) && !requestCancel)

                    {

                        if (Progress != null)

                        {

                            Progress(this, null);

                        }

                    }

                    if (ok)

                    {

                        // stopped because cancel was requested - requeue the node in its current state for resume

                        searchQueue.Enqueue(node);

                    }

                }

            } while (!requestCancel && ok);

            bool done = false;

            lock(workerLock)

            {

                generatorThreads.Remove(Thread.CurrentThread);

                done = (generatorThreads.Count == 0);

            }

            if (done)

            {

                if (Finished != null)

                {

                    Finished(this, null);

                }

                running = false;

            }

        }

        // Add the cheapest recipe to the recipe list

        // returns the discarded recipe from the pair (or null if no original recipe to replace)

        private PaintRecipe AddCheapestRecipe(PaintRecipe recipe)

        {

            PaintRecipe discarded = recipe;

            if (recipe.IsValid)

            {

                recipe.Reactions = reactions;

                string colorName = Palette.FindNearest(recipe.ReactedColor);

                //System.Console.WriteLine("Recipe: {0} {1}:", colorName, recipe.Cost);

                //foreach (PaintRecipe.RecipeIngredient ingr in recipe.Ingredients)

                //{

                //    System.Console.WriteLine("    -> {0} {1}", ingr.quantity, ingr.name);

                //}

                uint cost;

                lock (workerLock)

                {

                    if (recipeCosts.TryGetValue(colorName, out cost))

                    {

                        if (cost > recipe.Cost)

                        {

                            discarded = recipes[colorName];

                            recipeCosts[colorName] = recipe.Cost;

                            recipes[colorName] = recipe;

                            if (NewRecipe != null)

                            {

                                NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);

                                NewRecipe(this, args);

                            }

                        }

                    }

                    else

                    {

                        discarded = null;

                        recipeCosts.Add(colorName, recipe.Cost);

                        recipes.Add(colorName, recipe);

                        if (NewRecipe != null)

                        {

                            NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);

                            NewRecipe(this, args);

                        }

                    }

                }

            }

            return discarded;

        }

        private bool Iterate(SearchNode node)

        {

            // pick recipe quantities at current recipe ingredients/size

            if (NextRecipe(node))

            {

                lock(workerLock)

                {

                    ++recipeCount;

                }

                //System.Console.WriteLine("Found next recipe at size {0} qty {1}", node.Reagents.Count, node.CurrentTargetQuantity);

                return true;

            }

            if (NextRecipeSize(node))

            {

                //System.Console.WriteLine("Found next recipee size {0}", node.CurrentTargetQuantity);

                return true;

            }

            // Search for next ingredient combo - all quantity combos for previous were searched

            //System.Console.WriteLine("Finding next ingredient combo");

            do

            {

                if (!node.AddNextReagent())

                {

                    while ((node.Reagents.Count > node.InitialCount) && (node.LastReagent == (totalReagents-1)))

                    {

                        node.RemoveLastReagent();

                    }

                    if (node.Reagents.Count == node.InitialCount)

                    {

                        // done

                        return false;

                    }

                    uint nextReagent = node.NextFreeReagent(node.LastReagent);

                    while ((node.Reagents.Count > node.InitialCount) && (nextReagent >= totalReagents))

                    {

                        // No more reagents to try at this level

                        node.RemoveLastReagent();

                        if (node.Reagents.Count > node.InitialCount)

                        {

                            nextReagent = node.NextFreeReagent(node.LastReagent);

                        }

                    }

                    if (node.Reagents.Count == node.InitialCount)

                    {

                        // done

                        return false;

                    }

                    node.ReplaceLastReagent(nextReagent);

                }

            } while (node.MaxQuantity < (10 + node.CatalystCount));

            node.InitForQuantity(node.MaxQuantity);

            //string outStr = "{0} : {1} : ";

            //for (int i = 0; i < currentReagents.Count; ++i)

            //{

            //    Reagent reagent = costSortedReagents[(int)currentReagents[i]];

            //    if (i > 0)

            //    {

            //        outStr += ", ";

            //    }

            //    outStr += reagent.Name + " (" + reagent.Cost + ")";

            //}

            //Console.WriteLine(outStr, currentReagents.Count, recipeCount);

            return true;

        }

        private bool NextRecipe(SearchNode node)

        {

            // First, run the current recipe

            if (node.TestRecipe == null)

            {

                node.TestRecipe = new PaintRecipe();

                node.TestRecipe.Reactions = reactions;

            }

            node.TestRecipe.Clear();

            for (int i = 0; i < node.Reagents.Count; ++i)

            {

                node.TestRecipe.AddReagent(node.Reagent(i).Name, node.CurrentWeights[i]);

            }

            PaintRecipe replacement = AddCheapestRecipe(node.TestRecipe);

            if (replacement == null)

            {

                node.TestRecipe = new PaintRecipe();

                node.TestRecipe.Reactions = reactions;

            }

            else

            {

                node.TestRecipe = replacement;

            }

            // check for the next recipe

            uint remainingWeight = node.CurrentTargetQuantity - node.CatalystCount;

            if (remainingWeight < 10)

            {

                // not possible to make a valid recipe

                return false;

            }

            //uint remainingReagents = (uint)node.Reagents.Count - node.CatalystCount;

            uint depth = (uint)node.Reagents.Count;

            uint weightToConsume = 0;

            uint spaceBelow = 0;

            int reagentsBelow = 0;

            for (int i = (int)depth-1 ; i >= 0; --i)

            {

                uint currentWeight = node.CurrentWeights[i];

                if ((spaceBelow >= (weightToConsume+1)) && (currentWeight > 1))

                {

                    // reduce this node by 1, allocate remaining weight to reagents below it

                    node.SetWeight(i, currentWeight-1);

                    weightToConsume += 1;

                    for (int j = i+1; j < depth; ++j)

                    {

                        --reagentsBelow;

                        Reagent reagent = node.Reagent(j);

                        uint allocated = (uint)Math.Min(reagent.IsCatalyst ? 1 : (depth <= fullQuantityDepth ? fullQuantity : reagent.RecipeMax), weightToConsume - reagentsBelow);

                        if (allocated > 100)

                        {

                            Console.WriteLine("ACK: allocated = {0}", allocated);

                        }

                        node.SetWeight(j, allocated);