class SplitUtils {
    public static LinkedList split(String source) {
        int lastFind = 0;
        int currentFind = 0;
        LinkedList result = new LinkedList();

        while ((currentFind = source.indexOf(" ", lastFind)) != -1) {
            String token = source.substring(lastFind);
            if (currentFind != -1) {
                token = token.substring(0, currentFind - lastFind);
            }

        throw IllegalArgumentException(e)
      }
    } else {
      this.handshake = null
    }

    if (requestLine.isNotEmpty()) {
      val methodEnd = requestLine.indexOf(' ')
      val pathEnd = requestLine.indexOf(' ', methodEnd + 1)
      this.method = requestLine.substring(0, methodEnd)
      var path = requestLine.substring(methodEnd + 1, pathEnd)
      if (!path.startsWith("/")) {
        path = "/"

        println "-> CHECKING: $progressContent"
        def lines = progressContent
        def startIndex = lines.indexOf("[START " + operation + "]")
        if (startIndex == -1) {
            return false
        }
        lines = lines[startIndex..<lines.size()]
        lines = lines[0..lines.indexOf("[END " + operation + "]")]
        lines.size() >= 2
    }

    @Deprecated

        if (!GUtil.isTrue(part)) {
            throw new UnsupportedNotationException(notation);
        }
        for (char c : INVALID_SPEC_CHARS) {
            if (part.indexOf(c) != -1) {
                throw new UnsupportedNotationException(notation);
            }
        }
        return part;
    }

    public static String validate(String part) {

        }
    }

    @Override
    protected void applyChangeTo(BuildContext context, StringBuilder text) {
        int lastOpeningPos = text.lastIndexOf("{")
        int insertPos = text.indexOf("}", lastOpeningPos)
        boolean isClassClosing = insertPos == text.lastIndexOf("}")
        if (insertPos < 0 || isClassClosing) {

            didRemove(element);
        }
        getEventRegister().fireObjectRemoved(element);
        return element;
    }

    @Override
    public int indexOf(Object o) {
        return getStore().indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return getStore().lastIndexOf(o);
    }

    @Override
    public ListIterator<T> listIterator() {

      }
    } else {
      this.handshake = null
      this.handshakeServerNames = listOf()
    }

    if (requestLine.isNotEmpty()) {
      val methodEnd = requestLine.indexOf(' ')
      val pathEnd = requestLine.indexOf(' ', methodEnd + 1)
      this.method = requestLine.substring(0, methodEnd)
      var path = requestLine.substring(methodEnd + 1, pathEnd)
      if (!path.startsWith("/")) {
        path = "/"
      }

    @Override
    public String normalize(String url) {
        String result = url;

        if (result != null) {
            while (true) {
                int idx = result.indexOf("/../");
                if (idx < 0) {
                    break;
                } else if (idx == 0) {
                    result = result.substring(3);
                    continue;
                }

    public InetAddress[] resolve(final String host) throws UnknownHostException {
        return InetAddress.getAllByName(toAscii(host));
    }

    protected String decode(final String host) {
        if (host.indexOf('%') == -1) {
            return host;
        }
        try {
            return URLDecoder.decode(host, encoding);
        } catch (final UnsupportedEncodingException e) {
            return host;
        }

abstract class GuavaRule: ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        val variantVersion = context.details.id.version
        val version = variantVersion.substring(0, variantVersion.indexOf("-"))
        listOf("compile", "runtime").forEach { base ->
            mapOf(6 to "android", 8 to "jre").forEach { (targetJvmVersion, jarName) ->