var matchResults map[string]string
	for _, regex := range cgroupREs {
		matches := reSubMatchMap(regex, cgroupPath)
		if isValidCGroupPathMatches(matches) {
			if matchResults != nil {
				return "", "", false
			}
			matchResults = matches
		}
	}

	if matchResults != nil {
		var podUID types.UID
		if matchResults["poduid"] != "" {

            MASTER_BRANCH -> 0
            RELEASE_BRANCH -> 1
            else -> {
                val matchResult = OLD_RELEASE_PATTERN.find(branchName)
                if (matchResult == null) {
                    null
                } else {
                    (matchResult.groupValues[1].toInt() - 4).apply {
                        require(this in 2..23)
                    }
                }
            }

        while (matcher.find()) {
            MatchResult xrefMatcher = matcher.toMatchResult();
            String link = xrefMatcher.group(1);
            if (link.contains("#")) {
                Matcher linkMatcher = linkWithHashPattern.matcher(link);
                if (linkMatcher.matches()) {
                    MatchResult result = linkMatcher.toMatchResult();

			err := errLikeInvalidEscape
			return nil, errLikeInvalidInputs(err)
		}
	}

	matchResult, err := evalSQLLike(s, patternStr, escape)
	if err != nil {
		return nil, err
	}

	if e.Not {
		matchResult = !matchResult
	}

	return FromBool(matchResult), nil
}

func (e *ListExpr) evalNode(r Record, tableAlias string) (*Value, error) {
	res := make([]Value, len(e.Elements))

        override fun flush() {}

        override fun close() {}
      }

    private fun readClientRandom(param: String): String? {
      val matchResult = randomRegex.find(param)

      return if (matchResult != null) {
        matchResult.groupValues[1].replace(" ", "")
      } else {
        null
      }
    }

    override fun secureConnectStart(call: Call) {

          return left.getName().compareTo(right.getName());
        }
      };

  /**
   * Returns a new {@code MatchResult} that corresponds to a successful match. Apache Harmony (used
   * in Android) requires a successful match in order to generate a {@code MatchResult}:

/**
 * Returns a media type for this string.
 *
 * @throws IllegalArgumentException if this is not a well-formed media type.
 */
internal fun String.commonToMediaType(): MediaType {
  val typeSubtype: MatchResult =
    TYPE_SUBTYPE.matchAtPolyfill(this, 0)
      ?: throw IllegalArgumentException("No subtype found for: \"$this\"")
  val type = typeSubtype.groupValues[1].lowercase()
  val subtype = typeSubtype.groupValues[2].lowercase()

          return left.getName().compareTo(right.getName());
        }
      };

  /**
   * Returns a new {@code MatchResult} that corresponds to a successful match. Apache Harmony (used
   * in Android) requires a successful match in order to generate a {@code MatchResult}:

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import junit.framework.TestCase;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Unit test for {@link ArbitraryInstances}.
 *
 * @author Ben Yu

import okio.Options
import okio.Path
import okio.use

// TODO: migrate callers to [Regex.matchAt] when that API is not experimental.
internal fun Regex.matchAtPolyfill(
  input: CharSequence,
  index: Int,
): MatchResult? {
  val candidate = find(input, index) ?: return null
  if (candidate.range.first != index) return null // Didn't match where it should have.
  return candidate
}

@JvmField