module @_tpu_v1_compat_outlined {
    func.func nested @_tpu_v1_compat_outlined_func0(%arg0: tensor<i1>) -> tensor<i1> {
      %0 = "tf.opA"(%arg0) : (tensor<i1>) -> tensor<i1>
      func.return %0 : tensor<i1>
    }
    func.func nested @_tpu_v1_compat_outlined_func1(%arg0: tensor<i1>, %arg1: tensor<f32>) -> (tensor<i1>, tensor<i32>) {
      %0 = "tf.opA"(%arg0) : (tensor<i1>) -> tensor<i1>
      %1 = "tf.opA"(%0) : (tensor<i1>) -> tensor<i1>

//go:build asan

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

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

// Called from instrumented code.
// func runtime·doasanread(addr unsafe.Pointer, sz, sp, pc uintptr)
TEXT	runtime·doasanread(SB), NOSPLIT, $0-32
	MOVD	addr+0(FP), RARG0
	MOVD	sz+8(FP), RARG1
	MOVD	sp+16(FP), RARG2
	MOVD	pc+24(FP), RARG3

  func.return %1 : tensor<1xf32>
}

func.func @cond_true(%arg0: tensor<*xf32>, %arg1: tensor<*xf32>) -> tensor<*xf32> {
  %0 = tfl.add %arg0, %arg1 {fused_activation_function = "NONE"} : tensor<*xf32>
  func.return %0 : tensor<*xf32>
}

func.func @cond_false(%arg0: tensor<*xf32>, %arg1: tensor<*xf32>) -> tensor<*xf32> {
  %0 = tfl.mul %arg0, %arg1 {fused_activation_function = "NONE"} : tensor<*xf32>

// RUN: tf-opt %s -tfl-optimize-op-order | FileCheck %s

// CHECK-LABEL: dequantize_pushdown
func.func @dequantize_pushdown(%arg0: tensor<1000x1000x!quant.uniform<i8:f32, 7.812500e-03>>, %arg1: tensor<1x1xi32>) -> tensor<1x1x1000xf32> {
  %0 = "tfl.dequantize"(%arg0) : (tensor<1000x1000x!quant.uniform<i8:f32, 7.812500e-03>>) -> tensor<1000x1000xf32>

  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]]

    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> {

    %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()