func.return %dq : tensor<3x2xf32>
}

// -----

// CHECK-LABEL: @remove_volatile_qdq_with_requantization
// CHECK-SAME: %[[ARG0:.*]]: tensor<3x2xf32>
func.func @remove_volatile_qdq_with_requantization(%arg0: tensor<3x2xf32>) -> tensor<3x2xf32> {
  // CHECK: %[[Q1:.*]] = stablehlo.uniform_quantize %[[ARG0]]
  // CHECK: %[[Q2:.*]] = stablehlo.uniform_quantize %[[Q1]]
  // CHECK: %[[ABS:.*]] = stablehlo.abs %[[Q2]]

// CHECK-LABEL: identity
// CHECK: %0 = "tf.Identity"(%arg0) : (tensor<10xi32>) -> tensor<*xi32>
// CHECK: return %arg0, %arg1, %arg2, %0
}

func.func @sharding(%arg0: tensor<10x10xi32>) -> (tensor<10x10xi32>) {
  %0 = "tf.MatMul"(%arg0, %arg0) {device = "", transpose_a = false, transpose_b = false} : (tensor<10x10xi32>, tensor<10x10xi32>) -> tensor<10x10xi32>

    func.func @while_body_without_cluster_attr(%arg0: tensor<i32>) -> tensor<i32> {
      %0 = "tf.some_op"(%arg0) : (tensor<i32>) -> tensor<i32>
      func.return %0 : tensor<i32>
    }
    func.func @while_cond_without_cluster_attr(%arg0: tensor<i32>) -> tensor<i1> {
      %0 = "tf.some_other_op"(%arg0) : (tensor<i32>) -> tensor<i1>
      func.return %0 : tensor<i1>
    }
    func.func @callee_func(%arg0: tensor<i32>) -> tensor<i1> {

  }

  func.func private @f_callee(%arg0: tensor<*x!tf_type.resource>) -> tensor<f32>  {
    %val = "tf.PartitionedCall"(%arg0) {config = "", config_proto = "", executor_type = "", f = @f_callee_callee} : (tensor<*x!tf_type.resource>) -> (tensor<f32>)
    func.return %val : tensor<f32>
  }

  func.func private @f_callee_callee(%arg0: tensor<*x!tf_type.resource>) -> tensor<f32>  {

    %0 = "tf.some_op"(%arg0) {_xla_compile_device_type = "TPU", _replication_info = "cluster"} : (tensor<i32>) -> tensor<i32>
    func.return %0 : tensor<i32>
  }
  func.func @branch_3(%arg0: tensor<i32>) -> tensor<i32> {
    %0 = "tf.some_op"(%arg0) {_xla_compile_device_type = "TPU", _replication_info = "cluster"} : (tensor<i32>) -> tensor<i32>
    func.return %0 : tensor<i32>
  }

func.func @FuseTransposeFCRhsToBatchMatmul(%arg0: tensor<16x1024xf32>, %arg1: tensor<1024x128xf32>, %arg2: none) -> tensor<16x128xf32> {
  %cst = arith.constant dense<[1, 0]> : tensor<2xi32>
  %0 = "tfl.transpose"(%arg1, %cst) : (tensor<1024x128xf32>, tensor<2xi32>) -> tensor<128x1024xf32>
  // CHECK: "tfl.batch_matmul"(%arg0, %arg1)

    def getAsStr(self) -> str: ...
    def push_back(self, arg0) -> None: ...

class OpBuilder:
    @overload
    def __init__(self, arg0: MLIRContext) -> None: ...
    @overload
    def __init__(self, arg0: Region) -> None: ...
    @overload
    def __init__(self, arg0) -> None: ...
    @overload
    def __init__(self, arg0: Block, arg1: Block_Iterator) -> None: ...

func (m *MockRuntimeCache) ForceUpdateIfOlder(arg0 context.Context, arg1 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceUpdateIfOlder", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForceUpdateIfOlder indicates an expected call of ForceUpdateIfOlder.
func (mr *MockRuntimeCacheMockRecorder) ForceUpdateIfOlder(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()

// CHECK: %[[dw:.*]] = "tfl.depthwise_conv_2d"(%arg0, %arg1, %arg2)
// CHECK: %[[q:.*]] = "tfl.quantize"(%[[dw]])
// CHECK: %[[dq:.*]] = "tfl.dequantize"(%[[q]])
// CHECK: return %[[dq]], %[[dq]]
}

// Series of values needing requantization -- first the args then the results
// of concatenation operations. concat(concat(arg2, arg0), concat(arg1, arg0)),
// concat(concat(arg2, arg0), arg3)). arg0 should be requantized twice --

//go:build msan

#include "go_asm.h"
#include "textflag.h"

#define RARG0 R0
#define RARG1 R1
#define RARG2 R2
#define FARG R3

// func runtime·domsanread(addr unsafe.Pointer, sz uintptr)
// Called from msanread.
TEXT	runtime·domsanread(SB), NOSPLIT, $0-16
	MOVD	addr+0(FP), RARG0
	MOVD	sz+8(FP), RARG1
	// void __msan_read_go(void *addr, uintptr_t sz);
	MOVD	$__msan_read_go(SB), FARG