window_strides_values[0], input_sizes[0], output_sizes[0])) {
        align_corners = true;
        return success();
      }
      if (can_convert_to_bilinear(
              /*align_corners=*/false, lhs_dilation_values[0],
              padding_values[0], window_strides_values[0], input_sizes[0],
              output_sizes[0])) {
        align_corners = false;

// CHECK:  [[ZERO_1:%.*]] = arith.constant dense<0> : tensor<i32>
// CHECK:  [[INPUT_SIZE:%.*]] = "tf.Gather"([[SHAPE]], [[ZERO_1]]) <{validate_indices = true}> : (tensor<2xi32>, tensor<i32>) -> tensor<i32>
// CHECK:  [[SIZE_DIFF:%.*]] = "tf.Sub"([[SIZE]], [[INPUT_SIZE]]) : (tensor<i32>, tensor<i32>) -> tensor<i32>

}

static LogicalResult ComputeConvWindowedOutputSize(
    int64_t input_size, int64_t filter_size, int64_t dilation_rate,
    int64_t stride, tensorflow::Padding padding, int64_t* output_size) {
  int64_t pad_low;
  int64_t pad_high;

  tensorflow::Status status = tensorflow::GetWindowedOutputSizeVerbose(
      input_size, filter_size, dilation_rate, stride, padding, output_size,
      &pad_low, &pad_high);

        mlir::dyn_cast<RankedTensorType>(input.getType());
    if (!input_type) {
      return failure();
    }
    const ArrayRef<int64_t> input_shape = input_type.getShape();

    const int input_size = input_shape.size();

    RankedTensorType begin_type = mlir::cast<RankedTensorType>(begin.getType());
    const ArrayRef<int64_t> begin_shape = begin_type.getShape();
    const int begin_dim = begin_shape.size();

    TF_Float32Tensor:$sorted_gains,
    TF_Float32Tensor:$embedding_table,
    TF_Int32Tensor:$num_minibatches_per_physical_sparse_core,

    ConfinedAttr<I64Attr, [IntMinValue<0>]>:$input_size,
    OptionalAttr<F32Attr>:$quantization_config_low,
    OptionalAttr<F32Attr>:$quantization_config_high,
    OptionalAttr<I64Attr>:$quantization_config_num_buckets,
    StrAttr:$table_name
  );

    std::set<EdgeSpec> a_edges;  // actual edges
    // Get edges from inputs to body nodes and between body nodes
    for (const NodeDef& node_def : fdef.node_def()) {
      for (int i = 0; i < node_def.input_size(); ++i) {
        const string& in = node_def.input(i);
        const auto& v =
            a_edges.insert({in, strings::StrCat(node_def.name(), ":", i)});
        ASSERT_TRUE(v.second) << "Duplicate edge " << in << " -> "

  let description = [{
    A recurrent neural network specified by an RNN cell. This Op takes in input
    in a format {batch_size, seq_len, input_size} or
    {seq_len, batch_size, input_size} if it's time-majored.

    It implements the following operation for
    each element in the sequence s = 1...sequence_length:
      outputs[s] = state = activation(RNNOp(inputs[s]))

	for _, test := range tests {
		t.Run(fmt.Sprintf("inputSize=%d limit=%d writes=%d", test.inputSize, test.limit, test.writeSize), func(t *testing.T) {
			input := make([]byte, test.inputSize)
			r.Read(input)
			output := &bytes.Buffer{}
			w := LimitWriter(output, test.limit)

			var (
				err     error
				written int64
				n       int
			)
			for written < test.inputSize && err == nil {

  context.getOrLoadDialect<TF::TensorFlowDialect>();
  const std::string input_file =
      "tensorflow/compiler/mlir/lite/metrics/testdata/strided_slice.mlir";
  auto input_file_id = StringAttr::get(&context, input_file);

  context.enableMultithreading();

  auto module =
      LoadModule(&context, tensorflow::GetDataDependencyFilepath(input_file));
  EXPECT_EQ(module.ok(), true);

        assertEquals("test1 \" test2", list.get(1));

        cmd = "test.sh $INPUT_FILE";
        params.clear();
        list = extractor.parseCommand(cmd, params);
        assertEquals(2, list.size());
        assertEquals("test.sh", list.get(0));
        assertEquals("$INPUT_FILE", list.get(1));

        cmd = "test.sh $INPUT_FILE $OUTPUT_FILE";
        params.clear();
        list = extractor.parseCommand(cmd, params);