.throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)

	BEQ	R1, 2(PC)
	JAL	1(PC)		// CALL 1(PC)	// 0c00000f
	BEQ	R1, 2(PC)
	JAL	label0+0	// CALL 3	// 0c000007

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

//
// BEQ/BNE

        private final RequestOptionCall<BulkRequestBuilder> call;

        private final RequestOptionCall<B> entityCall;

        public BulkList(final List<E> parent, final RequestOptionCall<BulkRequestBuilder> call, final RequestOptionCall<B> entityCall) {
            this.parent = parent;
            this.entityCall = entityCall;
            this.call = call;
        }

        public int size() {

    dependencies: List["Dependant"] = field(default_factory=list)
    security_requirements: List[SecurityRequirement] = field(default_factory=list)
    name: Optional[str] = None
    call: Optional[Callable[..., Any]] = None
    request_param_name: Optional[str] = None
    websocket_param_name: Optional[str] = None
    http_connection_param_name: Optional[str] = None
    response_param_name: Optional[str] = None

   *
   * @return {@code true} if the network was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean removeNode(N node);

  /**
   * Removes {@code edge} from this network, if it is present.
   *
   * @return {@code true} if the network was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean removeEdge(E edge);

  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.";

		// 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).

    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;

   * receiving. With duplex the request and response may be interleaved! That is, request body bytes
   * may be sent after response headers or body bytes have been received.
   *
   * Though any call may be initiated as a duplex call, only web servers that are specially
   * designed for this nonstandard interaction will use it. As of 2019-01, the only widely-used
   * implementation of this pattern is [gRPC][grpc].
   *

   *
   * <p>Cancellation does not propagate from the output future to a callable that has begun to
   * execute, but if the output future is cancelled before {@link Callable#call()} is invoked,
   * {@link Callable#call()} will not be invoked.
   */
  public <T extends @Nullable Object> ListenableFuture<T> submit(
      Callable<T> callable, Executor executor) {
    checkNotNull(callable);