scalar_mul(dilation_rate_value, scalar_sub(filter_size, one)), one);

  // output_size = (input_size + stride - 1) / stride
  Value output_size = scalar_div(
      scalar_add(input_size, scalar_sub(stride_value, one)), stride_value);
  // padding_needed = std::max(
  //     0,
  //     (output_size - 1) * stride + effective_filter_size - input_size)
  Value padding_needed = scalar_sub(
      scalar_add(effective_filter_size_op,

        int64_t output_size;
        int64_t pad_low_int64;
        int64_t pad_high_int64;
        int64_t input_size = input_ty.getDimSize(dim);
        if (input_size == ShapedType::kDynamic) return failure();
        absl::Status status = tensorflow::GetWindowedOutputSizeVerbose(
            input_size, filter_ty.getDimSize(i), dilation, stride, padding,
            &output_size, &pad_low_int64, &pad_high_int64);

    Location loc = op.getLoc();
    Value scalar_zero = CreateI32SplatConst(loc, &rewriter, {}, 0);

    // Compute the input tensorlist's length and store it in `input_size`.
    IntegerType shape_dtype = rewriter.getIntegerType(32);
    auto input_size = rewriter.create<TF::TensorListLengthOp>(
        loc, tensorflow::GetTypeFromTFTensorShape({}, shape_dtype),
        op.getOperand(0));

      for (int64_t i = 0; i < input_ty.getRank(); ++i) {
        int64_t slice_size = slice_sizes.getValues<APInt>()[i].getSExtValue();
        int64_t input_size = input_shape[i];
        if (slice_size != -1 && input_size != ShapedType::kDynamic &&
            slice_size > input_size) {
          return op.emitOpError() << "requires size[i] <= Di, even if begin[i] "
                                     "is unknown at compile time";

                        std::vector<const Edge*> control_deps, Output* size) {
  // If slice_size[i] >= 0 then slice_size[i] = slice_size[i].
  //
  // If slice_size[i] == -1 then slice_size[i] = input_size[i] -
  // begin[i].
  //
  // If slice_size[i] < -1 then executing the slice will throw an error, and we
  // don't do anything here.  We've already filtered these cases out in
  // IsRewritableSlice.

                           b.device());
    }
    return false;
  }
  if (a.input_size() != b.input_size()) {
    if (diff) {
      *diff = absl::StrCat(diff_preamble, " mismatch for node ", a.name(),
                           ", expected ", a.input_size(), " inputs got ",
                           b.input_size(), " expected:\n", a.DebugString(),
                           "\ngot:\n", b.DebugString());
    }

              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;

}

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
  );