public string Get(Prefix prefix)
        {
            var suffixes = chain[prefix];
              var index = rnd.Next(suffixes.Count);

              return suffixes[index];
        }

        public FileSize(decimal plainValue, Prefix prefix)
        {
            PlainValue = plainValue;
            Prefix = prefix;

            InternalRepresentation = ToInternalRepresentation(plainValue, prefix);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DerivedUnit" /> class.
 /// </summary>
 /// <param name="prefix">The prefix.</param>
 /// <param name="notation">The notation.</param>
 /// <param name="expression">The expression.</param>
 public DerivedUnit(Prefix prefix, string notation, Expression expression)
 {
     this.prefix = prefix ?? Prefix.None;
     this.notation = notation;
     this.expression = expression;
     this.derivedBaseUnit = new DerivedBaseUnit(expression);
 }

        /// <summary>
        /// Creates a new instance of the CheatPrefixButton class
        /// </summary>
        /// <param name="i">The Prefix of the CheatPrefixButton</param>
        public CheatPrefixContainer(Prefix i)
            : base("")
        {
            Size = new Vector2(80f, 30f);

            Prefix = i;
        }

        private static void Main()
        {
            const int MAXGEN = 1000;

              var corpus = Resources.english;

              var suffixChain = new WordChain();

              var prefix = new Prefix();

              var words = corpus
            .Split(new[] {Environment.NewLine, " "}, StringSplitOptions.RemoveEmptyEntries)
            .ToList();
              foreach (var word in words)
              {
            suffixChain.Add(prefix, word);
            prefix.Add(word);
              }
              suffixChain.Add(prefix, NONWORD);

              var wordChain = Generate(suffixChain, MAXGEN);
              var text = string.Join(" ", wordChain);

              Console.WriteLine(text);
        }

        public void Add(Prefix prefix, string word)
        {
            prefix = prefix.Copy();

              if (!chain.ContainsKey(prefix))
            chain.Add(prefix, new List<string>());
              chain[prefix].Add(word);
        }

 public void TestPrefixDefaultConstructor()
 {
     Prefix prefix = new Prefix();
     Assert.AreEqual(string.Empty, prefix.Nick);
     Assert.AreEqual(string.Empty, prefix.UserName);
     Assert.AreEqual(string.Empty, prefix.HostName);
     Assert.IsFalse(prefix.Exists);
 }

        public ActionResult Create(Prefix prefix)
        {
            if (ModelState.IsValid)
            {
                db.Prefixes.Add(prefix);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            return View(prefix);
        }

        public Ping(string server, Prefix prefix, string message)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (String.IsNullOrWhiteSpace(message)) throw new ArgumentException("Null or whitespace string", "message");

            this.server = server;
            this.prefix = prefix;
            this.message = message;
            this.ircMessage = Common.CreateIrcMessageFormat(this.Prefix, Ping.CanonicalCommand, ":{0}", this.Message);
        }

        public Pass(string server, Prefix prefix, string password)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (String.IsNullOrWhiteSpace(password)) throw new ArgumentException("Null or whitespace string", "password");

            this.server = server;
            this.prefix = prefix;
            this.password = password;
            this.ircMessage = Common.CreateIrcMessageFormat(this.Prefix, Pass.CanonicalCommand, "{0}", this.Password);
        }

        public List(string server, Prefix prefix, IImmutableList<string> channels)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (channels == null) throw new ArgumentNullException("channels");
            if (channels.Count == 0 || channels.Any(c => String.IsNullOrWhiteSpace(c))) throw new ArgumentException("Empty channel list or list contains an empty element.", "channels");

            this.server = server;
            this.prefix = prefix;
            this.channels = channels;
            this.ircMessage = Common.CreateIrcMessageFormat(prefix, List.CanonicalCommand, "{0}", String.Join(",", this.Channels));
        }

        public Part(string server, Prefix prefix, IImmutableList<string> destinations)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (destinations == null) throw new ArgumentNullException("destinations");
            if (destinations.Count == 0 || destinations.Any(c => String.IsNullOrWhiteSpace(c))) throw new ArgumentException("Empty destination list or list contains an empty element.", "destinations");

            this.server = server;
            this.prefix = prefix;
            this.destinations = destinations;
            this.ircMessage = Common.CreateIrcMessageFormat(this.Prefix, Part.CanonicalCommand, "{0}", this.Destinations);
        }

        public Message(string server, Prefix prefix, string command, IImmutableList<string> parameters)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("String null or empty", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (String.IsNullOrWhiteSpace(command)) throw new ArgumentException("String null or empty", "command");
            if (parameters == null) throw new ArgumentNullException("parameters");
            if (parameters.Any(s => String.IsNullOrWhiteSpace(s))) throw new ArgumentException("Empty or null parameter", "parameters");

            this.server = server;
            this.prefix = prefix;
            this.command = command;
            this.parameters = parameters;
        }

        public void EqualityTest()
        {
            var p1 = new Prefix(_prefixConfig, "DEV", "iphone");
            var p2 = new Prefix(_prefixConfig, "DEV");
            var p3 = new Prefix(_prefixConfig, "stageB");
            var p4 = new Prefix(_prefixConfig, "DEV", "iphone");

            Assert.IsTrue(p1.CompareTo(p2) > 0);
            Assert.IsTrue(p1.CompareTo(p3) > 0);
            Assert.IsTrue(p2.CompareTo(p3) > 0);
            Assert.AreNotEqual(p1, p2);
            Assert.AreEqual(p1, p4);
        }

        /// <summary>
        /// Parses strings like:
        /// PFX A   0     re         .
        /// </summary>
        /// <param name="data"></param>
        /// <returns>null if parsing failes</returns>
        public static Prefix Parse(string[] data)
        {
            if (data.Length != 5)
                return null;
            if (data[0] != "PFX")
                return null;

            Prefix pfx = new Prefix ();
            if (!pfx.ParseData (data))
                return null;

            return pfx;
        }

        private static IEnumerable<string> Generate(WordChain suffixChain, int count)
        {
            var prefix = new Prefix();

              var words = Enumerable
            .Range(1, count)
            .Select(_ => suffixChain.Get(prefix))
            .TakeWhile(next => next != NONWORD);
              foreach (var next in words)
              {
            yield return next;
            prefix.Add(next);
              }
        }

        public User(string server, Prefix prefix, string userName, string realName, UserModes userMode)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (String.IsNullOrWhiteSpace(userName)) throw new ArgumentException("Null or whitespace string", "userName");
            if (String.IsNullOrWhiteSpace(realName)) throw new ArgumentException("Null or whitespace string", "realName");

            this.server = server;
            this.prefix = prefix;
            this.userName = userName;
            this.realName = realName;
            this.userModes = userMode;
            this.ircMessage = Common.CreateIrcMessageFormat(this.Prefix, User.CanonicalCommand, "{0} {1} * :{2}", this.UserName, (int)this.UserMode, this.RealName);
        }

	public PrefixDef(int prefixID, Prefix prefix) {
		this.prefixID = prefixID;
		this.prefix = prefix;
		
		Item item = new Item();
		item.SetDefaults("Unloaded Item");
		item.value = 100000;
		prefix.Apply(item);
		
		categories["Positive"] = item.value >= 100000;
		categories["Negative"] = item.value < 100000;
		
		showcaseItem = GetShowcaseItem(prefix);
	}

        public Join(string server, Prefix prefix, IImmutableList<string> channels, Maybe<IImmutableList<string>> keys)
        {
            if (String.IsNullOrWhiteSpace(server)) throw new ArgumentException("Null or whitespace string", "server");
            if (prefix == null) throw new ArgumentNullException("prefix");
            if (channels == null) throw new ArgumentNullException("channels");
            if (channels.Count == 0 || channels.Any(c => String.IsNullOrWhiteSpace(c))) throw new ArgumentException("Empty channel list or list contains an empty element.", "channels");
            if (keys.HasValue && keys.Value.Count != 0 && (keys.Value.Count != channels.Count || keys.Value.Any(k => String.IsNullOrWhiteSpace(k)))) throw new ArgumentException("Non-empty key list contains an empty element or doesn't have the same number of elements as the channel list.", "keys");

            this.server = server;
            this.prefix = prefix;
            this.channels = channels;
            this.keys = keys.DefaultIfEmpty(ImmutableList<string>.Empty).Single();
            this.ircMessage = Common.CreateIrcMessageFormat(prefix, Join.CanonicalCommand, "{0} {1}", String.Join(",", this.Channels), String.Join(",", this.Keys));
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MethodUnit" /> class.
 /// </summary>
 /// <param name="prefix">The prefix.</param>
 /// <param name="toBase">To base.</param>
 /// <param name="fromBase">From base.</param>
 /// <param name="notation">The notation.</param>
 /// <param name="expression">The expression.</param>
 public MethodUnit(
     Prefix prefix,
     Func<double, double> toBase,
     Func<double, double> fromBase,
     string notation,
     Expression expression)
 {
     this.prefix = prefix ?? Prefix.None;
     this.toBase = toBase;
     this.fromBase = fromBase;
     this.notation = notation;
     this.expression = expression;
     this.BaseUnit = new DerivedBaseUnit(expression);
     this.unitExpression = new UnitExpression(this);
 }