private void InitSortedReagents()

        {

            costSortedReagents.Clear();

            foreach (string name in ReagentManager.Names)

            {

                Reagent reagent = ReagentManager.GetReagent(name);

                costSortedReagents.Add(reagent);

            }

            costSortedReagents.Sort(new ReagentCostSort());

        }

        public void BeginRecipeGeneration(uint maxQuantity, uint maxReagents, uint fullQuantityDepth, uint fullQuantity)

        {

            if (running)

            {

                // Already running - don't start again

                return;

            }

            this.MaxQuantity = maxQuantity;

            this.MaxReagents = maxReagents;

            this.FullQuantity = fullQuantity;

            this.FullQuantityDepth = fullQuantityDepth;

            // first, sort reagents by cost.

            InitSortedReagents();

            totalReagents = (uint)costSortedReagents.Count;

            // Pre-populate recipes list with:

            // 1) 1-ingredient recipes @ 10db for all enabled ingredients with a count >= 10

            // 2) any previously-generated recipes

            int enabledReagentCount = 0;

            PaintRecipe recipe = new PaintRecipe();

            recipe.Reactions = reactions;

            foreach (Reagent reagent in costSortedReagents)

            {

                if (reagent.Enabled)

                {

                    if (!reagent.IsCatalyst && ((reagent.RecipeMax >= 10) || ((FullQuantityDepth > 0) && (FullQuantity >= 10))))

                    {

                        recipe.Clear();

                        recipe.AddReagent(reagent.Name, 10);

                        AddCheapestRecipe(recipe);

                    }

                    ++enabledReagentCount;

                }

            }

            this.MaxReagents = (uint)Math.Min(enabledReagentCount, this.MaxReagents);

            while (!searchQueue.IsEmpty)

            {

                RecipeSearchNode node;

                searchQueue.TryDequeue(out node);

            }

            for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)

            {

                if (costSortedReagents[(int)reagentIdx].Enabled)

                {

                    RecipeSearchNode initialNode = new RecipeSearchNode(costSortedReagents, reagentIdx);

                    initialNode.FullQuantity = FullQuantity;

                    initialNode.FullQuantityDepth = FullQuantityDepth;

                    initialNode.MaxQuantity = maxQuantity;

                    initialNode.MaxReagents = maxReagents;

                    searchQueue.Enqueue(initialNode);

                }

            }

            recipeCount = 0;

            if (log != null)

            {

                log.WriteLine("Begin recipe generation: MaxQuantity={0} MaxReagents={1} FullQuantity={2} FullQuantityDepth={3}", MaxQuantity, MaxReagents, FullQuantity, FullQuantityDepth);

            }

            // start worker threads to do the actual work

            ResumeRecipeGeneration();

        }

        public void ResumeRecipeGeneration()

        {

            if (running)

            {

                // Already running - don't start again

                return;

            }

            running = true;

            requestCancel = false;

            if (log != null)

            {

                log.WriteLine("Resuming recipe generation: pre-threads={0} reagent count={1} search queue={2}", runningThreads, costSortedReagents.Count, searchQueue.Count);

            }

            runningThreads = 0; // presumably!

            if (threadCount == 0)

            {

                if (Finished != null)

                {

                    Finished(this, null);

                }

            }

            generatorThreads.Clear();

            for (int i = 0; i < threadCount; ++i)

            {

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

                generatorThreads.Add(thr);

            }

            foreach (Thread thr in generatorThreads)

            {

                thr.Start();

            }

        }

        public bool SaveState(string file)

        {

            if (running)

            {

                // can't save state while running

                return false;

            }

            using (StreamWriter writer = new StreamWriter(file, false))

            {

                writer.WriteLine("MaxReagents: {0}", MaxReagents);

                writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);

                writer.WriteLine("FullQuantity: {0}", FullQuantity);

                writer.WriteLine("TotalReagents: {0}", totalReagents);

                writer.WriteLine("RecipeCount: {0}", recipeCount);

                writer.WriteLine("SearchType: {0}", Mode.ToString());

                foreach (KeyValuePair<string, PaintRecipe> pair in recipes)

                {

                    PaintRecipe recipe = pair.Value;

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

                    writer.WriteLine("BeginRecipe: {0}", colorName);

                    foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)

                    {

                        writer.WriteLine("Ingredient: {0}={1}", ingredient.name, ingredient.quantity);

                    }

                    writer.WriteLine("EndRecipe: {0}", colorName);

                }

                writer.WriteLine("SearchNodes: {0}", searchQueue.Count);

                foreach (RecipeSearchNode node in searchQueue)

                {

                    node.SaveState(writer);

               }

            }

            return true;

        }

        static Regex keyValueRegex = new Regex(@"(?<key>\w+)\:\s*(?<value>.+)\s*");

        static Regex ingredientRegex = new Regex(@"(?<ingredient>(\w+\s)*\w+)\s*=\s*(?<quantity>\d)\s*");

        public bool LoadState(string file)

        {

            // cannot be running, and reactions must be set

            if (running)

            {

                return false;

            }

            InitSortedReagents();

            bool success = true;

            PaintRecipe currentRecipe = null;

            Match match;

            string line;

            using (StreamReader reader = new StreamReader(file, false))

            {

                while (success && ((line = reader.ReadLine()) != null))

                {

                    match = keyValueRegex.Match(line);

                    if (match.Success)

                    {

                        string value = match.Groups["value"].Value;

                        switch(match.Groups["key"].Value)

                        {

                            case "MaxReagents":

                                MaxReagents = uint.Parse(value);

                                break;

                            case "FullQuantityDepth":

                                FullQuantityDepth = uint.Parse(value);

                                break;

                            case "FullQuantity":

                                FullQuantity = uint.Parse(value);

                                break;

                            case "TotalReagents":

                                totalReagents = uint.Parse(value);

                                break;

                            case "RecipeCount":

                                if (!ulong.TryParse(value, out recipeCount))

                                {