address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )
  }

  fun newChain(call: RealCall): RealInterceptorChain {
    return RealInterceptorChain(
      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )

[exec:patch] exec patch -p1 -i diff.patch
[exec:patch] go mod tidy -diff
[exec:patch] cmp go.mod go.mod.tidyResult
[exec:patch] cmp go.sum go.sum.tidyResult

go list -m all
cmp stdout m_all.txt

go mod edit -go=1.16
go list -m all
cmp stdout m_all.txt


# If we explicitly drop compatibility with 1.16, we retain fewer checksums,
# which gives a cleaner go.sum file but causes 1.16 to fail in readonly mode.

cp go.mod.orig go.mod

// license that can be found in the LICENSE file.

// Linkname "var" to reference newcoro is not allowed.

package main

import "unsafe"

func main() {
	call(&newcoro)
}

//go:linkname newcoro runtime.newcoro
var newcoro unsafe.Pointer

//go:noinline
func call(*unsafe.Pointer) {
	// not implemented

    %18 = stablehlo.multiply %16, %17 : tensor<1x3x3x4xf32>
    %19 = call @uniform_quantize_1(%18, %5, %6) : (tensor<1x3x3x4xf32>, tensor<1x1x1x1xf32>, tensor<1x1x1x1xi8>) -> tensor<1x3x3x4xi8>
    %20 = call @uniform_dequantize_0(%19, %5, %6) : (tensor<1x3x3x4xi8>, tensor<1x1x1x1xf32>, tensor<1x1x1x1xi8>) -> tensor<1x3x3x4xf32>
    return %20 : tensor<1x3x3x4xf32>
  }

//  0. Load the controller with initial data.
//  1. Call controllerTest.testCall() once as in TestSync()
//  2. For all volumes/claims changed by previous syncVolume/syncClaim calls,
//     call appropriate syncVolume/syncClaim (simulating "volume/claim changed"
//     events). Go to 2. if these calls change anything.
//  3. When all changes are processed and no new changes were made, call

// CHECK: %[[CALL:.+]] = "tf.XlaCallModule"(%[[ARG_0]], %[[DQ]])
// CHECK-SAME: _entry_function = @composite_conv_fn, _original_entry_function = "composite_conv_fn", _quantization_method = "weight_only_ptq { }"
// CHECK-SAME: (tensor<1x3x2x3xf32>, tensor<2x3x3x2xf32>) -> tensor<1x2x2x2xf32>
// CHECK: return %[[CALL]] : tensor<1x2x2x2xf32>

// -----

// Matches the following pattern that represents uniform quantization:
//
// `call @uniform_quantize(%input, %inverse_scale, %zero_point)`
//
// Provides helper functions to access the operands and the callee.
class UniformQuantizeFunctionCallPattern {
 public:
  // Returns Failure if it doesn't match. Returns the "wrapper" for the uniform
  // dequantization function call pattern when matched.

                super.visitExpression(expression)

                val bindingContext = analysisContext.analyze(expression)
                val call = bindingContext.get(BindingContext.CALL, expression) ?: return
                val resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, call)
                collector.checkResolveCall(resolvedCall)
            }

// an unexported name). The calls serve two purposes:
// 1) they are opaque to escape analysis, so the argument is considered to
// escape to the heap.
// 2) they keep the argument alive until the call site; the call is emitted after
// the end of the (presumed) use of the argument by C.
// cgoUse should not actually be called (see cgoAlwaysFalse).
func cgoUse(any) { throw("cgoUse should not be called") }

Second, the timer channel associated with a `Timer` or `Ticker` is
now unbuffered, with capacity 0.
The main effect of this change is that Go now guarantees
that for any call to a `Reset` or `Stop` method, no stale values
prepared before that call will be sent or received after the call.
Earlier versions of Go used channels with a one-element buffer,
making it difficult to use `Reset` and `Stop` correctly.