/*collapsedSliceDims=*/collapsed_dims,
        /*operandBatchingDims=*/{},
        /*startIndicesBatchingDims=*/{}, start_index_map,
        /*indexVectorDim=*/0);
    Value gather = rewriter.create<mhlo::GatherOp>(
        loc, op.getInput(), start_indices, dims_attr,
        GetI64ElementsAttr(slice_sizes, &rewriter));

    // We now need to broadcast the "in_bounds" boolean expression, as well as

//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of

  bool has_fixed_output_range = false;
  // Whether this op should have same operand and result scales (e.g. concat)
  bool has_same_scale_requirement = false;
  // Whether this op should have same operand and result type (e.g. gather)
  bool has_same_operand_and_result_type_requirement = false;
  // Returns the fixed output range, when has_fixed_output_range is set.
  GetFixedOutputRangeFunc fixed_output_range_func;

		err := sa.AddFileKubeMeshNetworks(tc.meshNetworksFile)
		if err != nil {
			return nil, fmt.Errorf("error apply mesh networks file %s: %v", tc.meshNetworksFile, err)
		}
	}

	// Gather test files
	var files []local.ReaderSource
	for _, f := range tc.inputFiles {
		of, err := os.Open(f)
		if err != nil {
			return nil, fmt.Errorf("error opening test file: %q", f)
		}

		}
		if !ctxt.isAbsPath(path) {
			p.Dir = ctxt.joinPath(srcDir, path)
		}
		// p.Dir directory may or may not exist. Gather partial information first, check if it exists later.
		// Determine canonical import path, if any.
		// Exclude results where the import path would include /testdata/.
		inTestdata := func(sub string) bool {

	MOVW	m_curg(R3), g
	JAL	runtime·save_g(SB)
	MOVW	(g_sched+gobuf_sp)(g), R2 // prepare stack as R2
	MOVW	(g_sched+gobuf_pc)(g), R4
	MOVW	R4, -(12+4)(R2)	// "saved LR"; must match frame size
	// Gather our arguments into registers.
	MOVW	fn+0(FP), R5
	MOVW	frame+4(FP), R6
	MOVW	ctxt+8(FP), R7
	MOVW	$-(12+4)(R2), R29	// switch stack; must match frame size
	MOVW	R5, 4(R29)
	MOVW	R6, 8(R29)
	MOVW	R7, 12(R29)

            !backward_pass_ops.contains(user)) {
          core_tpu_ops.insert(user);
        }
      }
    }
  }

  // Gather all TPU ops marked for compilation in this while loop body that also
  // are not in one of the two other sets.
  for (Operation& op : loop_body_func.getOps()) {
    // Find all TPU ops that don't belong to the forward or backward pass.

	reflector.UseWatchList = ptr.To(false)

	cacher.watchCache = watchCache
	cacher.reflector = reflector

	go cacher.dispatchEvents()
	go progressRequester.Run(stopCh)

	cacher.stopWg.Add(1)
	go func() {
		defer cacher.stopWg.Done()
		defer cacher.terminateAllWatchers()
		wait.Until(
			func() {
				if !cacher.isStopped() {
					cacher.startCaching(stopCh)
				}
			}, time.Second, stopCh,

		AVGATHERDPS,
		AVGATHERQPS,
		AVPGATHERDD,
		AVPGATHERQD,
		AVPGATHERDQ,
		AVPGATHERQQ:
		if p.GetFrom3() == nil {
			// gathers need a 3rd arg. See issue 58822.
			ctxt.Diag("need a third arg for gather instruction: %v", p)
			return
		}
		// AVX512 gather requires explicit K mask.
		if p.GetFrom3().Reg >= REG_K0 && p.GetFrom3().Reg <= REG_K7 {
			if !avx512gatherValid(ctxt, p) {
				return
			}

  EXPECT_THAT(subgraph->tensors[2]->name, Eq("output"));
  EXPECT_THAT(subgraph->tensors[2]->quantization->scale, SizeIs(1));
  EXPECT_THAT(subgraph->tensors[2]->quantization->zero_point, SizeIs(1));

  // The gather indices are of type INT32 and should not be quantized
  EXPECT_THAT(subgraph->tensors[1]->type, Eq(TensorType_INT32));
  EXPECT_THAT(subgraph->tensors[1]->quantization->scale, IsEmpty());