public int generateRandomNumber()
        {
            if (randomGenerator == null)
                randomGenerator = new RandomGenerator();

            return RandomNumber = randomGenerator.getRandomNumber();
        }

		public CipherGenContext(RandomGenerator random, int dataVarCount) {
			this.random = random;
			Block = new StatementBlock(); // new LoopStatement() { Begin = 0, Limit = 4 };
			dataVars = new Variable[dataVarCount];
			for (int i = 0; i < dataVarCount; i++)
				dataVars[i] = new Variable("v" + i) { Tag = i };
		}

        public SharedFactory()
        {
            rndGenerator = new RandomGenerator();

            prefixes = new List<string>
            {
                "http",
                "https",
                "ftp",
                "ftps",
                "sftp",
            };

            suffixes = new List<string>
            {
                "com",
                "edu",
                "org",
                "ca",
                "de",
                "es",
                "fr",
                "it",
                "pl",
                "ir",
                "ro",
                "co.uk",
                "net"
            };
        }

		/// <summary>
		///     Initializes a new instance of the <see cref="APIStore" /> class.
		/// </summary>
		/// <param name="context">The working context.</param>
		public APIStore(ConfuserContext context) {
			this.context = context;
			random = context.Registry.GetService<IRandomService>().GetRandomGenerator("APIStore");

			dataStores = new SortedList<int, List<IDataStore>>();
			predicates = new List<IOpaquePredicateDescriptor>();
		}

        static void Main(string[] args)
        {
            GuessGameEngine gameEngine = new GuessGameEngine();
            RandomGenerator ran = new RandomGenerator();
            ran.StartPoint = 50;
            ran.EndPoint = 100;
            gameEngine.randomGenerator = ran;
            gameEngine.startGame();

            Console.WriteLine("Enter number between 1 - 100");
            while (true)
            {
                int userInput = Convert.ToInt32(Console.ReadLine());
                Console.WriteLine(gameEngine.verifyGuess(userInput));

                if (gameEngine.isGameEnded)
                {
                    Console.WriteLine("Do you want to continue?");
                    var vote = Console.ReadLine().ToString();

                    if (vote.ToLower() == "yes")
                    {
                        Console.WriteLine("Enter number between 1 - 100");
                        gameEngine.restart();
                    }
                    else
                        break;
                }
            }

            Console.ReadKey();
        }

		static Expression GenerateExpression(RandomGenerator random, Expression current, int currentDepth, int targetDepth) {
			if (currentDepth == targetDepth || (currentDepth > targetDepth / 3 && random.NextInt32(100) > 85))
				return current;

			switch ((ExpressionOps)random.NextInt32(6)) {
				case ExpressionOps.Add:
					return GenerateExpression(random, current, currentDepth + 1, targetDepth) +
					       GenerateExpression(random, (LiteralExpression)random.NextUInt32(), currentDepth + 1, targetDepth);

				case ExpressionOps.Sub:
					return GenerateExpression(random, current, currentDepth + 1, targetDepth) -
					       GenerateExpression(random, (LiteralExpression)random.NextUInt32(), currentDepth + 1, targetDepth);

				case ExpressionOps.Mul:
					return GenerateExpression(random, current, currentDepth + 1, targetDepth) * (LiteralExpression)(random.NextUInt32() | 1);

				case ExpressionOps.Xor:
					return GenerateExpression(random, current, currentDepth + 1, targetDepth) ^
					       GenerateExpression(random, (LiteralExpression)random.NextUInt32(), currentDepth + 1, targetDepth);

				case ExpressionOps.Not:
					return ~GenerateExpression(random, current, currentDepth + 1, targetDepth);

				case ExpressionOps.Neg:
					return -GenerateExpression(random, current, currentDepth + 1, targetDepth);
			}
			throw new UnreachableException();
		}

        public void ShouldDecideNegatively()
        {
            var generator = new RandomGenerator(() => 0.9);
            bool decision = generator.Decide(0.3);

            Assert.That(decision, Is.False);
        }

        public void ShouldDecidePositively()
        {
            var generator = new RandomGenerator(() => 0.2);
            bool decision = generator.Decide(0.3);

            Assert.That(decision, Is.True);
        }

        public void ShouldGiveMiddleValue()
        {
            var generator = new RandomGenerator(() => 0.5);
            double value = generator.Value(3, 7);

            Assert.That(value, Is.InRange(5.0 - Delta, 5.0 + Delta));
        }

		public override void Initialize(RandomGenerator random) {
			if (random.NextInt32(3) == 0)
				Mask = 0xffffffff;
			else
				Mask = random.NextUInt32();
			Key = random.NextUInt32() | 1;
		}

        public void TestCalculadora()
        {
            RandomGenerator r = new RandomGenerator();
            var persons = Builder<Person>.CreateListOfSize(tests * tests).
                    All().With(x => x.Age = r.Next(0, 100))
                         .And(x => x.Height = r.Next(90, 180))
                         .And(x => x.Weight = r.Next(10, 90))
                         .And(x => x.IsMan = r.Next())
                         .And(x => x.BMR = r.Next(100, 2000))
                         .And(x => x.Hip = r.Next(20, 60))
                         .And(x => x.Waist = r.Next(20, 60))
                         .And(x => x.Neck = r.Next(10, 30))
                         .Random(15).With(x => x.BMR = 0.0f)
                   .Build();
            foreach (Person p in persons)
            {
                Calculadora c = new Calculadora(p);
                int value = r.Next(-5, 7);
                if (value < 1 || value > 5)
                {
                    Assert.IsFalse(c.seleccionarCalculadora(value.ToString()));
                }
                else
                {
                    Assert.IsTrue(c.seleccionarCalculadora(value.ToString()));
                    if (value == 5)
                        Assert.IsFalse(c.estaActiva);
                }

            }
        }

		Tuple<int, int> GetKey(RandomGenerator random, MethodDef init) {
			Tuple<int, int> ret;
			if (!keys.TryGetValue(init, out ret)) {
				int key = random.NextInt32() | 1;
				keys[init] = ret = Tuple.Create(key, (int)MathsUtils.modInv((uint)key));
			}
			return ret;
		}

        public void NextValueThrowsExceptionWithUnsupportedTypeTest()
        {
            var target = new RandomGenerator();

            Action action = () => target.NextValue('C', 'C');

            action.ShouldThrow<NotSupportedException>();
        }

        public void NextValueThrowsExceptionWhenMinimumGreaterThanMaximumTest()
        {
            var target = new RandomGenerator();

            Action action = () => target.NextValue(1, 0);

            action.ShouldThrow<ArgumentOutOfRangeException>();
        }

        /// <summary>
        /// Returns a random person from the test data set.
        /// </summary>
        /// <returns>A random person.</returns>
        public static Person NextPerson()
        {
            var generator = new RandomGenerator();

            var index = generator.NextValue(0, People.Count - 1);

            return People[index];
        }

        public void IsSupportedThrowsExceptionWithNullTypeTest()
        {
            var target = new RandomGenerator();

            Action action = () => target.IsSupported(null);

            action.ShouldThrow<ArgumentNullException>();
        }

        /// <summary>
        /// Returns a random male from the test data set.
        /// </summary>
        /// <returns>A random male.</returns>
        public static Person NextMale()
        {
            var generator = new RandomGenerator();

            var index = generator.NextValue(0, Males.Count - 1);

            return Males[index];
        }

		public override void Initialize(RandomGenerator random) {
			InverseKey = mul(transpose4(GenerateUnimodularMatrix(random)), GenerateUnimodularMatrix(random));

			var cof = new uint[4, 4];
			for (int i = 0; i < 4; i++)
				for (int j = 0; j < 4; j++)
					cof[i, j] = cofactor4(InverseKey, i, j);
			Key = transpose4(cof);
		}

        public void RandomBytesAreUnique(byte min, byte max)
        {
            RandomGenerator r = new RandomGenerator(new Random().Next());
            byte[] values = new byte[10];
            for (int i = 0; i < 10; i++)
                values[i] = r.GetByte();

            Assert.That(values, Is.Unique);
        }

        public void ShouldChooseItemRandomly()
        {
            int[] items = { 1, 2, 3 };
            
            var generator = new RandomGenerator(() => 0.4);
            int chosen = generator.Choose(items, 0.5, 1.0, 0.3);

            Assert.That(chosen, Is.EqualTo(2));
        }