%0 = "vhlo.slice_v1"(%arg0) <{limit_indices = #vhlo.tensor_v1<dense<[0, 0, 0]> : tensor<3xi64>>, 
                                start_indices = #vhlo.tensor_v1<dense<[1, 1, 1]> : tensor<3xi64>>,
                                strides = #vhlo.tensor_v1<dense<[1, 1, 1]> : tensor<3xi64>>}> : (tensor<160x20x1xf32>) -> tensor<1x1x1xf32>
  return %0 : tensor<1x1x1xf32>
}

//CHECK:func.func private @slice(%arg0: tensor<160x20x1xf32>) -> tensor<1x1x1xf32> {

  if (!TFDataFormatIsNDHWC(op)) return failure();

  auto tf_op = cast<TF::Conv3DOp>(op);

  IntegerAttr stride_depth, stride_height, stride_width;
  if (!TFIntListIs1XYZ1(op, "strides", &stride_depth, &stride_height,
                        &stride_width))
    return failure();

  IntegerAttr dilation_depth_factor, dilation_height_factor,
      dilation_width_factor;

				tc.nPix, tc.extraExisting, tc.extraSeparate, err, tc.wantErr)
		}

		if tc.wantErr != nil {
			continue
		}
		want := &image.Paletted{
			Pix:    []uint8{0, 0},
			Stride: 2,
			Rect:   image.Rect(0, 0, 2, 1),
			Palette: color.Palette{
				color.RGBA{0x10, 0x20, 0x30, 0xff},
				color.RGBA{0x40, 0x50, 0x60, 0xff},
			},
		}
		if !reflect.DeepEqual(got, want) {

	b := m.Bounds()
	xmax := b.Max.X - 1
	ymax := b.Max.Y - 1
	for j := 0; j < 8; j++ {
		sj := p.Y + j
		if sj > ymax {
			sj = ymax
		}
		offset := (sj-b.Min.Y)*m.Stride - b.Min.X*4
		for i := 0; i < 8; i++ {
			sx := p.X + i
			if sx > xmax {
				sx = xmax
			}
			pix := m.Pix[offset+sx*4:]
			yy, cb, cr := color.RGBToYCbCr(pix[0], pix[1], pix[2])

		t.Fatal("colorTablesMatch() == false, expected true")
	}
}

func TestEncodeCroppedSubImages(t *testing.T) {
	// This test means to ensure that Encode honors the Bounds and Strides of
	// images correctly when encoding.
	whole := image.NewPaletted(image.Rect(0, 0, 100, 100), palette.Plan9)
	subImages := []image.Rectangle{
		image.Rect(0, 0, 50, 50),
		image.Rect(50, 0, 100, 50),

      llvm::errs() << "Window " << window.DebugString()
                   << " has a non-positive dimension.\n";
      return std::nullopt;
    }
    if (dim.stride() <= 0) {
      llvm::errs() << "Window " << window.DebugString()
                   << " has a non-positive stride.\n";
      return std::nullopt;
    }
    if (dim.base_dilation() < 1) {
      llvm::errs() << "Window " << window.DebugString()

      /*begin=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({idx})),
      /*end=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({idx + 1})),
      /*strides=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({1})),
      /*begin_mask=*/0, /*end_mask=*/0, /*ellipsis_mask=*/0,
      /*new_axis_mask=*/0, /*shrink_axis_mask=*/1);
}

    Tin = "tfdtype$DT_FLOAT", Tout = "tfdtype$DT_FLOAT",
    attr_map = "", batch_group_count = 1 : i64,
    explicit_padding = [], feature_group_count = 1 : i64, lhs_dilation = [1, 1],
    padding = "SAME", rhs_dilation = [1, 1], strides = [1, 1, 1, 1]
  } : (tensor<2x10x10x10xf32>, tensor<3x3x10x20xf32>) -> tensor<2x10x10x20xf32>
  return %0 : tensor<2x10x10x20xf32>
})mlir";
  constexpr absl::string_view kProgram = R"mlir(

}

table StablehloReduceOptions {
  dimensions : [long];
  body_subgraph_index : int;
}

table StablehloSliceOptions{
  start_indices : [long];
  limit_indices : [long];
  strides : [long];
}

table StablehloConvolutionOptions{
  window_strides : [long];
  padding : [long];
  lhs_dilation : [long];
  rhs_dilation : [long];
  window_reversal : [bool];

  TF_DeleteTensor(tensor);
  TFE_DeleteTensorHandle(tensor_handle);

  std::vector<int64_t> values(4, 1);
  TFE_OpSetAttrIntList(op, "ksize", values.data(), values.size());
  TFE_OpSetAttrIntList(op, "strides", values.data(), values.size());

  const int BUFFER_SIZE = 10;
  char buffer[BUFFER_SIZE];
  std::strncpy(buffer, "VALID", BUFFER_SIZE);
  TFE_OpSetAttrString(op, "padding", buffer, std::strlen(buffer));