func, arg_number, symbol_table);
      if (!global_tensor) continue;

      auto arg_type = mlir::cast<RankedTensorType>(arg.getType());
      assert(arg_type.getRank() == 0);
      llvm::ArrayRef<TensorType> underlying_type =
          mlir::cast<TF::ResourceType>(arg_type.getElementType()).getSubtypes();

      // If the arg type already matches the global_tensor type, we don't need

     *
     * @since 4.0
     */
    String JVM_RESOURCES_DIRECTORY = "java-resources-directory";

    /**
     * Represents a zip file
     *
     * @since 5.3
     */
    String ZIP_TYPE = "zip";

    /**
     * Represents a raw directory
     *
     * @since 5.3
     */
    String DIRECTORY_TYPE = "directory";

    /**
     * Represents a binary file
     *
     * @since 7.4

  if (IsList()) {
    return "AddInputList";
  } else {
    return "AddInput";
  }
}

std::vector<string> ArgView::SetterArgs() const { return {VariableName()}; }

bool ArgView::IsList() const { return arg_.arg_type().is_list(); }

int ArgView::Position() const { return arg_.position(); }

}  // namespace cpp
}  // namespace generator

OpArgumentView::OpArgumentView(string type, string var, string def)
    : type_name_(type), variable_name_(var), default_value_(def) {}

OpArgumentView::OpArgumentView(ArgSpec arg)
    : type_name_(ArgTypeView(arg.arg_type()).TypeName()),
      variable_name_(ArgView(arg).VariableName()) {}

OpArgumentView::OpArgumentView(AttrSpec attr)
    : type_name_(AttrView(attr).VariableType()),
      variable_name_(AttrView(attr).VariableName()),

  LogicalResult matchAndRewrite(stablehlo::PadOp pad_op,
                                PatternRewriter& rewriter) const override {
    Value pad_input = pad_op.getOperand();
    RankedTensorType pad_type = pad_op.getType().cast<RankedTensorType>();

    auto transpose_op = pad_input.getDefiningOp<stablehlo::TransposeOp>();
    if (!transpose_op || !transpose_op->hasOneUse()) return failure();

// QuantizationUnitLoc uses CallSiteLoc as the base class so it can be printed
// with AsmPrinter and used to set the node name in MLIR to GraphDef exporter.
// The callee is named as `node_name@func_name` with child loc named as
// `op_type` while the caller is the quantization unit.
class QuantizationUnitLoc : public CallSiteLoc {
 public:
  using QuantizationUnit =
      tensorflow::quantization::UnitWiseQuantizationSpec::QuantizationUnit;

                           TF_Status* s) {
  unwrap(o)->outputs.push_back(unwrap(tensor));
}

void TF_AbstractOpSetOpType(TF_AbstractOp* op, const char* const op_type,
                            TF_Status* s) {
  tsl::Set_TF_Status_from_Status(
      s, unwrap(op)->Reset(op_type,
                           /*raw_device_name=*/nullptr));
}

void TF_AbstractOpSetOpName(TF_AbstractOp* op, const char* const op_name,

        publicationAttributes.attribute(Usage.USAGE_ATTRIBUTE, apiUsage);
        publicationAttributes.attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, ArtifactTypeDefinition.ZIP_TYPE);
        mainVariant = new MainLibraryVariant("api", apiElements, publicationAttributes, objectFactory);
    }

	struct sockaddr addr;
	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
};

// This structure is a duplicate of if_data on FreeBSD 8-STABLE.
// See /usr/include/net/if.h.
struct if_data8 {
	u_char  ifi_type;
	u_char  ifi_physical;
	u_char  ifi_addrlen;
	u_char  ifi_hdrlen;
	u_char  ifi_link_state;
	u_char  ifi_spare_char1;
	u_char  ifi_spare_char2;
	u_char  ifi_datalen;
	u_long  ifi_mtu;
	u_long  ifi_metric;