// canonicalization because it is neither supported in the old bridge
// nor in the reference TF implementation.
def GatherToV2 : Pat<
  (TF_GatherOp:$src $params, $indices, $ignored_validate_indices),
  (TF_GatherV2Op:$dest $params, $indices, (TF_ConstOp (GetI32Attr<0>)),
    (GetI64Attr<0>)),
  [], [(CopyAttrs $src, $dest)]>;

//===----------------------------------------------------------------------===//

  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;
    // Returning null tensors from a tf.function is not supported, so we keep
    // track of indices in the model's outputs are nullptr in this set.
    // The FunctionDef only outputs the non-null tensors. We later pad the
    // function op outputs to have nullptrs at the `null_indices`.
    absl::flat_hash_set<int> null_indices;

                        }
                        else -> 0
                    }

                fun String.isValidIndex(index: Int) = index in indices

                check(text.isValidIndex(offset))

                val realStartIndex = offset + offsetRelativeIndexRange.first
                check(text.isValidIndex(realStartIndex))

	"unsafe"
)

const (
	// The number of levels in the radix tree.
	summaryLevels = 4

	// Constants for testing.
	pageAlloc32Bit = 1
	pageAlloc64Bit = 0

	// Number of bits needed to represent all indices into the L1 of the
	// chunks map.
	//
	// See (*pageAlloc).chunks for more details. Update the documentation
	// there should this number change.
	pallocChunksL1Bits = 0
)

// See comment in mpagealloc_64bit.go.

        return true;
    }

    /**
     * Finds all the lines in the actual line that match any line in the expected list.
     *
     * @return a map of expected line index to a list of all actual line indices that match the expected line
     */
    private static Map<Integer, List<Integer>> findMatchingLines(List<String> expectedLines, List<String> actualLines) {

          op.getLoc(), cast_type, clamp_min, cast_op, clamp_max);
      start_indices_vector.push_back(clamped_index);
    }

    // Pack individual start indices to start indices tensor.
    Type start_indices_type = RankedTensorType::get(
        {static_cast<int64_t>(start_indices_vector.size())},
        signed_start_indices_element_type);

	"go/token"
	. "internal/types/errors"
	"strings"
)

// funcInst type-checks a function instantiation.
// The incoming x must be a generic function.
// If ix != nil, it provides some or all of the type arguments (ix.Indices).
// If target != nil, it may be used to infer missing type arguments of x, if any.
// At least one of T or ix must be provided.
//
// There are two modes of operation:
//

// -----

// CHECK-LABEL: @gather_v2
//  CHECK-SAME: %[[PARAMS:[a-zA-Z0-9_]+]]
//  CHECK-SAME: %[[INDICES:[a-zA-Z0-9_]+]]
func.func @gather_v2(%params: tensor<16x2x3xf32>, %indices: tensor<16x5xi32>) -> tensor<16x2x5xf32> {
  //      CHECK: mhlo.torch_index_select
  // CHECK-SAME:   %[[PARAMS]], %[[INDICES]]
  // CHECK-SAME:   batch_dims = 1
  // CHECK-SAME:   dim = 2

        FLAGS[prefixFlag or frameFlag or FLAG_PADDED] =
          FLAGS[prefixFlag] + '|'.toString() + FLAGS[frameFlag] + "|PADDED"
      }
    }

    for (i in FLAGS.indices) { // Fill in holes with binary representation.
      if (FLAGS[i] == null) FLAGS[i] = BINARY[i]
    }
  }

  /**
   * Returns a human-readable representation of HTTP/2 frame headers.
   *
   * The format is:

                              additional_attributes.end()) {}

  // Name of the output kernel implementing the contraction fusion.
  std::string output_kernel;

  // Indices of additional arguments that will be forwarded to the fused
  // operation (e.g. forward bias vector if fusing BiasAdd operation).
  SmallVector<int, 4> additional_arguments;

  // Add additional attributes to the fused node.