public static bool TestCondition(string variable, string condition, bool noCase, out GroupCollection groupCollection)
        {
            groupCollection = null;

            // negate condition ?
            var negate = false;
            if (condition.StartsWith("!")) {
                negate = true;
                condition = condition.Substring(1);
            }

            if (condition.StartsWith("=")) {
                condition = condition.Substring(1);
                return negate ^
                       String.Equals(variable, condition,
                                     noCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
            }

            if (condition.StartsWith("<")) {
                condition = condition.Substring(1);
                return negate ^ String.CompareOrdinal(variable, condition) == -1;
            }

            if (condition.StartsWith(">")) {
                condition = condition.Substring(1);
                return negate ^ String.CompareOrdinal(variable, condition) == 1;
            }

            // otherwise it's a regular expression
            var match = Regex.Match(variable, condition, noCase ? RegexOptions.IgnoreCase : RegexOptions.None);
            groupCollection = match.Groups;
            return negate ^ match.Success;
        }

 protected virtual IEnumerable<string> GetValues(GroupCollection groups)
 {
     for (var i = 1; i < groups.Count; i++)
     {
         yield return groups[i].Value;
     }
 }

        protected override void ExtraVideoMatch(VideoInfo video, GroupCollection matchGroups)
        {

            TrackingInfo ti = new TrackingInfo();

            // for southpark world
            System.Text.RegularExpressions.Group epGroup = matchGroups["Episode"];
            if (epGroup.Success)
                ti.Regex = Regex.Match(epGroup.Value, @"(?<Season>\d\d)(?<Episode>\d\d)");

            // for nl and de
            if (ti.Season == 0)
                ti.Regex = Regex.Match(video.VideoUrl, @"\/S(?<Season>\d{1,3})E(?<Episode>\d{1,3})-", RegexOptions.IgnoreCase);

            if (ti.Season != 0)
            {
                ti.Title = "South Park";
                ti.VideoKind = VideoKind.TvSeries;
                video.Other = new VideoInfoOtherHelper() { TI = ti };
            }
            else
                video.Other = new VideoInfoOtherHelper();
            int time;
            if (Int32.TryParse(video.Airdate, out time))
            {
                video.Airdate = epoch.AddSeconds(time).ToString();
            }
        }

        private void SetScorePosition(IScore score, GroupCollection parts)
        {
            var offset = string.IsNullOrEmpty(parts[2].Value) ? parts[1].Length : Convert.ToInt32(parts[2].Value);
            var timing = parts[1].Value.Last() == '\\' ? OffsetTiming.Early : OffsetTiming.Late;

            score.SetPosition(timing == OffsetTiming.Early ? -offset : offset);
        }

		private void AddPeople(string groupName, string singular, string plural, StringBuilder sb, GroupCollection groups) {
			if (groups[groupName].Success) {
				if (sb.Length != 0) sb.AppendLine();
				string people=htmlRx.Replace(groups[groupName].Value, string.Empty);
				sb.Append(people.Contains(",") ? plural:singular).Append(people);
			}
		}

		void SetStackTraceFilePosition(GroupCollection groups)
		{
			string fileName = groups[1].Value;
			int line = Convert.ToInt32(groups[2].Value);
			int column = 1;
			
			StackTraceFilePosition = new FilePosition(fileName, line, column);
		}

        protected override IEnumerable<string> GetValues(GroupCollection groups)
        {
            for (var i = 1; i < groups.Count; i++)
            {
                if (groups[i].Success) return new[] {groups[i].Value};
            }

            return new string[0];
        }

 private static string[] ConvertRegexGroupsToArray(GroupCollection groups)
 {
     var ret = new string[groups.Count - 1];
     for (var i = 1; i < groups.Count; i++)
     {
         ret[i - 1] = groups[i].Value;
     }
     return ret.Where(x => !String.IsNullOrWhiteSpace(x)).ToArray(); // HACK: This should be changed in the Regex behaviour and this hack should be removed (wait for internet to see the best way)
 }

 private int SelectValue( GroupCollection groups, ref string str )
 {
     int q = 4;
       do {
     str = groups[ q ].Value;
     q += 2;
       } while( q <= 8 && str.Length == 0 );
       return q - 2;
 }

        private static DynamicDictionary GetParameters(Regex regex, GroupCollection groups)
        {
            dynamic data = new DynamicDictionary();

            for (var i = 1; i <= groups.Count; i++)
            {
                data[regex.GroupNameFromNumber(i)] = groups[i].Value;
            }

            return data;
        }

        private static DynamicDictionary GetParameters(Regex regex, GroupCollection groups)
        {
            dynamic data = new DynamicDictionary();

            for (int i = 1; i <= groups.Count; i++)
            {
                data[regex.GroupNameFromNumber(i)] = Uri.UnescapeDataString(groups[i].Value);
            }

            return data;
        }

		private Match (Regex regex, IMachine machine,
						GroupCollection groups,
						string text, int text_length,
						int index, int length, int n_caps)
			: base (text, index, length, n_caps) {
			this.regex = regex;
			this.machine = machine;
			this.text_length = text_length;

			this.groups = groups;
			groups.SetValue (this, 0);
		}

        private void AddToList(GroupCollection groups, List<string> values, string[] ignoreValues)
        {
            string key = groups["name"].Value;
            string value = groups["value"].Value;

            if (!String.IsNullOrEmpty(key) && !String.IsNullOrEmpty(value))
            {
                string valueToAdd = String.Format("{0}={1}", key, HttpUtility.UrlEncode(value));
                if (ignoreValues == null || Array.IndexOf(ignoreValues, valueToAdd) == -1)
                    values.Add(valueToAdd);
            }
        }

 private void Add(GroupCollection g, string category, IDictionary<string, double> externalDictionary, string success, string fail)
 {
     var number = g[1].Value;
       var unit = g[2].Value;
       var wordToAdd = g[3].Value;
       var duration = BanTime(number, unit);
       if (!category.Contains("Regex")) wordToAdd = wordToAdd.ToLower();
       if (Datastore.AddToStateString(category, wordToAdd, duration.TotalSeconds, externalDictionary))
     Send(wordToAdd + success);
       else
     Send(wordToAdd + fail + Tools.PrettyDeltaTime(duration));
 }

 private static IEnumerable<string> DevNamesFrom(GroupCollection groups)
 {
     int skip = 1;
     foreach (Group @group in groups)
     {
         if (skip > 0)
         {
             skip--;
             continue;
         }
         yield return @group.Value;
     }
 }

        public static void AddNewAlias(GroupCollection aliasGroup)
        {
            string aliasName = aliasGroup[1].ToString();
            SteamID steamID = (SteamID) UInt64.Parse(aliasGroup[2].ToString());

            StreamWriter sw = File.AppendText("alias_list.txt");

            sw.WriteLine("{0}:{1}", aliasName, steamID.ConvertToUInt64());

            sw.Close();

            Roulette.BuildAliasList();
        }

 internal void InitializeParams(GroupCollection groups)
 {
     int iterator = 0;
     foreach (Group group in groups)
     {
         if (iterator != 0)
         {
             foreach (Capture capture in group.Captures)
             {
                 parameters.Set(capture.Value, iterator - 1);
             }
         }
         iterator++;
     }
 }

        internal Match(string text, Matcher matcher, Regex regex, int start)
            : base(text, start, start)
        {
            this.matcher = matcher;
            this.regex = regex;

            bool success = matcher.Find(start);
            if (success)
            {
                UpdateRegion(matcher.Start(), matcher.End());
                groupCollection = new GroupCollection(text, matcher, this);  
            }
            else
            {
                UpdateRegion(-1, -1);
            }
        }

        private static string ResultFileNameFromPatterns( string[] patterns, GroupCollection parts )
        {
            var rslt = new System.Text.StringBuilder();
            var ptr_parts = new List<string[]>();
            for( int i = 0; i < patterns.Length; ++i )
                ptr_parts.Add(patterns[i].Split('*'));

            int ptr_part_num = ptr_parts[0].Length;
            for( int i = 0; i < ptr_part_num; ++i )
            {
                if( i > 0 )
                    rslt.Append(parts[i].Value);

                rslt.Append(string.Join(string.Empty, ptr_parts.Select(ptrs => ptrs[i]).Distinct()));
            }

            return rslt.ToString();
        }

        public void httpBodyInfoHandle(HttpListenerContext context, GroupCollection url)
        {
            try {
                HttpListenerResponse response = context.Response;
                CelestialBody body = KerbalGIS.findBody (url [1].Value);
                if (body == null || body.BiomeMap.Attributes.Length <= 1) {
                    httpError (context);
                    return;
                }

                string ret = Info.getJSONInfo (body);

                response.StatusCode = 200;
                response.ContentType = "application/json";
                response.Close (Encoding.UTF8.GetBytes (ret), false);
            } catch (Exception e) {
                Debug.LogException (e);
            }
        }