.HalfPixelCenters(half_pixel_centers));
        return;
      case RESIZE_BICUBIC:
        *y = ResizeBicubic(scope_, *x, y_shape,
                           ResizeBicubic::AlignCorners(align_corners)
                               .HalfPixelCenters(half_pixel_centers));
        return;
    }
    assert(false);
  }

  template <typename T>

  bool half_pixel_centers;
  TF_RETURN_IF_ERROR(GetNodeAttr(op.node()->attrs(), "half_pixel_centers",
                                 &half_pixel_centers));
  grad_outputs->push_back(internal::ResizeBilinearGrad(
      scope, grad_inputs[0], op.input(0),
      internal::ResizeBilinearGrad::AlignCorners(align_corners)
          .HalfPixelCenters(half_pixel_centers)));
  grad_outputs->push_back(NoGradient());

      // CHECK: %{{.*}} = stablehlo.custom_call @tf.ResizeBilinear(%arg0, %{{.*}}) {align_corners = false, device = "", half_pixel_centers = true} : (tensor<1x32x32x128xf32>, tensor<2xi32>) -> tensor<1x64x64x128xf32>
      // CHECK-OPT: %{{.*}} = stablehlo.custom_call @tf.ResizeBilinear(%arg0, %cst) {align_corners = false, device = "", half_pixel_centers = true} : (tensor<1x32x32x128xf32>, tensor<2xi32>) -> tensor<1x64x64x128xf32>
      %1 = "tf.ResizeBilinear"(%arg0, %0) {

      %c = stablehlo.constant dense<40> : tensor<2xi32>
      %0 = "tf.UnconvertedOp"(%arg0, %c) {align_corners = false, half_pixel_centers = false} : (tensor<1x20x20x28xf32>, tensor<2xi32>) -> tensor<1x40x40x28xf32>
      func.return %0 : tensor<1x40x40x28xf32>
  }

    operand_layouts = #vhlo.array_v1<[]>,
    output_operand_aliases = #vhlo.array_v1<[]>,
    result_layouts = #vhlo.array_v1<[]>}> {align_corners = #vhlo.bool_v1<true>, device = #vhlo.string_v1<"">, half_pixel_centers = #vhlo.bool_v1<false>} : (tensor<1x320x1x1xf32>, tensor<2xi32>) -> tensor<1x1600x1x1xf32>
  return %0 : tensor<1x1600x1x1xf32>
}

namespace {

// Convert op to stablehlo.custom_call
//   "tf.ResizeBilinear"(%341, %138) {
//      align_corners = false, device = "", half_pixel_centers = true}
//   ==>
//   stablehlo.custom_call @tf.ResizeBilinear(%arg0, %arg1) {
//      align_corners = false, device = "", half_pixel_centers = true}
LogicalResult SmuggleOp(Operation* op, PatternRewriter& rewriter) {
  auto call_target =

module {
func.func @main(%arg0: tensor<21x32x32x128xf32>, %arg1: tensor<2xi32>) -> tensor<1x64x64x128xf32> {
  %0 = "tf.ResizeBilinear"(%arg0, %arg1) {align_corners = false, device = "", half_pixel_centers = true} : (tensor<21x32x32x128xf32>, tensor<2xi32>) -> tensor<1x64x64x128xf32>
  func.return %0 : tensor<1x64x64x128xf32>
}

  (TF_ResizeBilinearOp $images, $size, $align_corners, $half_pixel_centers),
  (TFL_ResizeBilinearOp $images, $size, $align_corners, $half_pixel_centers)>;
def LegalizeResizeNearestNeighbor : Pat<
  (TF_ResizeNearestNeighborOp $images, $size, $align_corners,
    $half_pixel_centers),
  (TFL_ResizeNearestNeighborOp $images, $size, $align_corners,
    $half_pixel_centers)>;

// CHECK-DAG:           %[[VAL_3:.*]] = arith.constant dense<32> : tensor<2xi32>
// CHECK-DAG:           %[[VAL_4:.*]] = "tfl.resize_bilinear"(%[[VAL_2]], %[[VAL_3]]) <{align_corners = false, half_pixel_centers = true}> : (tensor<1x16x16x64xf32>, tensor<2xi32>) -> tensor<1x32x32x64xf32>
// CHECK-DAG:           %[[VAL_5:.*]] = arith.constant dense<[0, 3, 1, 2]> : tensor<4xi32>

}

table ResizeBilinearOptions {
  new_height: int (deprecated);
  new_width: int (deprecated);
  align_corners: bool;
  half_pixel_centers: bool;
}

table ResizeNearestNeighborOptions {
  align_corners: bool;
  half_pixel_centers: bool;
}

// A call operation options
table CallOptions {
  // The subgraph index that needs to be called.
  subgraph:uint;
}