}
	rv = ValueOf(&xa).Elem()
	shouldPanic("Slice3", func() { rv.Slice3(1, 2, 1) })
	shouldPanic("Slice3", func() { rv.Slice3(1, 1, 11) })
	shouldPanic("Slice3", func() { rv.Slice3(2, 2, 1) })

	s := "hello world"
	rv = ValueOf(&s).Elem()
	shouldPanic("Slice3", func() { rv.Slice3(1, 2, 3) })

	rv = ValueOf(&xs).Elem()
	rv = rv.Slice3(3, 5, 7)
	ptr2 := rv.UnsafePointer()
	rv = rv.Slice3(4, 4, 4)

}

// Determines the output type of the `SliceOp` when it is being inserted in
// place of a `XlaGatherOp`. When the dimensions of `xla_gather_op_output_type`
// is known, the `collapsed_dims` are restored. `xla_gather_op_output_type` is
// the result of collapsing the `collapsed_dims`, but the `SliceOp`'s output
// should not have the dimensions collapsed already. Returns

                mlir::stablehlo::ReshapeOp, mlir::stablehlo::SelectOp,
                mlir::stablehlo::SliceOp, mlir::stablehlo::TransposeOp>(op)) {
    scale_spec->has_same_scale_requirement = true;
  }
  if (llvm::isa<mlir::stablehlo::DynamicSliceOp, mlir::stablehlo::GatherOp,
                mlir::stablehlo::PadOp, mlir::stablehlo::SliceOp>(op)) {
    scale_spec->has_same_operand_and_result_type_requirement = true;
  }
  return scale_spec;

  slice_size[0] = 1;
  auto size_const = GetR1Const(slice_size, builder, loc);
  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;

  Value packed_low_begin_value = CreateConstValue<int64_t>(
      builder, loc, {rank}, SmallVector<int64_t>(rank, 0));
  Value packed_low_value =
      builder.create<TF::SliceOp>(loc, packed_output_type, value,
                                  packed_low_begin_value, packed_shape_value);
  packed_low_value = builder.create<TF::BitwiseAndOp>(
      loc, packed_output_type, packed_low_value,

        rewriter->create<TFL::ConstOp>(split_op->getLoc(), slice_begin_attr);
    auto slice_size_const =
        rewriter->create<TFL::ConstOp>(split_op->getLoc(), slice_size_attr);

    auto slice_op = rewriter->create<TFL::SliceOp>(
        split_op->getLoc(), current_output_type, input, slice_begin_const,
        slice_size_const);

    // Rewire output.
    slice_outputs.push_back(slice_op.getResult());
  }
  return slice_outputs;

    return rewriter.notifyMatchFailure(
        concat, "Concatenate op should have at least two operands");

  auto first = concat.getVal()[0].getDefiningOp<mhlo::SliceOp>();
  auto second = concat.getVal()[1].getDefiningOp<mhlo::SliceOp>();
  if (!first || !second)
    return rewriter.notifyMatchFailure(concat, "operands are not slice ops");
  if (first.getOperand() != second.getOperand())

        TypeID::get<TF::SelfAdjointEigV2Op>(),
        TypeID::get<TF::SeluGradOp>(),
        TypeID::get<TF::SeluOp>(),
        TypeID::get<TF::SigmoidGradOp>(),
        TypeID::get<TF::SinOp>(),
        TypeID::get<TF::SliceOp>(),
        TypeID::get<TF::SoftplusGradOp>(),
        TypeID::get<TF::SoftsignGradOp>(),
        TypeID::get<TF::SoftsignOp>(),
        TypeID::get<TF::SpaceToBatchNDOp>(),
        TypeID::get<TF::SpaceToBatchOp>(),

           dnums.getKernelOutputFeatureDimension() == num_spatial_dims;
  }
};

class ConvertSliceOp : public OpConversionPattern<mhlo::SliceOp> {
 public:
  using OpConversionPattern::OpConversionPattern;

  LogicalResult matchAndRewrite(
      mhlo::SliceOp slice_op, OpAdaptor adaptor,
      ConversionPatternRewriter& rewriter) const final {
    auto begin = rewriter.create<TF::ConstOp>(slice_op.getLoc(),

      loc, input, /*use32Bit=*/builder.getBoolAttr(false));
  Value input_batch_dims = builder.create<TF::SliceOp>(
      loc, RankedTensorType::get({num_input_batch_dim}, builder.getI64Type()),
      input_shape, zero, num_input_batch_dim_value);
  Value input_matmul_dims = builder.create<TF::SliceOp>(
      loc, RankedTensorType::get({num_matmul_dim}, builder.getI64Type()),