// CHECK-NEXT: [[res:%.*]] = tfrt_fallback_async.executeop key(1) cost({{.*}}) device("/job:localhost/replica:0/task:0/device:CPU:0") "tf.GatherV2"([[value]], {{.*}}, [[const]])
// CHECK-NEXT: tfrt.return [[out_chain]], [[res]] : !tfrt.chain, !tfrt_fallback.tf_tensor
func.func @gather(%indices: tensor<?xi32>,
             %resource: tensor<*x!tf_type.resource>) -> tensor<*xi32> {

// CHECK: %[[GATHER:.*]] = "tf.XlaGather"(%[[DEQUANTIZED]], %arg0, %cst) <{dimension_numbers = "\0A\02\00\01\12\01\00\1A\02\00\01 \01", indices_are_sorted = true}> : (tensor<200x100x300xf32>, tensor<10x2xi32>, tensor<3xi64>) -> tensor<1x300x10xf32>
// CHECK: return %[[GATHER]] : tensor<1x300x10xf32>

// -----

module {

		t.Fatalf("incorrect sum: %v", s)
	}
}

func gatherHistogram(t *testing.T, name string) (count uint64, sum float64) {
	metrics, err := legacyregistry.DefaultGatherer.Gather()
	if err != nil {
		t.Fatalf("Failed to gather metrics: %s", err)
	}
	for _, mf := range metrics {
		if mf.GetName() == name {
			for _, m := range mf.GetMetric() {
				h := m.GetHistogram()
				count += h.GetSampleCount()

// Convert XlaGather op without batch to Slice op with above two functions.
def ConvertXlaGatherOpWithoutBatch : Pat<
  (TF_XlaGatherOp:$gather $operand,
    $start_indices, $slice_sizes, $dimension_numbers, $indices_are_sorted),
  (CreateSliceAndReshapeOpFromXlaGatherOpWithoutBatch $operand,
    $start_indices, $slice_sizes, $gather, $dimension_numbers),

	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/util/retry"
)

type MetricsTest struct {
	t      test.Failer
	reg    prometheus.Gatherer
	deltas map[metricKey]float64
}

type metricKey struct {
	name  string
	attrs attribute.Set
}

var reg = lazy.New(func() (prometheus.Gatherer, error) {
	// TODO: do not use a global and/or add a way to reset (https://github.com/open-telemetry/opentelemetry-go/issues/4291)

	"k8s.io/kubernetes/pkg/kubelet/metrics"
)

func TestRecordOperation(t *testing.T) {
	// Use local registry
	var registry = compbasemetrics.NewKubeRegistry()
	var gather compbasemetrics.Gatherer = registry

	registry.MustRegister(metrics.RuntimeOperations)
	registry.MustRegister(metrics.RuntimeOperationsDuration)
	registry.MustRegister(metrics.RuntimeOperationsErrors)

	registry.Reset()

        spec->biases_params[2] = {{0, 1},
                                  quant::GetUniformQuantizedTypeForBias};
      }
    } else if (function_name.contains("gather")) {
      // Note that gather has axis attribute that specifies channel axis.
      spec->coeff_op_quant_dim[0] = -1;
    }
    for (auto quantizable_operand : spec->coeff_op_quant_dim) {

	if err := rbacregistryvalidation.ConfirmNoEscalationInternal(ctx, s.ruleResolver, rules); err != nil {
		return nil, apierrors.NewForbidden(groupResource, clusterRole.Name, err)
	}
	// to set the aggregation rule, since it can gather anything, requires * on *.*
	if hasAggregationRule(clusterRole) {
		if err := rbacregistryvalidation.ConfirmNoEscalationInternal(ctx, s.ruleResolver, fullAuthority); err != nil {

  }

  LiftQuantizableSpotsAsFunctionsDRQPass(
      const LiftQuantizableSpotsAsFunctionsDRQPass& other) {
    quantization_method_ = other.quantization_method_;
    target_opset_ = other.target_opset_;
    min_num_elements_for_weights_ = other.min_num_elements_for_weights_;
  }

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in

    "FakeQuantWithMinMaxVars",
    "FakeQuantWithMinMaxVarsGradient",
    "FakeQuantWithMinMaxVarsPerChannel",
    "FakeQuantWithMinMaxVarsPerChannelGradient",
    "Fill",
    "Fingerprint",
    "Gather",
    "GuaranteeConst",
    "Identity",
    "IdentityN",
    "InplaceAdd",
    "InplaceSub",
    "InplaceUpdate",
    "InvertPermutation",
    "ListDiff",
    "MatrixBandPart",
    "MatrixDiag",