public class Nanofactory
    {
        private Dictionary<string, Chemical> _nameToChemicalResult;
        private Dictionary<Chemical, Reaction> _reactionMap;
        private Dictionary<string, int> _spares;
        private long _oreCount;

        public Nanofactory(string[] inputLines)
        {
            _nameToChemicalResult = new Dictionary<string, Chemical>();
            _reactionMap = new Dictionary<Chemical, Reaction>();
            foreach (string line in inputLines)
            {
                string[] split = line.Split(" => ");
                string[] required = split[0].Split(", ");
                string[] result = split[1].Split(" ");

                Chemical resultingChemical = new Chemical(result[1], int.Parse(result[0]));

                List<Chemical> reactionComponents = new List<Chemical>();
                foreach (string req in required)
                {
                    string[] s2 = req.Split(" ");
                    Chemical r = new Chemical(s2[1], int.Parse(s2[0]));
                    reactionComponents.Add(r);
                }
                Reaction react = new Reaction(reactionComponents.ToArray());

                _nameToChemicalResult.Add(resultingChemical.name, resultingChemical);
                _reactionMap.Add(resultingChemical, react);
            }
        }

        public long GetRequiredOreForFuel(int fuelCount)
        {
            _oreCount = 0;
            _spares = new Dictionary<string, int>();

            MakeMaterials("FUEL", fuelCount);

            return _oreCount;
        }

        private void MakeMaterials(string name, int amountNeeded)
        {
            Chemical key = _nameToChemicalResult[name];
            Reaction reaction = _reactionMap[key];

            int numSpares = 0;
            _spares.TryGetValue(name, out numSpares);

            int minimumCanMake = key.amount;
            int willMake = minimumCanMake;
            int difference = 0;
            while (willMake + numSpares < amountNeeded)
            {
                willMake += minimumCanMake;
            }
            if (willMake < amountNeeded)
            {
                difference = amountNeeded - willMake;
                willMake += difference;
                _spares[name] -= difference;
                Console.WriteLine($"  =>set spares[{name}] to {_spares[name]}");
            }
            int actuallyMake = willMake - difference;
            Console.WriteLine($"Will make {willMake} ({actuallyMake}) of {name}, using {difference} spares");

            foreach (Chemical required in reaction.required)
            {
                if (required.name.Equals("ORE"))
                {
                    long old = _oreCount;
                    _oreCount += actuallyMake * required.amount / key.amount;
                    Console.WriteLine($"    ORE ({old}) ----> ({_oreCount})");
                }
                else
                {
                    MakeMaterials(required.name, actuallyMake * required.amount / key.amount);
                }
            }

            if (!_spares.ContainsKey(name))
            {
                _spares.Add(name, 0);
            }
            if (willMake > amountNeeded)
            {
                _spares[name] += willMake - amountNeeded;
                Console.WriteLine($"  =>set spares[{name}] to {_spares[name]}");
            }
        }

        public struct Chemical
        {
            public string name;
            public int amount;
            public Chemical(string name, int amount)
            {
                this.name = name;
                this.amount = amount;
            }
        }

        public class Reaction
        {
            public List<Chemical> required;
            public Reaction(params Chemical[] results)
            {
                required = new List<Chemical>();
                required.AddRange(results);
            }
        }
    }