public void remove() {
      checkForConcurrentModification();
      checkState(current != null, "no calls to next() since the last call to remove()");
      if (current != next) { // after call to next()
        previous = current.previous;
        nextIndex--;
      } else { // after call to previous()
        next = current.next;
      }
      removeNode(current);
      current = null;
      expectedModCount = modCount;

	JMP	label0+0	// JMP 66
	BEQ	R1, 2(PC)
	JAL	1(PC)	// CALL 1(PC)
	BEQ	R1, 2(PC)
	JAL	label0+0	// CALL 66

	//	LBRA addr
	//	{
	//		outcode(int($1), &nullgen, 0, &$2);
	//	}
	BEQ	R1, 2(PC)
	JMP	0(R1)	// JMP (R1)
	BEQ	R1, 2(PC)
	JMP	foo+0(SB)	// JMP foo(SB)
	BEQ	R1, 2(PC)
	JAL	0(R1)	// CALL (R1)
	BEQ	R1, 2(PC)
	JAL	foo+0(SB)	// CALL foo(SB)

//
// BEQ/BNE
//
//	LBRA rreg ',' rel

	public fun requestBodyStart (Lokhttp3/Call;)V
	public fun requestFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun requestHeadersEnd (Lokhttp3/Call;Lokhttp3/Request;)V
	public fun requestHeadersStart (Lokhttp3/Call;)V
	public fun responseBodyEnd (Lokhttp3/Call;J)V
	public fun responseBodyStart (Lokhttp3/Call;)V
	public fun responseFailed (Lokhttp3/Call;Ljava/io/IOException;)V

  static final String MULTIPLE_EDGES_CONNECTING =
      "Cannot call edgeConnecting() when parallel edges exist between %s and %s. Consider calling "
          + "edgesConnecting() instead.";
  static final String PARALLEL_EDGES_NOT_ALLOWED =
      "Nodes %s and %s are already connected by a different edge. To construct a graph "
          + "that allows parallel edges, call allowsParallelEdges(true) on the Builder.";

      throw new AssertionFailedError();
    }

    @Override
    public V get() throws InterruptedException {
      /*
       * Wait a little to give us time to call addListener before the future's
       * value is set in addition to the call we'll make after then.
       */
      allowGetToComplete.await(1, SECONDS);
      throw new RuntimeException("expected, should be caught");
    }

    @Override

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse = throw UnsupportedOperationException("unexpected call")

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

        .header("Sec-WebSocket-Version", "13")
        .header("Sec-WebSocket-Extensions", "permessage-deflate")
        .build()
    call = RealCall(webSocketClient, request, forWebSocket = true)
    call!!.enqueue(
      object : Callback {
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          val socket =
            try {
              checkUpgradeSuccess(response)

		// Dummy Bucket Calls
		// GetBucketACL -- this is a dummy call.
		router.Methods(http.MethodGet).
			HandlerFunc(s3APIMiddleware(api.GetBucketACLHandler)).
			Queries("acl", "")
		// PutBucketACL -- this is a dummy call.
		router.Methods(http.MethodPut).
			HandlerFunc(s3APIMiddleware(api.PutBucketACLHandler)).
			Queries("acl", "")
		// GetBucketCors - this is a dummy call.
		router.Methods(http.MethodGet).

     * must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The call timeout spans the entire call: resolving DNS, connecting, writing the request body,
     * server processing, and reading the response body. If the call requires redirects or retries
     * all must complete within one timeout period.
     *
     * The default value is 0 which imposes no timeout.
     */

     * we must return it in the following next() call even if it was in the process of being removed
     * when hasNext() was called.
     */
    private @Nullable E nextItem;

    /**
     * Index of element returned by most recent call to next. Reset to -1 if this element is deleted
     * by a call to remove.
     */
    private int lastRet;

    Itr() {
      lastRet = -1;