indices.getType().getRank() != 1 || port[1] >= indices.getNumElements()) {
    return {};
  }

  int64_t input_idx = indices.getValues<IntegerAttr>()[port[1]].getInt();
  if (input_idx >= params_ty.getDimSize(0)) return {};

  ValuePort req(params);
  req.port.push_back(input_idx);
  return req;
}

ValuePort ComputeInputComponentFor(Operation* op, ArrayRef<unsigned int> port) {

    // output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])
    auto get_output_dim_for_same_padding = [](int64_t input_dim,
                                              int64_t stride_dim) -> int64_t {
      return std::ceil(input_dim / static_cast<double>(stride_dim));
    };
    return output_height ==
               get_output_dim_for_same_padding(input_height, stride_height) &&

                                 llvm::StringRef crop_b_name) -> LogicalResult {
      int64_t input_dim = input_shape[spatial_dim_index];
      int64_t output_dim = output_shape[spatial_dim_index];
      if (!static_dims(input_dim, output_dim)) return success();

      int64_t input_dim_pad = input_dim * block_size;
      // If crops are unknown, the maximum output spatial dim size is input

                 << "multiples[" << i << "] = " << m;
        }

        if (!ShapedType::isDynamic(input_dim) &&
            !ShapedType::isDynamic(output_dim) && output_dim != input_dim * m) {
          return op.emitOpError()
                 << "requires input.shape[" << i << "] (" << input_dim << ")"
                 << " * " << m << " to be equal to "

    arg_nodes->resize(inputs.size());
    ret_nodes->resize(outputs.size());

    for (Node* n : GetOrderedNodes()) {
      // Handle inputs/arguments.
      auto input_it = inputs.find(n->name());
      if (input_it != inputs.end()) {
        (*arg_nodes)[input_it->second] = {n, 0};
      }

      // Handle outputs/returns.
      if (output_node_names.contains(n->name())) {