.getData()
                            .computeIfAbsent(PROJECT_INDEX, () -> new ProjectIndex(session.getProjects()));

                    int index = projectIndex.getIndices().get(projectId);

                    MavenProject forkedProject = projectIndex.getProjects().get(projectId);

                    forkedProjects.add(forkedProject);

    return gather.emitOpError("unknown tensor array");
  }
  OpBuilder builder(gather);
  auto buffer = cutil::ReadLocalVariable(local_var, builder, gather.getLoc());
  auto result = cutil::GatherElements(gather.getIndices(), buffer, builder,
                                      gather.getLoc());
  ReplaceAllUsesExceptTerminator(gather.getValue(), result);
  ReplaceAllUsesWithCast(gather.getValue(), result);
  gather.erase();

      rewriter.replaceOpWithNewOp<mhlo::GatherOp>(
          op, op.getType(), op.getParams(), op.getIndices(), dims_attr,
          GetI64ElementsAttr(slice_sizes, &rewriter));
    } else {
      rewriter.replaceOpWithNewOp<mhlo::DynamicGatherOp>(
          op, op.getType(), op.getParams(), op.getIndices(), slice_sizes_value,
          dims_attr);
    }
    return success();
  }
};

        "requires tensor operand to have at least 1 dimension");
  if (!HasRankAtLeast(op.getIndices(), 1))
    return op.emitOpError(
        "requires indices operand to have at least 1 dimension");

  auto tensor_ty = op.getTensor().getType().dyn_cast<RankedTensorType>();
  auto indices_ty = op.getIndices().getType().dyn_cast<RankedTensorType>();
  if (!tensor_ty || !indices_ty) return success();

  }

  llvm::SmallDenseSet<int64_t, 8> index_values;
  bool all_indices_const = true;
  int32_t max_index = -1;
  std::optional<SmallVector<int64_t, 4>> inferred_item_shape;
  for (auto it : llvm::zip(op.getIndices(), op.getData())) {
    Value index = std::get<0>(it);

    DenseIntElementsAttr index_attr;
    if (matchPattern(index, m_Constant(&index_attr))) {
      for (int32_t index : index_attr.getValues<int32_t>()) {

    // Extract out all the constant indices' attributes and verify that data
    // types are static.
    SmallVector<DenseIntElementsAttr, 4> indices;
    indices.reserve(op.getN());
    for (auto it : llvm::zip(op.getIndices(), op.getData())) {
      Value index = std::get<0>(it);
      Value data = std::get<1>(it);

      DenseIntElementsAttr index_attr;
      if (!matchPattern(index, m_Constant(&index_attr))) return failure();

      axis.getNumElements() != 1 ||
      !axis.getSplatValue<llvm::APInt>().isZero()) {
    return {};
  }

  DenseIntElementsAttr indices;
  if (!matchPattern(op.getIndices(), m_Constant(&indices)) ||
      indices.getType().getRank() != 1 || port[1] >= indices.getNumElements()) {
    return {};
  }

  int64_t input_idx = indices.getValues<IntegerAttr>()[port[1]].getInt();

        array_segments = tflite::CreateInt32Vector(
                             builder_, builder_.CreateVector(vector_segments))
                             .Union();
      }

      auto indices = dim_metadata.getIndices();
      std::vector<int> vector_indices(indices.size(), 0);
      int max_of_indices = 0;
      for (int j = 0, end = indices.size(); j < end; j++) {
        vector_indices[j] = indices[j];

// ScatterNdOp
//===----------------------------------------------------------------------===//

mlir::LogicalResult ScatterNdOp::verify() {
  ScatterNdOp op = *this;
  auto indices = op.getIndices();
  auto updates = op.getUpdates();
  auto shape = op.getShape();
  auto output = op.getOutput();

  auto updates_type = updates.getType().cast<ShapedType>();