if (!crops_values.empty()) {
        // output spatial dim = input spatial dim * block_size - crops.
        int64_t crop_a = crops_values[2 * (spatial_dim_index - 1)];
        int64_t crop_b = crops_values[2 * (spatial_dim_index - 1) + 1];
        if (output_dim != input_dim_pad - crop_a - crop_b)
          return op.emitOpError()
                 << "requires output " << dim_name << " (dimension "

  // it's a constant. Basically, `paddings` tensor in `SpaceToBatch` and `crops`
  // tensor  in `BatchToSpace` must satisfy the following:
  //  paddings[i, 0] = base_paddings[i, 0].
  //  0 <= paddings[i, 1] - base_paddings[i, 1] < block_shape[i]
  // (input_shape[i] + paddings[i, 0] + paddings[i, 1]) % block_shape[i] == 0.
  //  crops[i, 0] = 0.
  //  crops[i, 1] = paddings[i, 1] - base_paddings[i, 1].

    %op_a = "tf.OpA"() : () -> tensor<f32>
    // CHECK: [[OP_B:%.*]] = "tf.OpB"
    %op_b = "tf.OpB"() : () -> tensor<i32>
    // CHECK-NOT: tf.AssignVariableOp
    "tf.AssignVariableOp"(%arg0, %op_a) : (!tf_res_f32, tensor<f32>) -> ()
    // CHECK: tf_device.return [[OP_B]], [[OP_A]] : tensor<i32>, tensor<f32>
    tf_device.return %op_b : tensor<i32>
  }
  // CHECK: "tf.AssignVariableOp"([[ARG0]], [[REPLICATE]]#2)

  }
  func.return %0#2, %0#1 : tensor<i1>, tensor<i1>
}

// CHECK-NEXT: %[[OP_A:[0-9]*]] = "tf.opA"(%[[ARG_0]])
// CHECK-NEXT: %[[OP_B:[0-9]*]] = "tf.opB"(%[[OP_A]])
// CHECK-NEXT: "tf.opC"(%[[OP_B]])
// CHECK-NEXT: return %[[OP_B]], %[[OP_A]] : tensor<i1>, tensor<i1>


// Test nested graphs and islands.
// CHECK-LABEL: func @nested_graph
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<i1>)

// CHECK-NEXT:     %[[OP_A:[0-9]*]] = "tf.opA"(%[[ARG_0]], %[[ARG_0]])
// CHECK-NEXT:     %[[OP_B:[0-9]*]] = "tf.opB"(%[[OP_A]], %[[ARG_0]])
// CHECK-NEXT:     %[[OP_C:[0-9]*]] = "tf.opC"(%[[OP_B]], %[[ARG_1]])
// CHECK-NEXT:     %[[OP_D:[0-9]*]] = "tf.opD"(%[[OP_C]], %[[ARG_0]])
// CHECK-NEXT:     %[[OP_E:[0-9]*]] = "tf.opE"(%[[OP_D]], %[[OP_B]])
// CHECK-NEXT:     %[[OP_F:[0-9]*]] = "tf.opF"(%[[OP_E]], %[[OP_E]])

  }
  func.return
}

// CHECK: %[[SHAPE:[0-9]*]] = "tf.Shape"(%[[ARG_0]])
// CHECK: %[[OP_A:[0-9]*]] = "tf.opA"(%[[SHAPE]])
// CHECK: %[[OP_B:[0-9]*]] = "tf.opB"(%[[SHAPE]], %[[OP_A]])
// CHECK: tf_device.replicate
// CHECK:   tf_device.return %[[SHAPE]], %[[OP_A]], %[[OP_B]]


// CHECK-LABEL: func @nested_ops
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<*xf32>, %{{[a-z0-9]*}}: tensor<*xf32>)

    // 4. Crop the start and end of dimensions `[1, ..., M]` of
    //    `reshaped_permuted` according to `crops` to produce the output of
    //    shape:
    //      [batch / prod(block_shape),
    //
    //       input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],
    //       ...,
    //       input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],
    //

  func.return %2 : tensor<i1>
}

// CHECK:      %[[CLUSTER:[0-9]*]]:2 = "tf_device.cluster"() ({
// CHECK-NEXT:   %[[OP_A:[0-9]*]] = "tf.opA"(%[[ARG_0]])
// CHECK-NEXT:   %[[OP_B:[0-9]*]] = "tf.opB"(%[[OP_A]])
// CHECK-NEXT:   tf_device.return %[[OP_A]], %[[OP_B]]
// CHECK-NEXT: _replication_info = "replicate"
// CHECK-SAME: device = "/device:TPU:0"
// CHECK-SAME: topology = "topology"
// CHECK:      tf_device.launch

  "ArrayRef<APInt>{$0.getValue(), $0.getValue()})">;

def BatchToSpaceToBatchToSpaceND : Pat<
  (TF_BatchToSpaceOp:$src $input, $crops, $block_size),
  (TF_BatchToSpaceNDOp:$dest $input,
    (TF_ConstOp (BatchToSpaceBlockSizeToBlockShape $block_size)), $crops),
  [(IsRank4Tensor $input), (IsRank2Tensor $crops)], [(CopyAttrs $src, $dest)]>;

//===----------------------------------------------------------------------===//

    tf_device.return
  }
  func.return

// CHECK:      %[[OP_A:[a-z0-9]*]] = "tf.opA"
// CHECK:      %[[OP_B:[a-z0-9]*]] = "tf.opB"
// CHECK:      %[[OP_C:[a-z0-9]*]] = "tf.opC"
// CHECK:      %[[OP_D:[a-z0-9]*]] = "tf.opD"
// CHECK:      %[[OP_E:[a-z0-9]*]] = "tf.opE"
// CHECK:      %[[OP_F:[a-z0-9]*]] = "tf.opF"