public static RubyArray GetGroup(ConversionStorage<int>/*!*/ fixnumCast, MatchData/*!*/ self, [NotNull]Range/*!*/ range) {
     int begin, count;
     if (!IListOps.NormalizeRange(fixnumCast, self.Groups.Count, range, out begin, out count)) {
         return null;
     }
     return GetGroup(fixnumCast.Context, self, begin, count);
 }

 public static RubyArray GetGroup(RubyContext/*!*/ context, MatchData/*!*/ self, [NotNull]Range/*!*/ range) {
     int begin, count;
     if (!IListOps.NormalizeRange(context, self.Groups.Count, range, out begin, out count)) {
         return null;
     }
     return GetGroup(context, self, begin, count);
 }

 public static RubyArray/*!*/ Offset(MatchData/*!*/ self, [DefaultProtocol]int groupIndex) {
     var group = self.GetExistingGroup(groupIndex);
     RubyArray result = new RubyArray(2);
     if (group.Success) {
         result.Add(group.Index);
         result.Add(group.Index + group.Length);
     } else {
         result.Add(null);
         result.Add(null);
     }
     return result;
 }

 public static RubyArray/*!*/ Offset(MatchData/*!*/ self, [DefaultProtocol]int groupIndex) {
     self.RequireExistingGroup(groupIndex);
     RubyArray result = new RubyArray(2);
     if (self.GroupSuccess(groupIndex)) {
         result.Add(self.GetGroupStart(groupIndex));
         result.Add(self.GetGroupEnd(groupIndex));
     } else {
         result.Add(null);
         result.Add(null);
     }
     return result;
 }

 public static MutableString/*!*/ PreMatch(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return self.OriginalString.GetSlice(0, self.Index).TaintBy(self, context);
 }

 public static RubyArray/*!*/ Captures(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return ReturnMatchingGroups(context, self, 1);
 }

 private static object MatchToScanResult(RubyScope/*!*/ scope, MutableString/*!*/ self, RubyRegex/*!*/ regex, MatchData/*!*/ match) {
     if (match.GroupCount == 1) {
         return match.GetValue().TaintBy(regex, scope);
     } else {
         var result = new RubyArray(match.GroupCount - 1);
         for (int i = 1; i < match.GroupCount; i++) {
             MutableString value = match.GetGroupValue(i);
             result.Add(value != null ? value.TaintBy(regex, scope) : value);
         }
         return result;
     }
 }

        private static void AppendLastCharOfLastMatchGroup(MatchData/*!*/ match, MutableString/*!*/ result) {
            int i = match.GroupCount - 1;
            // move to last successful match group
            while (i > 0 && !match.GroupSuccess(i)) {
                i--;
            }

            if (i > 0 && match.GroupSuccess(i)) {
                int length = match.GetGroupLength(i);
                if (length > 0) {
                   result.Append(match.OriginalString, match.GetGroupStart(i) + length - 1, 1);
                }
            }
        }

 public static MatchData/*!*/ InitializeCopy(MatchData/*!*/ self, [NotNull]MatchData/*!*/ other) {
     self.InitializeFrom(other);
     return self;
 }

 public static MutableString/*!*/ ToS(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return MutableString.Create(self.Value).TaintBy(self, context);
 }

 public static MutableString/*!*/ Inspect(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return RubyUtils.ObjectToMutableString(context, self);
 }

        public static RubyArray/*!*/ ValuesAt(ConversionStorage<int>/*!*/ conversionStorage, 
            MatchData/*!*/ self, [DefaultProtocol, NotNull]params int[]/*!*/ indices) {

            RubyArray result = new RubyArray();
            for (int i = 0; i < indices.Length; i++) {
                result.Add(GetGroup(conversionStorage.Context, self, indices[i]));
            }
            return result;
        }

        public static object Select(RubyContext/*!*/ context, [NotNull]BlockParam/*!*/ block, MatchData/*!*/ self) {
            RubyArray result = new RubyArray();
            for (int i = 0; i < self.Groups.Count; i++) {
                MutableString value = self.GetGroupValue(context, i);

                object blockResult;
                if (block.Yield(value, out blockResult)) {
                    return blockResult;
                }

                if (RubyOps.IsTrue(blockResult)) {
                    result.Add(value);
                }
            }
            return result;
        }

 public static MutableString/*!*/ ReturnFrozenString(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return MutableString.Create(self.OriginalString).TaintBy(self, context).Freeze();
 }

 public static RubyArray/*!*/ ToArray(RubyContext/*!*/ context, MatchData/*!*/ self) {
     return ReturnMatchingGroups(context, self, 0);
 }

 protected MatchData(MatchData/*!*/ data)
     : this(data._match, data._originalString, data._kIndices) {
 }

 public void InitializeFrom(MatchData/*!*/ other) {
     _match = other._match;
     _kIndices = other._kIndices;
     _originalString = other._originalString;
 }

        private static void AppendReplacementExpression(MutableString/*!*/ input, MatchData/*!*/ match, MutableString/*!*/ result, 
            MutableString/*!*/ replacement) {

            int backslashCount = 0;
            for (int i = 0; i < replacement.Length; i++) {
                char c = replacement.GetChar(i);
                if (c == '\\') {
                    backslashCount++;
                } else if (backslashCount == 0) {
                    result.Append(c);
                } else {
                    AppendBackslashes(backslashCount, result, 0);
                    // Odd number of \'s + digit means insert replacement expression
                    if ((backslashCount & 1) == 1) {
                        if (Char.IsDigit(c)) {
                            AppendGroupByIndex(match, c - '0', result);
                        } else if (c == '&') {
                            AppendGroupByIndex(match, match.GroupCount - 1, result);
                        } else if (c == '`') {
                            // Replace with everything in the input string BEFORE the match
                            result.Append(input, 0, match.Index);
                        } else if (c == '\'') {
                            // Replace with everything in the input string AFTER the match
                            int start = match.Index + match.Length;
                            // TODO:
                            result.Append(input, start, input.GetLength() - start);
                        } else if (c == '+') {
                            // Replace last character in last successful match group
                            AppendLastCharOfLastMatchGroup(match, result);
                        } else {
                            // unknown escaped replacement char, go ahead and replace untouched
                            result.Append('\\');
                            result.Append(c);
                        }
                    } else {
                        // Any other # of \'s or a non-digit character means insert literal \'s and character
                        AppendBackslashes(backslashCount, result, 1);
                        result.Append(c);
                    }
                    backslashCount = 0;
                }
            }
            AppendBackslashes(backslashCount, result, 1);
        }

 private static void AppendGroupByIndex(MatchData/*!*/ match, int index, MutableString/*!*/ result) {
     var value = match.GetGroupValue(index);
     if (value != null) {
         result.Append(value);
     }
 }

 private static void AppendReplacementExpression(MutableString/*!*/ input, MatchData/*!*/ match, MutableString/*!*/ result, MutableString/*!*/ replacement) {
     AppendReplacementExpression(input, match.Groups, result, replacement);
 }