Value input_shape = rewriter.create<ShapeOp>(
        loc, tensorflow::GetTypeFromTFTensorShape({4}, rewriter.getI64Type()),
        input);
    input_shape = rewriter.create<CastOp>(
        loc, tensorflow::GetTypeFromTFTensorShape({4}, out_size_element_ty),
        input_shape);

    auto scalar_dim_ty =
        tensorflow::GetTypeFromTFTensorShape({}, out_size_element_ty);

  auto slice_type = tensorflow::GetTypeFromTFTensorShape(
      slice_size, buffer_type.getElementType());
  auto slice = builder.create<TF::SliceOp>(
      loc, ArrayRef<Type>{slice_type},
      ArrayRef<Value>{buffer, GetIndicesForElement(index, buffer, builder, loc),
                      size_const});
  if (keep_slice_shape) return slice;
  auto element_type = tensorflow::GetTypeFromTFTensorShape(

  RankedTensorType position_type =
      tensorflow::GetTypeFromTFTensorShape({-1}, shape_dtype);
  Value partial_start_position =
      CreateI32SplatTensor(loc, rewriter, item_rank, 0);
  Value scalar_zero = CreateI32SplatConst(loc, rewriter, {}, 0);
  RankedTensorType vector_type =
      tensorflow::GetTypeFromTFTensorShape({1}, shape_dtype);
  auto expanded_start_index = rewriter->create<TF::ExpandDimsOp>(

    mlir::arith::ConstantOp fill_shape =
        op_builder->create<mlir::arith::ConstantOp>(
            const_op->getLoc(),
            DenseIntElementsAttr::get(
                tensorflow::GetTypeFromTFTensorShape(
                    {splat_elements_attr.getType().getRank()},
                    op_builder->getI64Type()),
                splat_elements_attr.getType().getShape()));
    mlir::arith::ConstantOp fill_value =

  OpBuilder::InsertionGuard insertion_point_gurad(*builder);

  Type input_type =
      tensorflow::GetTypeFromTFTensorShape(/*shape=*/{}, input_element_type);
  Type index_type =
      tensorflow::GetTypeFromTFTensorShape(/*shape=*/{}, index_element_type);
  Block *block = builder->createBlock(body);
  Location loc = body->getLoc();

    llvm::ArrayRef<int64_t> shapes) {
  return llvm::to_vector(llvm::map_range(shapes, [](int64_t shape) {
    return mlir::ShapedType::isDynamic(shape) ? kTFDynamicSize : shape;
  }));
}

mlir::RankedTensorType GetTypeFromTFTensorShape(llvm::ArrayRef<int64_t> shape,
                                                mlir::Type elementType,
                                                mlir::Attribute encoding) {

                                        tensor.shape_signature.end());
    return tensorflow::GetTypeFromTFTensorShape(shape, elem_type);
  }

  if (!tensor.shape.empty()) {
    llvm::SmallVector<int64_t, 4> shape(tensor.shape.begin(),
                                        tensor.shape.end());
    return tensorflow::GetTypeFromTFTensorShape(shape, elem_type);
  }

  return UnrankedTensorType::get(elem_type);
}

    auto elem_type = filter_type.getElementType();
    auto result_type =
        tensorflow::GetTypeFromTFTensorShape(result_shape, elem_type);
    // TensorFlow Lite `Reshape` op only support int32 shape tensor currently.
    auto shape_type =
        tensorflow::GetTypeFromTFTensorShape({4}, rewriter.getIntegerType(32));
    SmallVector<Attribute, 4> result_shape_data(4);
    for (int i = 0; i < 4; ++i) {

llvm::SmallVector<int64_t> ConvertTFShapeToMlir(llvm::ArrayRef<int64_t> shapes);

llvm::SmallVector<int64_t> ConvertMlirShapeToTF(llvm::ArrayRef<int64_t> shape);

static constexpr int64_t kTFDynamicSize = -1;
mlir::RankedTensorType GetTypeFromTFTensorShape(llvm::ArrayRef<int64_t> shape,
                                                mlir::Type elementType,
                                                mlir::Attribute encoding = {});

}  // namespace tensorflow

    return RangeOp::build(
        builder, result,
        tensorflow::GetTypeFromTFTensorShape(
            size.getSExtValue(),
            start.getType().cast<TensorType>().getElementType()),
        start, limit, delta);
  }
  return RangeOp::build(
      builder, result,
      tensorflow::GetTypeFromTFTensorShape(
          {-1}, start.getType().cast<TensorType>().getElementType()),