*     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 * import static org.codelibs.core.io.LineIterator.*;
 *
 * BufferedReader reader = ...;
 * for (Indexed&lt;String&gt; indexed : indexed(iterable(reader))) {
 *     System.out.println(indexed.getIndex());

	// If the chunk size is zero we return io.EOF. As specified by AWS,
	// only the last chunk is zero-sized.
	if len(cr.buffer) == 0 {
		if cr.debug {
			fmt.Println("EOF")
		}
		if cr.trailers != nil {
			err = cr.readTrailers()
			if cr.debug {
				fmt.Println("trailer returned:", err)
			}
			if err != nil {
				cr.err = err
				return 0, err
			}
		}
		cr.err = io.EOF
		return n, cr.err
	}

        assertTrue(provider.getMaxMessageSize() > 0, "Max message size should be positive");

        System.out.println("Selected RDMA provider: " + provider.getProviderName());
        System.out.println("Supported capabilities: " + provider.getSupportedCapabilities());
        System.out.println("Max message size: " + provider.getMaxMessageSize());
    }

    @Test

    // Ensure we are compiling against the right variant
    println(AndroidPlatform.isSupported)

    val url = "https://github.com/square/okhttp".toHttpUrl()
    println(url.topPrivateDomain())

    client.newCall(Request(url)).enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          println("failed: $e")
        }

        override fun onResponse(

	v, err := li.Get()
	if err != nil {
		log.Fatalf("Error retrieving STS credentials: %v", err)
	}

	if displayCreds {
		fmt.Println("Only displaying credentials:")
		fmt.Println("AccessKeyID:", v.AccessKeyID)
		fmt.Println("SecretAccessKey:", v.SecretAccessKey)
		fmt.Println("SessionToken:", v.SessionToken)
		return
	}

	// Use generated credentials to authenticate with MinIO server

          if (response.request().header("Authorization") != null) {
            return null; // Give up, we've already attempted to authenticate.
          }

          System.out.println("Authenticating for response: " + response);
          System.out.println("Challenges: " + response.challenges());
          String credential = Credentials.basic("jesse", "password1");
          return response.request().newBuilder()

			continue
		}
		r, err := parseGoroutineType2(arg)
		if err != nil {
			log.Fatal(err)
		}

		profFName := path.Base(arg)
		fmt.Println(strings.Repeat("=", len(profFName)))
		fmt.Println(profFName)
		fmt.Println(strings.Repeat("=", len(profFName)))
		fmt.Println("")

		for t, stacks := range r {
			if less != 0 && t >= less {
				continue
			}

    if (!testData.scheme.isEmpty() && !HTTP_URL_SCHEMES.contains(testData.scheme)) {
      System.err.println("Ignoring unsupported scheme ${testData.scheme}")
      return
    }

    if (!testData.base!!.startsWith("https:") &&
      !testData.base!!.startsWith("http:") &&
      testData.base != "about:blank"
    ) {
      System.err.println("Ignoring unsupported base ${testData.base}")
      return
    }

    try {

        System.out.println("[ Looking for " + groupId + ":" + artifactId + " ]");
        for (Artifact a : project.getArtifacts()) {
            System.out.println(a.toString());
            if (artifactId.equals(a.getArtifactId()) && a.getGroupId().equals(groupId)) {
                System.out.println("RETURN");
                return a;
            }
        }

	}
	defer r.Close()

	// Iterate through the files in the archive,
	// printing some of their contents.
	for _, f := range r.File {
		fmt.Printf("Contents of %s:\n", f.Name)
		rc, err := f.Open()
		if err != nil {
			log.Fatal(err)
		}
		_, err = io.CopyN(os.Stdout, rc, 68)
		if err != nil {
			log.Fatal(err)
		}
		rc.Close()
		fmt.Println()
	}
	// Output:
	// Contents of README: