* @since 22.0
   */
  void putCoalescing(Range<K> range, V value);

  /** Puts all the associations from {@code rangeMap} into this range map (optional operation). */
  void putAll(RangeMap<K, ? extends V> rangeMap);

  /** Removes all associations from this range map (optional operation). */
  void clear();

  /**
   * Removes all associations from this range map in the specified range (optional operation).
   *

    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**
   * Invoked as soon as a connection is successfully established.
   */
  open fun connectEnd(
    connection: Connection,
    route: Route,
    call: Call,
  ) {}

  /**

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "../../../../../runtime/textflag.h"
// TODO: cover more instruction

TEXT foo(SB),DUPOK|NOSPLIT,$0
	JAL	1(PC)	//CALL 1(PC)	//00040054
	JAL	(R4)	//CALL (R4)	//8100004c
	// relocation in play so the assembled offset should be 0

	argv0, err := exec.LookPath(os.Args[0])
	if err != nil {
		return err
	}

	// Invokes the execve system call.
	// Re-uses the same pid. This preserves the pid over multiple server-respawns.
	return syscall.Exec(argv0, os.Args, os.Environ())
}

// freezeServices will freeze all incoming S3 API calls.
// For each call, unfreezeServices must be called once.
func freezeServices() {

	
    // The typed instance is also used for calls
    conn := manager.Connection("host")
    resp, err := instance.Call(ctx, conn, grid.NewMSSWith(map[string]string{"myfield": "myvalue"}))
    if err == nil {
        fmt.Println("Got response with field", resp["result"])
    }
```

The wrapper will handle all serialization and de-seralization of the request and response,

	cb := NewCallback()

	c.SetCallback(cb)
	s := c.Call()
	if s != "Callback::run" {
		fatal("unexpected string from Call: %q", s)
	}
	c.DelCallback()
}

func testCallback() {
	c := NewCaller()
	cb := NewDirectorCallback(&GoCallback{})
	c.SetCallback(cb)
	s := c.Call()
	if s != "GoCallback.Run" {
		fatal("unexpected string from Call with callback: %q", s)
	}
	c.DelCallback()

    ```

!!! tip
    All this might seem contrived. And it might not be very clear how is it useful yet.

    These examples are intentionally simple, but show how it all works.

    In the chapters about security, there are utility functions that are implemented in this same way.

	void setCallback(Callback *cb) { delCallback(); callback_ = cb; }
	std::string call();

    final Exception e = new Exception();
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                throw e;
              }
            });
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    try {
      getDone(task);
      fail();

    }
    while (filesQueueToAnalyze.isNotEmpty()) {
        val file = filesQueueToAnalyze.removeFirst()
        analyze(file) {
            require(this is KtFe10AnalysisSession) {
                "K2 implementation shouldn't call this code"
            }
            file.accept(InlineDelegatedPropertyAccessorsAnalyzer(analysisContext, collector))
        }
    }
}

@OptIn(KtAnalysisNonPublicApi::class)