public static IEnumerable<BigInt> FibonacciSequence(Func<BigInt, bool> stopPredicate)
        {
            BigInt fibo1 = new BigInt(1);
            BigInt fibo2 = new BigInt(1);

            yield return fibo1;
            yield return fibo2;

            while (true)
            {
                fibo1 = fibo1 + fibo2;
                fibo2 = fibo1 + fibo2;

                if (!stopPredicate(fibo1))
                {
                    yield break;
                }

                yield return fibo1;

                if (!stopPredicate(fibo2))
                {
                    yield break;
                }

                yield return fibo2;
            }
        }
        public override void Solve()
        {
            BigInt number = new BigInt(1);
            for (int counter = 0; counter < 1000; counter++)
            {
                number = number + number;
            }

            int sum = number.ToString()
                            .ToCharArray()
                            .Select(c => int.Parse(c.ToString()))
                            .Sum();

            Verify(sum);
        }
        private static BigInt MultiplyInternal(BigInt number, long multiplier)
        {
            if (multiplier % 10 == 0)
            {
                byte factorsOfTen = 0;
                while (multiplier % 10 == 0)
                {
                    multiplier /= 10;
                    factorsOfTen++;
                }

                number = new BigInt(
                                Enumerable.Repeat<byte>(0, factorsOfTen)
                                          .Concat(number.digits)
                                          .ToArray());
            }

            if (multiplier == 1)
            {
                return number;
            }
            else if (multiplier == 0)
            {
                return default(BigInt);
            }

            byte carry = 0;
            byte[] resultArray = null;
            byte product = 0;

            BigInt result = new BigInt(new byte[0]);
            var digits = multiplier.Digits();

            for (int digitIndex = 0; digitIndex < digits.Length; digitIndex++)
            {
                if (digits[digitIndex] == 0)
                {
                    continue;
                }

                resultArray = new byte[number.Length];
                carry = 0;
                product = 0;

                for (int index = 0; index < number.Length; index++)
                {
                    product = (byte)(number[index] * digits[digitIndex]);

                    product += carry;

                    if (product > 9)
                    {
                        carry = (byte)(product / 10);
                        product %= 10;
                    }
                    else
                    {
                        carry = 0;
                    }

                    resultArray[index] = product;
                }

                if (carry != 0)
                {
                    resultArray = resultArray.Concat(new byte[] { carry }).ToArray();
                }

                result = result + (new BigInt(resultArray) * 10.Power(digitIndex));
            }

            return result;
        }
        private static BigInt SumInternal(BigInt first, BigInt second)
        {
            if (first.Length < second.Length)
            {
                BigInt swap = first;
                first = second;
                second = swap;
            }

            bool carry = false;
            byte[] result = new byte[first.Length];
            byte sumDigits = 0;

            for (int index = 0; index < first.Length; index++)
            {
                if (index < second.Length)
                {
                    sumDigits = (byte)(first[index] + second[index]);
                }
                else
                {
                    sumDigits = first[index];
                }

                if (carry)
                {
                    sumDigits++;
                }

                if (sumDigits > 9)
                {
                    sumDigits -= 10;
                    carry = true;
                }
                else
                {
                    carry = false;
                }

                result[index] = (byte)sumDigits;
            }

            if (carry)
            {
                result = result.Concat(new byte[] { 1 }).ToArray();
            }

            return new BigInt(result);
        }
        public static BigInt Factorial(this int number)
        {
            BigInt factorer = new BigInt(1);
            for (int counter = 1; counter <= 100; counter++)
            {
                factorer = factorer * counter;
            }

            return factorer;
        }