1	// Generated by the protocol buffer compiler. DO NOT EDIT!
2	// source: opencv-onnx.proto
3
4	#ifndef GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
5	#define GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
6
7	#include <limits>
8	#include <string>
9
10	#include <google/protobuf/port_def.inc>
11	#if PROTOBUF_VERSION < 3019000
12	#error This file was generated by a newer version of protoc which is
13	#error incompatible with your Protocol Buffer headers. Please update
14	#error your headers.
15	#endif
16	#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
17	#error This file was generated by an older version of protoc which is
18	#error incompatible with your Protocol Buffer headers. Please
19	#error regenerate this file with a newer version of protoc.
20	#endif
21
22	#include <google/protobuf/port_undef.inc>
23	#include <google/protobuf/io/coded_stream.h>
24	#include <google/protobuf/arena.h>
25	#include <google/protobuf/arenastring.h>
26	#include <google/protobuf/generated_message_table_driven.h>
27	#include <google/protobuf/generated_message_util.h>
28	#include <google/protobuf/metadata_lite.h>
29	#include <google/protobuf/generated_message_reflection.h>
30	#include <google/protobuf/message.h>
31	#include <google/protobuf/repeated_field.h> // IWYU pragma: export
32	#include <google/protobuf/extension_set.h> // IWYU pragma: export
33	#include <google/protobuf/generated_enum_reflection.h>
34	#include <google/protobuf/unknown_field_set.h>
35	// @@protoc_insertion_point(includes)
36	#include <google/protobuf/port_def.inc>
37	#define PROTOBUF_INTERNAL_EXPORT_opencv_2donnx_2eproto
38	PROTOBUF_NAMESPACE_OPEN
39	namespace internal {
40	class AnyMetadata;
41	} // namespace internal
42	PROTOBUF_NAMESPACE_CLOSE
43
44	// Internal implementation detail -- do not use these members.
45	struct TableStruct_opencv_2donnx_2eproto {
46	static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
47	PROTOBUF_SECTION_VARIABLE(protodesc_cold);
48	static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
49	PROTOBUF_SECTION_VARIABLE(protodesc_cold);
50	static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
51	PROTOBUF_SECTION_VARIABLE(protodesc_cold);
52	static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
53	static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
54	static const uint32_t offsets[];
55	};
56	extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_opencv_2donnx_2eproto;
57	namespace opencv_onnx {
58	class AttributeProto;
59	struct AttributeProtoDefaultTypeInternal;
60	extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
61	class GraphProto;
62	struct GraphProtoDefaultTypeInternal;
63	extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
64	class ModelProto;
65	struct ModelProtoDefaultTypeInternal;
66	extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
67	class NodeProto;
68	struct NodeProtoDefaultTypeInternal;
69	extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
70	class OperatorSetIdProto;
71	struct OperatorSetIdProtoDefaultTypeInternal;
72	extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
73	class StringStringEntryProto;
74	struct StringStringEntryProtoDefaultTypeInternal;
75	extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
76	class TensorProto;
77	struct TensorProtoDefaultTypeInternal;
78	extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
79	class TensorProto_Segment;
80	struct TensorProto_SegmentDefaultTypeInternal;
81	extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
82	class TensorShapeProto;
83	struct TensorShapeProtoDefaultTypeInternal;
84	extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
85	class TensorShapeProto_Dimension;
86	struct TensorShapeProto_DimensionDefaultTypeInternal;
87	extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
88	class TypeProto;
89	struct TypeProtoDefaultTypeInternal;
90	extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
91	class TypeProto_Tensor;
92	struct TypeProto_TensorDefaultTypeInternal;
93	extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
94	class ValueInfoProto;
95	struct ValueInfoProtoDefaultTypeInternal;
96	extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
97	} // namespace opencv_onnx
98	PROTOBUF_NAMESPACE_OPEN
99	template<> ::opencv_onnx::AttributeProto* Arena::CreateMaybeMessage<::opencv_onnx::AttributeProto>(Arena*);
100	template<> ::opencv_onnx::GraphProto* Arena::CreateMaybeMessage<::opencv_onnx::GraphProto>(Arena*);
101	template<> ::opencv_onnx::ModelProto* Arena::CreateMaybeMessage<::opencv_onnx::ModelProto>(Arena*);
102	template<> ::opencv_onnx::NodeProto* Arena::CreateMaybeMessage<::opencv_onnx::NodeProto>(Arena*);
103	template<> ::opencv_onnx::OperatorSetIdProto* Arena::CreateMaybeMessage<::opencv_onnx::OperatorSetIdProto>(Arena*);
104	template<> ::opencv_onnx::StringStringEntryProto* Arena::CreateMaybeMessage<::opencv_onnx::StringStringEntryProto>(Arena*);
105	template<> ::opencv_onnx::TensorProto* Arena::CreateMaybeMessage<::opencv_onnx::TensorProto>(Arena*);
106	template<> ::opencv_onnx::TensorProto_Segment* Arena::CreateMaybeMessage<::opencv_onnx::TensorProto_Segment>(Arena*);
107	template<> ::opencv_onnx::TensorShapeProto* Arena::CreateMaybeMessage<::opencv_onnx::TensorShapeProto>(Arena*);
108	template<> ::opencv_onnx::TensorShapeProto_Dimension* Arena::CreateMaybeMessage<::opencv_onnx::TensorShapeProto_Dimension>(Arena*);
109	template<> ::opencv_onnx::TypeProto* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto>(Arena*);
110	template<> ::opencv_onnx::TypeProto_Tensor* Arena::CreateMaybeMessage<::opencv_onnx::TypeProto_Tensor>(Arena*);
111	template<> ::opencv_onnx::ValueInfoProto* Arena::CreateMaybeMessage<::opencv_onnx::ValueInfoProto>(Arena*);
112	PROTOBUF_NAMESPACE_CLOSE
113	namespace opencv_onnx {
114
115	enum AttributeProto_AttributeType : int {
116	AttributeProto_AttributeType_UNDEFINED = 0,
117	AttributeProto_AttributeType_FLOAT = 1,
118	AttributeProto_AttributeType_INT = 2,
119	AttributeProto_AttributeType_STRING = 3,
120	AttributeProto_AttributeType_TENSOR = 4,
121	AttributeProto_AttributeType_GRAPH = 5,
122	AttributeProto_AttributeType_FLOATS = 6,
123	AttributeProto_AttributeType_INTS = 7,
124	AttributeProto_AttributeType_STRINGS = 8,
125	AttributeProto_AttributeType_TENSORS = 9,
126	AttributeProto_AttributeType_GRAPHS = 10
127	};
128	bool AttributeProto_AttributeType_IsValid(int value);
129	constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
130	constexpr AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_GRAPHS;
131	constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
132
133	const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AttributeProto_AttributeType_descriptor();
134	template<typename T>
135	inline const std::string& AttributeProto_AttributeType_Name(T enum_t_value) {
136	static_assert(::std::is_same<T, AttributeProto_AttributeType>::value ||
137	::std::is_integral<T>::value,
138	"Incorrect type passed to function AttributeProto_AttributeType_Name.");
139	return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
140	descriptor: AttributeProto_AttributeType_descriptor(), value: enum_t_value);
141	}
142	inline bool AttributeProto_AttributeType_Parse(
143	::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttributeProto_AttributeType* value) {
144	return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AttributeProto_AttributeType>(
145	descriptor: AttributeProto_AttributeType_descriptor(), name, value);
146	}
147	enum TensorProto_DataType : int {
148	TensorProto_DataType_UNDEFINED = 0,
149	TensorProto_DataType_FLOAT = 1,
150	TensorProto_DataType_UINT8 = 2,
151	TensorProto_DataType_INT8 = 3,
152	TensorProto_DataType_UINT16 = 4,
153	TensorProto_DataType_INT16 = 5,
154	TensorProto_DataType_INT32 = 6,
155	TensorProto_DataType_INT64 = 7,
156	TensorProto_DataType_STRING = 8,
157	TensorProto_DataType_BOOL = 9,
158	TensorProto_DataType_FLOAT16 = 10,
159	TensorProto_DataType_DOUBLE = 11,
160	TensorProto_DataType_UINT32 = 12,
161	TensorProto_DataType_UINT64 = 13,
162	TensorProto_DataType_COMPLEX64 = 14,
163	TensorProto_DataType_COMPLEX128 = 15
164	};
165	bool TensorProto_DataType_IsValid(int value);
166	constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
167	constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_COMPLEX128;
168	constexpr int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
169
170	const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_DataType_descriptor();
171	template<typename T>
172	inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
173	static_assert(::std::is_same<T, TensorProto_DataType>::value ||
174	::std::is_integral<T>::value,
175	"Incorrect type passed to function TensorProto_DataType_Name.");
176	return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
177	descriptor: TensorProto_DataType_descriptor(), value: enum_t_value);
178	}
179	inline bool TensorProto_DataType_Parse(
180	::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataType* value) {
181	return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_DataType>(
182	descriptor: TensorProto_DataType_descriptor(), name, value);
183	}
184	enum Version : int {
185	_START_VERSION = 0,
186	IR_VERSION_2017_10_10 = 1,
187	IR_VERSION_2017_10_30 = 2,
188	IR_VERSION = 3
189	};
190	bool Version_IsValid(int value);
191	constexpr Version Version_MIN = _START_VERSION;
192	constexpr Version Version_MAX = IR_VERSION;
193	constexpr int Version_ARRAYSIZE = Version_MAX + 1;
194
195	const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Version_descriptor();
196	template<typename T>
197	inline const std::string& Version_Name(T enum_t_value) {
198	static_assert(::std::is_same<T, Version>::value ||
199	::std::is_integral<T>::value,
200	"Incorrect type passed to function Version_Name.");
201	return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
202	descriptor: Version_descriptor(), value: enum_t_value);
203	}
204	inline bool Version_Parse(
205	::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Version* value) {
206	return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Version>(
207	descriptor: Version_descriptor(), name, value);
208	}
209	// ===================================================================
210
211	class AttributeProto final :
212	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.AttributeProto) */ {
213	public:
214	inline AttributeProto() : AttributeProto(nullptr) {}
215	~AttributeProto() override;
216	explicit constexpr AttributeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
217
218	AttributeProto(const AttributeProto& from);
219	AttributeProto(AttributeProto&& from) noexcept
220	: AttributeProto() {
221	*this = ::std::move(from);
222	}
223
224	inline AttributeProto& operator=(const AttributeProto& from) {
225	CopyFrom(from);
226	return *this;
227	}
228	inline AttributeProto& operator=(AttributeProto&& from) noexcept {
229	if (this == &from) return *this;
230	if (GetOwningArena() == from.GetOwningArena()
231	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
232	&& GetOwningArena() != nullptr
233	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
234	) {
235	InternalSwap(other: &from);
236	} else {
237	CopyFrom(from);
238	}
239	return *this;
240	}
241
242	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
243	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
244	}
245	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
246	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
247	}
248
249	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
250	return GetDescriptor();
251	}
252	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
253	return default_instance().GetMetadata().descriptor;
254	}
255	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
256	return default_instance().GetMetadata().reflection;
257	}
258	static const AttributeProto& default_instance() {
259	return *internal_default_instance();
260	}
261	static inline const AttributeProto* internal_default_instance() {
262	return reinterpret_cast<const AttributeProto*>(
263	&_AttributeProto_default_instance_);
264	}
265	static constexpr int kIndexInFileMessages =
266	0;
267
268	friend void swap(AttributeProto& a, AttributeProto& b) {
269	a.Swap(other: &b);
270	}
271	inline void Swap(AttributeProto* other) {
272	if (other == this) return;
273	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
274	if (GetOwningArena() != nullptr &&
275	GetOwningArena() == other->GetOwningArena()) {
276	#else // PROTOBUF_FORCE_COPY_IN_SWAP
277	if (GetOwningArena() == other->GetOwningArena()) {
278	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
279	InternalSwap(other);
280	} else {
281	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
282	}
283	}
284	void UnsafeArenaSwap(AttributeProto* other) {
285	if (other == this) return;
286	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
287	InternalSwap(other);
288	}
289
290	// implements Message ----------------------------------------------
291
292	AttributeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
293	return CreateMaybeMessage<AttributeProto>(arena);
294	}
295	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
296	void CopyFrom(const AttributeProto& from);
297	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
298	void MergeFrom(const AttributeProto& from);
299	private:
300	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
301	public:
302	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
303	bool IsInitialized() const final;
304
305	size_t ByteSizeLong() const final;
306	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
307	uint8_t* _InternalSerialize(
308	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
309	int GetCachedSize() const final { return _cached_size_.Get(); }
310
311	private:
312	void SharedCtor();
313	void SharedDtor();
314	void SetCachedSize(int size) const final;
315	void InternalSwap(AttributeProto* other);
316
317	private:
318	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
319	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
320	return "opencv_onnx.AttributeProto";
321	}
322	protected:
323	explicit AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
324	bool is_message_owned = false);
325	private:
326	static void ArenaDtor(void* object);
327	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
328	public:
329
330	static const ClassData _class_data_;
331	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
332
333	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
334
335	// nested types ----------------------------------------------------
336
337	typedef AttributeProto_AttributeType AttributeType;
338	static constexpr AttributeType UNDEFINED =
339	AttributeProto_AttributeType_UNDEFINED;
340	static constexpr AttributeType FLOAT =
341	AttributeProto_AttributeType_FLOAT;
342	static constexpr AttributeType INT =
343	AttributeProto_AttributeType_INT;
344	static constexpr AttributeType STRING =
345	AttributeProto_AttributeType_STRING;
346	static constexpr AttributeType TENSOR =
347	AttributeProto_AttributeType_TENSOR;
348	static constexpr AttributeType GRAPH =
349	AttributeProto_AttributeType_GRAPH;
350	static constexpr AttributeType FLOATS =
351	AttributeProto_AttributeType_FLOATS;
352	static constexpr AttributeType INTS =
353	AttributeProto_AttributeType_INTS;
354	static constexpr AttributeType STRINGS =
355	AttributeProto_AttributeType_STRINGS;
356	static constexpr AttributeType TENSORS =
357	AttributeProto_AttributeType_TENSORS;
358	static constexpr AttributeType GRAPHS =
359	AttributeProto_AttributeType_GRAPHS;
360	static inline bool AttributeType_IsValid(int value) {
361	return AttributeProto_AttributeType_IsValid(value);
362	}
363	static constexpr AttributeType AttributeType_MIN =
364	AttributeProto_AttributeType_AttributeType_MIN;
365	static constexpr AttributeType AttributeType_MAX =
366	AttributeProto_AttributeType_AttributeType_MAX;
367	static constexpr int AttributeType_ARRAYSIZE =
368	AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
369	static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
370	AttributeType_descriptor() {
371	return AttributeProto_AttributeType_descriptor();
372	}
373	template<typename T>
374	static inline const std::string& AttributeType_Name(T enum_t_value) {
375	static_assert(::std::is_same<T, AttributeType>::value ||
376	::std::is_integral<T>::value,
377	"Incorrect type passed to function AttributeType_Name.");
378	return AttributeProto_AttributeType_Name(enum_t_value);
379	}
380	static inline bool AttributeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
381	AttributeType* value) {
382	return AttributeProto_AttributeType_Parse(name, value);
383	}
384
385	// accessors -------------------------------------------------------
386
387	enum : int {
388	kFloatsFieldNumber = 7,
389	kIntsFieldNumber = 8,
390	kStringsFieldNumber = 9,
391	kTensorsFieldNumber = 10,
392	kGraphsFieldNumber = 11,
393	kNameFieldNumber = 1,
394	kSFieldNumber = 4,
395	kDocStringFieldNumber = 13,
396	kRefAttrNameFieldNumber = 21,
397	kTFieldNumber = 5,
398	kGFieldNumber = 6,
399	kIFieldNumber = 3,
400	kFFieldNumber = 2,
401	kTypeFieldNumber = 20,
402	};
403	// repeated float floats = 7;
404	int floats_size() const;
405	private:
406	int _internal_floats_size() const;
407	public:
408	void clear_floats();
409	private:
410	float _internal_floats(int index) const;
411	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
412	_internal_floats() const;
413	void _internal_add_floats(float value);
414	::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
415	_internal_mutable_floats();
416	public:
417	float floats(int index) const;
418	void set_floats(int index, float value);
419	void add_floats(float value);
420	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
421	floats() const;
422	::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
423	mutable_floats();
424
425	// repeated int64 ints = 8;
426	int ints_size() const;
427	private:
428	int _internal_ints_size() const;
429	public:
430	void clear_ints();
431	private:
432	int64_t _internal_ints(int index) const;
433	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
434	_internal_ints() const;
435	void _internal_add_ints(int64_t value);
436	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
437	_internal_mutable_ints();
438	public:
439	int64_t ints(int index) const;
440	void set_ints(int index, int64_t value);
441	void add_ints(int64_t value);
442	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
443	ints() const;
444	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
445	mutable_ints();
446
447	// repeated bytes strings = 9;
448	int strings_size() const;
449	private:
450	int _internal_strings_size() const;
451	public:
452	void clear_strings();
453	const std::string& strings(int index) const;
454	std::string* mutable_strings(int index);
455	void set_strings(int index, const std::string& value);
456	void set_strings(int index, std::string&& value);
457	void set_strings(int index, const char* value);
458	void set_strings(int index, const void* value, size_t size);
459	std::string* add_strings();
460	void add_strings(const std::string& value);
461	void add_strings(std::string&& value);
462	void add_strings(const char* value);
463	void add_strings(const void* value, size_t size);
464	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
465	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
466	private:
467	const std::string& _internal_strings(int index) const;
468	std::string* _internal_add_strings();
469	public:
470
471	// repeated .opencv_onnx.TensorProto tensors = 10;
472	int tensors_size() const;
473	private:
474	int _internal_tensors_size() const;
475	public:
476	void clear_tensors();
477	::opencv_onnx::TensorProto* mutable_tensors(int index);
478	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
479	mutable_tensors();
480	private:
481	const ::opencv_onnx::TensorProto& _internal_tensors(int index) const;
482	::opencv_onnx::TensorProto* _internal_add_tensors();
483	public:
484	const ::opencv_onnx::TensorProto& tensors(int index) const;
485	::opencv_onnx::TensorProto* add_tensors();
486	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
487	tensors() const;
488
489	// repeated .opencv_onnx.GraphProto graphs = 11;
490	int graphs_size() const;
491	private:
492	int _internal_graphs_size() const;
493	public:
494	void clear_graphs();
495	::opencv_onnx::GraphProto* mutable_graphs(int index);
496	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >*
497	mutable_graphs();
498	private:
499	const ::opencv_onnx::GraphProto& _internal_graphs(int index) const;
500	::opencv_onnx::GraphProto* _internal_add_graphs();
501	public:
502	const ::opencv_onnx::GraphProto& graphs(int index) const;
503	::opencv_onnx::GraphProto* add_graphs();
504	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >&
505	graphs() const;
506
507	// optional string name = 1;
508	bool has_name() const;
509	private:
510	bool _internal_has_name() const;
511	public:
512	void clear_name();
513	const std::string& name() const;
514	template <typename ArgT0 = const std::string&, typename... ArgT>
515	void set_name(ArgT0&& arg0, ArgT... args);
516	std::string* mutable_name();
517	PROTOBUF_NODISCARD std::string* release_name();
518	void set_allocated_name(std::string* name);
519	private:
520	const std::string& _internal_name() const;
521	inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
522	std::string* _internal_mutable_name();
523	public:
524
525	// optional bytes s = 4;
526	bool has_s() const;
527	private:
528	bool _internal_has_s() const;
529	public:
530	void clear_s();
531	const std::string& s() const;
532	template <typename ArgT0 = const std::string&, typename... ArgT>
533	void set_s(ArgT0&& arg0, ArgT... args);
534	std::string* mutable_s();
535	PROTOBUF_NODISCARD std::string* release_s();
536	void set_allocated_s(std::string* s);
537	private:
538	const std::string& _internal_s() const;
539	inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(const std::string& value);
540	std::string* _internal_mutable_s();
541	public:
542
543	// optional string doc_string = 13;
544	bool has_doc_string() const;
545	private:
546	bool _internal_has_doc_string() const;
547	public:
548	void clear_doc_string();
549	const std::string& doc_string() const;
550	template <typename ArgT0 = const std::string&, typename... ArgT>
551	void set_doc_string(ArgT0&& arg0, ArgT... args);
552	std::string* mutable_doc_string();
553	PROTOBUF_NODISCARD std::string* release_doc_string();
554	void set_allocated_doc_string(std::string* doc_string);
555	private:
556	const std::string& _internal_doc_string() const;
557	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
558	std::string* _internal_mutable_doc_string();
559	public:
560
561	// optional string ref_attr_name = 21;
562	bool has_ref_attr_name() const;
563	private:
564	bool _internal_has_ref_attr_name() const;
565	public:
566	void clear_ref_attr_name();
567	const std::string& ref_attr_name() const;
568	template <typename ArgT0 = const std::string&, typename... ArgT>
569	void set_ref_attr_name(ArgT0&& arg0, ArgT... args);
570	std::string* mutable_ref_attr_name();
571	PROTOBUF_NODISCARD std::string* release_ref_attr_name();
572	void set_allocated_ref_attr_name(std::string* ref_attr_name);
573	private:
574	const std::string& _internal_ref_attr_name() const;
575	inline PROTOBUF_ALWAYS_INLINE void _internal_set_ref_attr_name(const std::string& value);
576	std::string* _internal_mutable_ref_attr_name();
577	public:
578
579	// optional .opencv_onnx.TensorProto t = 5;
580	bool has_t() const;
581	private:
582	bool _internal_has_t() const;
583	public:
584	void clear_t();
585	const ::opencv_onnx::TensorProto& t() const;
586	PROTOBUF_NODISCARD ::opencv_onnx::TensorProto* release_t();
587	::opencv_onnx::TensorProto* mutable_t();
588	void set_allocated_t(::opencv_onnx::TensorProto* t);
589	private:
590	const ::opencv_onnx::TensorProto& _internal_t() const;
591	::opencv_onnx::TensorProto* _internal_mutable_t();
592	public:
593	void unsafe_arena_set_allocated_t(
594	::opencv_onnx::TensorProto* t);
595	::opencv_onnx::TensorProto* unsafe_arena_release_t();
596
597	// optional .opencv_onnx.GraphProto g = 6;
598	bool has_g() const;
599	private:
600	bool _internal_has_g() const;
601	public:
602	void clear_g();
603	const ::opencv_onnx::GraphProto& g() const;
604	PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_g();
605	::opencv_onnx::GraphProto* mutable_g();
606	void set_allocated_g(::opencv_onnx::GraphProto* g);
607	private:
608	const ::opencv_onnx::GraphProto& _internal_g() const;
609	::opencv_onnx::GraphProto* _internal_mutable_g();
610	public:
611	void unsafe_arena_set_allocated_g(
612	::opencv_onnx::GraphProto* g);
613	::opencv_onnx::GraphProto* unsafe_arena_release_g();
614
615	// optional int64 i = 3;
616	bool has_i() const;
617	private:
618	bool _internal_has_i() const;
619	public:
620	void clear_i();
621	int64_t i() const;
622	void set_i(int64_t value);
623	private:
624	int64_t _internal_i() const;
625	void _internal_set_i(int64_t value);
626	public:
627
628	// optional float f = 2;
629	bool has_f() const;
630	private:
631	bool _internal_has_f() const;
632	public:
633	void clear_f();
634	float f() const;
635	void set_f(float value);
636	private:
637	float _internal_f() const;
638	void _internal_set_f(float value);
639	public:
640
641	// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
642	bool has_type() const;
643	private:
644	bool _internal_has_type() const;
645	public:
646	void clear_type();
647	::opencv_onnx::AttributeProto_AttributeType type() const;
648	void set_type(::opencv_onnx::AttributeProto_AttributeType value);
649	private:
650	::opencv_onnx::AttributeProto_AttributeType _internal_type() const;
651	void _internal_set_type(::opencv_onnx::AttributeProto_AttributeType value);
652	public:
653
654	// @@protoc_insertion_point(class_scope:opencv_onnx.AttributeProto)
655	private:
656	class _Internal;
657
658	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
659	typedef void InternalArenaConstructable_;
660	typedef void DestructorSkippable_;
661	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
662	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
663	::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
664	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > ints_;
665	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
666	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto > tensors_;
667	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto > graphs_;
668	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
669	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
670	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
671	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ref_attr_name_;
672	::opencv_onnx::TensorProto* t_;
673	::opencv_onnx::GraphProto* g_;
674	int64_t i_;
675	float f_;
676	int type_;
677	friend struct ::TableStruct_opencv_2donnx_2eproto;
678	};
679	// -------------------------------------------------------------------
680
681	class ValueInfoProto final :
682	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ValueInfoProto) */ {
683	public:
684	inline ValueInfoProto() : ValueInfoProto(nullptr) {}
685	~ValueInfoProto() override;
686	explicit constexpr ValueInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
687
688	ValueInfoProto(const ValueInfoProto& from);
689	ValueInfoProto(ValueInfoProto&& from) noexcept
690	: ValueInfoProto() {
691	*this = ::std::move(from);
692	}
693
694	inline ValueInfoProto& operator=(const ValueInfoProto& from) {
695	CopyFrom(from);
696	return *this;
697	}
698	inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
699	if (this == &from) return *this;
700	if (GetOwningArena() == from.GetOwningArena()
701	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
702	&& GetOwningArena() != nullptr
703	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
704	) {
705	InternalSwap(other: &from);
706	} else {
707	CopyFrom(from);
708	}
709	return *this;
710	}
711
712	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
713	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
714	}
715	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
716	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
717	}
718
719	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
720	return GetDescriptor();
721	}
722	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
723	return default_instance().GetMetadata().descriptor;
724	}
725	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
726	return default_instance().GetMetadata().reflection;
727	}
728	static const ValueInfoProto& default_instance() {
729	return *internal_default_instance();
730	}
731	static inline const ValueInfoProto* internal_default_instance() {
732	return reinterpret_cast<const ValueInfoProto*>(
733	&_ValueInfoProto_default_instance_);
734	}
735	static constexpr int kIndexInFileMessages =
736	1;
737
738	friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
739	a.Swap(other: &b);
740	}
741	inline void Swap(ValueInfoProto* other) {
742	if (other == this) return;
743	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
744	if (GetOwningArena() != nullptr &&
745	GetOwningArena() == other->GetOwningArena()) {
746	#else // PROTOBUF_FORCE_COPY_IN_SWAP
747	if (GetOwningArena() == other->GetOwningArena()) {
748	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
749	InternalSwap(other);
750	} else {
751	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
752	}
753	}
754	void UnsafeArenaSwap(ValueInfoProto* other) {
755	if (other == this) return;
756	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
757	InternalSwap(other);
758	}
759
760	// implements Message ----------------------------------------------
761
762	ValueInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
763	return CreateMaybeMessage<ValueInfoProto>(arena);
764	}
765	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
766	void CopyFrom(const ValueInfoProto& from);
767	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
768	void MergeFrom(const ValueInfoProto& from);
769	private:
770	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
771	public:
772	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
773	bool IsInitialized() const final;
774
775	size_t ByteSizeLong() const final;
776	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
777	uint8_t* _InternalSerialize(
778	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
779	int GetCachedSize() const final { return _cached_size_.Get(); }
780
781	private:
782	void SharedCtor();
783	void SharedDtor();
784	void SetCachedSize(int size) const final;
785	void InternalSwap(ValueInfoProto* other);
786
787	private:
788	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
789	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
790	return "opencv_onnx.ValueInfoProto";
791	}
792	protected:
793	explicit ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
794	bool is_message_owned = false);
795	private:
796	static void ArenaDtor(void* object);
797	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
798	public:
799
800	static const ClassData _class_data_;
801	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
802
803	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
804
805	// nested types ----------------------------------------------------
806
807	// accessors -------------------------------------------------------
808
809	enum : int {
810	kNameFieldNumber = 1,
811	kDocStringFieldNumber = 3,
812	kTypeFieldNumber = 2,
813	};
814	// optional string name = 1;
815	bool has_name() const;
816	private:
817	bool _internal_has_name() const;
818	public:
819	void clear_name();
820	const std::string& name() const;
821	template <typename ArgT0 = const std::string&, typename... ArgT>
822	void set_name(ArgT0&& arg0, ArgT... args);
823	std::string* mutable_name();
824	PROTOBUF_NODISCARD std::string* release_name();
825	void set_allocated_name(std::string* name);
826	private:
827	const std::string& _internal_name() const;
828	inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
829	std::string* _internal_mutable_name();
830	public:
831
832	// optional string doc_string = 3;
833	bool has_doc_string() const;
834	private:
835	bool _internal_has_doc_string() const;
836	public:
837	void clear_doc_string();
838	const std::string& doc_string() const;
839	template <typename ArgT0 = const std::string&, typename... ArgT>
840	void set_doc_string(ArgT0&& arg0, ArgT... args);
841	std::string* mutable_doc_string();
842	PROTOBUF_NODISCARD std::string* release_doc_string();
843	void set_allocated_doc_string(std::string* doc_string);
844	private:
845	const std::string& _internal_doc_string() const;
846	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
847	std::string* _internal_mutable_doc_string();
848	public:
849
850	// optional .opencv_onnx.TypeProto type = 2;
851	bool has_type() const;
852	private:
853	bool _internal_has_type() const;
854	public:
855	void clear_type();
856	const ::opencv_onnx::TypeProto& type() const;
857	PROTOBUF_NODISCARD ::opencv_onnx::TypeProto* release_type();
858	::opencv_onnx::TypeProto* mutable_type();
859	void set_allocated_type(::opencv_onnx::TypeProto* type);
860	private:
861	const ::opencv_onnx::TypeProto& _internal_type() const;
862	::opencv_onnx::TypeProto* _internal_mutable_type();
863	public:
864	void unsafe_arena_set_allocated_type(
865	::opencv_onnx::TypeProto* type);
866	::opencv_onnx::TypeProto* unsafe_arena_release_type();
867
868	// @@protoc_insertion_point(class_scope:opencv_onnx.ValueInfoProto)
869	private:
870	class _Internal;
871
872	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
873	typedef void InternalArenaConstructable_;
874	typedef void DestructorSkippable_;
875	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
876	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
877	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
878	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
879	::opencv_onnx::TypeProto* type_;
880	friend struct ::TableStruct_opencv_2donnx_2eproto;
881	};
882	// -------------------------------------------------------------------
883
884	class NodeProto final :
885	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.NodeProto) */ {
886	public:
887	inline NodeProto() : NodeProto(nullptr) {}
888	~NodeProto() override;
889	explicit constexpr NodeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
890
891	NodeProto(const NodeProto& from);
892	NodeProto(NodeProto&& from) noexcept
893	: NodeProto() {
894	*this = ::std::move(from);
895	}
896
897	inline NodeProto& operator=(const NodeProto& from) {
898	CopyFrom(from);
899	return *this;
900	}
901	inline NodeProto& operator=(NodeProto&& from) noexcept {
902	if (this == &from) return *this;
903	if (GetOwningArena() == from.GetOwningArena()
904	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
905	&& GetOwningArena() != nullptr
906	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
907	) {
908	InternalSwap(other: &from);
909	} else {
910	CopyFrom(from);
911	}
912	return *this;
913	}
914
915	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
916	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
917	}
918	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
919	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
920	}
921
922	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
923	return GetDescriptor();
924	}
925	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
926	return default_instance().GetMetadata().descriptor;
927	}
928	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
929	return default_instance().GetMetadata().reflection;
930	}
931	static const NodeProto& default_instance() {
932	return *internal_default_instance();
933	}
934	static inline const NodeProto* internal_default_instance() {
935	return reinterpret_cast<const NodeProto*>(
936	&_NodeProto_default_instance_);
937	}
938	static constexpr int kIndexInFileMessages =
939	2;
940
941	friend void swap(NodeProto& a, NodeProto& b) {
942	a.Swap(other: &b);
943	}
944	inline void Swap(NodeProto* other) {
945	if (other == this) return;
946	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
947	if (GetOwningArena() != nullptr &&
948	GetOwningArena() == other->GetOwningArena()) {
949	#else // PROTOBUF_FORCE_COPY_IN_SWAP
950	if (GetOwningArena() == other->GetOwningArena()) {
951	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
952	InternalSwap(other);
953	} else {
954	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
955	}
956	}
957	void UnsafeArenaSwap(NodeProto* other) {
958	if (other == this) return;
959	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
960	InternalSwap(other);
961	}
962
963	// implements Message ----------------------------------------------
964
965	NodeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
966	return CreateMaybeMessage<NodeProto>(arena);
967	}
968	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
969	void CopyFrom(const NodeProto& from);
970	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
971	void MergeFrom(const NodeProto& from);
972	private:
973	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
974	public:
975	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
976	bool IsInitialized() const final;
977
978	size_t ByteSizeLong() const final;
979	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
980	uint8_t* _InternalSerialize(
981	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
982	int GetCachedSize() const final { return _cached_size_.Get(); }
983
984	private:
985	void SharedCtor();
986	void SharedDtor();
987	void SetCachedSize(int size) const final;
988	void InternalSwap(NodeProto* other);
989
990	private:
991	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
992	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
993	return "opencv_onnx.NodeProto";
994	}
995	protected:
996	explicit NodeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
997	bool is_message_owned = false);
998	private:
999	static void ArenaDtor(void* object);
1000	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1001	public:
1002
1003	static const ClassData _class_data_;
1004	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1005
1006	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1007
1008	// nested types ----------------------------------------------------
1009
1010	// accessors -------------------------------------------------------
1011
1012	enum : int {
1013	kInputFieldNumber = 1,
1014	kOutputFieldNumber = 2,
1015	kAttributeFieldNumber = 5,
1016	kNameFieldNumber = 3,
1017	kOpTypeFieldNumber = 4,
1018	kDocStringFieldNumber = 6,
1019	kDomainFieldNumber = 7,
1020	};
1021	// repeated string input = 1;
1022	int input_size() const;
1023	private:
1024	int _internal_input_size() const;
1025	public:
1026	void clear_input();
1027	const std::string& input(int index) const;
1028	std::string* mutable_input(int index);
1029	void set_input(int index, const std::string& value);
1030	void set_input(int index, std::string&& value);
1031	void set_input(int index, const char* value);
1032	void set_input(int index, const char* value, size_t size);
1033	std::string* add_input();
1034	void add_input(const std::string& value);
1035	void add_input(std::string&& value);
1036	void add_input(const char* value);
1037	void add_input(const char* value, size_t size);
1038	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
1039	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
1040	private:
1041	const std::string& _internal_input(int index) const;
1042	std::string* _internal_add_input();
1043	public:
1044
1045	// repeated string output = 2;
1046	int output_size() const;
1047	private:
1048	int _internal_output_size() const;
1049	public:
1050	void clear_output();
1051	const std::string& output(int index) const;
1052	std::string* mutable_output(int index);
1053	void set_output(int index, const std::string& value);
1054	void set_output(int index, std::string&& value);
1055	void set_output(int index, const char* value);
1056	void set_output(int index, const char* value, size_t size);
1057	std::string* add_output();
1058	void add_output(const std::string& value);
1059	void add_output(std::string&& value);
1060	void add_output(const char* value);
1061	void add_output(const char* value, size_t size);
1062	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
1063	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
1064	private:
1065	const std::string& _internal_output(int index) const;
1066	std::string* _internal_add_output();
1067	public:
1068
1069	// repeated .opencv_onnx.AttributeProto attribute = 5;
1070	int attribute_size() const;
1071	private:
1072	int _internal_attribute_size() const;
1073	public:
1074	void clear_attribute();
1075	::opencv_onnx::AttributeProto* mutable_attribute(int index);
1076	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
1077	mutable_attribute();
1078	private:
1079	const ::opencv_onnx::AttributeProto& _internal_attribute(int index) const;
1080	::opencv_onnx::AttributeProto* _internal_add_attribute();
1081	public:
1082	const ::opencv_onnx::AttributeProto& attribute(int index) const;
1083	::opencv_onnx::AttributeProto* add_attribute();
1084	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
1085	attribute() const;
1086
1087	// optional string name = 3;
1088	bool has_name() const;
1089	private:
1090	bool _internal_has_name() const;
1091	public:
1092	void clear_name();
1093	const std::string& name() const;
1094	template <typename ArgT0 = const std::string&, typename... ArgT>
1095	void set_name(ArgT0&& arg0, ArgT... args);
1096	std::string* mutable_name();
1097	PROTOBUF_NODISCARD std::string* release_name();
1098	void set_allocated_name(std::string* name);
1099	private:
1100	const std::string& _internal_name() const;
1101	inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1102	std::string* _internal_mutable_name();
1103	public:
1104
1105	// optional string op_type = 4;
1106	bool has_op_type() const;
1107	private:
1108	bool _internal_has_op_type() const;
1109	public:
1110	void clear_op_type();
1111	const std::string& op_type() const;
1112	template <typename ArgT0 = const std::string&, typename... ArgT>
1113	void set_op_type(ArgT0&& arg0, ArgT... args);
1114	std::string* mutable_op_type();
1115	PROTOBUF_NODISCARD std::string* release_op_type();
1116	void set_allocated_op_type(std::string* op_type);
1117	private:
1118	const std::string& _internal_op_type() const;
1119	inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(const std::string& value);
1120	std::string* _internal_mutable_op_type();
1121	public:
1122
1123	// optional string doc_string = 6;
1124	bool has_doc_string() const;
1125	private:
1126	bool _internal_has_doc_string() const;
1127	public:
1128	void clear_doc_string();
1129	const std::string& doc_string() const;
1130	template <typename ArgT0 = const std::string&, typename... ArgT>
1131	void set_doc_string(ArgT0&& arg0, ArgT... args);
1132	std::string* mutable_doc_string();
1133	PROTOBUF_NODISCARD std::string* release_doc_string();
1134	void set_allocated_doc_string(std::string* doc_string);
1135	private:
1136	const std::string& _internal_doc_string() const;
1137	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
1138	std::string* _internal_mutable_doc_string();
1139	public:
1140
1141	// optional string domain = 7;
1142	bool has_domain() const;
1143	private:
1144	bool _internal_has_domain() const;
1145	public:
1146	void clear_domain();
1147	const std::string& domain() const;
1148	template <typename ArgT0 = const std::string&, typename... ArgT>
1149	void set_domain(ArgT0&& arg0, ArgT... args);
1150	std::string* mutable_domain();
1151	PROTOBUF_NODISCARD std::string* release_domain();
1152	void set_allocated_domain(std::string* domain);
1153	private:
1154	const std::string& _internal_domain() const;
1155	inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
1156	std::string* _internal_mutable_domain();
1157	public:
1158
1159	// @@protoc_insertion_point(class_scope:opencv_onnx.NodeProto)
1160	private:
1161	class _Internal;
1162
1163	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1164	typedef void InternalArenaConstructable_;
1165	typedef void DestructorSkippable_;
1166	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1167	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1168	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
1169	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
1170	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto > attribute_;
1171	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1172	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
1173	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
1174	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
1175	friend struct ::TableStruct_opencv_2donnx_2eproto;
1176	};
1177	// -------------------------------------------------------------------
1178
1179	class ModelProto final :
1180	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ModelProto) */ {
1181	public:
1182	inline ModelProto() : ModelProto(nullptr) {}
1183	~ModelProto() override;
1184	explicit constexpr ModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1185
1186	ModelProto(const ModelProto& from);
1187	ModelProto(ModelProto&& from) noexcept
1188	: ModelProto() {
1189	*this = ::std::move(from);
1190	}
1191
1192	inline ModelProto& operator=(const ModelProto& from) {
1193	CopyFrom(from);
1194	return *this;
1195	}
1196	inline ModelProto& operator=(ModelProto&& from) noexcept {
1197	if (this == &from) return *this;
1198	if (GetOwningArena() == from.GetOwningArena()
1199	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1200	&& GetOwningArena() != nullptr
1201	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1202	) {
1203	InternalSwap(other: &from);
1204	} else {
1205	CopyFrom(from);
1206	}
1207	return *this;
1208	}
1209
1210	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1211	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1212	}
1213	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1214	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1215	}
1216
1217	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1218	return GetDescriptor();
1219	}
1220	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1221	return default_instance().GetMetadata().descriptor;
1222	}
1223	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1224	return default_instance().GetMetadata().reflection;
1225	}
1226	static const ModelProto& default_instance() {
1227	return *internal_default_instance();
1228	}
1229	static inline const ModelProto* internal_default_instance() {
1230	return reinterpret_cast<const ModelProto*>(
1231	&_ModelProto_default_instance_);
1232	}
1233	static constexpr int kIndexInFileMessages =
1234	3;
1235
1236	friend void swap(ModelProto& a, ModelProto& b) {
1237	a.Swap(other: &b);
1238	}
1239	inline void Swap(ModelProto* other) {
1240	if (other == this) return;
1241	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1242	if (GetOwningArena() != nullptr &&
1243	GetOwningArena() == other->GetOwningArena()) {
1244	#else // PROTOBUF_FORCE_COPY_IN_SWAP
1245	if (GetOwningArena() == other->GetOwningArena()) {
1246	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1247	InternalSwap(other);
1248	} else {
1249	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1250	}
1251	}
1252	void UnsafeArenaSwap(ModelProto* other) {
1253	if (other == this) return;
1254	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1255	InternalSwap(other);
1256	}
1257
1258	// implements Message ----------------------------------------------
1259
1260	ModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1261	return CreateMaybeMessage<ModelProto>(arena);
1262	}
1263	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1264	void CopyFrom(const ModelProto& from);
1265	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1266	void MergeFrom(const ModelProto& from);
1267	private:
1268	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
1269	public:
1270	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1271	bool IsInitialized() const final;
1272
1273	size_t ByteSizeLong() const final;
1274	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1275	uint8_t* _InternalSerialize(
1276	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1277	int GetCachedSize() const final { return _cached_size_.Get(); }
1278
1279	private:
1280	void SharedCtor();
1281	void SharedDtor();
1282	void SetCachedSize(int size) const final;
1283	void InternalSwap(ModelProto* other);
1284
1285	private:
1286	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1287	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1288	return "opencv_onnx.ModelProto";
1289	}
1290	protected:
1291	explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1292	bool is_message_owned = false);
1293	private:
1294	static void ArenaDtor(void* object);
1295	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1296	public:
1297
1298	static const ClassData _class_data_;
1299	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1300
1301	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1302
1303	// nested types ----------------------------------------------------
1304
1305	// accessors -------------------------------------------------------
1306
1307	enum : int {
1308	kOpsetImportFieldNumber = 8,
1309	kMetadataPropsFieldNumber = 14,
1310	kProducerNameFieldNumber = 2,
1311	kProducerVersionFieldNumber = 3,
1312	kDomainFieldNumber = 4,
1313	kDocStringFieldNumber = 6,
1314	kGraphFieldNumber = 7,
1315	kIrVersionFieldNumber = 1,
1316	kModelVersionFieldNumber = 5,
1317	};
1318	// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
1319	int opset_import_size() const;
1320	private:
1321	int _internal_opset_import_size() const;
1322	public:
1323	void clear_opset_import();
1324	::opencv_onnx::OperatorSetIdProto* mutable_opset_import(int index);
1325	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
1326	mutable_opset_import();
1327	private:
1328	const ::opencv_onnx::OperatorSetIdProto& _internal_opset_import(int index) const;
1329	::opencv_onnx::OperatorSetIdProto* _internal_add_opset_import();
1330	public:
1331	const ::opencv_onnx::OperatorSetIdProto& opset_import(int index) const;
1332	::opencv_onnx::OperatorSetIdProto* add_opset_import();
1333	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
1334	opset_import() const;
1335
1336	// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
1337	int metadata_props_size() const;
1338	private:
1339	int _internal_metadata_props_size() const;
1340	public:
1341	void clear_metadata_props();
1342	::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
1343	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
1344	mutable_metadata_props();
1345	private:
1346	const ::opencv_onnx::StringStringEntryProto& _internal_metadata_props(int index) const;
1347	::opencv_onnx::StringStringEntryProto* _internal_add_metadata_props();
1348	public:
1349	const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
1350	::opencv_onnx::StringStringEntryProto* add_metadata_props();
1351	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
1352	metadata_props() const;
1353
1354	// optional string producer_name = 2;
1355	bool has_producer_name() const;
1356	private:
1357	bool _internal_has_producer_name() const;
1358	public:
1359	void clear_producer_name();
1360	const std::string& producer_name() const;
1361	template <typename ArgT0 = const std::string&, typename... ArgT>
1362	void set_producer_name(ArgT0&& arg0, ArgT... args);
1363	std::string* mutable_producer_name();
1364	PROTOBUF_NODISCARD std::string* release_producer_name();
1365	void set_allocated_producer_name(std::string* producer_name);
1366	private:
1367	const std::string& _internal_producer_name() const;
1368	inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_name(const std::string& value);
1369	std::string* _internal_mutable_producer_name();
1370	public:
1371
1372	// optional string producer_version = 3;
1373	bool has_producer_version() const;
1374	private:
1375	bool _internal_has_producer_version() const;
1376	public:
1377	void clear_producer_version();
1378	const std::string& producer_version() const;
1379	template <typename ArgT0 = const std::string&, typename... ArgT>
1380	void set_producer_version(ArgT0&& arg0, ArgT... args);
1381	std::string* mutable_producer_version();
1382	PROTOBUF_NODISCARD std::string* release_producer_version();
1383	void set_allocated_producer_version(std::string* producer_version);
1384	private:
1385	const std::string& _internal_producer_version() const;
1386	inline PROTOBUF_ALWAYS_INLINE void _internal_set_producer_version(const std::string& value);
1387	std::string* _internal_mutable_producer_version();
1388	public:
1389
1390	// optional string domain = 4;
1391	bool has_domain() const;
1392	private:
1393	bool _internal_has_domain() const;
1394	public:
1395	void clear_domain();
1396	const std::string& domain() const;
1397	template <typename ArgT0 = const std::string&, typename... ArgT>
1398	void set_domain(ArgT0&& arg0, ArgT... args);
1399	std::string* mutable_domain();
1400	PROTOBUF_NODISCARD std::string* release_domain();
1401	void set_allocated_domain(std::string* domain);
1402	private:
1403	const std::string& _internal_domain() const;
1404	inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
1405	std::string* _internal_mutable_domain();
1406	public:
1407
1408	// optional string doc_string = 6;
1409	bool has_doc_string() const;
1410	private:
1411	bool _internal_has_doc_string() const;
1412	public:
1413	void clear_doc_string();
1414	const std::string& doc_string() const;
1415	template <typename ArgT0 = const std::string&, typename... ArgT>
1416	void set_doc_string(ArgT0&& arg0, ArgT... args);
1417	std::string* mutable_doc_string();
1418	PROTOBUF_NODISCARD std::string* release_doc_string();
1419	void set_allocated_doc_string(std::string* doc_string);
1420	private:
1421	const std::string& _internal_doc_string() const;
1422	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
1423	std::string* _internal_mutable_doc_string();
1424	public:
1425
1426	// optional .opencv_onnx.GraphProto graph = 7;
1427	bool has_graph() const;
1428	private:
1429	bool _internal_has_graph() const;
1430	public:
1431	void clear_graph();
1432	const ::opencv_onnx::GraphProto& graph() const;
1433	PROTOBUF_NODISCARD ::opencv_onnx::GraphProto* release_graph();
1434	::opencv_onnx::GraphProto* mutable_graph();
1435	void set_allocated_graph(::opencv_onnx::GraphProto* graph);
1436	private:
1437	const ::opencv_onnx::GraphProto& _internal_graph() const;
1438	::opencv_onnx::GraphProto* _internal_mutable_graph();
1439	public:
1440	void unsafe_arena_set_allocated_graph(
1441	::opencv_onnx::GraphProto* graph);
1442	::opencv_onnx::GraphProto* unsafe_arena_release_graph();
1443
1444	// optional int64 ir_version = 1;
1445	bool has_ir_version() const;
1446	private:
1447	bool _internal_has_ir_version() const;
1448	public:
1449	void clear_ir_version();
1450	int64_t ir_version() const;
1451	void set_ir_version(int64_t value);
1452	private:
1453	int64_t _internal_ir_version() const;
1454	void _internal_set_ir_version(int64_t value);
1455	public:
1456
1457	// optional int64 model_version = 5;
1458	bool has_model_version() const;
1459	private:
1460	bool _internal_has_model_version() const;
1461	public:
1462	void clear_model_version();
1463	int64_t model_version() const;
1464	void set_model_version(int64_t value);
1465	private:
1466	int64_t _internal_model_version() const;
1467	void _internal_set_model_version(int64_t value);
1468	public:
1469
1470	// @@protoc_insertion_point(class_scope:opencv_onnx.ModelProto)
1471	private:
1472	class _Internal;
1473
1474	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1475	typedef void InternalArenaConstructable_;
1476	typedef void DestructorSkippable_;
1477	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1478	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1479	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto > opset_import_;
1480	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
1481	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_;
1482	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_version_;
1483	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
1484	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
1485	::opencv_onnx::GraphProto* graph_;
1486	int64_t ir_version_;
1487	int64_t model_version_;
1488	friend struct ::TableStruct_opencv_2donnx_2eproto;
1489	};
1490	// -------------------------------------------------------------------
1491
1492	class StringStringEntryProto final :
1493	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.StringStringEntryProto) */ {
1494	public:
1495	inline StringStringEntryProto() : StringStringEntryProto(nullptr) {}
1496	~StringStringEntryProto() override;
1497	explicit constexpr StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1498
1499	StringStringEntryProto(const StringStringEntryProto& from);
1500	StringStringEntryProto(StringStringEntryProto&& from) noexcept
1501	: StringStringEntryProto() {
1502	*this = ::std::move(from);
1503	}
1504
1505	inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
1506	CopyFrom(from);
1507	return *this;
1508	}
1509	inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
1510	if (this == &from) return *this;
1511	if (GetOwningArena() == from.GetOwningArena()
1512	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1513	&& GetOwningArena() != nullptr
1514	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1515	) {
1516	InternalSwap(other: &from);
1517	} else {
1518	CopyFrom(from);
1519	}
1520	return *this;
1521	}
1522
1523	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1524	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1525	}
1526	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1527	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1528	}
1529
1530	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1531	return GetDescriptor();
1532	}
1533	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1534	return default_instance().GetMetadata().descriptor;
1535	}
1536	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1537	return default_instance().GetMetadata().reflection;
1538	}
1539	static const StringStringEntryProto& default_instance() {
1540	return *internal_default_instance();
1541	}
1542	static inline const StringStringEntryProto* internal_default_instance() {
1543	return reinterpret_cast<const StringStringEntryProto*>(
1544	&_StringStringEntryProto_default_instance_);
1545	}
1546	static constexpr int kIndexInFileMessages =
1547	4;
1548
1549	friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
1550	a.Swap(other: &b);
1551	}
1552	inline void Swap(StringStringEntryProto* other) {
1553	if (other == this) return;
1554	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1555	if (GetOwningArena() != nullptr &&
1556	GetOwningArena() == other->GetOwningArena()) {
1557	#else // PROTOBUF_FORCE_COPY_IN_SWAP
1558	if (GetOwningArena() == other->GetOwningArena()) {
1559	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1560	InternalSwap(other);
1561	} else {
1562	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1563	}
1564	}
1565	void UnsafeArenaSwap(StringStringEntryProto* other) {
1566	if (other == this) return;
1567	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1568	InternalSwap(other);
1569	}
1570
1571	// implements Message ----------------------------------------------
1572
1573	StringStringEntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1574	return CreateMaybeMessage<StringStringEntryProto>(arena);
1575	}
1576	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1577	void CopyFrom(const StringStringEntryProto& from);
1578	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1579	void MergeFrom(const StringStringEntryProto& from);
1580	private:
1581	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
1582	public:
1583	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1584	bool IsInitialized() const final;
1585
1586	size_t ByteSizeLong() const final;
1587	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1588	uint8_t* _InternalSerialize(
1589	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1590	int GetCachedSize() const final { return _cached_size_.Get(); }
1591
1592	private:
1593	void SharedCtor();
1594	void SharedDtor();
1595	void SetCachedSize(int size) const final;
1596	void InternalSwap(StringStringEntryProto* other);
1597
1598	private:
1599	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1600	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1601	return "opencv_onnx.StringStringEntryProto";
1602	}
1603	protected:
1604	explicit StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1605	bool is_message_owned = false);
1606	private:
1607	static void ArenaDtor(void* object);
1608	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1609	public:
1610
1611	static const ClassData _class_data_;
1612	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1613
1614	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1615
1616	// nested types ----------------------------------------------------
1617
1618	// accessors -------------------------------------------------------
1619
1620	enum : int {
1621	kKeyFieldNumber = 1,
1622	kValueFieldNumber = 2,
1623	};
1624	// optional string key = 1;
1625	bool has_key() const;
1626	private:
1627	bool _internal_has_key() const;
1628	public:
1629	void clear_key();
1630	const std::string& key() const;
1631	template <typename ArgT0 = const std::string&, typename... ArgT>
1632	void set_key(ArgT0&& arg0, ArgT... args);
1633	std::string* mutable_key();
1634	PROTOBUF_NODISCARD std::string* release_key();
1635	void set_allocated_key(std::string* key);
1636	private:
1637	const std::string& _internal_key() const;
1638	inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
1639	std::string* _internal_mutable_key();
1640	public:
1641
1642	// optional string value = 2;
1643	bool has_value() const;
1644	private:
1645	bool _internal_has_value() const;
1646	public:
1647	void clear_value();
1648	const std::string& value() const;
1649	template <typename ArgT0 = const std::string&, typename... ArgT>
1650	void set_value(ArgT0&& arg0, ArgT... args);
1651	std::string* mutable_value();
1652	PROTOBUF_NODISCARD std::string* release_value();
1653	void set_allocated_value(std::string* value);
1654	private:
1655	const std::string& _internal_value() const;
1656	inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
1657	std::string* _internal_mutable_value();
1658	public:
1659
1660	// @@protoc_insertion_point(class_scope:opencv_onnx.StringStringEntryProto)
1661	private:
1662	class _Internal;
1663
1664	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1665	typedef void InternalArenaConstructable_;
1666	typedef void DestructorSkippable_;
1667	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1668	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1669	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
1670	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
1671	friend struct ::TableStruct_opencv_2donnx_2eproto;
1672	};
1673	// -------------------------------------------------------------------
1674
1675	class GraphProto final :
1676	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.GraphProto) */ {
1677	public:
1678	inline GraphProto() : GraphProto(nullptr) {}
1679	~GraphProto() override;
1680	explicit constexpr GraphProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1681
1682	GraphProto(const GraphProto& from);
1683	GraphProto(GraphProto&& from) noexcept
1684	: GraphProto() {
1685	*this = ::std::move(from);
1686	}
1687
1688	inline GraphProto& operator=(const GraphProto& from) {
1689	CopyFrom(from);
1690	return *this;
1691	}
1692	inline GraphProto& operator=(GraphProto&& from) noexcept {
1693	if (this == &from) return *this;
1694	if (GetOwningArena() == from.GetOwningArena()
1695	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1696	&& GetOwningArena() != nullptr
1697	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1698	) {
1699	InternalSwap(other: &from);
1700	} else {
1701	CopyFrom(from);
1702	}
1703	return *this;
1704	}
1705
1706	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1707	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1708	}
1709	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1710	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1711	}
1712
1713	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1714	return GetDescriptor();
1715	}
1716	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1717	return default_instance().GetMetadata().descriptor;
1718	}
1719	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1720	return default_instance().GetMetadata().reflection;
1721	}
1722	static const GraphProto& default_instance() {
1723	return *internal_default_instance();
1724	}
1725	static inline const GraphProto* internal_default_instance() {
1726	return reinterpret_cast<const GraphProto*>(
1727	&_GraphProto_default_instance_);
1728	}
1729	static constexpr int kIndexInFileMessages =
1730	5;
1731
1732	friend void swap(GraphProto& a, GraphProto& b) {
1733	a.Swap(other: &b);
1734	}
1735	inline void Swap(GraphProto* other) {
1736	if (other == this) return;
1737	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1738	if (GetOwningArena() != nullptr &&
1739	GetOwningArena() == other->GetOwningArena()) {
1740	#else // PROTOBUF_FORCE_COPY_IN_SWAP
1741	if (GetOwningArena() == other->GetOwningArena()) {
1742	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1743	InternalSwap(other);
1744	} else {
1745	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
1746	}
1747	}
1748	void UnsafeArenaSwap(GraphProto* other) {
1749	if (other == this) return;
1750	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1751	InternalSwap(other);
1752	}
1753
1754	// implements Message ----------------------------------------------
1755
1756	GraphProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1757	return CreateMaybeMessage<GraphProto>(arena);
1758	}
1759	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1760	void CopyFrom(const GraphProto& from);
1761	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1762	void MergeFrom(const GraphProto& from);
1763	private:
1764	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
1765	public:
1766	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1767	bool IsInitialized() const final;
1768
1769	size_t ByteSizeLong() const final;
1770	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1771	uint8_t* _InternalSerialize(
1772	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1773	int GetCachedSize() const final { return _cached_size_.Get(); }
1774
1775	private:
1776	void SharedCtor();
1777	void SharedDtor();
1778	void SetCachedSize(int size) const final;
1779	void InternalSwap(GraphProto* other);
1780
1781	private:
1782	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1783	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1784	return "opencv_onnx.GraphProto";
1785	}
1786	protected:
1787	explicit GraphProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1788	bool is_message_owned = false);
1789	private:
1790	static void ArenaDtor(void* object);
1791	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1792	public:
1793
1794	static const ClassData _class_data_;
1795	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1796
1797	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1798
1799	// nested types ----------------------------------------------------
1800
1801	// accessors -------------------------------------------------------
1802
1803	enum : int {
1804	kNodeFieldNumber = 1,
1805	kInitializerFieldNumber = 5,
1806	kInputFieldNumber = 11,
1807	kOutputFieldNumber = 12,
1808	kValueInfoFieldNumber = 13,
1809	kNameFieldNumber = 2,
1810	kDocStringFieldNumber = 10,
1811	};
1812	// repeated .opencv_onnx.NodeProto node = 1;
1813	int node_size() const;
1814	private:
1815	int _internal_node_size() const;
1816	public:
1817	void clear_node();
1818	::opencv_onnx::NodeProto* mutable_node(int index);
1819	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
1820	mutable_node();
1821	private:
1822	const ::opencv_onnx::NodeProto& _internal_node(int index) const;
1823	::opencv_onnx::NodeProto* _internal_add_node();
1824	public:
1825	const ::opencv_onnx::NodeProto& node(int index) const;
1826	::opencv_onnx::NodeProto* add_node();
1827	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
1828	node() const;
1829
1830	// repeated .opencv_onnx.TensorProto initializer = 5;
1831	int initializer_size() const;
1832	private:
1833	int _internal_initializer_size() const;
1834	public:
1835	void clear_initializer();
1836	::opencv_onnx::TensorProto* mutable_initializer(int index);
1837	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
1838	mutable_initializer();
1839	private:
1840	const ::opencv_onnx::TensorProto& _internal_initializer(int index) const;
1841	::opencv_onnx::TensorProto* _internal_add_initializer();
1842	public:
1843	const ::opencv_onnx::TensorProto& initializer(int index) const;
1844	::opencv_onnx::TensorProto* add_initializer();
1845	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
1846	initializer() const;
1847
1848	// repeated .opencv_onnx.ValueInfoProto input = 11;
1849	int input_size() const;
1850	private:
1851	int _internal_input_size() const;
1852	public:
1853	void clear_input();
1854	::opencv_onnx::ValueInfoProto* mutable_input(int index);
1855	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1856	mutable_input();
1857	private:
1858	const ::opencv_onnx::ValueInfoProto& _internal_input(int index) const;
1859	::opencv_onnx::ValueInfoProto* _internal_add_input();
1860	public:
1861	const ::opencv_onnx::ValueInfoProto& input(int index) const;
1862	::opencv_onnx::ValueInfoProto* add_input();
1863	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1864	input() const;
1865
1866	// repeated .opencv_onnx.ValueInfoProto output = 12;
1867	int output_size() const;
1868	private:
1869	int _internal_output_size() const;
1870	public:
1871	void clear_output();
1872	::opencv_onnx::ValueInfoProto* mutable_output(int index);
1873	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1874	mutable_output();
1875	private:
1876	const ::opencv_onnx::ValueInfoProto& _internal_output(int index) const;
1877	::opencv_onnx::ValueInfoProto* _internal_add_output();
1878	public:
1879	const ::opencv_onnx::ValueInfoProto& output(int index) const;
1880	::opencv_onnx::ValueInfoProto* add_output();
1881	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1882	output() const;
1883
1884	// repeated .opencv_onnx.ValueInfoProto value_info = 13;
1885	int value_info_size() const;
1886	private:
1887	int _internal_value_info_size() const;
1888	public:
1889	void clear_value_info();
1890	::opencv_onnx::ValueInfoProto* mutable_value_info(int index);
1891	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1892	mutable_value_info();
1893	private:
1894	const ::opencv_onnx::ValueInfoProto& _internal_value_info(int index) const;
1895	::opencv_onnx::ValueInfoProto* _internal_add_value_info();
1896	public:
1897	const ::opencv_onnx::ValueInfoProto& value_info(int index) const;
1898	::opencv_onnx::ValueInfoProto* add_value_info();
1899	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1900	value_info() const;
1901
1902	// optional string name = 2;
1903	bool has_name() const;
1904	private:
1905	bool _internal_has_name() const;
1906	public:
1907	void clear_name();
1908	const std::string& name() const;
1909	template <typename ArgT0 = const std::string&, typename... ArgT>
1910	void set_name(ArgT0&& arg0, ArgT... args);
1911	std::string* mutable_name();
1912	PROTOBUF_NODISCARD std::string* release_name();
1913	void set_allocated_name(std::string* name);
1914	private:
1915	const std::string& _internal_name() const;
1916	inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1917	std::string* _internal_mutable_name();
1918	public:
1919
1920	// optional string doc_string = 10;
1921	bool has_doc_string() const;
1922	private:
1923	bool _internal_has_doc_string() const;
1924	public:
1925	void clear_doc_string();
1926	const std::string& doc_string() const;
1927	template <typename ArgT0 = const std::string&, typename... ArgT>
1928	void set_doc_string(ArgT0&& arg0, ArgT... args);
1929	std::string* mutable_doc_string();
1930	PROTOBUF_NODISCARD std::string* release_doc_string();
1931	void set_allocated_doc_string(std::string* doc_string);
1932	private:
1933	const std::string& _internal_doc_string() const;
1934	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
1935	std::string* _internal_mutable_doc_string();
1936	public:
1937
1938	// @@protoc_insertion_point(class_scope:opencv_onnx.GraphProto)
1939	private:
1940	class _Internal;
1941
1942	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1943	typedef void InternalArenaConstructable_;
1944	typedef void DestructorSkippable_;
1945	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1946	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1947	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto > node_;
1948	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto > initializer_;
1949	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > input_;
1950	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > output_;
1951	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > value_info_;
1952	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1953	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
1954	friend struct ::TableStruct_opencv_2donnx_2eproto;
1955	};
1956	// -------------------------------------------------------------------
1957
1958	class TensorProto_Segment final :
1959	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto.Segment) */ {
1960	public:
1961	inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
1962	~TensorProto_Segment() override;
1963	explicit constexpr TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1964
1965	TensorProto_Segment(const TensorProto_Segment& from);
1966	TensorProto_Segment(TensorProto_Segment&& from) noexcept
1967	: TensorProto_Segment() {
1968	*this = ::std::move(from);
1969	}
1970
1971	inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
1972	CopyFrom(from);
1973	return *this;
1974	}
1975	inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
1976	if (this == &from) return *this;
1977	if (GetOwningArena() == from.GetOwningArena()
1978	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1979	&& GetOwningArena() != nullptr
1980	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1981	) {
1982	InternalSwap(other: &from);
1983	} else {
1984	CopyFrom(from);
1985	}
1986	return *this;
1987	}
1988
1989	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1990	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1991	}
1992	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1993	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1994	}
1995
1996	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1997	return GetDescriptor();
1998	}
1999	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2000	return default_instance().GetMetadata().descriptor;
2001	}
2002	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2003	return default_instance().GetMetadata().reflection;
2004	}
2005	static const TensorProto_Segment& default_instance() {
2006	return *internal_default_instance();
2007	}
2008	static inline const TensorProto_Segment* internal_default_instance() {
2009	return reinterpret_cast<const TensorProto_Segment*>(
2010	&_TensorProto_Segment_default_instance_);
2011	}
2012	static constexpr int kIndexInFileMessages =
2013	6;
2014
2015	friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
2016	a.Swap(other: &b);
2017	}
2018	inline void Swap(TensorProto_Segment* other) {
2019	if (other == this) return;
2020	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2021	if (GetOwningArena() != nullptr &&
2022	GetOwningArena() == other->GetOwningArena()) {
2023	#else // PROTOBUF_FORCE_COPY_IN_SWAP
2024	if (GetOwningArena() == other->GetOwningArena()) {
2025	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2026	InternalSwap(other);
2027	} else {
2028	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
2029	}
2030	}
2031	void UnsafeArenaSwap(TensorProto_Segment* other) {
2032	if (other == this) return;
2033	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2034	InternalSwap(other);
2035	}
2036
2037	// implements Message ----------------------------------------------
2038
2039	TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2040	return CreateMaybeMessage<TensorProto_Segment>(arena);
2041	}
2042	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2043	void CopyFrom(const TensorProto_Segment& from);
2044	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2045	void MergeFrom(const TensorProto_Segment& from);
2046	private:
2047	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
2048	public:
2049	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2050	bool IsInitialized() const final;
2051
2052	size_t ByteSizeLong() const final;
2053	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2054	uint8_t* _InternalSerialize(
2055	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2056	int GetCachedSize() const final { return _cached_size_.Get(); }
2057
2058	private:
2059	void SharedCtor();
2060	void SharedDtor();
2061	void SetCachedSize(int size) const final;
2062	void InternalSwap(TensorProto_Segment* other);
2063
2064	private:
2065	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2066	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2067	return "opencv_onnx.TensorProto.Segment";
2068	}
2069	protected:
2070	explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2071	bool is_message_owned = false);
2072	private:
2073	static void ArenaDtor(void* object);
2074	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2075	public:
2076
2077	static const ClassData _class_data_;
2078	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2079
2080	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2081
2082	// nested types ----------------------------------------------------
2083
2084	// accessors -------------------------------------------------------
2085
2086	enum : int {
2087	kBeginFieldNumber = 1,
2088	kEndFieldNumber = 2,
2089	};
2090	// optional int64 begin = 1;
2091	bool has_begin() const;
2092	private:
2093	bool _internal_has_begin() const;
2094	public:
2095	void clear_begin();
2096	int64_t begin() const;
2097	void set_begin(int64_t value);
2098	private:
2099	int64_t _internal_begin() const;
2100	void _internal_set_begin(int64_t value);
2101	public:
2102
2103	// optional int64 end = 2;
2104	bool has_end() const;
2105	private:
2106	bool _internal_has_end() const;
2107	public:
2108	void clear_end();
2109	int64_t end() const;
2110	void set_end(int64_t value);
2111	private:
2112	int64_t _internal_end() const;
2113	void _internal_set_end(int64_t value);
2114	public:
2115
2116	// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto.Segment)
2117	private:
2118	class _Internal;
2119
2120	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2121	typedef void InternalArenaConstructable_;
2122	typedef void DestructorSkippable_;
2123	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2124	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2125	int64_t begin_;
2126	int64_t end_;
2127	friend struct ::TableStruct_opencv_2donnx_2eproto;
2128	};
2129	// -------------------------------------------------------------------
2130
2131	class TensorProto final :
2132	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto) */ {
2133	public:
2134	inline TensorProto() : TensorProto(nullptr) {}
2135	~TensorProto() override;
2136	explicit constexpr TensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2137
2138	TensorProto(const TensorProto& from);
2139	TensorProto(TensorProto&& from) noexcept
2140	: TensorProto() {
2141	*this = ::std::move(from);
2142	}
2143
2144	inline TensorProto& operator=(const TensorProto& from) {
2145	CopyFrom(from);
2146	return *this;
2147	}
2148	inline TensorProto& operator=(TensorProto&& from) noexcept {
2149	if (this == &from) return *this;
2150	if (GetOwningArena() == from.GetOwningArena()
2151	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2152	&& GetOwningArena() != nullptr
2153	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2154	) {
2155	InternalSwap(other: &from);
2156	} else {
2157	CopyFrom(from);
2158	}
2159	return *this;
2160	}
2161
2162	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2163	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2164	}
2165	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2166	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2167	}
2168
2169	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2170	return GetDescriptor();
2171	}
2172	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2173	return default_instance().GetMetadata().descriptor;
2174	}
2175	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2176	return default_instance().GetMetadata().reflection;
2177	}
2178	static const TensorProto& default_instance() {
2179	return *internal_default_instance();
2180	}
2181	static inline const TensorProto* internal_default_instance() {
2182	return reinterpret_cast<const TensorProto*>(
2183	&_TensorProto_default_instance_);
2184	}
2185	static constexpr int kIndexInFileMessages =
2186	7;
2187
2188	friend void swap(TensorProto& a, TensorProto& b) {
2189	a.Swap(other: &b);
2190	}
2191	inline void Swap(TensorProto* other) {
2192	if (other == this) return;
2193	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2194	if (GetOwningArena() != nullptr &&
2195	GetOwningArena() == other->GetOwningArena()) {
2196	#else // PROTOBUF_FORCE_COPY_IN_SWAP
2197	if (GetOwningArena() == other->GetOwningArena()) {
2198	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2199	InternalSwap(other);
2200	} else {
2201	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
2202	}
2203	}
2204	void UnsafeArenaSwap(TensorProto* other) {
2205	if (other == this) return;
2206	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2207	InternalSwap(other);
2208	}
2209
2210	// implements Message ----------------------------------------------
2211
2212	TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2213	return CreateMaybeMessage<TensorProto>(arena);
2214	}
2215	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2216	void CopyFrom(const TensorProto& from);
2217	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2218	void MergeFrom(const TensorProto& from);
2219	private:
2220	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
2221	public:
2222	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2223	bool IsInitialized() const final;
2224
2225	size_t ByteSizeLong() const final;
2226	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2227	uint8_t* _InternalSerialize(
2228	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2229	int GetCachedSize() const final { return _cached_size_.Get(); }
2230
2231	private:
2232	void SharedCtor();
2233	void SharedDtor();
2234	void SetCachedSize(int size) const final;
2235	void InternalSwap(TensorProto* other);
2236
2237	private:
2238	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2239	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2240	return "opencv_onnx.TensorProto";
2241	}
2242	protected:
2243	explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2244	bool is_message_owned = false);
2245	private:
2246	static void ArenaDtor(void* object);
2247	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2248	public:
2249
2250	static const ClassData _class_data_;
2251	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2252
2253	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2254
2255	// nested types ----------------------------------------------------
2256
2257	typedef TensorProto_Segment Segment;
2258
2259	typedef TensorProto_DataType DataType;
2260	static constexpr DataType UNDEFINED =
2261	TensorProto_DataType_UNDEFINED;
2262	static constexpr DataType FLOAT =
2263	TensorProto_DataType_FLOAT;
2264	static constexpr DataType UINT8 =
2265	TensorProto_DataType_UINT8;
2266	static constexpr DataType INT8 =
2267	TensorProto_DataType_INT8;
2268	static constexpr DataType UINT16 =
2269	TensorProto_DataType_UINT16;
2270	static constexpr DataType INT16 =
2271	TensorProto_DataType_INT16;
2272	static constexpr DataType INT32 =
2273	TensorProto_DataType_INT32;
2274	static constexpr DataType INT64 =
2275	TensorProto_DataType_INT64;
2276	static constexpr DataType STRING =
2277	TensorProto_DataType_STRING;
2278	static constexpr DataType BOOL =
2279	TensorProto_DataType_BOOL;
2280	static constexpr DataType FLOAT16 =
2281	TensorProto_DataType_FLOAT16;
2282	static constexpr DataType DOUBLE =
2283	TensorProto_DataType_DOUBLE;
2284	static constexpr DataType UINT32 =
2285	TensorProto_DataType_UINT32;
2286	static constexpr DataType UINT64 =
2287	TensorProto_DataType_UINT64;
2288	static constexpr DataType COMPLEX64 =
2289	TensorProto_DataType_COMPLEX64;
2290	static constexpr DataType COMPLEX128 =
2291	TensorProto_DataType_COMPLEX128;
2292	static inline bool DataType_IsValid(int value) {
2293	return TensorProto_DataType_IsValid(value);
2294	}
2295	static constexpr DataType DataType_MIN =
2296	TensorProto_DataType_DataType_MIN;
2297	static constexpr DataType DataType_MAX =
2298	TensorProto_DataType_DataType_MAX;
2299	static constexpr int DataType_ARRAYSIZE =
2300	TensorProto_DataType_DataType_ARRAYSIZE;
2301	static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
2302	DataType_descriptor() {
2303	return TensorProto_DataType_descriptor();
2304	}
2305	template<typename T>
2306	static inline const std::string& DataType_Name(T enum_t_value) {
2307	static_assert(::std::is_same<T, DataType>::value ||
2308	::std::is_integral<T>::value,
2309	"Incorrect type passed to function DataType_Name.");
2310	return TensorProto_DataType_Name(enum_t_value);
2311	}
2312	static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2313	DataType* value) {
2314	return TensorProto_DataType_Parse(name, value);
2315	}
2316
2317	// accessors -------------------------------------------------------
2318
2319	enum : int {
2320	kDimsFieldNumber = 1,
2321	kFloatDataFieldNumber = 4,
2322	kInt32DataFieldNumber = 5,
2323	kStringDataFieldNumber = 6,
2324	kInt64DataFieldNumber = 7,
2325	kDoubleDataFieldNumber = 10,
2326	kUint64DataFieldNumber = 11,
2327	kNameFieldNumber = 8,
2328	kRawDataFieldNumber = 9,
2329	kDocStringFieldNumber = 12,
2330	kSegmentFieldNumber = 3,
2331	kDataTypeFieldNumber = 2,
2332	};
2333	// repeated int64 dims = 1;
2334	int dims_size() const;
2335	private:
2336	int _internal_dims_size() const;
2337	public:
2338	void clear_dims();
2339	private:
2340	int64_t _internal_dims(int index) const;
2341	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
2342	_internal_dims() const;
2343	void _internal_add_dims(int64_t value);
2344	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
2345	_internal_mutable_dims();
2346	public:
2347	int64_t dims(int index) const;
2348	void set_dims(int index, int64_t value);
2349	void add_dims(int64_t value);
2350	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
2351	dims() const;
2352	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
2353	mutable_dims();
2354
2355	// repeated float float_data = 4 [packed = true];
2356	int float_data_size() const;
2357	private:
2358	int _internal_float_data_size() const;
2359	public:
2360	void clear_float_data();
2361	private:
2362	float _internal_float_data(int index) const;
2363	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
2364	_internal_float_data() const;
2365	void _internal_add_float_data(float value);
2366	::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
2367	_internal_mutable_float_data();
2368	public:
2369	float float_data(int index) const;
2370	void set_float_data(int index, float value);
2371	void add_float_data(float value);
2372	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
2373	float_data() const;
2374	::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
2375	mutable_float_data();
2376
2377	// repeated int32 int32_data = 5 [packed = true];
2378	int int32_data_size() const;
2379	private:
2380	int _internal_int32_data_size() const;
2381	public:
2382	void clear_int32_data();
2383	private:
2384	int32_t _internal_int32_data(int index) const;
2385	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
2386	_internal_int32_data() const;
2387	void _internal_add_int32_data(int32_t value);
2388	::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
2389	_internal_mutable_int32_data();
2390	public:
2391	int32_t int32_data(int index) const;
2392	void set_int32_data(int index, int32_t value);
2393	void add_int32_data(int32_t value);
2394	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
2395	int32_data() const;
2396	::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
2397	mutable_int32_data();
2398
2399	// repeated bytes string_data = 6;
2400	int string_data_size() const;
2401	private:
2402	int _internal_string_data_size() const;
2403	public:
2404	void clear_string_data();
2405	const std::string& string_data(int index) const;
2406	std::string* mutable_string_data(int index);
2407	void set_string_data(int index, const std::string& value);
2408	void set_string_data(int index, std::string&& value);
2409	void set_string_data(int index, const char* value);
2410	void set_string_data(int index, const void* value, size_t size);
2411	std::string* add_string_data();
2412	void add_string_data(const std::string& value);
2413	void add_string_data(std::string&& value);
2414	void add_string_data(const char* value);
2415	void add_string_data(const void* value, size_t size);
2416	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
2417	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
2418	private:
2419	const std::string& _internal_string_data(int index) const;
2420	std::string* _internal_add_string_data();
2421	public:
2422
2423	// repeated int64 int64_data = 7 [packed = true];
2424	int int64_data_size() const;
2425	private:
2426	int _internal_int64_data_size() const;
2427	public:
2428	void clear_int64_data();
2429	private:
2430	int64_t _internal_int64_data(int index) const;
2431	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
2432	_internal_int64_data() const;
2433	void _internal_add_int64_data(int64_t value);
2434	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
2435	_internal_mutable_int64_data();
2436	public:
2437	int64_t int64_data(int index) const;
2438	void set_int64_data(int index, int64_t value);
2439	void add_int64_data(int64_t value);
2440	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
2441	int64_data() const;
2442	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
2443	mutable_int64_data();
2444
2445	// repeated double double_data = 10 [packed = true];
2446	int double_data_size() const;
2447	private:
2448	int _internal_double_data_size() const;
2449	public:
2450	void clear_double_data();
2451	private:
2452	double _internal_double_data(int index) const;
2453	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
2454	_internal_double_data() const;
2455	void _internal_add_double_data(double value);
2456	::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
2457	_internal_mutable_double_data();
2458	public:
2459	double double_data(int index) const;
2460	void set_double_data(int index, double value);
2461	void add_double_data(double value);
2462	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
2463	double_data() const;
2464	::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
2465	mutable_double_data();
2466
2467	// repeated uint64 uint64_data = 11 [packed = true];
2468	int uint64_data_size() const;
2469	private:
2470	int _internal_uint64_data_size() const;
2471	public:
2472	void clear_uint64_data();
2473	private:
2474	uint64_t _internal_uint64_data(int index) const;
2475	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
2476	_internal_uint64_data() const;
2477	void _internal_add_uint64_data(uint64_t value);
2478	::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
2479	_internal_mutable_uint64_data();
2480	public:
2481	uint64_t uint64_data(int index) const;
2482	void set_uint64_data(int index, uint64_t value);
2483	void add_uint64_data(uint64_t value);
2484	const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
2485	uint64_data() const;
2486	::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
2487	mutable_uint64_data();
2488
2489	// optional string name = 8;
2490	bool has_name() const;
2491	private:
2492	bool _internal_has_name() const;
2493	public:
2494	void clear_name();
2495	const std::string& name() const;
2496	template <typename ArgT0 = const std::string&, typename... ArgT>
2497	void set_name(ArgT0&& arg0, ArgT... args);
2498	std::string* mutable_name();
2499	PROTOBUF_NODISCARD std::string* release_name();
2500	void set_allocated_name(std::string* name);
2501	private:
2502	const std::string& _internal_name() const;
2503	inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
2504	std::string* _internal_mutable_name();
2505	public:
2506
2507	// optional bytes raw_data = 9;
2508	bool has_raw_data() const;
2509	private:
2510	bool _internal_has_raw_data() const;
2511	public:
2512	void clear_raw_data();
2513	const std::string& raw_data() const;
2514	template <typename ArgT0 = const std::string&, typename... ArgT>
2515	void set_raw_data(ArgT0&& arg0, ArgT... args);
2516	std::string* mutable_raw_data();
2517	PROTOBUF_NODISCARD std::string* release_raw_data();
2518	void set_allocated_raw_data(std::string* raw_data);
2519	private:
2520	const std::string& _internal_raw_data() const;
2521	inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
2522	std::string* _internal_mutable_raw_data();
2523	public:
2524
2525	// optional string doc_string = 12;
2526	bool has_doc_string() const;
2527	private:
2528	bool _internal_has_doc_string() const;
2529	public:
2530	void clear_doc_string();
2531	const std::string& doc_string() const;
2532	template <typename ArgT0 = const std::string&, typename... ArgT>
2533	void set_doc_string(ArgT0&& arg0, ArgT... args);
2534	std::string* mutable_doc_string();
2535	PROTOBUF_NODISCARD std::string* release_doc_string();
2536	void set_allocated_doc_string(std::string* doc_string);
2537	private:
2538	const std::string& _internal_doc_string() const;
2539	inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(const std::string& value);
2540	std::string* _internal_mutable_doc_string();
2541	public:
2542
2543	// optional .opencv_onnx.TensorProto.Segment segment = 3;
2544	bool has_segment() const;
2545	private:
2546	bool _internal_has_segment() const;
2547	public:
2548	void clear_segment();
2549	const ::opencv_onnx::TensorProto_Segment& segment() const;
2550	PROTOBUF_NODISCARD ::opencv_onnx::TensorProto_Segment* release_segment();
2551	::opencv_onnx::TensorProto_Segment* mutable_segment();
2552	void set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment);
2553	private:
2554	const ::opencv_onnx::TensorProto_Segment& _internal_segment() const;
2555	::opencv_onnx::TensorProto_Segment* _internal_mutable_segment();
2556	public:
2557	void unsafe_arena_set_allocated_segment(
2558	::opencv_onnx::TensorProto_Segment* segment);
2559	::opencv_onnx::TensorProto_Segment* unsafe_arena_release_segment();
2560
2561	// optional .opencv_onnx.TensorProto.DataType data_type = 2;
2562	bool has_data_type() const;
2563	private:
2564	bool _internal_has_data_type() const;
2565	public:
2566	void clear_data_type();
2567	::opencv_onnx::TensorProto_DataType data_type() const;
2568	void set_data_type(::opencv_onnx::TensorProto_DataType value);
2569	private:
2570	::opencv_onnx::TensorProto_DataType _internal_data_type() const;
2571	void _internal_set_data_type(::opencv_onnx::TensorProto_DataType value);
2572	public:
2573
2574	// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto)
2575	private:
2576	class _Internal;
2577
2578	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2579	typedef void InternalArenaConstructable_;
2580	typedef void DestructorSkippable_;
2581	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2582	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2583	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dims_;
2584	::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
2585	::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > int32_data_;
2586	mutable std::atomic<int> _int32_data_cached_byte_size_;
2587	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
2588	::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > int64_data_;
2589	mutable std::atomic<int> _int64_data_cached_byte_size_;
2590	::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
2591	::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > uint64_data_;
2592	mutable std::atomic<int> _uint64_data_cached_byte_size_;
2593	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2594	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
2595	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_;
2596	::opencv_onnx::TensorProto_Segment* segment_;
2597	int data_type_;
2598	friend struct ::TableStruct_opencv_2donnx_2eproto;
2599	};
2600	// -------------------------------------------------------------------
2601
2602	class TensorShapeProto_Dimension final :
2603	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto.Dimension) */ {
2604	public:
2605	inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {}
2606	~TensorShapeProto_Dimension() override;
2607	explicit constexpr TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2608
2609	TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
2610	TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
2611	: TensorShapeProto_Dimension() {
2612	*this = ::std::move(from);
2613	}
2614
2615	inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
2616	CopyFrom(from);
2617	return *this;
2618	}
2619	inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
2620	if (this == &from) return *this;
2621	if (GetOwningArena() == from.GetOwningArena()
2622	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2623	&& GetOwningArena() != nullptr
2624	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2625	) {
2626	InternalSwap(other: &from);
2627	} else {
2628	CopyFrom(from);
2629	}
2630	return *this;
2631	}
2632
2633	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2634	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2635	}
2636	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2637	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2638	}
2639
2640	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2641	return GetDescriptor();
2642	}
2643	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2644	return default_instance().GetMetadata().descriptor;
2645	}
2646	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2647	return default_instance().GetMetadata().reflection;
2648	}
2649	static const TensorShapeProto_Dimension& default_instance() {
2650	return *internal_default_instance();
2651	}
2652	enum ValueCase {
2653	kDimValue = 1,
2654	kDimParam = 2,
2655	VALUE_NOT_SET = 0,
2656	};
2657
2658	static inline const TensorShapeProto_Dimension* internal_default_instance() {
2659	return reinterpret_cast<const TensorShapeProto_Dimension*>(
2660	&_TensorShapeProto_Dimension_default_instance_);
2661	}
2662	static constexpr int kIndexInFileMessages =
2663	8;
2664
2665	friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
2666	a.Swap(other: &b);
2667	}
2668	inline void Swap(TensorShapeProto_Dimension* other) {
2669	if (other == this) return;
2670	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2671	if (GetOwningArena() != nullptr &&
2672	GetOwningArena() == other->GetOwningArena()) {
2673	#else // PROTOBUF_FORCE_COPY_IN_SWAP
2674	if (GetOwningArena() == other->GetOwningArena()) {
2675	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2676	InternalSwap(other);
2677	} else {
2678	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
2679	}
2680	}
2681	void UnsafeArenaSwap(TensorShapeProto_Dimension* other) {
2682	if (other == this) return;
2683	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2684	InternalSwap(other);
2685	}
2686
2687	// implements Message ----------------------------------------------
2688
2689	TensorShapeProto_Dimension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2690	return CreateMaybeMessage<TensorShapeProto_Dimension>(arena);
2691	}
2692	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2693	void CopyFrom(const TensorShapeProto_Dimension& from);
2694	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2695	void MergeFrom(const TensorShapeProto_Dimension& from);
2696	private:
2697	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
2698	public:
2699	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2700	bool IsInitialized() const final;
2701
2702	size_t ByteSizeLong() const final;
2703	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2704	uint8_t* _InternalSerialize(
2705	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2706	int GetCachedSize() const final { return _cached_size_.Get(); }
2707
2708	private:
2709	void SharedCtor();
2710	void SharedDtor();
2711	void SetCachedSize(int size) const final;
2712	void InternalSwap(TensorShapeProto_Dimension* other);
2713
2714	private:
2715	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2716	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2717	return "opencv_onnx.TensorShapeProto.Dimension";
2718	}
2719	protected:
2720	explicit TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2721	bool is_message_owned = false);
2722	private:
2723	static void ArenaDtor(void* object);
2724	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2725	public:
2726
2727	static const ClassData _class_data_;
2728	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2729
2730	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2731
2732	// nested types ----------------------------------------------------
2733
2734	// accessors -------------------------------------------------------
2735
2736	enum : int {
2737	kDenotationFieldNumber = 3,
2738	kDimValueFieldNumber = 1,
2739	kDimParamFieldNumber = 2,
2740	};
2741	// optional string denotation = 3;
2742	bool has_denotation() const;
2743	private:
2744	bool _internal_has_denotation() const;
2745	public:
2746	void clear_denotation();
2747	const std::string& denotation() const;
2748	template <typename ArgT0 = const std::string&, typename... ArgT>
2749	void set_denotation(ArgT0&& arg0, ArgT... args);
2750	std::string* mutable_denotation();
2751	PROTOBUF_NODISCARD std::string* release_denotation();
2752	void set_allocated_denotation(std::string* denotation);
2753	private:
2754	const std::string& _internal_denotation() const;
2755	inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const std::string& value);
2756	std::string* _internal_mutable_denotation();
2757	public:
2758
2759	// int64 dim_value = 1;
2760	bool has_dim_value() const;
2761	private:
2762	bool _internal_has_dim_value() const;
2763	public:
2764	void clear_dim_value();
2765	int64_t dim_value() const;
2766	void set_dim_value(int64_t value);
2767	private:
2768	int64_t _internal_dim_value() const;
2769	void _internal_set_dim_value(int64_t value);
2770	public:
2771
2772	// string dim_param = 2;
2773	bool has_dim_param() const;
2774	private:
2775	bool _internal_has_dim_param() const;
2776	public:
2777	void clear_dim_param();
2778	const std::string& dim_param() const;
2779	template <typename ArgT0 = const std::string&, typename... ArgT>
2780	void set_dim_param(ArgT0&& arg0, ArgT... args);
2781	std::string* mutable_dim_param();
2782	PROTOBUF_NODISCARD std::string* release_dim_param();
2783	void set_allocated_dim_param(std::string* dim_param);
2784	private:
2785	const std::string& _internal_dim_param() const;
2786	inline PROTOBUF_ALWAYS_INLINE void _internal_set_dim_param(const std::string& value);
2787	std::string* _internal_mutable_dim_param();
2788	public:
2789
2790	void clear_value();
2791	ValueCase value_case() const;
2792	// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto.Dimension)
2793	private:
2794	class _Internal;
2795	void set_has_dim_value();
2796	void set_has_dim_param();
2797
2798	inline bool has_value() const;
2799	inline void clear_has_value();
2800
2801	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2802	typedef void InternalArenaConstructable_;
2803	typedef void DestructorSkippable_;
2804	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2805	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2806	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
2807	union ValueUnion {
2808	constexpr ValueUnion() : _constinit_{} {}
2809	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2810	int64_t dim_value_;
2811	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_;
2812	} value_;
2813	uint32_t _oneof_case_[1];
2814
2815	friend struct ::TableStruct_opencv_2donnx_2eproto;
2816	};
2817	// -------------------------------------------------------------------
2818
2819	class TensorShapeProto final :
2820	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto) */ {
2821	public:
2822	inline TensorShapeProto() : TensorShapeProto(nullptr) {}
2823	~TensorShapeProto() override;
2824	explicit constexpr TensorShapeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2825
2826	TensorShapeProto(const TensorShapeProto& from);
2827	TensorShapeProto(TensorShapeProto&& from) noexcept
2828	: TensorShapeProto() {
2829	*this = ::std::move(from);
2830	}
2831
2832	inline TensorShapeProto& operator=(const TensorShapeProto& from) {
2833	CopyFrom(from);
2834	return *this;
2835	}
2836	inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
2837	if (this == &from) return *this;
2838	if (GetOwningArena() == from.GetOwningArena()
2839	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2840	&& GetOwningArena() != nullptr
2841	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2842	) {
2843	InternalSwap(other: &from);
2844	} else {
2845	CopyFrom(from);
2846	}
2847	return *this;
2848	}
2849
2850	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2851	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2852	}
2853	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2854	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2855	}
2856
2857	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2858	return GetDescriptor();
2859	}
2860	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2861	return default_instance().GetMetadata().descriptor;
2862	}
2863	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2864	return default_instance().GetMetadata().reflection;
2865	}
2866	static const TensorShapeProto& default_instance() {
2867	return *internal_default_instance();
2868	}
2869	static inline const TensorShapeProto* internal_default_instance() {
2870	return reinterpret_cast<const TensorShapeProto*>(
2871	&_TensorShapeProto_default_instance_);
2872	}
2873	static constexpr int kIndexInFileMessages =
2874	9;
2875
2876	friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
2877	a.Swap(other: &b);
2878	}
2879	inline void Swap(TensorShapeProto* other) {
2880	if (other == this) return;
2881	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2882	if (GetOwningArena() != nullptr &&
2883	GetOwningArena() == other->GetOwningArena()) {
2884	#else // PROTOBUF_FORCE_COPY_IN_SWAP
2885	if (GetOwningArena() == other->GetOwningArena()) {
2886	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2887	InternalSwap(other);
2888	} else {
2889	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
2890	}
2891	}
2892	void UnsafeArenaSwap(TensorShapeProto* other) {
2893	if (other == this) return;
2894	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2895	InternalSwap(other);
2896	}
2897
2898	// implements Message ----------------------------------------------
2899
2900	TensorShapeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2901	return CreateMaybeMessage<TensorShapeProto>(arena);
2902	}
2903	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2904	void CopyFrom(const TensorShapeProto& from);
2905	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2906	void MergeFrom(const TensorShapeProto& from);
2907	private:
2908	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
2909	public:
2910	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2911	bool IsInitialized() const final;
2912
2913	size_t ByteSizeLong() const final;
2914	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2915	uint8_t* _InternalSerialize(
2916	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2917	int GetCachedSize() const final { return _cached_size_.Get(); }
2918
2919	private:
2920	void SharedCtor();
2921	void SharedDtor();
2922	void SetCachedSize(int size) const final;
2923	void InternalSwap(TensorShapeProto* other);
2924
2925	private:
2926	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2927	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2928	return "opencv_onnx.TensorShapeProto";
2929	}
2930	protected:
2931	explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2932	bool is_message_owned = false);
2933	private:
2934	static void ArenaDtor(void* object);
2935	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2936	public:
2937
2938	static const ClassData _class_data_;
2939	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2940
2941	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2942
2943	// nested types ----------------------------------------------------
2944
2945	typedef TensorShapeProto_Dimension Dimension;
2946
2947	// accessors -------------------------------------------------------
2948
2949	enum : int {
2950	kDimFieldNumber = 1,
2951	};
2952	// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
2953	int dim_size() const;
2954	private:
2955	int _internal_dim_size() const;
2956	public:
2957	void clear_dim();
2958	::opencv_onnx::TensorShapeProto_Dimension* mutable_dim(int index);
2959	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
2960	mutable_dim();
2961	private:
2962	const ::opencv_onnx::TensorShapeProto_Dimension& _internal_dim(int index) const;
2963	::opencv_onnx::TensorShapeProto_Dimension* _internal_add_dim();
2964	public:
2965	const ::opencv_onnx::TensorShapeProto_Dimension& dim(int index) const;
2966	::opencv_onnx::TensorShapeProto_Dimension* add_dim();
2967	const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
2968	dim() const;
2969
2970	// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto)
2971	private:
2972	class _Internal;
2973
2974	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2975	typedef void InternalArenaConstructable_;
2976	typedef void DestructorSkippable_;
2977	::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension > dim_;
2978	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2979	friend struct ::TableStruct_opencv_2donnx_2eproto;
2980	};
2981	// -------------------------------------------------------------------
2982
2983	class TypeProto_Tensor final :
2984	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Tensor) */ {
2985	public:
2986	inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {}
2987	~TypeProto_Tensor() override;
2988	explicit constexpr TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2989
2990	TypeProto_Tensor(const TypeProto_Tensor& from);
2991	TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
2992	: TypeProto_Tensor() {
2993	*this = ::std::move(from);
2994	}
2995
2996	inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
2997	CopyFrom(from);
2998	return *this;
2999	}
3000	inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
3001	if (this == &from) return *this;
3002	if (GetOwningArena() == from.GetOwningArena()
3003	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3004	&& GetOwningArena() != nullptr
3005	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3006	) {
3007	InternalSwap(other: &from);
3008	} else {
3009	CopyFrom(from);
3010	}
3011	return *this;
3012	}
3013
3014	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3015	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3016	}
3017	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3018	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3019	}
3020
3021	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3022	return GetDescriptor();
3023	}
3024	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3025	return default_instance().GetMetadata().descriptor;
3026	}
3027	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3028	return default_instance().GetMetadata().reflection;
3029	}
3030	static const TypeProto_Tensor& default_instance() {
3031	return *internal_default_instance();
3032	}
3033	static inline const TypeProto_Tensor* internal_default_instance() {
3034	return reinterpret_cast<const TypeProto_Tensor*>(
3035	&_TypeProto_Tensor_default_instance_);
3036	}
3037	static constexpr int kIndexInFileMessages =
3038	10;
3039
3040	friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
3041	a.Swap(other: &b);
3042	}
3043	inline void Swap(TypeProto_Tensor* other) {
3044	if (other == this) return;
3045	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3046	if (GetOwningArena() != nullptr &&
3047	GetOwningArena() == other->GetOwningArena()) {
3048	#else // PROTOBUF_FORCE_COPY_IN_SWAP
3049	if (GetOwningArena() == other->GetOwningArena()) {
3050	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3051	InternalSwap(other);
3052	} else {
3053	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
3054	}
3055	}
3056	void UnsafeArenaSwap(TypeProto_Tensor* other) {
3057	if (other == this) return;
3058	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3059	InternalSwap(other);
3060	}
3061
3062	// implements Message ----------------------------------------------
3063
3064	TypeProto_Tensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3065	return CreateMaybeMessage<TypeProto_Tensor>(arena);
3066	}
3067	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3068	void CopyFrom(const TypeProto_Tensor& from);
3069	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3070	void MergeFrom(const TypeProto_Tensor& from);
3071	private:
3072	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
3073	public:
3074	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3075	bool IsInitialized() const final;
3076
3077	size_t ByteSizeLong() const final;
3078	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3079	uint8_t* _InternalSerialize(
3080	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3081	int GetCachedSize() const final { return _cached_size_.Get(); }
3082
3083	private:
3084	void SharedCtor();
3085	void SharedDtor();
3086	void SetCachedSize(int size) const final;
3087	void InternalSwap(TypeProto_Tensor* other);
3088
3089	private:
3090	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3091	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3092	return "opencv_onnx.TypeProto.Tensor";
3093	}
3094	protected:
3095	explicit TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3096	bool is_message_owned = false);
3097	private:
3098	static void ArenaDtor(void* object);
3099	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3100	public:
3101
3102	static const ClassData _class_data_;
3103	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3104
3105	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3106
3107	// nested types ----------------------------------------------------
3108
3109	// accessors -------------------------------------------------------
3110
3111	enum : int {
3112	kShapeFieldNumber = 2,
3113	kElemTypeFieldNumber = 1,
3114	};
3115	// optional .opencv_onnx.TensorShapeProto shape = 2;
3116	bool has_shape() const;
3117	private:
3118	bool _internal_has_shape() const;
3119	public:
3120	void clear_shape();
3121	const ::opencv_onnx::TensorShapeProto& shape() const;
3122	PROTOBUF_NODISCARD ::opencv_onnx::TensorShapeProto* release_shape();
3123	::opencv_onnx::TensorShapeProto* mutable_shape();
3124	void set_allocated_shape(::opencv_onnx::TensorShapeProto* shape);
3125	private:
3126	const ::opencv_onnx::TensorShapeProto& _internal_shape() const;
3127	::opencv_onnx::TensorShapeProto* _internal_mutable_shape();
3128	public:
3129	void unsafe_arena_set_allocated_shape(
3130	::opencv_onnx::TensorShapeProto* shape);
3131	::opencv_onnx::TensorShapeProto* unsafe_arena_release_shape();
3132
3133	// optional .opencv_onnx.TensorProto.DataType elem_type = 1;
3134	bool has_elem_type() const;
3135	private:
3136	bool _internal_has_elem_type() const;
3137	public:
3138	void clear_elem_type();
3139	::opencv_onnx::TensorProto_DataType elem_type() const;
3140	void set_elem_type(::opencv_onnx::TensorProto_DataType value);
3141	private:
3142	::opencv_onnx::TensorProto_DataType _internal_elem_type() const;
3143	void _internal_set_elem_type(::opencv_onnx::TensorProto_DataType value);
3144	public:
3145
3146	// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Tensor)
3147	private:
3148	class _Internal;
3149
3150	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3151	typedef void InternalArenaConstructable_;
3152	typedef void DestructorSkippable_;
3153	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3154	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3155	::opencv_onnx::TensorShapeProto* shape_;
3156	int elem_type_;
3157	friend struct ::TableStruct_opencv_2donnx_2eproto;
3158	};
3159	// -------------------------------------------------------------------
3160
3161	class TypeProto final :
3162	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto) */ {
3163	public:
3164	inline TypeProto() : TypeProto(nullptr) {}
3165	~TypeProto() override;
3166	explicit constexpr TypeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3167
3168	TypeProto(const TypeProto& from);
3169	TypeProto(TypeProto&& from) noexcept
3170	: TypeProto() {
3171	*this = ::std::move(from);
3172	}
3173
3174	inline TypeProto& operator=(const TypeProto& from) {
3175	CopyFrom(from);
3176	return *this;
3177	}
3178	inline TypeProto& operator=(TypeProto&& from) noexcept {
3179	if (this == &from) return *this;
3180	if (GetOwningArena() == from.GetOwningArena()
3181	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3182	&& GetOwningArena() != nullptr
3183	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3184	) {
3185	InternalSwap(other: &from);
3186	} else {
3187	CopyFrom(from);
3188	}
3189	return *this;
3190	}
3191
3192	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3193	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3194	}
3195	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3196	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3197	}
3198
3199	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3200	return GetDescriptor();
3201	}
3202	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3203	return default_instance().GetMetadata().descriptor;
3204	}
3205	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3206	return default_instance().GetMetadata().reflection;
3207	}
3208	static const TypeProto& default_instance() {
3209	return *internal_default_instance();
3210	}
3211	enum ValueCase {
3212	kTensorType = 1,
3213	VALUE_NOT_SET = 0,
3214	};
3215
3216	static inline const TypeProto* internal_default_instance() {
3217	return reinterpret_cast<const TypeProto*>(
3218	&_TypeProto_default_instance_);
3219	}
3220	static constexpr int kIndexInFileMessages =
3221	11;
3222
3223	friend void swap(TypeProto& a, TypeProto& b) {
3224	a.Swap(other: &b);
3225	}
3226	inline void Swap(TypeProto* other) {
3227	if (other == this) return;
3228	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3229	if (GetOwningArena() != nullptr &&
3230	GetOwningArena() == other->GetOwningArena()) {
3231	#else // PROTOBUF_FORCE_COPY_IN_SWAP
3232	if (GetOwningArena() == other->GetOwningArena()) {
3233	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3234	InternalSwap(other);
3235	} else {
3236	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
3237	}
3238	}
3239	void UnsafeArenaSwap(TypeProto* other) {
3240	if (other == this) return;
3241	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3242	InternalSwap(other);
3243	}
3244
3245	// implements Message ----------------------------------------------
3246
3247	TypeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3248	return CreateMaybeMessage<TypeProto>(arena);
3249	}
3250	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3251	void CopyFrom(const TypeProto& from);
3252	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3253	void MergeFrom(const TypeProto& from);
3254	private:
3255	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
3256	public:
3257	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3258	bool IsInitialized() const final;
3259
3260	size_t ByteSizeLong() const final;
3261	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3262	uint8_t* _InternalSerialize(
3263	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3264	int GetCachedSize() const final { return _cached_size_.Get(); }
3265
3266	private:
3267	void SharedCtor();
3268	void SharedDtor();
3269	void SetCachedSize(int size) const final;
3270	void InternalSwap(TypeProto* other);
3271
3272	private:
3273	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3274	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3275	return "opencv_onnx.TypeProto";
3276	}
3277	protected:
3278	explicit TypeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3279	bool is_message_owned = false);
3280	private:
3281	static void ArenaDtor(void* object);
3282	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3283	public:
3284
3285	static const ClassData _class_data_;
3286	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3287
3288	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3289
3290	// nested types ----------------------------------------------------
3291
3292	typedef TypeProto_Tensor Tensor;
3293
3294	// accessors -------------------------------------------------------
3295
3296	enum : int {
3297	kDenotationFieldNumber = 6,
3298	kTensorTypeFieldNumber = 1,
3299	};
3300	// optional string denotation = 6;
3301	bool has_denotation() const;
3302	private:
3303	bool _internal_has_denotation() const;
3304	public:
3305	void clear_denotation();
3306	const std::string& denotation() const;
3307	template <typename ArgT0 = const std::string&, typename... ArgT>
3308	void set_denotation(ArgT0&& arg0, ArgT... args);
3309	std::string* mutable_denotation();
3310	PROTOBUF_NODISCARD std::string* release_denotation();
3311	void set_allocated_denotation(std::string* denotation);
3312	private:
3313	const std::string& _internal_denotation() const;
3314	inline PROTOBUF_ALWAYS_INLINE void _internal_set_denotation(const std::string& value);
3315	std::string* _internal_mutable_denotation();
3316	public:
3317
3318	// .opencv_onnx.TypeProto.Tensor tensor_type = 1;
3319	bool has_tensor_type() const;
3320	private:
3321	bool _internal_has_tensor_type() const;
3322	public:
3323	void clear_tensor_type();
3324	const ::opencv_onnx::TypeProto_Tensor& tensor_type() const;
3325	PROTOBUF_NODISCARD ::opencv_onnx::TypeProto_Tensor* release_tensor_type();
3326	::opencv_onnx::TypeProto_Tensor* mutable_tensor_type();
3327	void set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type);
3328	private:
3329	const ::opencv_onnx::TypeProto_Tensor& _internal_tensor_type() const;
3330	::opencv_onnx::TypeProto_Tensor* _internal_mutable_tensor_type();
3331	public:
3332	void unsafe_arena_set_allocated_tensor_type(
3333	::opencv_onnx::TypeProto_Tensor* tensor_type);
3334	::opencv_onnx::TypeProto_Tensor* unsafe_arena_release_tensor_type();
3335
3336	void clear_value();
3337	ValueCase value_case() const;
3338	// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto)
3339	private:
3340	class _Internal;
3341	void set_has_tensor_type();
3342
3343	inline bool has_value() const;
3344	inline void clear_has_value();
3345
3346	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3347	typedef void InternalArenaConstructable_;
3348	typedef void DestructorSkippable_;
3349	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3350	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3351	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_;
3352	union ValueUnion {
3353	constexpr ValueUnion() : _constinit_{} {}
3354	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
3355	::opencv_onnx::TypeProto_Tensor* tensor_type_;
3356	} value_;
3357	uint32_t _oneof_case_[1];
3358
3359	friend struct ::TableStruct_opencv_2donnx_2eproto;
3360	};
3361	// -------------------------------------------------------------------
3362
3363	class OperatorSetIdProto final :
3364	public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.OperatorSetIdProto) */ {
3365	public:
3366	inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {}
3367	~OperatorSetIdProto() override;
3368	explicit constexpr OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3369
3370	OperatorSetIdProto(const OperatorSetIdProto& from);
3371	OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
3372	: OperatorSetIdProto() {
3373	*this = ::std::move(from);
3374	}
3375
3376	inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
3377	CopyFrom(from);
3378	return *this;
3379	}
3380	inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
3381	if (this == &from) return *this;
3382	if (GetOwningArena() == from.GetOwningArena()
3383	#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3384	&& GetOwningArena() != nullptr
3385	#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3386	) {
3387	InternalSwap(other: &from);
3388	} else {
3389	CopyFrom(from);
3390	}
3391	return *this;
3392	}
3393
3394	inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3395	return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(default_instance: ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3396	}
3397	inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3398	return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3399	}
3400
3401	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3402	return GetDescriptor();
3403	}
3404	static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3405	return default_instance().GetMetadata().descriptor;
3406	}
3407	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3408	return default_instance().GetMetadata().reflection;
3409	}
3410	static const OperatorSetIdProto& default_instance() {
3411	return *internal_default_instance();
3412	}
3413	static inline const OperatorSetIdProto* internal_default_instance() {
3414	return reinterpret_cast<const OperatorSetIdProto*>(
3415	&_OperatorSetIdProto_default_instance_);
3416	}
3417	static constexpr int kIndexInFileMessages =
3418	12;
3419
3420	friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
3421	a.Swap(other: &b);
3422	}
3423	inline void Swap(OperatorSetIdProto* other) {
3424	if (other == this) return;
3425	#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3426	if (GetOwningArena() != nullptr &&
3427	GetOwningArena() == other->GetOwningArena()) {
3428	#else // PROTOBUF_FORCE_COPY_IN_SWAP
3429	if (GetOwningArena() == other->GetOwningArena()) {
3430	#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3431	InternalSwap(other);
3432	} else {
3433	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(m1: this, m2: other);
3434	}
3435	}
3436	void UnsafeArenaSwap(OperatorSetIdProto* other) {
3437	if (other == this) return;
3438	GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3439	InternalSwap(other);
3440	}
3441
3442	// implements Message ----------------------------------------------
3443
3444	OperatorSetIdProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3445	return CreateMaybeMessage<OperatorSetIdProto>(arena);
3446	}
3447	using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3448	void CopyFrom(const OperatorSetIdProto& from);
3449	using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3450	void MergeFrom(const OperatorSetIdProto& from);
3451	private:
3452	static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
3453	public:
3454	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3455	bool IsInitialized() const final;
3456
3457	size_t ByteSizeLong() const final;
3458	const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3459	uint8_t* _InternalSerialize(
3460	uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3461	int GetCachedSize() const final { return _cached_size_.Get(); }
3462
3463	private:
3464	void SharedCtor();
3465	void SharedDtor();
3466	void SetCachedSize(int size) const final;
3467	void InternalSwap(OperatorSetIdProto* other);
3468
3469	private:
3470	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3471	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3472	return "opencv_onnx.OperatorSetIdProto";
3473	}
3474	protected:
3475	explicit OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3476	bool is_message_owned = false);
3477	private:
3478	static void ArenaDtor(void* object);
3479	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3480	public:
3481
3482	static const ClassData _class_data_;
3483	const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3484
3485	::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3486
3487	// nested types ----------------------------------------------------
3488
3489	// accessors -------------------------------------------------------
3490
3491	enum : int {
3492	kDomainFieldNumber = 1,
3493	kVersionFieldNumber = 2,
3494	};
3495	// optional string domain = 1;
3496	bool has_domain() const;
3497	private:
3498	bool _internal_has_domain() const;
3499	public:
3500	void clear_domain();
3501	const std::string& domain() const;
3502	template <typename ArgT0 = const std::string&, typename... ArgT>
3503	void set_domain(ArgT0&& arg0, ArgT... args);
3504	std::string* mutable_domain();
3505	PROTOBUF_NODISCARD std::string* release_domain();
3506	void set_allocated_domain(std::string* domain);
3507	private:
3508	const std::string& _internal_domain() const;
3509	inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
3510	std::string* _internal_mutable_domain();
3511	public:
3512
3513	// optional int64 version = 2;
3514	bool has_version() const;
3515	private:
3516	bool _internal_has_version() const;
3517	public:
3518	void clear_version();
3519	int64_t version() const;
3520	void set_version(int64_t value);
3521	private:
3522	int64_t _internal_version() const;
3523	void _internal_set_version(int64_t value);
3524	public:
3525
3526	// @@protoc_insertion_point(class_scope:opencv_onnx.OperatorSetIdProto)
3527	private:
3528	class _Internal;
3529
3530	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3531	typedef void InternalArenaConstructable_;
3532	typedef void DestructorSkippable_;
3533	::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3534	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3535	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
3536	int64_t version_;
3537	friend struct ::TableStruct_opencv_2donnx_2eproto;
3538	};
3539	// ===================================================================
3540
3541
3542	// ===================================================================
3543
3544	#ifdef __GNUC__
3545	#pragma GCC diagnostic push
3546	#pragma GCC diagnostic ignored "-Wstrict-aliasing"
3547	#endif // __GNUC__
3548	// AttributeProto
3549
3550	// optional string name = 1;
3551	inline bool AttributeProto::_internal_has_name() const {
3552	bool value = (_has_bits_[0] & 0x00000001u) != 0;
3553	return value;
3554	}
3555	inline bool AttributeProto::has_name() const {
3556	return _internal_has_name();
3557	}
3558	inline void AttributeProto::clear_name() {
3559	name_.ClearToEmpty();
3560	_has_bits_[0] &= ~0x00000001u;
3561	}
3562	inline const std::string& AttributeProto::name() const {
3563	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.name)
3564	return _internal_name();
3565	}
3566	template <typename ArgT0, typename... ArgT>
3567	inline PROTOBUF_ALWAYS_INLINE
3568	void AttributeProto::set_name(ArgT0&& arg0, ArgT... args) {
3569	_has_bits_[0] |= 0x00000001u;
3570	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3571	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.name)
3572	}
3573	inline std::string* AttributeProto::mutable_name() {
3574	std::string* _s = _internal_mutable_name();
3575	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.name)
3576	return _s;
3577	}
3578	inline const std::string& AttributeProto::_internal_name() const {
3579	return name_.Get();
3580	}
3581	inline void AttributeProto::_internal_set_name(const std::string& value) {
3582	_has_bits_[0] |= 0x00000001u;
3583	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
3584	}
3585	inline std::string* AttributeProto::_internal_mutable_name() {
3586	_has_bits_[0] |= 0x00000001u;
3587	return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
3588	}
3589	inline std::string* AttributeProto::release_name() {
3590	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.name)
3591	if (!_internal_has_name()) {
3592	return nullptr;
3593	}
3594	_has_bits_[0] &= ~0x00000001u;
3595	auto* p = name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
3596	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3597	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3598	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3599	}
3600	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3601	return p;
3602	}
3603	inline void AttributeProto::set_allocated_name(std::string* name) {
3604	if (name != nullptr) {
3605	_has_bits_[0] |= 0x00000001u;
3606	} else {
3607	_has_bits_[0] &= ~0x00000001u;
3608	}
3609	name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: name,
3610	arena: GetArenaForAllocation());
3611	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3612	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3613	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3614	}
3615	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3616	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.name)
3617	}
3618
3619	// optional string ref_attr_name = 21;
3620	inline bool AttributeProto::_internal_has_ref_attr_name() const {
3621	bool value = (_has_bits_[0] & 0x00000008u) != 0;
3622	return value;
3623	}
3624	inline bool AttributeProto::has_ref_attr_name() const {
3625	return _internal_has_ref_attr_name();
3626	}
3627	inline void AttributeProto::clear_ref_attr_name() {
3628	ref_attr_name_.ClearToEmpty();
3629	_has_bits_[0] &= ~0x00000008u;
3630	}
3631	inline const std::string& AttributeProto::ref_attr_name() const {
3632	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ref_attr_name)
3633	return _internal_ref_attr_name();
3634	}
3635	template <typename ArgT0, typename... ArgT>
3636	inline PROTOBUF_ALWAYS_INLINE
3637	void AttributeProto::set_ref_attr_name(ArgT0&& arg0, ArgT... args) {
3638	_has_bits_[0] |= 0x00000008u;
3639	ref_attr_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3640	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ref_attr_name)
3641	}
3642	inline std::string* AttributeProto::mutable_ref_attr_name() {
3643	std::string* _s = _internal_mutable_ref_attr_name();
3644	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.ref_attr_name)
3645	return _s;
3646	}
3647	inline const std::string& AttributeProto::_internal_ref_attr_name() const {
3648	return ref_attr_name_.Get();
3649	}
3650	inline void AttributeProto::_internal_set_ref_attr_name(const std::string& value) {
3651	_has_bits_[0] |= 0x00000008u;
3652	ref_attr_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
3653	}
3654	inline std::string* AttributeProto::_internal_mutable_ref_attr_name() {
3655	_has_bits_[0] |= 0x00000008u;
3656	return ref_attr_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
3657	}
3658	inline std::string* AttributeProto::release_ref_attr_name() {
3659	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.ref_attr_name)
3660	if (!_internal_has_ref_attr_name()) {
3661	return nullptr;
3662	}
3663	_has_bits_[0] &= ~0x00000008u;
3664	auto* p = ref_attr_name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
3665	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3666	if (ref_attr_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3667	ref_attr_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3668	}
3669	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3670	return p;
3671	}
3672	inline void AttributeProto::set_allocated_ref_attr_name(std::string* ref_attr_name) {
3673	if (ref_attr_name != nullptr) {
3674	_has_bits_[0] |= 0x00000008u;
3675	} else {
3676	_has_bits_[0] &= ~0x00000008u;
3677	}
3678	ref_attr_name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: ref_attr_name,
3679	arena: GetArenaForAllocation());
3680	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3681	if (ref_attr_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3682	ref_attr_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3683	}
3684	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3685	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.ref_attr_name)
3686	}
3687
3688	// optional string doc_string = 13;
3689	inline bool AttributeProto::_internal_has_doc_string() const {
3690	bool value = (_has_bits_[0] & 0x00000004u) != 0;
3691	return value;
3692	}
3693	inline bool AttributeProto::has_doc_string() const {
3694	return _internal_has_doc_string();
3695	}
3696	inline void AttributeProto::clear_doc_string() {
3697	doc_string_.ClearToEmpty();
3698	_has_bits_[0] &= ~0x00000004u;
3699	}
3700	inline const std::string& AttributeProto::doc_string() const {
3701	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.doc_string)
3702	return _internal_doc_string();
3703	}
3704	template <typename ArgT0, typename... ArgT>
3705	inline PROTOBUF_ALWAYS_INLINE
3706	void AttributeProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
3707	_has_bits_[0] |= 0x00000004u;
3708	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3709	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.doc_string)
3710	}
3711	inline std::string* AttributeProto::mutable_doc_string() {
3712	std::string* _s = _internal_mutable_doc_string();
3713	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.doc_string)
3714	return _s;
3715	}
3716	inline const std::string& AttributeProto::_internal_doc_string() const {
3717	return doc_string_.Get();
3718	}
3719	inline void AttributeProto::_internal_set_doc_string(const std::string& value) {
3720	_has_bits_[0] |= 0x00000004u;
3721	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
3722	}
3723	inline std::string* AttributeProto::_internal_mutable_doc_string() {
3724	_has_bits_[0] |= 0x00000004u;
3725	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
3726	}
3727	inline std::string* AttributeProto::release_doc_string() {
3728	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.doc_string)
3729	if (!_internal_has_doc_string()) {
3730	return nullptr;
3731	}
3732	_has_bits_[0] &= ~0x00000004u;
3733	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
3734	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3735	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3736	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3737	}
3738	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3739	return p;
3740	}
3741	inline void AttributeProto::set_allocated_doc_string(std::string* doc_string) {
3742	if (doc_string != nullptr) {
3743	_has_bits_[0] |= 0x00000004u;
3744	} else {
3745	_has_bits_[0] &= ~0x00000004u;
3746	}
3747	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
3748	arena: GetArenaForAllocation());
3749	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3750	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3751	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3752	}
3753	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3754	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.doc_string)
3755	}
3756
3757	// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
3758	inline bool AttributeProto::_internal_has_type() const {
3759	bool value = (_has_bits_[0] & 0x00000100u) != 0;
3760	return value;
3761	}
3762	inline bool AttributeProto::has_type() const {
3763	return _internal_has_type();
3764	}
3765	inline void AttributeProto::clear_type() {
3766	type_ = 0;
3767	_has_bits_[0] &= ~0x00000100u;
3768	}
3769	inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::_internal_type() const {
3770	return static_cast< ::opencv_onnx::AttributeProto_AttributeType >(type_);
3771	}
3772	inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::type() const {
3773	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.type)
3774	return _internal_type();
3775	}
3776	inline void AttributeProto::_internal_set_type(::opencv_onnx::AttributeProto_AttributeType value) {
3777	assert(::opencv_onnx::AttributeProto_AttributeType_IsValid(value));
3778	_has_bits_[0] |= 0x00000100u;
3779	type_ = value;
3780	}
3781	inline void AttributeProto::set_type(::opencv_onnx::AttributeProto_AttributeType value) {
3782	_internal_set_type(value);
3783	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.type)
3784	}
3785
3786	// optional float f = 2;
3787	inline bool AttributeProto::_internal_has_f() const {
3788	bool value = (_has_bits_[0] & 0x00000080u) != 0;
3789	return value;
3790	}
3791	inline bool AttributeProto::has_f() const {
3792	return _internal_has_f();
3793	}
3794	inline void AttributeProto::clear_f() {
3795	f_ = 0;
3796	_has_bits_[0] &= ~0x00000080u;
3797	}
3798	inline float AttributeProto::_internal_f() const {
3799	return f_;
3800	}
3801	inline float AttributeProto::f() const {
3802	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.f)
3803	return _internal_f();
3804	}
3805	inline void AttributeProto::_internal_set_f(float value) {
3806	_has_bits_[0] |= 0x00000080u;
3807	f_ = value;
3808	}
3809	inline void AttributeProto::set_f(float value) {
3810	_internal_set_f(value);
3811	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.f)
3812	}
3813
3814	// optional int64 i = 3;
3815	inline bool AttributeProto::_internal_has_i() const {
3816	bool value = (_has_bits_[0] & 0x00000040u) != 0;
3817	return value;
3818	}
3819	inline bool AttributeProto::has_i() const {
3820	return _internal_has_i();
3821	}
3822	inline void AttributeProto::clear_i() {
3823	i_ = int64_t{0};
3824	_has_bits_[0] &= ~0x00000040u;
3825	}
3826	inline int64_t AttributeProto::_internal_i() const {
3827	return i_;
3828	}
3829	inline int64_t AttributeProto::i() const {
3830	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.i)
3831	return _internal_i();
3832	}
3833	inline void AttributeProto::_internal_set_i(int64_t value) {
3834	_has_bits_[0] |= 0x00000040u;
3835	i_ = value;
3836	}
3837	inline void AttributeProto::set_i(int64_t value) {
3838	_internal_set_i(value);
3839	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.i)
3840	}
3841
3842	// optional bytes s = 4;
3843	inline bool AttributeProto::_internal_has_s() const {
3844	bool value = (_has_bits_[0] & 0x00000002u) != 0;
3845	return value;
3846	}
3847	inline bool AttributeProto::has_s() const {
3848	return _internal_has_s();
3849	}
3850	inline void AttributeProto::clear_s() {
3851	s_.ClearToEmpty();
3852	_has_bits_[0] &= ~0x00000002u;
3853	}
3854	inline const std::string& AttributeProto::s() const {
3855	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.s)
3856	return _internal_s();
3857	}
3858	template <typename ArgT0, typename... ArgT>
3859	inline PROTOBUF_ALWAYS_INLINE
3860	void AttributeProto::set_s(ArgT0&& arg0, ArgT... args) {
3861	_has_bits_[0] |= 0x00000002u;
3862	s_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3863	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.s)
3864	}
3865	inline std::string* AttributeProto::mutable_s() {
3866	std::string* _s = _internal_mutable_s();
3867	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.s)
3868	return _s;
3869	}
3870	inline const std::string& AttributeProto::_internal_s() const {
3871	return s_.Get();
3872	}
3873	inline void AttributeProto::_internal_set_s(const std::string& value) {
3874	_has_bits_[0] |= 0x00000002u;
3875	s_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
3876	}
3877	inline std::string* AttributeProto::_internal_mutable_s() {
3878	_has_bits_[0] |= 0x00000002u;
3879	return s_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
3880	}
3881	inline std::string* AttributeProto::release_s() {
3882	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.s)
3883	if (!_internal_has_s()) {
3884	return nullptr;
3885	}
3886	_has_bits_[0] &= ~0x00000002u;
3887	auto* p = s_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
3888	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3889	if (s_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3890	s_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3891	}
3892	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3893	return p;
3894	}
3895	inline void AttributeProto::set_allocated_s(std::string* s) {
3896	if (s != nullptr) {
3897	_has_bits_[0] |= 0x00000002u;
3898	} else {
3899	_has_bits_[0] &= ~0x00000002u;
3900	}
3901	s_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: s,
3902	arena: GetArenaForAllocation());
3903	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3904	if (s_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
3905	s_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
3906	}
3907	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3908	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.s)
3909	}
3910
3911	// optional .opencv_onnx.TensorProto t = 5;
3912	inline bool AttributeProto::_internal_has_t() const {
3913	bool value = (_has_bits_[0] & 0x00000010u) != 0;
3914	PROTOBUF_ASSUME(!value || t_ != nullptr);
3915	return value;
3916	}
3917	inline bool AttributeProto::has_t() const {
3918	return _internal_has_t();
3919	}
3920	inline void AttributeProto::clear_t() {
3921	if (t_ != nullptr) t_->Clear();
3922	_has_bits_[0] &= ~0x00000010u;
3923	}
3924	inline const ::opencv_onnx::TensorProto& AttributeProto::_internal_t() const {
3925	const ::opencv_onnx::TensorProto* p = t_;
3926	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto&>(
3927	::opencv_onnx::_TensorProto_default_instance_);
3928	}
3929	inline const ::opencv_onnx::TensorProto& AttributeProto::t() const {
3930	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.t)
3931	return _internal_t();
3932	}
3933	inline void AttributeProto::unsafe_arena_set_allocated_t(
3934	::opencv_onnx::TensorProto* t) {
3935	if (GetArenaForAllocation() == nullptr) {
3936	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
3937	}
3938	t_ = t;
3939	if (t) {
3940	_has_bits_[0] |= 0x00000010u;
3941	} else {
3942	_has_bits_[0] &= ~0x00000010u;
3943	}
3944	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.t)
3945	}
3946	inline ::opencv_onnx::TensorProto* AttributeProto::release_t() {
3947	_has_bits_[0] &= ~0x00000010u;
3948	::opencv_onnx::TensorProto* temp = t_;
3949	t_ = nullptr;
3950	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3951	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3952	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3953	if (GetArenaForAllocation() == nullptr) { delete old; }
3954	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
3955	if (GetArenaForAllocation() != nullptr) {
3956	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
3957	}
3958	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3959	return temp;
3960	}
3961	inline ::opencv_onnx::TensorProto* AttributeProto::unsafe_arena_release_t() {
3962	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.t)
3963	_has_bits_[0] &= ~0x00000010u;
3964	::opencv_onnx::TensorProto* temp = t_;
3965	t_ = nullptr;
3966	return temp;
3967	}
3968	inline ::opencv_onnx::TensorProto* AttributeProto::_internal_mutable_t() {
3969	_has_bits_[0] |= 0x00000010u;
3970	if (t_ == nullptr) {
3971	auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto>(arena: GetArenaForAllocation());
3972	t_ = p;
3973	}
3974	return t_;
3975	}
3976	inline ::opencv_onnx::TensorProto* AttributeProto::mutable_t() {
3977	::opencv_onnx::TensorProto* _msg = _internal_mutable_t();
3978	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.t)
3979	return _msg;
3980	}
3981	inline void AttributeProto::set_allocated_t(::opencv_onnx::TensorProto* t) {
3982	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3983	if (message_arena == nullptr) {
3984	delete t_;
3985	}
3986	if (t) {
3987	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3988	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto>::GetOwningArena(p: t);
3989	if (message_arena != submessage_arena) {
3990	t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3991	message_arena, submessage: t, submessage_arena);
3992	}
3993	_has_bits_[0] |= 0x00000010u;
3994	} else {
3995	_has_bits_[0] &= ~0x00000010u;
3996	}
3997	t_ = t;
3998	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.t)
3999	}
4000
4001	// optional .opencv_onnx.GraphProto g = 6;
4002	inline bool AttributeProto::_internal_has_g() const {
4003	bool value = (_has_bits_[0] & 0x00000020u) != 0;
4004	PROTOBUF_ASSUME(!value || g_ != nullptr);
4005	return value;
4006	}
4007	inline bool AttributeProto::has_g() const {
4008	return _internal_has_g();
4009	}
4010	inline void AttributeProto::clear_g() {
4011	if (g_ != nullptr) g_->Clear();
4012	_has_bits_[0] &= ~0x00000020u;
4013	}
4014	inline const ::opencv_onnx::GraphProto& AttributeProto::_internal_g() const {
4015	const ::opencv_onnx::GraphProto* p = g_;
4016	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
4017	::opencv_onnx::_GraphProto_default_instance_);
4018	}
4019	inline const ::opencv_onnx::GraphProto& AttributeProto::g() const {
4020	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.g)
4021	return _internal_g();
4022	}
4023	inline void AttributeProto::unsafe_arena_set_allocated_g(
4024	::opencv_onnx::GraphProto* g) {
4025	if (GetArenaForAllocation() == nullptr) {
4026	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(g_);
4027	}
4028	g_ = g;
4029	if (g) {
4030	_has_bits_[0] |= 0x00000020u;
4031	} else {
4032	_has_bits_[0] &= ~0x00000020u;
4033	}
4034	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.AttributeProto.g)
4035	}
4036	inline ::opencv_onnx::GraphProto* AttributeProto::release_g() {
4037	_has_bits_[0] &= ~0x00000020u;
4038	::opencv_onnx::GraphProto* temp = g_;
4039	g_ = nullptr;
4040	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4041	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4042	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4043	if (GetArenaForAllocation() == nullptr) { delete old; }
4044	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
4045	if (GetArenaForAllocation() != nullptr) {
4046	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
4047	}
4048	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4049	return temp;
4050	}
4051	inline ::opencv_onnx::GraphProto* AttributeProto::unsafe_arena_release_g() {
4052	// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.g)
4053	_has_bits_[0] &= ~0x00000020u;
4054	::opencv_onnx::GraphProto* temp = g_;
4055	g_ = nullptr;
4056	return temp;
4057	}
4058	inline ::opencv_onnx::GraphProto* AttributeProto::_internal_mutable_g() {
4059	_has_bits_[0] |= 0x00000020u;
4060	if (g_ == nullptr) {
4061	auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(arena: GetArenaForAllocation());
4062	g_ = p;
4063	}
4064	return g_;
4065	}
4066	inline ::opencv_onnx::GraphProto* AttributeProto::mutable_g() {
4067	::opencv_onnx::GraphProto* _msg = _internal_mutable_g();
4068	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.g)
4069	return _msg;
4070	}
4071	inline void AttributeProto::set_allocated_g(::opencv_onnx::GraphProto* g) {
4072	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4073	if (message_arena == nullptr) {
4074	delete g_;
4075	}
4076	if (g) {
4077	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4078	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(p: g);
4079	if (message_arena != submessage_arena) {
4080	g = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4081	message_arena, submessage: g, submessage_arena);
4082	}
4083	_has_bits_[0] |= 0x00000020u;
4084	} else {
4085	_has_bits_[0] &= ~0x00000020u;
4086	}
4087	g_ = g;
4088	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.g)
4089	}
4090
4091	// repeated float floats = 7;
4092	inline int AttributeProto::_internal_floats_size() const {
4093	return floats_.size();
4094	}
4095	inline int AttributeProto::floats_size() const {
4096	return _internal_floats_size();
4097	}
4098	inline void AttributeProto::clear_floats() {
4099	floats_.Clear();
4100	}
4101	inline float AttributeProto::_internal_floats(int index) const {
4102	return floats_.Get(index);
4103	}
4104	inline float AttributeProto::floats(int index) const {
4105	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.floats)
4106	return _internal_floats(index);
4107	}
4108	inline void AttributeProto::set_floats(int index, float value) {
4109	floats_.Set(index, value);
4110	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.floats)
4111	}
4112	inline void AttributeProto::_internal_add_floats(float value) {
4113	floats_.Add(value);
4114	}
4115	inline void AttributeProto::add_floats(float value) {
4116	_internal_add_floats(value);
4117	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.floats)
4118	}
4119	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
4120	AttributeProto::_internal_floats() const {
4121	return floats_;
4122	}
4123	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
4124	AttributeProto::floats() const {
4125	// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.floats)
4126	return _internal_floats();
4127	}
4128	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
4129	AttributeProto::_internal_mutable_floats() {
4130	return &floats_;
4131	}
4132	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
4133	AttributeProto::mutable_floats() {
4134	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.floats)
4135	return _internal_mutable_floats();
4136	}
4137
4138	// repeated int64 ints = 8;
4139	inline int AttributeProto::_internal_ints_size() const {
4140	return ints_.size();
4141	}
4142	inline int AttributeProto::ints_size() const {
4143	return _internal_ints_size();
4144	}
4145	inline void AttributeProto::clear_ints() {
4146	ints_.Clear();
4147	}
4148	inline int64_t AttributeProto::_internal_ints(int index) const {
4149	return ints_.Get(index);
4150	}
4151	inline int64_t AttributeProto::ints(int index) const {
4152	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ints)
4153	return _internal_ints(index);
4154	}
4155	inline void AttributeProto::set_ints(int index, int64_t value) {
4156	ints_.Set(index, value);
4157	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ints)
4158	}
4159	inline void AttributeProto::_internal_add_ints(int64_t value) {
4160	ints_.Add(value);
4161	}
4162	inline void AttributeProto::add_ints(int64_t value) {
4163	_internal_add_ints(value);
4164	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.ints)
4165	}
4166	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
4167	AttributeProto::_internal_ints() const {
4168	return ints_;
4169	}
4170	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
4171	AttributeProto::ints() const {
4172	// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.ints)
4173	return _internal_ints();
4174	}
4175	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
4176	AttributeProto::_internal_mutable_ints() {
4177	return &ints_;
4178	}
4179	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
4180	AttributeProto::mutable_ints() {
4181	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.ints)
4182	return _internal_mutable_ints();
4183	}
4184
4185	// repeated bytes strings = 9;
4186	inline int AttributeProto::_internal_strings_size() const {
4187	return strings_.size();
4188	}
4189	inline int AttributeProto::strings_size() const {
4190	return _internal_strings_size();
4191	}
4192	inline void AttributeProto::clear_strings() {
4193	strings_.Clear();
4194	}
4195	inline std::string* AttributeProto::add_strings() {
4196	std::string* _s = _internal_add_strings();
4197	// @@protoc_insertion_point(field_add_mutable:opencv_onnx.AttributeProto.strings)
4198	return _s;
4199	}
4200	inline const std::string& AttributeProto::_internal_strings(int index) const {
4201	return strings_.Get(index);
4202	}
4203	inline const std::string& AttributeProto::strings(int index) const {
4204	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.strings)
4205	return _internal_strings(index);
4206	}
4207	inline std::string* AttributeProto::mutable_strings(int index) {
4208	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.strings)
4209	return strings_.Mutable(index);
4210	}
4211	inline void AttributeProto::set_strings(int index, const std::string& value) {
4212	strings_.Mutable(index)->assign(str: value);
4213	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
4214	}
4215	inline void AttributeProto::set_strings(int index, std::string&& value) {
4216	strings_.Mutable(index)->assign(str: std::move(value));
4217	// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
4218	}
4219	inline void AttributeProto::set_strings(int index, const char* value) {
4220	GOOGLE_DCHECK(value != nullptr);
4221	strings_.Mutable(index)->assign(s: value);
4222	// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.strings)
4223	}
4224	inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
4225	strings_.Mutable(index)->assign(
4226	s: reinterpret_cast<const char*>(value), n: size);
4227	// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.strings)
4228	}
4229	inline std::string* AttributeProto::_internal_add_strings() {
4230	return strings_.Add();
4231	}
4232	inline void AttributeProto::add_strings(const std::string& value) {
4233	strings_.Add()->assign(str: value);
4234	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
4235	}
4236	inline void AttributeProto::add_strings(std::string&& value) {
4237	strings_.Add(value: std::move(value));
4238	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
4239	}
4240	inline void AttributeProto::add_strings(const char* value) {
4241	GOOGLE_DCHECK(value != nullptr);
4242	strings_.Add()->assign(s: value);
4243	// @@protoc_insertion_point(field_add_char:opencv_onnx.AttributeProto.strings)
4244	}
4245	inline void AttributeProto::add_strings(const void* value, size_t size) {
4246	strings_.Add()->assign(s: reinterpret_cast<const char*>(value), n: size);
4247	// @@protoc_insertion_point(field_add_pointer:opencv_onnx.AttributeProto.strings)
4248	}
4249	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4250	AttributeProto::strings() const {
4251	// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.strings)
4252	return strings_;
4253	}
4254	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4255	AttributeProto::mutable_strings() {
4256	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.strings)
4257	return &strings_;
4258	}
4259
4260	// repeated .opencv_onnx.TensorProto tensors = 10;
4261	inline int AttributeProto::_internal_tensors_size() const {
4262	return tensors_.size();
4263	}
4264	inline int AttributeProto::tensors_size() const {
4265	return _internal_tensors_size();
4266	}
4267	inline void AttributeProto::clear_tensors() {
4268	tensors_.Clear();
4269	}
4270	inline ::opencv_onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
4271	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.tensors)
4272	return tensors_.Mutable(index);
4273	}
4274	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
4275	AttributeProto::mutable_tensors() {
4276	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.tensors)
4277	return &tensors_;
4278	}
4279	inline const ::opencv_onnx::TensorProto& AttributeProto::_internal_tensors(int index) const {
4280	return tensors_.Get(index);
4281	}
4282	inline const ::opencv_onnx::TensorProto& AttributeProto::tensors(int index) const {
4283	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.tensors)
4284	return _internal_tensors(index);
4285	}
4286	inline ::opencv_onnx::TensorProto* AttributeProto::_internal_add_tensors() {
4287	return tensors_.Add();
4288	}
4289	inline ::opencv_onnx::TensorProto* AttributeProto::add_tensors() {
4290	::opencv_onnx::TensorProto* _add = _internal_add_tensors();
4291	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.tensors)
4292	return _add;
4293	}
4294	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
4295	AttributeProto::tensors() const {
4296	// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.tensors)
4297	return tensors_;
4298	}
4299
4300	// repeated .opencv_onnx.GraphProto graphs = 11;
4301	inline int AttributeProto::_internal_graphs_size() const {
4302	return graphs_.size();
4303	}
4304	inline int AttributeProto::graphs_size() const {
4305	return _internal_graphs_size();
4306	}
4307	inline void AttributeProto::clear_graphs() {
4308	graphs_.Clear();
4309	}
4310	inline ::opencv_onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
4311	// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.graphs)
4312	return graphs_.Mutable(index);
4313	}
4314	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >*
4315	AttributeProto::mutable_graphs() {
4316	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.graphs)
4317	return &graphs_;
4318	}
4319	inline const ::opencv_onnx::GraphProto& AttributeProto::_internal_graphs(int index) const {
4320	return graphs_.Get(index);
4321	}
4322	inline const ::opencv_onnx::GraphProto& AttributeProto::graphs(int index) const {
4323	// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.graphs)
4324	return _internal_graphs(index);
4325	}
4326	inline ::opencv_onnx::GraphProto* AttributeProto::_internal_add_graphs() {
4327	return graphs_.Add();
4328	}
4329	inline ::opencv_onnx::GraphProto* AttributeProto::add_graphs() {
4330	::opencv_onnx::GraphProto* _add = _internal_add_graphs();
4331	// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.graphs)
4332	return _add;
4333	}
4334	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::GraphProto >&
4335	AttributeProto::graphs() const {
4336	// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.graphs)
4337	return graphs_;
4338	}
4339
4340	// -------------------------------------------------------------------
4341
4342	// ValueInfoProto
4343
4344	// optional string name = 1;
4345	inline bool ValueInfoProto::_internal_has_name() const {
4346	bool value = (_has_bits_[0] & 0x00000001u) != 0;
4347	return value;
4348	}
4349	inline bool ValueInfoProto::has_name() const {
4350	return _internal_has_name();
4351	}
4352	inline void ValueInfoProto::clear_name() {
4353	name_.ClearToEmpty();
4354	_has_bits_[0] &= ~0x00000001u;
4355	}
4356	inline const std::string& ValueInfoProto::name() const {
4357	// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.name)
4358	return _internal_name();
4359	}
4360	template <typename ArgT0, typename... ArgT>
4361	inline PROTOBUF_ALWAYS_INLINE
4362	void ValueInfoProto::set_name(ArgT0&& arg0, ArgT... args) {
4363	_has_bits_[0] |= 0x00000001u;
4364	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4365	// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.name)
4366	}
4367	inline std::string* ValueInfoProto::mutable_name() {
4368	std::string* _s = _internal_mutable_name();
4369	// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.name)
4370	return _s;
4371	}
4372	inline const std::string& ValueInfoProto::_internal_name() const {
4373	return name_.Get();
4374	}
4375	inline void ValueInfoProto::_internal_set_name(const std::string& value) {
4376	_has_bits_[0] |= 0x00000001u;
4377	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
4378	}
4379	inline std::string* ValueInfoProto::_internal_mutable_name() {
4380	_has_bits_[0] |= 0x00000001u;
4381	return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
4382	}
4383	inline std::string* ValueInfoProto::release_name() {
4384	// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.name)
4385	if (!_internal_has_name()) {
4386	return nullptr;
4387	}
4388	_has_bits_[0] &= ~0x00000001u;
4389	auto* p = name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
4390	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4391	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4392	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4393	}
4394	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4395	return p;
4396	}
4397	inline void ValueInfoProto::set_allocated_name(std::string* name) {
4398	if (name != nullptr) {
4399	_has_bits_[0] |= 0x00000001u;
4400	} else {
4401	_has_bits_[0] &= ~0x00000001u;
4402	}
4403	name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: name,
4404	arena: GetArenaForAllocation());
4405	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4406	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4407	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4408	}
4409	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4410	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.name)
4411	}
4412
4413	// optional .opencv_onnx.TypeProto type = 2;
4414	inline bool ValueInfoProto::_internal_has_type() const {
4415	bool value = (_has_bits_[0] & 0x00000004u) != 0;
4416	PROTOBUF_ASSUME(!value || type_ != nullptr);
4417	return value;
4418	}
4419	inline bool ValueInfoProto::has_type() const {
4420	return _internal_has_type();
4421	}
4422	inline void ValueInfoProto::clear_type() {
4423	if (type_ != nullptr) type_->Clear();
4424	_has_bits_[0] &= ~0x00000004u;
4425	}
4426	inline const ::opencv_onnx::TypeProto& ValueInfoProto::_internal_type() const {
4427	const ::opencv_onnx::TypeProto* p = type_;
4428	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TypeProto&>(
4429	::opencv_onnx::_TypeProto_default_instance_);
4430	}
4431	inline const ::opencv_onnx::TypeProto& ValueInfoProto::type() const {
4432	// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.type)
4433	return _internal_type();
4434	}
4435	inline void ValueInfoProto::unsafe_arena_set_allocated_type(
4436	::opencv_onnx::TypeProto* type) {
4437	if (GetArenaForAllocation() == nullptr) {
4438	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
4439	}
4440	type_ = type;
4441	if (type) {
4442	_has_bits_[0] |= 0x00000004u;
4443	} else {
4444	_has_bits_[0] &= ~0x00000004u;
4445	}
4446	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.ValueInfoProto.type)
4447	}
4448	inline ::opencv_onnx::TypeProto* ValueInfoProto::release_type() {
4449	_has_bits_[0] &= ~0x00000004u;
4450	::opencv_onnx::TypeProto* temp = type_;
4451	type_ = nullptr;
4452	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4453	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4454	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4455	if (GetArenaForAllocation() == nullptr) { delete old; }
4456	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
4457	if (GetArenaForAllocation() != nullptr) {
4458	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
4459	}
4460	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4461	return temp;
4462	}
4463	inline ::opencv_onnx::TypeProto* ValueInfoProto::unsafe_arena_release_type() {
4464	// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.type)
4465	_has_bits_[0] &= ~0x00000004u;
4466	::opencv_onnx::TypeProto* temp = type_;
4467	type_ = nullptr;
4468	return temp;
4469	}
4470	inline ::opencv_onnx::TypeProto* ValueInfoProto::_internal_mutable_type() {
4471	_has_bits_[0] |= 0x00000004u;
4472	if (type_ == nullptr) {
4473	auto* p = CreateMaybeMessage<::opencv_onnx::TypeProto>(arena: GetArenaForAllocation());
4474	type_ = p;
4475	}
4476	return type_;
4477	}
4478	inline ::opencv_onnx::TypeProto* ValueInfoProto::mutable_type() {
4479	::opencv_onnx::TypeProto* _msg = _internal_mutable_type();
4480	// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.type)
4481	return _msg;
4482	}
4483	inline void ValueInfoProto::set_allocated_type(::opencv_onnx::TypeProto* type) {
4484	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4485	if (message_arena == nullptr) {
4486	delete type_;
4487	}
4488	if (type) {
4489	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4490	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TypeProto>::GetOwningArena(p: type);
4491	if (message_arena != submessage_arena) {
4492	type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4493	message_arena, submessage: type, submessage_arena);
4494	}
4495	_has_bits_[0] |= 0x00000004u;
4496	} else {
4497	_has_bits_[0] &= ~0x00000004u;
4498	}
4499	type_ = type;
4500	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.type)
4501	}
4502
4503	// optional string doc_string = 3;
4504	inline bool ValueInfoProto::_internal_has_doc_string() const {
4505	bool value = (_has_bits_[0] & 0x00000002u) != 0;
4506	return value;
4507	}
4508	inline bool ValueInfoProto::has_doc_string() const {
4509	return _internal_has_doc_string();
4510	}
4511	inline void ValueInfoProto::clear_doc_string() {
4512	doc_string_.ClearToEmpty();
4513	_has_bits_[0] &= ~0x00000002u;
4514	}
4515	inline const std::string& ValueInfoProto::doc_string() const {
4516	// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.doc_string)
4517	return _internal_doc_string();
4518	}
4519	template <typename ArgT0, typename... ArgT>
4520	inline PROTOBUF_ALWAYS_INLINE
4521	void ValueInfoProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
4522	_has_bits_[0] |= 0x00000002u;
4523	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4524	// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.doc_string)
4525	}
4526	inline std::string* ValueInfoProto::mutable_doc_string() {
4527	std::string* _s = _internal_mutable_doc_string();
4528	// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.doc_string)
4529	return _s;
4530	}
4531	inline const std::string& ValueInfoProto::_internal_doc_string() const {
4532	return doc_string_.Get();
4533	}
4534	inline void ValueInfoProto::_internal_set_doc_string(const std::string& value) {
4535	_has_bits_[0] |= 0x00000002u;
4536	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
4537	}
4538	inline std::string* ValueInfoProto::_internal_mutable_doc_string() {
4539	_has_bits_[0] |= 0x00000002u;
4540	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
4541	}
4542	inline std::string* ValueInfoProto::release_doc_string() {
4543	// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.doc_string)
4544	if (!_internal_has_doc_string()) {
4545	return nullptr;
4546	}
4547	_has_bits_[0] &= ~0x00000002u;
4548	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
4549	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4550	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4551	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4552	}
4553	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4554	return p;
4555	}
4556	inline void ValueInfoProto::set_allocated_doc_string(std::string* doc_string) {
4557	if (doc_string != nullptr) {
4558	_has_bits_[0] |= 0x00000002u;
4559	} else {
4560	_has_bits_[0] &= ~0x00000002u;
4561	}
4562	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
4563	arena: GetArenaForAllocation());
4564	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4565	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4566	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4567	}
4568	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4569	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.doc_string)
4570	}
4571
4572	// -------------------------------------------------------------------
4573
4574	// NodeProto
4575
4576	// repeated string input = 1;
4577	inline int NodeProto::_internal_input_size() const {
4578	return input_.size();
4579	}
4580	inline int NodeProto::input_size() const {
4581	return _internal_input_size();
4582	}
4583	inline void NodeProto::clear_input() {
4584	input_.Clear();
4585	}
4586	inline std::string* NodeProto::add_input() {
4587	std::string* _s = _internal_add_input();
4588	// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.input)
4589	return _s;
4590	}
4591	inline const std::string& NodeProto::_internal_input(int index) const {
4592	return input_.Get(index);
4593	}
4594	inline const std::string& NodeProto::input(int index) const {
4595	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.input)
4596	return _internal_input(index);
4597	}
4598	inline std::string* NodeProto::mutable_input(int index) {
4599	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.input)
4600	return input_.Mutable(index);
4601	}
4602	inline void NodeProto::set_input(int index, const std::string& value) {
4603	input_.Mutable(index)->assign(str: value);
4604	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
4605	}
4606	inline void NodeProto::set_input(int index, std::string&& value) {
4607	input_.Mutable(index)->assign(str: std::move(value));
4608	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
4609	}
4610	inline void NodeProto::set_input(int index, const char* value) {
4611	GOOGLE_DCHECK(value != nullptr);
4612	input_.Mutable(index)->assign(s: value);
4613	// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.input)
4614	}
4615	inline void NodeProto::set_input(int index, const char* value, size_t size) {
4616	input_.Mutable(index)->assign(
4617	s: reinterpret_cast<const char*>(value), n: size);
4618	// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.input)
4619	}
4620	inline std::string* NodeProto::_internal_add_input() {
4621	return input_.Add();
4622	}
4623	inline void NodeProto::add_input(const std::string& value) {
4624	input_.Add()->assign(str: value);
4625	// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
4626	}
4627	inline void NodeProto::add_input(std::string&& value) {
4628	input_.Add(value: std::move(value));
4629	// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
4630	}
4631	inline void NodeProto::add_input(const char* value) {
4632	GOOGLE_DCHECK(value != nullptr);
4633	input_.Add()->assign(s: value);
4634	// @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.input)
4635	}
4636	inline void NodeProto::add_input(const char* value, size_t size) {
4637	input_.Add()->assign(s: reinterpret_cast<const char*>(value), n: size);
4638	// @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.input)
4639	}
4640	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4641	NodeProto::input() const {
4642	// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.input)
4643	return input_;
4644	}
4645	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4646	NodeProto::mutable_input() {
4647	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.input)
4648	return &input_;
4649	}
4650
4651	// repeated string output = 2;
4652	inline int NodeProto::_internal_output_size() const {
4653	return output_.size();
4654	}
4655	inline int NodeProto::output_size() const {
4656	return _internal_output_size();
4657	}
4658	inline void NodeProto::clear_output() {
4659	output_.Clear();
4660	}
4661	inline std::string* NodeProto::add_output() {
4662	std::string* _s = _internal_add_output();
4663	// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.output)
4664	return _s;
4665	}
4666	inline const std::string& NodeProto::_internal_output(int index) const {
4667	return output_.Get(index);
4668	}
4669	inline const std::string& NodeProto::output(int index) const {
4670	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.output)
4671	return _internal_output(index);
4672	}
4673	inline std::string* NodeProto::mutable_output(int index) {
4674	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.output)
4675	return output_.Mutable(index);
4676	}
4677	inline void NodeProto::set_output(int index, const std::string& value) {
4678	output_.Mutable(index)->assign(str: value);
4679	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
4680	}
4681	inline void NodeProto::set_output(int index, std::string&& value) {
4682	output_.Mutable(index)->assign(str: std::move(value));
4683	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
4684	}
4685	inline void NodeProto::set_output(int index, const char* value) {
4686	GOOGLE_DCHECK(value != nullptr);
4687	output_.Mutable(index)->assign(s: value);
4688	// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.output)
4689	}
4690	inline void NodeProto::set_output(int index, const char* value, size_t size) {
4691	output_.Mutable(index)->assign(
4692	s: reinterpret_cast<const char*>(value), n: size);
4693	// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.output)
4694	}
4695	inline std::string* NodeProto::_internal_add_output() {
4696	return output_.Add();
4697	}
4698	inline void NodeProto::add_output(const std::string& value) {
4699	output_.Add()->assign(str: value);
4700	// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
4701	}
4702	inline void NodeProto::add_output(std::string&& value) {
4703	output_.Add(value: std::move(value));
4704	// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
4705	}
4706	inline void NodeProto::add_output(const char* value) {
4707	GOOGLE_DCHECK(value != nullptr);
4708	output_.Add()->assign(s: value);
4709	// @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.output)
4710	}
4711	inline void NodeProto::add_output(const char* value, size_t size) {
4712	output_.Add()->assign(s: reinterpret_cast<const char*>(value), n: size);
4713	// @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.output)
4714	}
4715	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4716	NodeProto::output() const {
4717	// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.output)
4718	return output_;
4719	}
4720	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4721	NodeProto::mutable_output() {
4722	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.output)
4723	return &output_;
4724	}
4725
4726	// optional string name = 3;
4727	inline bool NodeProto::_internal_has_name() const {
4728	bool value = (_has_bits_[0] & 0x00000001u) != 0;
4729	return value;
4730	}
4731	inline bool NodeProto::has_name() const {
4732	return _internal_has_name();
4733	}
4734	inline void NodeProto::clear_name() {
4735	name_.ClearToEmpty();
4736	_has_bits_[0] &= ~0x00000001u;
4737	}
4738	inline const std::string& NodeProto::name() const {
4739	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.name)
4740	return _internal_name();
4741	}
4742	template <typename ArgT0, typename... ArgT>
4743	inline PROTOBUF_ALWAYS_INLINE
4744	void NodeProto::set_name(ArgT0&& arg0, ArgT... args) {
4745	_has_bits_[0] |= 0x00000001u;
4746	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4747	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.name)
4748	}
4749	inline std::string* NodeProto::mutable_name() {
4750	std::string* _s = _internal_mutable_name();
4751	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.name)
4752	return _s;
4753	}
4754	inline const std::string& NodeProto::_internal_name() const {
4755	return name_.Get();
4756	}
4757	inline void NodeProto::_internal_set_name(const std::string& value) {
4758	_has_bits_[0] |= 0x00000001u;
4759	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
4760	}
4761	inline std::string* NodeProto::_internal_mutable_name() {
4762	_has_bits_[0] |= 0x00000001u;
4763	return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
4764	}
4765	inline std::string* NodeProto::release_name() {
4766	// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.name)
4767	if (!_internal_has_name()) {
4768	return nullptr;
4769	}
4770	_has_bits_[0] &= ~0x00000001u;
4771	auto* p = name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
4772	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4773	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4774	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4775	}
4776	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4777	return p;
4778	}
4779	inline void NodeProto::set_allocated_name(std::string* name) {
4780	if (name != nullptr) {
4781	_has_bits_[0] |= 0x00000001u;
4782	} else {
4783	_has_bits_[0] &= ~0x00000001u;
4784	}
4785	name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: name,
4786	arena: GetArenaForAllocation());
4787	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4788	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4789	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4790	}
4791	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4792	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.name)
4793	}
4794
4795	// optional string op_type = 4;
4796	inline bool NodeProto::_internal_has_op_type() const {
4797	bool value = (_has_bits_[0] & 0x00000002u) != 0;
4798	return value;
4799	}
4800	inline bool NodeProto::has_op_type() const {
4801	return _internal_has_op_type();
4802	}
4803	inline void NodeProto::clear_op_type() {
4804	op_type_.ClearToEmpty();
4805	_has_bits_[0] &= ~0x00000002u;
4806	}
4807	inline const std::string& NodeProto::op_type() const {
4808	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.op_type)
4809	return _internal_op_type();
4810	}
4811	template <typename ArgT0, typename... ArgT>
4812	inline PROTOBUF_ALWAYS_INLINE
4813	void NodeProto::set_op_type(ArgT0&& arg0, ArgT... args) {
4814	_has_bits_[0] |= 0x00000002u;
4815	op_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4816	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.op_type)
4817	}
4818	inline std::string* NodeProto::mutable_op_type() {
4819	std::string* _s = _internal_mutable_op_type();
4820	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.op_type)
4821	return _s;
4822	}
4823	inline const std::string& NodeProto::_internal_op_type() const {
4824	return op_type_.Get();
4825	}
4826	inline void NodeProto::_internal_set_op_type(const std::string& value) {
4827	_has_bits_[0] |= 0x00000002u;
4828	op_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
4829	}
4830	inline std::string* NodeProto::_internal_mutable_op_type() {
4831	_has_bits_[0] |= 0x00000002u;
4832	return op_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
4833	}
4834	inline std::string* NodeProto::release_op_type() {
4835	// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.op_type)
4836	if (!_internal_has_op_type()) {
4837	return nullptr;
4838	}
4839	_has_bits_[0] &= ~0x00000002u;
4840	auto* p = op_type_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
4841	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4842	if (op_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4843	op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4844	}
4845	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4846	return p;
4847	}
4848	inline void NodeProto::set_allocated_op_type(std::string* op_type) {
4849	if (op_type != nullptr) {
4850	_has_bits_[0] |= 0x00000002u;
4851	} else {
4852	_has_bits_[0] &= ~0x00000002u;
4853	}
4854	op_type_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: op_type,
4855	arena: GetArenaForAllocation());
4856	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4857	if (op_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4858	op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4859	}
4860	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4861	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.op_type)
4862	}
4863
4864	// optional string domain = 7;
4865	inline bool NodeProto::_internal_has_domain() const {
4866	bool value = (_has_bits_[0] & 0x00000008u) != 0;
4867	return value;
4868	}
4869	inline bool NodeProto::has_domain() const {
4870	return _internal_has_domain();
4871	}
4872	inline void NodeProto::clear_domain() {
4873	domain_.ClearToEmpty();
4874	_has_bits_[0] &= ~0x00000008u;
4875	}
4876	inline const std::string& NodeProto::domain() const {
4877	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.domain)
4878	return _internal_domain();
4879	}
4880	template <typename ArgT0, typename... ArgT>
4881	inline PROTOBUF_ALWAYS_INLINE
4882	void NodeProto::set_domain(ArgT0&& arg0, ArgT... args) {
4883	_has_bits_[0] |= 0x00000008u;
4884	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4885	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.domain)
4886	}
4887	inline std::string* NodeProto::mutable_domain() {
4888	std::string* _s = _internal_mutable_domain();
4889	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.domain)
4890	return _s;
4891	}
4892	inline const std::string& NodeProto::_internal_domain() const {
4893	return domain_.Get();
4894	}
4895	inline void NodeProto::_internal_set_domain(const std::string& value) {
4896	_has_bits_[0] |= 0x00000008u;
4897	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
4898	}
4899	inline std::string* NodeProto::_internal_mutable_domain() {
4900	_has_bits_[0] |= 0x00000008u;
4901	return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
4902	}
4903	inline std::string* NodeProto::release_domain() {
4904	// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.domain)
4905	if (!_internal_has_domain()) {
4906	return nullptr;
4907	}
4908	_has_bits_[0] &= ~0x00000008u;
4909	auto* p = domain_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
4910	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4911	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4912	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4913	}
4914	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4915	return p;
4916	}
4917	inline void NodeProto::set_allocated_domain(std::string* domain) {
4918	if (domain != nullptr) {
4919	_has_bits_[0] |= 0x00000008u;
4920	} else {
4921	_has_bits_[0] &= ~0x00000008u;
4922	}
4923	domain_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: domain,
4924	arena: GetArenaForAllocation());
4925	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4926	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
4927	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
4928	}
4929	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4930	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.domain)
4931	}
4932
4933	// repeated .opencv_onnx.AttributeProto attribute = 5;
4934	inline int NodeProto::_internal_attribute_size() const {
4935	return attribute_.size();
4936	}
4937	inline int NodeProto::attribute_size() const {
4938	return _internal_attribute_size();
4939	}
4940	inline void NodeProto::clear_attribute() {
4941	attribute_.Clear();
4942	}
4943	inline ::opencv_onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
4944	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.attribute)
4945	return attribute_.Mutable(index);
4946	}
4947	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
4948	NodeProto::mutable_attribute() {
4949	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.attribute)
4950	return &attribute_;
4951	}
4952	inline const ::opencv_onnx::AttributeProto& NodeProto::_internal_attribute(int index) const {
4953	return attribute_.Get(index);
4954	}
4955	inline const ::opencv_onnx::AttributeProto& NodeProto::attribute(int index) const {
4956	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.attribute)
4957	return _internal_attribute(index);
4958	}
4959	inline ::opencv_onnx::AttributeProto* NodeProto::_internal_add_attribute() {
4960	return attribute_.Add();
4961	}
4962	inline ::opencv_onnx::AttributeProto* NodeProto::add_attribute() {
4963	::opencv_onnx::AttributeProto* _add = _internal_add_attribute();
4964	// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.attribute)
4965	return _add;
4966	}
4967	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
4968	NodeProto::attribute() const {
4969	// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.attribute)
4970	return attribute_;
4971	}
4972
4973	// optional string doc_string = 6;
4974	inline bool NodeProto::_internal_has_doc_string() const {
4975	bool value = (_has_bits_[0] & 0x00000004u) != 0;
4976	return value;
4977	}
4978	inline bool NodeProto::has_doc_string() const {
4979	return _internal_has_doc_string();
4980	}
4981	inline void NodeProto::clear_doc_string() {
4982	doc_string_.ClearToEmpty();
4983	_has_bits_[0] &= ~0x00000004u;
4984	}
4985	inline const std::string& NodeProto::doc_string() const {
4986	// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.doc_string)
4987	return _internal_doc_string();
4988	}
4989	template <typename ArgT0, typename... ArgT>
4990	inline PROTOBUF_ALWAYS_INLINE
4991	void NodeProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
4992	_has_bits_[0] |= 0x00000004u;
4993	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4994	// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.doc_string)
4995	}
4996	inline std::string* NodeProto::mutable_doc_string() {
4997	std::string* _s = _internal_mutable_doc_string();
4998	// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.doc_string)
4999	return _s;
5000	}
5001	inline const std::string& NodeProto::_internal_doc_string() const {
5002	return doc_string_.Get();
5003	}
5004	inline void NodeProto::_internal_set_doc_string(const std::string& value) {
5005	_has_bits_[0] |= 0x00000004u;
5006	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5007	}
5008	inline std::string* NodeProto::_internal_mutable_doc_string() {
5009	_has_bits_[0] |= 0x00000004u;
5010	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5011	}
5012	inline std::string* NodeProto::release_doc_string() {
5013	// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.doc_string)
5014	if (!_internal_has_doc_string()) {
5015	return nullptr;
5016	}
5017	_has_bits_[0] &= ~0x00000004u;
5018	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5019	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5020	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5021	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5022	}
5023	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5024	return p;
5025	}
5026	inline void NodeProto::set_allocated_doc_string(std::string* doc_string) {
5027	if (doc_string != nullptr) {
5028	_has_bits_[0] |= 0x00000004u;
5029	} else {
5030	_has_bits_[0] &= ~0x00000004u;
5031	}
5032	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
5033	arena: GetArenaForAllocation());
5034	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5035	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5036	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5037	}
5038	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5039	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.doc_string)
5040	}
5041
5042	// -------------------------------------------------------------------
5043
5044	// ModelProto
5045
5046	// optional int64 ir_version = 1;
5047	inline bool ModelProto::_internal_has_ir_version() const {
5048	bool value = (_has_bits_[0] & 0x00000020u) != 0;
5049	return value;
5050	}
5051	inline bool ModelProto::has_ir_version() const {
5052	return _internal_has_ir_version();
5053	}
5054	inline void ModelProto::clear_ir_version() {
5055	ir_version_ = int64_t{0};
5056	_has_bits_[0] &= ~0x00000020u;
5057	}
5058	inline int64_t ModelProto::_internal_ir_version() const {
5059	return ir_version_;
5060	}
5061	inline int64_t ModelProto::ir_version() const {
5062	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.ir_version)
5063	return _internal_ir_version();
5064	}
5065	inline void ModelProto::_internal_set_ir_version(int64_t value) {
5066	_has_bits_[0] |= 0x00000020u;
5067	ir_version_ = value;
5068	}
5069	inline void ModelProto::set_ir_version(int64_t value) {
5070	_internal_set_ir_version(value);
5071	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.ir_version)
5072	}
5073
5074	// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
5075	inline int ModelProto::_internal_opset_import_size() const {
5076	return opset_import_.size();
5077	}
5078	inline int ModelProto::opset_import_size() const {
5079	return _internal_opset_import_size();
5080	}
5081	inline void ModelProto::clear_opset_import() {
5082	opset_import_.Clear();
5083	}
5084	inline ::opencv_onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
5085	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.opset_import)
5086	return opset_import_.Mutable(index);
5087	}
5088	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
5089	ModelProto::mutable_opset_import() {
5090	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.opset_import)
5091	return &opset_import_;
5092	}
5093	inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::_internal_opset_import(int index) const {
5094	return opset_import_.Get(index);
5095	}
5096	inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
5097	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.opset_import)
5098	return _internal_opset_import(index);
5099	}
5100	inline ::opencv_onnx::OperatorSetIdProto* ModelProto::_internal_add_opset_import() {
5101	return opset_import_.Add();
5102	}
5103	inline ::opencv_onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
5104	::opencv_onnx::OperatorSetIdProto* _add = _internal_add_opset_import();
5105	// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.opset_import)
5106	return _add;
5107	}
5108	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
5109	ModelProto::opset_import() const {
5110	// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.opset_import)
5111	return opset_import_;
5112	}
5113
5114	// optional string producer_name = 2;
5115	inline bool ModelProto::_internal_has_producer_name() const {
5116	bool value = (_has_bits_[0] & 0x00000001u) != 0;
5117	return value;
5118	}
5119	inline bool ModelProto::has_producer_name() const {
5120	return _internal_has_producer_name();
5121	}
5122	inline void ModelProto::clear_producer_name() {
5123	producer_name_.ClearToEmpty();
5124	_has_bits_[0] &= ~0x00000001u;
5125	}
5126	inline const std::string& ModelProto::producer_name() const {
5127	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_name)
5128	return _internal_producer_name();
5129	}
5130	template <typename ArgT0, typename... ArgT>
5131	inline PROTOBUF_ALWAYS_INLINE
5132	void ModelProto::set_producer_name(ArgT0&& arg0, ArgT... args) {
5133	_has_bits_[0] |= 0x00000001u;
5134	producer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5135	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_name)
5136	}
5137	inline std::string* ModelProto::mutable_producer_name() {
5138	std::string* _s = _internal_mutable_producer_name();
5139	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_name)
5140	return _s;
5141	}
5142	inline const std::string& ModelProto::_internal_producer_name() const {
5143	return producer_name_.Get();
5144	}
5145	inline void ModelProto::_internal_set_producer_name(const std::string& value) {
5146	_has_bits_[0] |= 0x00000001u;
5147	producer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5148	}
5149	inline std::string* ModelProto::_internal_mutable_producer_name() {
5150	_has_bits_[0] |= 0x00000001u;
5151	return producer_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5152	}
5153	inline std::string* ModelProto::release_producer_name() {
5154	// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_name)
5155	if (!_internal_has_producer_name()) {
5156	return nullptr;
5157	}
5158	_has_bits_[0] &= ~0x00000001u;
5159	auto* p = producer_name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5160	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5161	if (producer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5162	producer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5163	}
5164	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5165	return p;
5166	}
5167	inline void ModelProto::set_allocated_producer_name(std::string* producer_name) {
5168	if (producer_name != nullptr) {
5169	_has_bits_[0] |= 0x00000001u;
5170	} else {
5171	_has_bits_[0] &= ~0x00000001u;
5172	}
5173	producer_name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: producer_name,
5174	arena: GetArenaForAllocation());
5175	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5176	if (producer_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5177	producer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5178	}
5179	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5180	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_name)
5181	}
5182
5183	// optional string producer_version = 3;
5184	inline bool ModelProto::_internal_has_producer_version() const {
5185	bool value = (_has_bits_[0] & 0x00000002u) != 0;
5186	return value;
5187	}
5188	inline bool ModelProto::has_producer_version() const {
5189	return _internal_has_producer_version();
5190	}
5191	inline void ModelProto::clear_producer_version() {
5192	producer_version_.ClearToEmpty();
5193	_has_bits_[0] &= ~0x00000002u;
5194	}
5195	inline const std::string& ModelProto::producer_version() const {
5196	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_version)
5197	return _internal_producer_version();
5198	}
5199	template <typename ArgT0, typename... ArgT>
5200	inline PROTOBUF_ALWAYS_INLINE
5201	void ModelProto::set_producer_version(ArgT0&& arg0, ArgT... args) {
5202	_has_bits_[0] |= 0x00000002u;
5203	producer_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5204	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_version)
5205	}
5206	inline std::string* ModelProto::mutable_producer_version() {
5207	std::string* _s = _internal_mutable_producer_version();
5208	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_version)
5209	return _s;
5210	}
5211	inline const std::string& ModelProto::_internal_producer_version() const {
5212	return producer_version_.Get();
5213	}
5214	inline void ModelProto::_internal_set_producer_version(const std::string& value) {
5215	_has_bits_[0] |= 0x00000002u;
5216	producer_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5217	}
5218	inline std::string* ModelProto::_internal_mutable_producer_version() {
5219	_has_bits_[0] |= 0x00000002u;
5220	return producer_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5221	}
5222	inline std::string* ModelProto::release_producer_version() {
5223	// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_version)
5224	if (!_internal_has_producer_version()) {
5225	return nullptr;
5226	}
5227	_has_bits_[0] &= ~0x00000002u;
5228	auto* p = producer_version_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5229	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5230	if (producer_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5231	producer_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5232	}
5233	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5234	return p;
5235	}
5236	inline void ModelProto::set_allocated_producer_version(std::string* producer_version) {
5237	if (producer_version != nullptr) {
5238	_has_bits_[0] |= 0x00000002u;
5239	} else {
5240	_has_bits_[0] &= ~0x00000002u;
5241	}
5242	producer_version_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: producer_version,
5243	arena: GetArenaForAllocation());
5244	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5245	if (producer_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5246	producer_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5247	}
5248	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5249	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_version)
5250	}
5251
5252	// optional string domain = 4;
5253	inline bool ModelProto::_internal_has_domain() const {
5254	bool value = (_has_bits_[0] & 0x00000004u) != 0;
5255	return value;
5256	}
5257	inline bool ModelProto::has_domain() const {
5258	return _internal_has_domain();
5259	}
5260	inline void ModelProto::clear_domain() {
5261	domain_.ClearToEmpty();
5262	_has_bits_[0] &= ~0x00000004u;
5263	}
5264	inline const std::string& ModelProto::domain() const {
5265	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.domain)
5266	return _internal_domain();
5267	}
5268	template <typename ArgT0, typename... ArgT>
5269	inline PROTOBUF_ALWAYS_INLINE
5270	void ModelProto::set_domain(ArgT0&& arg0, ArgT... args) {
5271	_has_bits_[0] |= 0x00000004u;
5272	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5273	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.domain)
5274	}
5275	inline std::string* ModelProto::mutable_domain() {
5276	std::string* _s = _internal_mutable_domain();
5277	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.domain)
5278	return _s;
5279	}
5280	inline const std::string& ModelProto::_internal_domain() const {
5281	return domain_.Get();
5282	}
5283	inline void ModelProto::_internal_set_domain(const std::string& value) {
5284	_has_bits_[0] |= 0x00000004u;
5285	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5286	}
5287	inline std::string* ModelProto::_internal_mutable_domain() {
5288	_has_bits_[0] |= 0x00000004u;
5289	return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5290	}
5291	inline std::string* ModelProto::release_domain() {
5292	// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.domain)
5293	if (!_internal_has_domain()) {
5294	return nullptr;
5295	}
5296	_has_bits_[0] &= ~0x00000004u;
5297	auto* p = domain_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5298	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5299	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5300	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5301	}
5302	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5303	return p;
5304	}
5305	inline void ModelProto::set_allocated_domain(std::string* domain) {
5306	if (domain != nullptr) {
5307	_has_bits_[0] |= 0x00000004u;
5308	} else {
5309	_has_bits_[0] &= ~0x00000004u;
5310	}
5311	domain_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: domain,
5312	arena: GetArenaForAllocation());
5313	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5314	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5315	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5316	}
5317	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5318	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.domain)
5319	}
5320
5321	// optional int64 model_version = 5;
5322	inline bool ModelProto::_internal_has_model_version() const {
5323	bool value = (_has_bits_[0] & 0x00000040u) != 0;
5324	return value;
5325	}
5326	inline bool ModelProto::has_model_version() const {
5327	return _internal_has_model_version();
5328	}
5329	inline void ModelProto::clear_model_version() {
5330	model_version_ = int64_t{0};
5331	_has_bits_[0] &= ~0x00000040u;
5332	}
5333	inline int64_t ModelProto::_internal_model_version() const {
5334	return model_version_;
5335	}
5336	inline int64_t ModelProto::model_version() const {
5337	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.model_version)
5338	return _internal_model_version();
5339	}
5340	inline void ModelProto::_internal_set_model_version(int64_t value) {
5341	_has_bits_[0] |= 0x00000040u;
5342	model_version_ = value;
5343	}
5344	inline void ModelProto::set_model_version(int64_t value) {
5345	_internal_set_model_version(value);
5346	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.model_version)
5347	}
5348
5349	// optional string doc_string = 6;
5350	inline bool ModelProto::_internal_has_doc_string() const {
5351	bool value = (_has_bits_[0] & 0x00000008u) != 0;
5352	return value;
5353	}
5354	inline bool ModelProto::has_doc_string() const {
5355	return _internal_has_doc_string();
5356	}
5357	inline void ModelProto::clear_doc_string() {
5358	doc_string_.ClearToEmpty();
5359	_has_bits_[0] &= ~0x00000008u;
5360	}
5361	inline const std::string& ModelProto::doc_string() const {
5362	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.doc_string)
5363	return _internal_doc_string();
5364	}
5365	template <typename ArgT0, typename... ArgT>
5366	inline PROTOBUF_ALWAYS_INLINE
5367	void ModelProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
5368	_has_bits_[0] |= 0x00000008u;
5369	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5370	// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.doc_string)
5371	}
5372	inline std::string* ModelProto::mutable_doc_string() {
5373	std::string* _s = _internal_mutable_doc_string();
5374	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.doc_string)
5375	return _s;
5376	}
5377	inline const std::string& ModelProto::_internal_doc_string() const {
5378	return doc_string_.Get();
5379	}
5380	inline void ModelProto::_internal_set_doc_string(const std::string& value) {
5381	_has_bits_[0] |= 0x00000008u;
5382	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5383	}
5384	inline std::string* ModelProto::_internal_mutable_doc_string() {
5385	_has_bits_[0] |= 0x00000008u;
5386	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5387	}
5388	inline std::string* ModelProto::release_doc_string() {
5389	// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.doc_string)
5390	if (!_internal_has_doc_string()) {
5391	return nullptr;
5392	}
5393	_has_bits_[0] &= ~0x00000008u;
5394	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5395	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5396	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5397	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5398	}
5399	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5400	return p;
5401	}
5402	inline void ModelProto::set_allocated_doc_string(std::string* doc_string) {
5403	if (doc_string != nullptr) {
5404	_has_bits_[0] |= 0x00000008u;
5405	} else {
5406	_has_bits_[0] &= ~0x00000008u;
5407	}
5408	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
5409	arena: GetArenaForAllocation());
5410	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5411	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5412	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5413	}
5414	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5415	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.doc_string)
5416	}
5417
5418	// optional .opencv_onnx.GraphProto graph = 7;
5419	inline bool ModelProto::_internal_has_graph() const {
5420	bool value = (_has_bits_[0] & 0x00000010u) != 0;
5421	PROTOBUF_ASSUME(!value || graph_ != nullptr);
5422	return value;
5423	}
5424	inline bool ModelProto::has_graph() const {
5425	return _internal_has_graph();
5426	}
5427	inline void ModelProto::clear_graph() {
5428	if (graph_ != nullptr) graph_->Clear();
5429	_has_bits_[0] &= ~0x00000010u;
5430	}
5431	inline const ::opencv_onnx::GraphProto& ModelProto::_internal_graph() const {
5432	const ::opencv_onnx::GraphProto* p = graph_;
5433	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::GraphProto&>(
5434	::opencv_onnx::_GraphProto_default_instance_);
5435	}
5436	inline const ::opencv_onnx::GraphProto& ModelProto::graph() const {
5437	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.graph)
5438	return _internal_graph();
5439	}
5440	inline void ModelProto::unsafe_arena_set_allocated_graph(
5441	::opencv_onnx::GraphProto* graph) {
5442	if (GetArenaForAllocation() == nullptr) {
5443	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_);
5444	}
5445	graph_ = graph;
5446	if (graph) {
5447	_has_bits_[0] |= 0x00000010u;
5448	} else {
5449	_has_bits_[0] &= ~0x00000010u;
5450	}
5451	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.ModelProto.graph)
5452	}
5453	inline ::opencv_onnx::GraphProto* ModelProto::release_graph() {
5454	_has_bits_[0] &= ~0x00000010u;
5455	::opencv_onnx::GraphProto* temp = graph_;
5456	graph_ = nullptr;
5457	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5458	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5459	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5460	if (GetArenaForAllocation() == nullptr) { delete old; }
5461	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
5462	if (GetArenaForAllocation() != nullptr) {
5463	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
5464	}
5465	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
5466	return temp;
5467	}
5468	inline ::opencv_onnx::GraphProto* ModelProto::unsafe_arena_release_graph() {
5469	// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.graph)
5470	_has_bits_[0] &= ~0x00000010u;
5471	::opencv_onnx::GraphProto* temp = graph_;
5472	graph_ = nullptr;
5473	return temp;
5474	}
5475	inline ::opencv_onnx::GraphProto* ModelProto::_internal_mutable_graph() {
5476	_has_bits_[0] |= 0x00000010u;
5477	if (graph_ == nullptr) {
5478	auto* p = CreateMaybeMessage<::opencv_onnx::GraphProto>(arena: GetArenaForAllocation());
5479	graph_ = p;
5480	}
5481	return graph_;
5482	}
5483	inline ::opencv_onnx::GraphProto* ModelProto::mutable_graph() {
5484	::opencv_onnx::GraphProto* _msg = _internal_mutable_graph();
5485	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.graph)
5486	return _msg;
5487	}
5488	inline void ModelProto::set_allocated_graph(::opencv_onnx::GraphProto* graph) {
5489	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5490	if (message_arena == nullptr) {
5491	delete graph_;
5492	}
5493	if (graph) {
5494	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5495	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::GraphProto>::GetOwningArena(p: graph);
5496	if (message_arena != submessage_arena) {
5497	graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5498	message_arena, submessage: graph, submessage_arena);
5499	}
5500	_has_bits_[0] |= 0x00000010u;
5501	} else {
5502	_has_bits_[0] &= ~0x00000010u;
5503	}
5504	graph_ = graph;
5505	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.graph)
5506	}
5507
5508	// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
5509	inline int ModelProto::_internal_metadata_props_size() const {
5510	return metadata_props_.size();
5511	}
5512	inline int ModelProto::metadata_props_size() const {
5513	return _internal_metadata_props_size();
5514	}
5515	inline void ModelProto::clear_metadata_props() {
5516	metadata_props_.Clear();
5517	}
5518	inline ::opencv_onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
5519	// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.metadata_props)
5520	return metadata_props_.Mutable(index);
5521	}
5522	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
5523	ModelProto::mutable_metadata_props() {
5524	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.metadata_props)
5525	return &metadata_props_;
5526	}
5527	inline const ::opencv_onnx::StringStringEntryProto& ModelProto::_internal_metadata_props(int index) const {
5528	return metadata_props_.Get(index);
5529	}
5530	inline const ::opencv_onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
5531	// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.metadata_props)
5532	return _internal_metadata_props(index);
5533	}
5534	inline ::opencv_onnx::StringStringEntryProto* ModelProto::_internal_add_metadata_props() {
5535	return metadata_props_.Add();
5536	}
5537	inline ::opencv_onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
5538	::opencv_onnx::StringStringEntryProto* _add = _internal_add_metadata_props();
5539	// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.metadata_props)
5540	return _add;
5541	}
5542	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
5543	ModelProto::metadata_props() const {
5544	// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.metadata_props)
5545	return metadata_props_;
5546	}
5547
5548	// -------------------------------------------------------------------
5549
5550	// StringStringEntryProto
5551
5552	// optional string key = 1;
5553	inline bool StringStringEntryProto::_internal_has_key() const {
5554	bool value = (_has_bits_[0] & 0x00000001u) != 0;
5555	return value;
5556	}
5557	inline bool StringStringEntryProto::has_key() const {
5558	return _internal_has_key();
5559	}
5560	inline void StringStringEntryProto::clear_key() {
5561	key_.ClearToEmpty();
5562	_has_bits_[0] &= ~0x00000001u;
5563	}
5564	inline const std::string& StringStringEntryProto::key() const {
5565	// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.key)
5566	return _internal_key();
5567	}
5568	template <typename ArgT0, typename... ArgT>
5569	inline PROTOBUF_ALWAYS_INLINE
5570	void StringStringEntryProto::set_key(ArgT0&& arg0, ArgT... args) {
5571	_has_bits_[0] |= 0x00000001u;
5572	key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5573	// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.key)
5574	}
5575	inline std::string* StringStringEntryProto::mutable_key() {
5576	std::string* _s = _internal_mutable_key();
5577	// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.key)
5578	return _s;
5579	}
5580	inline const std::string& StringStringEntryProto::_internal_key() const {
5581	return key_.Get();
5582	}
5583	inline void StringStringEntryProto::_internal_set_key(const std::string& value) {
5584	_has_bits_[0] |= 0x00000001u;
5585	key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5586	}
5587	inline std::string* StringStringEntryProto::_internal_mutable_key() {
5588	_has_bits_[0] |= 0x00000001u;
5589	return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5590	}
5591	inline std::string* StringStringEntryProto::release_key() {
5592	// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.key)
5593	if (!_internal_has_key()) {
5594	return nullptr;
5595	}
5596	_has_bits_[0] &= ~0x00000001u;
5597	auto* p = key_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5598	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5599	if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5600	key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5601	}
5602	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5603	return p;
5604	}
5605	inline void StringStringEntryProto::set_allocated_key(std::string* key) {
5606	if (key != nullptr) {
5607	_has_bits_[0] |= 0x00000001u;
5608	} else {
5609	_has_bits_[0] &= ~0x00000001u;
5610	}
5611	key_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: key,
5612	arena: GetArenaForAllocation());
5613	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5614	if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5615	key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5616	}
5617	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5618	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.key)
5619	}
5620
5621	// optional string value = 2;
5622	inline bool StringStringEntryProto::_internal_has_value() const {
5623	bool value = (_has_bits_[0] & 0x00000002u) != 0;
5624	return value;
5625	}
5626	inline bool StringStringEntryProto::has_value() const {
5627	return _internal_has_value();
5628	}
5629	inline void StringStringEntryProto::clear_value() {
5630	value_.ClearToEmpty();
5631	_has_bits_[0] &= ~0x00000002u;
5632	}
5633	inline const std::string& StringStringEntryProto::value() const {
5634	// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.value)
5635	return _internal_value();
5636	}
5637	template <typename ArgT0, typename... ArgT>
5638	inline PROTOBUF_ALWAYS_INLINE
5639	void StringStringEntryProto::set_value(ArgT0&& arg0, ArgT... args) {
5640	_has_bits_[0] |= 0x00000002u;
5641	value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5642	// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.value)
5643	}
5644	inline std::string* StringStringEntryProto::mutable_value() {
5645	std::string* _s = _internal_mutable_value();
5646	// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.value)
5647	return _s;
5648	}
5649	inline const std::string& StringStringEntryProto::_internal_value() const {
5650	return value_.Get();
5651	}
5652	inline void StringStringEntryProto::_internal_set_value(const std::string& value) {
5653	_has_bits_[0] |= 0x00000002u;
5654	value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5655	}
5656	inline std::string* StringStringEntryProto::_internal_mutable_value() {
5657	_has_bits_[0] |= 0x00000002u;
5658	return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5659	}
5660	inline std::string* StringStringEntryProto::release_value() {
5661	// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.value)
5662	if (!_internal_has_value()) {
5663	return nullptr;
5664	}
5665	_has_bits_[0] &= ~0x00000002u;
5666	auto* p = value_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5667	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5668	if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5669	value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5670	}
5671	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5672	return p;
5673	}
5674	inline void StringStringEntryProto::set_allocated_value(std::string* value) {
5675	if (value != nullptr) {
5676	_has_bits_[0] |= 0x00000002u;
5677	} else {
5678	_has_bits_[0] &= ~0x00000002u;
5679	}
5680	value_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
5681	arena: GetArenaForAllocation());
5682	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5683	if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5684	value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5685	}
5686	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5687	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.value)
5688	}
5689
5690	// -------------------------------------------------------------------
5691
5692	// GraphProto
5693
5694	// repeated .opencv_onnx.NodeProto node = 1;
5695	inline int GraphProto::_internal_node_size() const {
5696	return node_.size();
5697	}
5698	inline int GraphProto::node_size() const {
5699	return _internal_node_size();
5700	}
5701	inline void GraphProto::clear_node() {
5702	node_.Clear();
5703	}
5704	inline ::opencv_onnx::NodeProto* GraphProto::mutable_node(int index) {
5705	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.node)
5706	return node_.Mutable(index);
5707	}
5708	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >*
5709	GraphProto::mutable_node() {
5710	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.node)
5711	return &node_;
5712	}
5713	inline const ::opencv_onnx::NodeProto& GraphProto::_internal_node(int index) const {
5714	return node_.Get(index);
5715	}
5716	inline const ::opencv_onnx::NodeProto& GraphProto::node(int index) const {
5717	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.node)
5718	return _internal_node(index);
5719	}
5720	inline ::opencv_onnx::NodeProto* GraphProto::_internal_add_node() {
5721	return node_.Add();
5722	}
5723	inline ::opencv_onnx::NodeProto* GraphProto::add_node() {
5724	::opencv_onnx::NodeProto* _add = _internal_add_node();
5725	// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.node)
5726	return _add;
5727	}
5728	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::NodeProto >&
5729	GraphProto::node() const {
5730	// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.node)
5731	return node_;
5732	}
5733
5734	// optional string name = 2;
5735	inline bool GraphProto::_internal_has_name() const {
5736	bool value = (_has_bits_[0] & 0x00000001u) != 0;
5737	return value;
5738	}
5739	inline bool GraphProto::has_name() const {
5740	return _internal_has_name();
5741	}
5742	inline void GraphProto::clear_name() {
5743	name_.ClearToEmpty();
5744	_has_bits_[0] &= ~0x00000001u;
5745	}
5746	inline const std::string& GraphProto::name() const {
5747	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.name)
5748	return _internal_name();
5749	}
5750	template <typename ArgT0, typename... ArgT>
5751	inline PROTOBUF_ALWAYS_INLINE
5752	void GraphProto::set_name(ArgT0&& arg0, ArgT... args) {
5753	_has_bits_[0] |= 0x00000001u;
5754	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5755	// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.name)
5756	}
5757	inline std::string* GraphProto::mutable_name() {
5758	std::string* _s = _internal_mutable_name();
5759	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.name)
5760	return _s;
5761	}
5762	inline const std::string& GraphProto::_internal_name() const {
5763	return name_.Get();
5764	}
5765	inline void GraphProto::_internal_set_name(const std::string& value) {
5766	_has_bits_[0] |= 0x00000001u;
5767	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5768	}
5769	inline std::string* GraphProto::_internal_mutable_name() {
5770	_has_bits_[0] |= 0x00000001u;
5771	return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5772	}
5773	inline std::string* GraphProto::release_name() {
5774	// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.name)
5775	if (!_internal_has_name()) {
5776	return nullptr;
5777	}
5778	_has_bits_[0] &= ~0x00000001u;
5779	auto* p = name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5780	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5781	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5782	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5783	}
5784	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5785	return p;
5786	}
5787	inline void GraphProto::set_allocated_name(std::string* name) {
5788	if (name != nullptr) {
5789	_has_bits_[0] |= 0x00000001u;
5790	} else {
5791	_has_bits_[0] &= ~0x00000001u;
5792	}
5793	name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: name,
5794	arena: GetArenaForAllocation());
5795	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5796	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5797	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5798	}
5799	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5800	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.name)
5801	}
5802
5803	// repeated .opencv_onnx.TensorProto initializer = 5;
5804	inline int GraphProto::_internal_initializer_size() const {
5805	return initializer_.size();
5806	}
5807	inline int GraphProto::initializer_size() const {
5808	return _internal_initializer_size();
5809	}
5810	inline void GraphProto::clear_initializer() {
5811	initializer_.Clear();
5812	}
5813	inline ::opencv_onnx::TensorProto* GraphProto::mutable_initializer(int index) {
5814	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.initializer)
5815	return initializer_.Mutable(index);
5816	}
5817	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >*
5818	GraphProto::mutable_initializer() {
5819	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.initializer)
5820	return &initializer_;
5821	}
5822	inline const ::opencv_onnx::TensorProto& GraphProto::_internal_initializer(int index) const {
5823	return initializer_.Get(index);
5824	}
5825	inline const ::opencv_onnx::TensorProto& GraphProto::initializer(int index) const {
5826	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.initializer)
5827	return _internal_initializer(index);
5828	}
5829	inline ::opencv_onnx::TensorProto* GraphProto::_internal_add_initializer() {
5830	return initializer_.Add();
5831	}
5832	inline ::opencv_onnx::TensorProto* GraphProto::add_initializer() {
5833	::opencv_onnx::TensorProto* _add = _internal_add_initializer();
5834	// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.initializer)
5835	return _add;
5836	}
5837	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorProto >&
5838	GraphProto::initializer() const {
5839	// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.initializer)
5840	return initializer_;
5841	}
5842
5843	// optional string doc_string = 10;
5844	inline bool GraphProto::_internal_has_doc_string() const {
5845	bool value = (_has_bits_[0] & 0x00000002u) != 0;
5846	return value;
5847	}
5848	inline bool GraphProto::has_doc_string() const {
5849	return _internal_has_doc_string();
5850	}
5851	inline void GraphProto::clear_doc_string() {
5852	doc_string_.ClearToEmpty();
5853	_has_bits_[0] &= ~0x00000002u;
5854	}
5855	inline const std::string& GraphProto::doc_string() const {
5856	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.doc_string)
5857	return _internal_doc_string();
5858	}
5859	template <typename ArgT0, typename... ArgT>
5860	inline PROTOBUF_ALWAYS_INLINE
5861	void GraphProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
5862	_has_bits_[0] |= 0x00000002u;
5863	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5864	// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.doc_string)
5865	}
5866	inline std::string* GraphProto::mutable_doc_string() {
5867	std::string* _s = _internal_mutable_doc_string();
5868	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.doc_string)
5869	return _s;
5870	}
5871	inline const std::string& GraphProto::_internal_doc_string() const {
5872	return doc_string_.Get();
5873	}
5874	inline void GraphProto::_internal_set_doc_string(const std::string& value) {
5875	_has_bits_[0] |= 0x00000002u;
5876	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
5877	}
5878	inline std::string* GraphProto::_internal_mutable_doc_string() {
5879	_has_bits_[0] |= 0x00000002u;
5880	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
5881	}
5882	inline std::string* GraphProto::release_doc_string() {
5883	// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.doc_string)
5884	if (!_internal_has_doc_string()) {
5885	return nullptr;
5886	}
5887	_has_bits_[0] &= ~0x00000002u;
5888	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
5889	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5890	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5891	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5892	}
5893	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5894	return p;
5895	}
5896	inline void GraphProto::set_allocated_doc_string(std::string* doc_string) {
5897	if (doc_string != nullptr) {
5898	_has_bits_[0] |= 0x00000002u;
5899	} else {
5900	_has_bits_[0] &= ~0x00000002u;
5901	}
5902	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
5903	arena: GetArenaForAllocation());
5904	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5905	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
5906	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
5907	}
5908	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5909	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.doc_string)
5910	}
5911
5912	// repeated .opencv_onnx.ValueInfoProto input = 11;
5913	inline int GraphProto::_internal_input_size() const {
5914	return input_.size();
5915	}
5916	inline int GraphProto::input_size() const {
5917	return _internal_input_size();
5918	}
5919	inline void GraphProto::clear_input() {
5920	input_.Clear();
5921	}
5922	inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
5923	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.input)
5924	return input_.Mutable(index);
5925	}
5926	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
5927	GraphProto::mutable_input() {
5928	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.input)
5929	return &input_;
5930	}
5931	inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_input(int index) const {
5932	return input_.Get(index);
5933	}
5934	inline const ::opencv_onnx::ValueInfoProto& GraphProto::input(int index) const {
5935	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.input)
5936	return _internal_input(index);
5937	}
5938	inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_input() {
5939	return input_.Add();
5940	}
5941	inline ::opencv_onnx::ValueInfoProto* GraphProto::add_input() {
5942	::opencv_onnx::ValueInfoProto* _add = _internal_add_input();
5943	// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.input)
5944	return _add;
5945	}
5946	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
5947	GraphProto::input() const {
5948	// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.input)
5949	return input_;
5950	}
5951
5952	// repeated .opencv_onnx.ValueInfoProto output = 12;
5953	inline int GraphProto::_internal_output_size() const {
5954	return output_.size();
5955	}
5956	inline int GraphProto::output_size() const {
5957	return _internal_output_size();
5958	}
5959	inline void GraphProto::clear_output() {
5960	output_.Clear();
5961	}
5962	inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
5963	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.output)
5964	return output_.Mutable(index);
5965	}
5966	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
5967	GraphProto::mutable_output() {
5968	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.output)
5969	return &output_;
5970	}
5971	inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_output(int index) const {
5972	return output_.Get(index);
5973	}
5974	inline const ::opencv_onnx::ValueInfoProto& GraphProto::output(int index) const {
5975	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.output)
5976	return _internal_output(index);
5977	}
5978	inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_output() {
5979	return output_.Add();
5980	}
5981	inline ::opencv_onnx::ValueInfoProto* GraphProto::add_output() {
5982	::opencv_onnx::ValueInfoProto* _add = _internal_add_output();
5983	// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.output)
5984	return _add;
5985	}
5986	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
5987	GraphProto::output() const {
5988	// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.output)
5989	return output_;
5990	}
5991
5992	// repeated .opencv_onnx.ValueInfoProto value_info = 13;
5993	inline int GraphProto::_internal_value_info_size() const {
5994	return value_info_.size();
5995	}
5996	inline int GraphProto::value_info_size() const {
5997	return _internal_value_info_size();
5998	}
5999	inline void GraphProto::clear_value_info() {
6000	value_info_.Clear();
6001	}
6002	inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
6003	// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.value_info)
6004	return value_info_.Mutable(index);
6005	}
6006	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
6007	GraphProto::mutable_value_info() {
6008	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.value_info)
6009	return &value_info_;
6010	}
6011	inline const ::opencv_onnx::ValueInfoProto& GraphProto::_internal_value_info(int index) const {
6012	return value_info_.Get(index);
6013	}
6014	inline const ::opencv_onnx::ValueInfoProto& GraphProto::value_info(int index) const {
6015	// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.value_info)
6016	return _internal_value_info(index);
6017	}
6018	inline ::opencv_onnx::ValueInfoProto* GraphProto::_internal_add_value_info() {
6019	return value_info_.Add();
6020	}
6021	inline ::opencv_onnx::ValueInfoProto* GraphProto::add_value_info() {
6022	::opencv_onnx::ValueInfoProto* _add = _internal_add_value_info();
6023	// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.value_info)
6024	return _add;
6025	}
6026	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
6027	GraphProto::value_info() const {
6028	// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.value_info)
6029	return value_info_;
6030	}
6031
6032	// -------------------------------------------------------------------
6033
6034	// TensorProto_Segment
6035
6036	// optional int64 begin = 1;
6037	inline bool TensorProto_Segment::_internal_has_begin() const {
6038	bool value = (_has_bits_[0] & 0x00000001u) != 0;
6039	return value;
6040	}
6041	inline bool TensorProto_Segment::has_begin() const {
6042	return _internal_has_begin();
6043	}
6044	inline void TensorProto_Segment::clear_begin() {
6045	begin_ = int64_t{0};
6046	_has_bits_[0] &= ~0x00000001u;
6047	}
6048	inline int64_t TensorProto_Segment::_internal_begin() const {
6049	return begin_;
6050	}
6051	inline int64_t TensorProto_Segment::begin() const {
6052	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.begin)
6053	return _internal_begin();
6054	}
6055	inline void TensorProto_Segment::_internal_set_begin(int64_t value) {
6056	_has_bits_[0] |= 0x00000001u;
6057	begin_ = value;
6058	}
6059	inline void TensorProto_Segment::set_begin(int64_t value) {
6060	_internal_set_begin(value);
6061	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.begin)
6062	}
6063
6064	// optional int64 end = 2;
6065	inline bool TensorProto_Segment::_internal_has_end() const {
6066	bool value = (_has_bits_[0] & 0x00000002u) != 0;
6067	return value;
6068	}
6069	inline bool TensorProto_Segment::has_end() const {
6070	return _internal_has_end();
6071	}
6072	inline void TensorProto_Segment::clear_end() {
6073	end_ = int64_t{0};
6074	_has_bits_[0] &= ~0x00000002u;
6075	}
6076	inline int64_t TensorProto_Segment::_internal_end() const {
6077	return end_;
6078	}
6079	inline int64_t TensorProto_Segment::end() const {
6080	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.end)
6081	return _internal_end();
6082	}
6083	inline void TensorProto_Segment::_internal_set_end(int64_t value) {
6084	_has_bits_[0] |= 0x00000002u;
6085	end_ = value;
6086	}
6087	inline void TensorProto_Segment::set_end(int64_t value) {
6088	_internal_set_end(value);
6089	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.end)
6090	}
6091
6092	// -------------------------------------------------------------------
6093
6094	// TensorProto
6095
6096	// repeated int64 dims = 1;
6097	inline int TensorProto::_internal_dims_size() const {
6098	return dims_.size();
6099	}
6100	inline int TensorProto::dims_size() const {
6101	return _internal_dims_size();
6102	}
6103	inline void TensorProto::clear_dims() {
6104	dims_.Clear();
6105	}
6106	inline int64_t TensorProto::_internal_dims(int index) const {
6107	return dims_.Get(index);
6108	}
6109	inline int64_t TensorProto::dims(int index) const {
6110	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.dims)
6111	return _internal_dims(index);
6112	}
6113	inline void TensorProto::set_dims(int index, int64_t value) {
6114	dims_.Set(index, value);
6115	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.dims)
6116	}
6117	inline void TensorProto::_internal_add_dims(int64_t value) {
6118	dims_.Add(value);
6119	}
6120	inline void TensorProto::add_dims(int64_t value) {
6121	_internal_add_dims(value);
6122	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.dims)
6123	}
6124	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
6125	TensorProto::_internal_dims() const {
6126	return dims_;
6127	}
6128	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
6129	TensorProto::dims() const {
6130	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.dims)
6131	return _internal_dims();
6132	}
6133	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
6134	TensorProto::_internal_mutable_dims() {
6135	return &dims_;
6136	}
6137	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
6138	TensorProto::mutable_dims() {
6139	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.dims)
6140	return _internal_mutable_dims();
6141	}
6142
6143	// optional .opencv_onnx.TensorProto.DataType data_type = 2;
6144	inline bool TensorProto::_internal_has_data_type() const {
6145	bool value = (_has_bits_[0] & 0x00000010u) != 0;
6146	return value;
6147	}
6148	inline bool TensorProto::has_data_type() const {
6149	return _internal_has_data_type();
6150	}
6151	inline void TensorProto::clear_data_type() {
6152	data_type_ = 0;
6153	_has_bits_[0] &= ~0x00000010u;
6154	}
6155	inline ::opencv_onnx::TensorProto_DataType TensorProto::_internal_data_type() const {
6156	return static_cast< ::opencv_onnx::TensorProto_DataType >(data_type_);
6157	}
6158	inline ::opencv_onnx::TensorProto_DataType TensorProto::data_type() const {
6159	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_type)
6160	return _internal_data_type();
6161	}
6162	inline void TensorProto::_internal_set_data_type(::opencv_onnx::TensorProto_DataType value) {
6163	assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
6164	_has_bits_[0] |= 0x00000010u;
6165	data_type_ = value;
6166	}
6167	inline void TensorProto::set_data_type(::opencv_onnx::TensorProto_DataType value) {
6168	_internal_set_data_type(value);
6169	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_type)
6170	}
6171
6172	// optional .opencv_onnx.TensorProto.Segment segment = 3;
6173	inline bool TensorProto::_internal_has_segment() const {
6174	bool value = (_has_bits_[0] & 0x00000008u) != 0;
6175	PROTOBUF_ASSUME(!value || segment_ != nullptr);
6176	return value;
6177	}
6178	inline bool TensorProto::has_segment() const {
6179	return _internal_has_segment();
6180	}
6181	inline void TensorProto::clear_segment() {
6182	if (segment_ != nullptr) segment_->Clear();
6183	_has_bits_[0] &= ~0x00000008u;
6184	}
6185	inline const ::opencv_onnx::TensorProto_Segment& TensorProto::_internal_segment() const {
6186	const ::opencv_onnx::TensorProto_Segment* p = segment_;
6187	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorProto_Segment&>(
6188	::opencv_onnx::_TensorProto_Segment_default_instance_);
6189	}
6190	inline const ::opencv_onnx::TensorProto_Segment& TensorProto::segment() const {
6191	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.segment)
6192	return _internal_segment();
6193	}
6194	inline void TensorProto::unsafe_arena_set_allocated_segment(
6195	::opencv_onnx::TensorProto_Segment* segment) {
6196	if (GetArenaForAllocation() == nullptr) {
6197	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
6198	}
6199	segment_ = segment;
6200	if (segment) {
6201	_has_bits_[0] |= 0x00000008u;
6202	} else {
6203	_has_bits_[0] &= ~0x00000008u;
6204	}
6205	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TensorProto.segment)
6206	}
6207	inline ::opencv_onnx::TensorProto_Segment* TensorProto::release_segment() {
6208	_has_bits_[0] &= ~0x00000008u;
6209	::opencv_onnx::TensorProto_Segment* temp = segment_;
6210	segment_ = nullptr;
6211	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6212	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6213	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6214	if (GetArenaForAllocation() == nullptr) { delete old; }
6215	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
6216	if (GetArenaForAllocation() != nullptr) {
6217	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
6218	}
6219	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
6220	return temp;
6221	}
6222	inline ::opencv_onnx::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
6223	// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.segment)
6224	_has_bits_[0] &= ~0x00000008u;
6225	::opencv_onnx::TensorProto_Segment* temp = segment_;
6226	segment_ = nullptr;
6227	return temp;
6228	}
6229	inline ::opencv_onnx::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
6230	_has_bits_[0] |= 0x00000008u;
6231	if (segment_ == nullptr) {
6232	auto* p = CreateMaybeMessage<::opencv_onnx::TensorProto_Segment>(arena: GetArenaForAllocation());
6233	segment_ = p;
6234	}
6235	return segment_;
6236	}
6237	inline ::opencv_onnx::TensorProto_Segment* TensorProto::mutable_segment() {
6238	::opencv_onnx::TensorProto_Segment* _msg = _internal_mutable_segment();
6239	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.segment)
6240	return _msg;
6241	}
6242	inline void TensorProto::set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment) {
6243	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6244	if (message_arena == nullptr) {
6245	delete segment_;
6246	}
6247	if (segment) {
6248	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6249	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorProto_Segment>::GetOwningArena(p: segment);
6250	if (message_arena != submessage_arena) {
6251	segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6252	message_arena, submessage: segment, submessage_arena);
6253	}
6254	_has_bits_[0] |= 0x00000008u;
6255	} else {
6256	_has_bits_[0] &= ~0x00000008u;
6257	}
6258	segment_ = segment;
6259	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.segment)
6260	}
6261
6262	// repeated float float_data = 4 [packed = true];
6263	inline int TensorProto::_internal_float_data_size() const {
6264	return float_data_.size();
6265	}
6266	inline int TensorProto::float_data_size() const {
6267	return _internal_float_data_size();
6268	}
6269	inline void TensorProto::clear_float_data() {
6270	float_data_.Clear();
6271	}
6272	inline float TensorProto::_internal_float_data(int index) const {
6273	return float_data_.Get(index);
6274	}
6275	inline float TensorProto::float_data(int index) const {
6276	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.float_data)
6277	return _internal_float_data(index);
6278	}
6279	inline void TensorProto::set_float_data(int index, float value) {
6280	float_data_.Set(index, value);
6281	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.float_data)
6282	}
6283	inline void TensorProto::_internal_add_float_data(float value) {
6284	float_data_.Add(value);
6285	}
6286	inline void TensorProto::add_float_data(float value) {
6287	_internal_add_float_data(value);
6288	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.float_data)
6289	}
6290	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
6291	TensorProto::_internal_float_data() const {
6292	return float_data_;
6293	}
6294	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
6295	TensorProto::float_data() const {
6296	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.float_data)
6297	return _internal_float_data();
6298	}
6299	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
6300	TensorProto::_internal_mutable_float_data() {
6301	return &float_data_;
6302	}
6303	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
6304	TensorProto::mutable_float_data() {
6305	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.float_data)
6306	return _internal_mutable_float_data();
6307	}
6308
6309	// repeated int32 int32_data = 5 [packed = true];
6310	inline int TensorProto::_internal_int32_data_size() const {
6311	return int32_data_.size();
6312	}
6313	inline int TensorProto::int32_data_size() const {
6314	return _internal_int32_data_size();
6315	}
6316	inline void TensorProto::clear_int32_data() {
6317	int32_data_.Clear();
6318	}
6319	inline int32_t TensorProto::_internal_int32_data(int index) const {
6320	return int32_data_.Get(index);
6321	}
6322	inline int32_t TensorProto::int32_data(int index) const {
6323	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int32_data)
6324	return _internal_int32_data(index);
6325	}
6326	inline void TensorProto::set_int32_data(int index, int32_t value) {
6327	int32_data_.Set(index, value);
6328	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int32_data)
6329	}
6330	inline void TensorProto::_internal_add_int32_data(int32_t value) {
6331	int32_data_.Add(value);
6332	}
6333	inline void TensorProto::add_int32_data(int32_t value) {
6334	_internal_add_int32_data(value);
6335	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int32_data)
6336	}
6337	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
6338	TensorProto::_internal_int32_data() const {
6339	return int32_data_;
6340	}
6341	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
6342	TensorProto::int32_data() const {
6343	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int32_data)
6344	return _internal_int32_data();
6345	}
6346	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
6347	TensorProto::_internal_mutable_int32_data() {
6348	return &int32_data_;
6349	}
6350	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
6351	TensorProto::mutable_int32_data() {
6352	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int32_data)
6353	return _internal_mutable_int32_data();
6354	}
6355
6356	// repeated bytes string_data = 6;
6357	inline int TensorProto::_internal_string_data_size() const {
6358	return string_data_.size();
6359	}
6360	inline int TensorProto::string_data_size() const {
6361	return _internal_string_data_size();
6362	}
6363	inline void TensorProto::clear_string_data() {
6364	string_data_.Clear();
6365	}
6366	inline std::string* TensorProto::add_string_data() {
6367	std::string* _s = _internal_add_string_data();
6368	// @@protoc_insertion_point(field_add_mutable:opencv_onnx.TensorProto.string_data)
6369	return _s;
6370	}
6371	inline const std::string& TensorProto::_internal_string_data(int index) const {
6372	return string_data_.Get(index);
6373	}
6374	inline const std::string& TensorProto::string_data(int index) const {
6375	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.string_data)
6376	return _internal_string_data(index);
6377	}
6378	inline std::string* TensorProto::mutable_string_data(int index) {
6379	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.string_data)
6380	return string_data_.Mutable(index);
6381	}
6382	inline void TensorProto::set_string_data(int index, const std::string& value) {
6383	string_data_.Mutable(index)->assign(str: value);
6384	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
6385	}
6386	inline void TensorProto::set_string_data(int index, std::string&& value) {
6387	string_data_.Mutable(index)->assign(str: std::move(value));
6388	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
6389	}
6390	inline void TensorProto::set_string_data(int index, const char* value) {
6391	GOOGLE_DCHECK(value != nullptr);
6392	string_data_.Mutable(index)->assign(s: value);
6393	// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.string_data)
6394	}
6395	inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
6396	string_data_.Mutable(index)->assign(
6397	s: reinterpret_cast<const char*>(value), n: size);
6398	// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.string_data)
6399	}
6400	inline std::string* TensorProto::_internal_add_string_data() {
6401	return string_data_.Add();
6402	}
6403	inline void TensorProto::add_string_data(const std::string& value) {
6404	string_data_.Add()->assign(str: value);
6405	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
6406	}
6407	inline void TensorProto::add_string_data(std::string&& value) {
6408	string_data_.Add(value: std::move(value));
6409	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
6410	}
6411	inline void TensorProto::add_string_data(const char* value) {
6412	GOOGLE_DCHECK(value != nullptr);
6413	string_data_.Add()->assign(s: value);
6414	// @@protoc_insertion_point(field_add_char:opencv_onnx.TensorProto.string_data)
6415	}
6416	inline void TensorProto::add_string_data(const void* value, size_t size) {
6417	string_data_.Add()->assign(s: reinterpret_cast<const char*>(value), n: size);
6418	// @@protoc_insertion_point(field_add_pointer:opencv_onnx.TensorProto.string_data)
6419	}
6420	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
6421	TensorProto::string_data() const {
6422	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.string_data)
6423	return string_data_;
6424	}
6425	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
6426	TensorProto::mutable_string_data() {
6427	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.string_data)
6428	return &string_data_;
6429	}
6430
6431	// repeated int64 int64_data = 7 [packed = true];
6432	inline int TensorProto::_internal_int64_data_size() const {
6433	return int64_data_.size();
6434	}
6435	inline int TensorProto::int64_data_size() const {
6436	return _internal_int64_data_size();
6437	}
6438	inline void TensorProto::clear_int64_data() {
6439	int64_data_.Clear();
6440	}
6441	inline int64_t TensorProto::_internal_int64_data(int index) const {
6442	return int64_data_.Get(index);
6443	}
6444	inline int64_t TensorProto::int64_data(int index) const {
6445	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int64_data)
6446	return _internal_int64_data(index);
6447	}
6448	inline void TensorProto::set_int64_data(int index, int64_t value) {
6449	int64_data_.Set(index, value);
6450	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int64_data)
6451	}
6452	inline void TensorProto::_internal_add_int64_data(int64_t value) {
6453	int64_data_.Add(value);
6454	}
6455	inline void TensorProto::add_int64_data(int64_t value) {
6456	_internal_add_int64_data(value);
6457	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int64_data)
6458	}
6459	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
6460	TensorProto::_internal_int64_data() const {
6461	return int64_data_;
6462	}
6463	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
6464	TensorProto::int64_data() const {
6465	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int64_data)
6466	return _internal_int64_data();
6467	}
6468	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
6469	TensorProto::_internal_mutable_int64_data() {
6470	return &int64_data_;
6471	}
6472	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
6473	TensorProto::mutable_int64_data() {
6474	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int64_data)
6475	return _internal_mutable_int64_data();
6476	}
6477
6478	// optional string name = 8;
6479	inline bool TensorProto::_internal_has_name() const {
6480	bool value = (_has_bits_[0] & 0x00000001u) != 0;
6481	return value;
6482	}
6483	inline bool TensorProto::has_name() const {
6484	return _internal_has_name();
6485	}
6486	inline void TensorProto::clear_name() {
6487	name_.ClearToEmpty();
6488	_has_bits_[0] &= ~0x00000001u;
6489	}
6490	inline const std::string& TensorProto::name() const {
6491	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.name)
6492	return _internal_name();
6493	}
6494	template <typename ArgT0, typename... ArgT>
6495	inline PROTOBUF_ALWAYS_INLINE
6496	void TensorProto::set_name(ArgT0&& arg0, ArgT... args) {
6497	_has_bits_[0] |= 0x00000001u;
6498	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6499	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.name)
6500	}
6501	inline std::string* TensorProto::mutable_name() {
6502	std::string* _s = _internal_mutable_name();
6503	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.name)
6504	return _s;
6505	}
6506	inline const std::string& TensorProto::_internal_name() const {
6507	return name_.Get();
6508	}
6509	inline void TensorProto::_internal_set_name(const std::string& value) {
6510	_has_bits_[0] |= 0x00000001u;
6511	name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
6512	}
6513	inline std::string* TensorProto::_internal_mutable_name() {
6514	_has_bits_[0] |= 0x00000001u;
6515	return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6516	}
6517	inline std::string* TensorProto::release_name() {
6518	// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.name)
6519	if (!_internal_has_name()) {
6520	return nullptr;
6521	}
6522	_has_bits_[0] &= ~0x00000001u;
6523	auto* p = name_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
6524	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6525	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6526	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6527	}
6528	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6529	return p;
6530	}
6531	inline void TensorProto::set_allocated_name(std::string* name) {
6532	if (name != nullptr) {
6533	_has_bits_[0] |= 0x00000001u;
6534	} else {
6535	_has_bits_[0] &= ~0x00000001u;
6536	}
6537	name_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: name,
6538	arena: GetArenaForAllocation());
6539	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6540	if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6541	name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6542	}
6543	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6544	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.name)
6545	}
6546
6547	// optional string doc_string = 12;
6548	inline bool TensorProto::_internal_has_doc_string() const {
6549	bool value = (_has_bits_[0] & 0x00000004u) != 0;
6550	return value;
6551	}
6552	inline bool TensorProto::has_doc_string() const {
6553	return _internal_has_doc_string();
6554	}
6555	inline void TensorProto::clear_doc_string() {
6556	doc_string_.ClearToEmpty();
6557	_has_bits_[0] &= ~0x00000004u;
6558	}
6559	inline const std::string& TensorProto::doc_string() const {
6560	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.doc_string)
6561	return _internal_doc_string();
6562	}
6563	template <typename ArgT0, typename... ArgT>
6564	inline PROTOBUF_ALWAYS_INLINE
6565	void TensorProto::set_doc_string(ArgT0&& arg0, ArgT... args) {
6566	_has_bits_[0] |= 0x00000004u;
6567	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6568	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.doc_string)
6569	}
6570	inline std::string* TensorProto::mutable_doc_string() {
6571	std::string* _s = _internal_mutable_doc_string();
6572	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.doc_string)
6573	return _s;
6574	}
6575	inline const std::string& TensorProto::_internal_doc_string() const {
6576	return doc_string_.Get();
6577	}
6578	inline void TensorProto::_internal_set_doc_string(const std::string& value) {
6579	_has_bits_[0] |= 0x00000004u;
6580	doc_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
6581	}
6582	inline std::string* TensorProto::_internal_mutable_doc_string() {
6583	_has_bits_[0] |= 0x00000004u;
6584	return doc_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6585	}
6586	inline std::string* TensorProto::release_doc_string() {
6587	// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.doc_string)
6588	if (!_internal_has_doc_string()) {
6589	return nullptr;
6590	}
6591	_has_bits_[0] &= ~0x00000004u;
6592	auto* p = doc_string_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
6593	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6594	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6595	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6596	}
6597	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6598	return p;
6599	}
6600	inline void TensorProto::set_allocated_doc_string(std::string* doc_string) {
6601	if (doc_string != nullptr) {
6602	_has_bits_[0] |= 0x00000004u;
6603	} else {
6604	_has_bits_[0] &= ~0x00000004u;
6605	}
6606	doc_string_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: doc_string,
6607	arena: GetArenaForAllocation());
6608	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6609	if (doc_string_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6610	doc_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6611	}
6612	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6613	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.doc_string)
6614	}
6615
6616	// optional bytes raw_data = 9;
6617	inline bool TensorProto::_internal_has_raw_data() const {
6618	bool value = (_has_bits_[0] & 0x00000002u) != 0;
6619	return value;
6620	}
6621	inline bool TensorProto::has_raw_data() const {
6622	return _internal_has_raw_data();
6623	}
6624	inline void TensorProto::clear_raw_data() {
6625	raw_data_.ClearToEmpty();
6626	_has_bits_[0] &= ~0x00000002u;
6627	}
6628	inline const std::string& TensorProto::raw_data() const {
6629	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.raw_data)
6630	return _internal_raw_data();
6631	}
6632	template <typename ArgT0, typename... ArgT>
6633	inline PROTOBUF_ALWAYS_INLINE
6634	void TensorProto::set_raw_data(ArgT0&& arg0, ArgT... args) {
6635	_has_bits_[0] |= 0x00000002u;
6636	raw_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6637	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.raw_data)
6638	}
6639	inline std::string* TensorProto::mutable_raw_data() {
6640	std::string* _s = _internal_mutable_raw_data();
6641	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.raw_data)
6642	return _s;
6643	}
6644	inline const std::string& TensorProto::_internal_raw_data() const {
6645	return raw_data_.Get();
6646	}
6647	inline void TensorProto::_internal_set_raw_data(const std::string& value) {
6648	_has_bits_[0] |= 0x00000002u;
6649	raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
6650	}
6651	inline std::string* TensorProto::_internal_mutable_raw_data() {
6652	_has_bits_[0] |= 0x00000002u;
6653	return raw_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6654	}
6655	inline std::string* TensorProto::release_raw_data() {
6656	// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.raw_data)
6657	if (!_internal_has_raw_data()) {
6658	return nullptr;
6659	}
6660	_has_bits_[0] &= ~0x00000002u;
6661	auto* p = raw_data_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
6662	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6663	if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6664	raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6665	}
6666	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6667	return p;
6668	}
6669	inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
6670	if (raw_data != nullptr) {
6671	_has_bits_[0] |= 0x00000002u;
6672	} else {
6673	_has_bits_[0] &= ~0x00000002u;
6674	}
6675	raw_data_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: raw_data,
6676	arena: GetArenaForAllocation());
6677	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6678	if (raw_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6679	raw_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6680	}
6681	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6682	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.raw_data)
6683	}
6684
6685	// repeated double double_data = 10 [packed = true];
6686	inline int TensorProto::_internal_double_data_size() const {
6687	return double_data_.size();
6688	}
6689	inline int TensorProto::double_data_size() const {
6690	return _internal_double_data_size();
6691	}
6692	inline void TensorProto::clear_double_data() {
6693	double_data_.Clear();
6694	}
6695	inline double TensorProto::_internal_double_data(int index) const {
6696	return double_data_.Get(index);
6697	}
6698	inline double TensorProto::double_data(int index) const {
6699	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.double_data)
6700	return _internal_double_data(index);
6701	}
6702	inline void TensorProto::set_double_data(int index, double value) {
6703	double_data_.Set(index, value);
6704	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.double_data)
6705	}
6706	inline void TensorProto::_internal_add_double_data(double value) {
6707	double_data_.Add(value);
6708	}
6709	inline void TensorProto::add_double_data(double value) {
6710	_internal_add_double_data(value);
6711	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.double_data)
6712	}
6713	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
6714	TensorProto::_internal_double_data() const {
6715	return double_data_;
6716	}
6717	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
6718	TensorProto::double_data() const {
6719	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.double_data)
6720	return _internal_double_data();
6721	}
6722	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
6723	TensorProto::_internal_mutable_double_data() {
6724	return &double_data_;
6725	}
6726	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
6727	TensorProto::mutable_double_data() {
6728	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.double_data)
6729	return _internal_mutable_double_data();
6730	}
6731
6732	// repeated uint64 uint64_data = 11 [packed = true];
6733	inline int TensorProto::_internal_uint64_data_size() const {
6734	return uint64_data_.size();
6735	}
6736	inline int TensorProto::uint64_data_size() const {
6737	return _internal_uint64_data_size();
6738	}
6739	inline void TensorProto::clear_uint64_data() {
6740	uint64_data_.Clear();
6741	}
6742	inline uint64_t TensorProto::_internal_uint64_data(int index) const {
6743	return uint64_data_.Get(index);
6744	}
6745	inline uint64_t TensorProto::uint64_data(int index) const {
6746	// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.uint64_data)
6747	return _internal_uint64_data(index);
6748	}
6749	inline void TensorProto::set_uint64_data(int index, uint64_t value) {
6750	uint64_data_.Set(index, value);
6751	// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.uint64_data)
6752	}
6753	inline void TensorProto::_internal_add_uint64_data(uint64_t value) {
6754	uint64_data_.Add(value);
6755	}
6756	inline void TensorProto::add_uint64_data(uint64_t value) {
6757	_internal_add_uint64_data(value);
6758	// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.uint64_data)
6759	}
6760	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
6761	TensorProto::_internal_uint64_data() const {
6762	return uint64_data_;
6763	}
6764	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
6765	TensorProto::uint64_data() const {
6766	// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.uint64_data)
6767	return _internal_uint64_data();
6768	}
6769	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
6770	TensorProto::_internal_mutable_uint64_data() {
6771	return &uint64_data_;
6772	}
6773	inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
6774	TensorProto::mutable_uint64_data() {
6775	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.uint64_data)
6776	return _internal_mutable_uint64_data();
6777	}
6778
6779	// -------------------------------------------------------------------
6780
6781	// TensorShapeProto_Dimension
6782
6783	// int64 dim_value = 1;
6784	inline bool TensorShapeProto_Dimension::_internal_has_dim_value() const {
6785	return value_case() == kDimValue;
6786	}
6787	inline bool TensorShapeProto_Dimension::has_dim_value() const {
6788	return _internal_has_dim_value();
6789	}
6790	inline void TensorShapeProto_Dimension::set_has_dim_value() {
6791	_oneof_case_[0] = kDimValue;
6792	}
6793	inline void TensorShapeProto_Dimension::clear_dim_value() {
6794	if (_internal_has_dim_value()) {
6795	value_.dim_value_ = int64_t{0};
6796	clear_has_value();
6797	}
6798	}
6799	inline int64_t TensorShapeProto_Dimension::_internal_dim_value() const {
6800	if (_internal_has_dim_value()) {
6801	return value_.dim_value_;
6802	}
6803	return int64_t{0};
6804	}
6805	inline void TensorShapeProto_Dimension::_internal_set_dim_value(int64_t value) {
6806	if (!_internal_has_dim_value()) {
6807	clear_value();
6808	set_has_dim_value();
6809	}
6810	value_.dim_value_ = value;
6811	}
6812	inline int64_t TensorShapeProto_Dimension::dim_value() const {
6813	// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_value)
6814	return _internal_dim_value();
6815	}
6816	inline void TensorShapeProto_Dimension::set_dim_value(int64_t value) {
6817	_internal_set_dim_value(value);
6818	// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_value)
6819	}
6820
6821	// string dim_param = 2;
6822	inline bool TensorShapeProto_Dimension::_internal_has_dim_param() const {
6823	return value_case() == kDimParam;
6824	}
6825	inline bool TensorShapeProto_Dimension::has_dim_param() const {
6826	return _internal_has_dim_param();
6827	}
6828	inline void TensorShapeProto_Dimension::set_has_dim_param() {
6829	_oneof_case_[0] = kDimParam;
6830	}
6831	inline void TensorShapeProto_Dimension::clear_dim_param() {
6832	if (_internal_has_dim_param()) {
6833	value_.dim_param_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6834	clear_has_value();
6835	}
6836	}
6837	inline const std::string& TensorShapeProto_Dimension::dim_param() const {
6838	// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_param)
6839	return _internal_dim_param();
6840	}
6841	template <typename ArgT0, typename... ArgT>
6842	inline void TensorShapeProto_Dimension::set_dim_param(ArgT0&& arg0, ArgT... args) {
6843	if (!_internal_has_dim_param()) {
6844	clear_value();
6845	set_has_dim_param();
6846	value_.dim_param_.UnsafeSetDefault(value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6847	}
6848	value_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6849	// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
6850	}
6851	inline std::string* TensorShapeProto_Dimension::mutable_dim_param() {
6852	std::string* _s = _internal_mutable_dim_param();
6853	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.dim_param)
6854	return _s;
6855	}
6856	inline const std::string& TensorShapeProto_Dimension::_internal_dim_param() const {
6857	if (_internal_has_dim_param()) {
6858	return value_.dim_param_.Get();
6859	}
6860	return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
6861	}
6862	inline void TensorShapeProto_Dimension::_internal_set_dim_param(const std::string& value) {
6863	if (!_internal_has_dim_param()) {
6864	clear_value();
6865	set_has_dim_param();
6866	value_.dim_param_.UnsafeSetDefault(value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6867	}
6868	value_.dim_param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
6869	}
6870	inline std::string* TensorShapeProto_Dimension::_internal_mutable_dim_param() {
6871	if (!_internal_has_dim_param()) {
6872	clear_value();
6873	set_has_dim_param();
6874	value_.dim_param_.UnsafeSetDefault(value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6875	}
6876	return value_.dim_param_.Mutable(
6877	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6878	}
6879	inline std::string* TensorShapeProto_Dimension::release_dim_param() {
6880	// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.dim_param)
6881	if (_internal_has_dim_param()) {
6882	clear_has_value();
6883	return value_.dim_param_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
6884	} else {
6885	return nullptr;
6886	}
6887	}
6888	inline void TensorShapeProto_Dimension::set_allocated_dim_param(std::string* dim_param) {
6889	if (has_value()) {
6890	clear_value();
6891	}
6892	if (dim_param != nullptr) {
6893	set_has_dim_param();
6894	value_.dim_param_.UnsafeSetDefault(value: dim_param);
6895	::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
6896	if (arena != nullptr) {
6897	arena->Own(object: dim_param);
6898	}
6899	}
6900	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.dim_param)
6901	}
6902
6903	// optional string denotation = 3;
6904	inline bool TensorShapeProto_Dimension::_internal_has_denotation() const {
6905	bool value = (_has_bits_[0] & 0x00000001u) != 0;
6906	return value;
6907	}
6908	inline bool TensorShapeProto_Dimension::has_denotation() const {
6909	return _internal_has_denotation();
6910	}
6911	inline void TensorShapeProto_Dimension::clear_denotation() {
6912	denotation_.ClearToEmpty();
6913	_has_bits_[0] &= ~0x00000001u;
6914	}
6915	inline const std::string& TensorShapeProto_Dimension::denotation() const {
6916	// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.denotation)
6917	return _internal_denotation();
6918	}
6919	template <typename ArgT0, typename... ArgT>
6920	inline PROTOBUF_ALWAYS_INLINE
6921	void TensorShapeProto_Dimension::set_denotation(ArgT0&& arg0, ArgT... args) {
6922	_has_bits_[0] |= 0x00000001u;
6923	denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6924	// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.denotation)
6925	}
6926	inline std::string* TensorShapeProto_Dimension::mutable_denotation() {
6927	std::string* _s = _internal_mutable_denotation();
6928	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.denotation)
6929	return _s;
6930	}
6931	inline const std::string& TensorShapeProto_Dimension::_internal_denotation() const {
6932	return denotation_.Get();
6933	}
6934	inline void TensorShapeProto_Dimension::_internal_set_denotation(const std::string& value) {
6935	_has_bits_[0] |= 0x00000001u;
6936	denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
6937	}
6938	inline std::string* TensorShapeProto_Dimension::_internal_mutable_denotation() {
6939	_has_bits_[0] |= 0x00000001u;
6940	return denotation_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
6941	}
6942	inline std::string* TensorShapeProto_Dimension::release_denotation() {
6943	// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.denotation)
6944	if (!_internal_has_denotation()) {
6945	return nullptr;
6946	}
6947	_has_bits_[0] &= ~0x00000001u;
6948	auto* p = denotation_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
6949	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6950	if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6951	denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6952	}
6953	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6954	return p;
6955	}
6956	inline void TensorShapeProto_Dimension::set_allocated_denotation(std::string* denotation) {
6957	if (denotation != nullptr) {
6958	_has_bits_[0] |= 0x00000001u;
6959	} else {
6960	_has_bits_[0] &= ~0x00000001u;
6961	}
6962	denotation_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: denotation,
6963	arena: GetArenaForAllocation());
6964	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6965	if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
6966	denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
6967	}
6968	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6969	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.denotation)
6970	}
6971
6972	inline bool TensorShapeProto_Dimension::has_value() const {
6973	return value_case() != VALUE_NOT_SET;
6974	}
6975	inline void TensorShapeProto_Dimension::clear_has_value() {
6976	_oneof_case_[0] = VALUE_NOT_SET;
6977	}
6978	inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
6979	return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
6980	}
6981	// -------------------------------------------------------------------
6982
6983	// TensorShapeProto
6984
6985	// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
6986	inline int TensorShapeProto::_internal_dim_size() const {
6987	return dim_.size();
6988	}
6989	inline int TensorShapeProto::dim_size() const {
6990	return _internal_dim_size();
6991	}
6992	inline void TensorShapeProto::clear_dim() {
6993	dim_.Clear();
6994	}
6995	inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
6996	// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.dim)
6997	return dim_.Mutable(index);
6998	}
6999	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
7000	TensorShapeProto::mutable_dim() {
7001	// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorShapeProto.dim)
7002	return &dim_;
7003	}
7004	inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::_internal_dim(int index) const {
7005	return dim_.Get(index);
7006	}
7007	inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
7008	// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.dim)
7009	return _internal_dim(index);
7010	}
7011	inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::_internal_add_dim() {
7012	return dim_.Add();
7013	}
7014	inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
7015	::opencv_onnx::TensorShapeProto_Dimension* _add = _internal_add_dim();
7016	// @@protoc_insertion_point(field_add:opencv_onnx.TensorShapeProto.dim)
7017	return _add;
7018	}
7019	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
7020	TensorShapeProto::dim() const {
7021	// @@protoc_insertion_point(field_list:opencv_onnx.TensorShapeProto.dim)
7022	return dim_;
7023	}
7024
7025	// -------------------------------------------------------------------
7026
7027	// TypeProto_Tensor
7028
7029	// optional .opencv_onnx.TensorProto.DataType elem_type = 1;
7030	inline bool TypeProto_Tensor::_internal_has_elem_type() const {
7031	bool value = (_has_bits_[0] & 0x00000002u) != 0;
7032	return value;
7033	}
7034	inline bool TypeProto_Tensor::has_elem_type() const {
7035	return _internal_has_elem_type();
7036	}
7037	inline void TypeProto_Tensor::clear_elem_type() {
7038	elem_type_ = 0;
7039	_has_bits_[0] &= ~0x00000002u;
7040	}
7041	inline ::opencv_onnx::TensorProto_DataType TypeProto_Tensor::_internal_elem_type() const {
7042	return static_cast< ::opencv_onnx::TensorProto_DataType >(elem_type_);
7043	}
7044	inline ::opencv_onnx::TensorProto_DataType TypeProto_Tensor::elem_type() const {
7045	// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.elem_type)
7046	return _internal_elem_type();
7047	}
7048	inline void TypeProto_Tensor::_internal_set_elem_type(::opencv_onnx::TensorProto_DataType value) {
7049	assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
7050	_has_bits_[0] |= 0x00000002u;
7051	elem_type_ = value;
7052	}
7053	inline void TypeProto_Tensor::set_elem_type(::opencv_onnx::TensorProto_DataType value) {
7054	_internal_set_elem_type(value);
7055	// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Tensor.elem_type)
7056	}
7057
7058	// optional .opencv_onnx.TensorShapeProto shape = 2;
7059	inline bool TypeProto_Tensor::_internal_has_shape() const {
7060	bool value = (_has_bits_[0] & 0x00000001u) != 0;
7061	PROTOBUF_ASSUME(!value || shape_ != nullptr);
7062	return value;
7063	}
7064	inline bool TypeProto_Tensor::has_shape() const {
7065	return _internal_has_shape();
7066	}
7067	inline void TypeProto_Tensor::clear_shape() {
7068	if (shape_ != nullptr) shape_->Clear();
7069	_has_bits_[0] &= ~0x00000001u;
7070	}
7071	inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::_internal_shape() const {
7072	const ::opencv_onnx::TensorShapeProto* p = shape_;
7073	return p != nullptr ? *p : reinterpret_cast<const ::opencv_onnx::TensorShapeProto&>(
7074	::opencv_onnx::_TensorShapeProto_default_instance_);
7075	}
7076	inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
7077	// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.shape)
7078	return _internal_shape();
7079	}
7080	inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape(
7081	::opencv_onnx::TensorShapeProto* shape) {
7082	if (GetArenaForAllocation() == nullptr) {
7083	delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
7084	}
7085	shape_ = shape;
7086	if (shape) {
7087	_has_bits_[0] |= 0x00000001u;
7088	} else {
7089	_has_bits_[0] &= ~0x00000001u;
7090	}
7091	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
7092	}
7093	inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
7094	_has_bits_[0] &= ~0x00000001u;
7095	::opencv_onnx::TensorShapeProto* temp = shape_;
7096	shape_ = nullptr;
7097	#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7098	auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
7099	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7100	if (GetArenaForAllocation() == nullptr) { delete old; }
7101	#else // PROTOBUF_FORCE_COPY_IN_RELEASE
7102	if (GetArenaForAllocation() != nullptr) {
7103	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
7104	}
7105	#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
7106	return temp;
7107	}
7108	inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::unsafe_arena_release_shape() {
7109	// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Tensor.shape)
7110	_has_bits_[0] &= ~0x00000001u;
7111	::opencv_onnx::TensorShapeProto* temp = shape_;
7112	shape_ = nullptr;
7113	return temp;
7114	}
7115	inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::_internal_mutable_shape() {
7116	_has_bits_[0] |= 0x00000001u;
7117	if (shape_ == nullptr) {
7118	auto* p = CreateMaybeMessage<::opencv_onnx::TensorShapeProto>(arena: GetArenaForAllocation());
7119	shape_ = p;
7120	}
7121	return shape_;
7122	}
7123	inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
7124	::opencv_onnx::TensorShapeProto* _msg = _internal_mutable_shape();
7125	// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Tensor.shape)
7126	return _msg;
7127	}
7128	inline void TypeProto_Tensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
7129	::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
7130	if (message_arena == nullptr) {
7131	delete shape_;
7132	}
7133	if (shape) {
7134	::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7135	::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::opencv_onnx::TensorShapeProto>::GetOwningArena(p: shape);
7136	if (message_arena != submessage_arena) {
7137	shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7138	message_arena, submessage: shape, submessage_arena);
7139	}
7140	_has_bits_[0] |= 0x00000001u;
7141	} else {
7142	_has_bits_[0] &= ~0x00000001u;
7143	}
7144	shape_ = shape;
7145	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
7146	}
7147
7148	// -------------------------------------------------------------------
7149
7150	// TypeProto
7151
7152	// .opencv_onnx.TypeProto.Tensor tensor_type = 1;
7153	inline bool TypeProto::_internal_has_tensor_type() const {
7154	return value_case() == kTensorType;
7155	}
7156	inline bool TypeProto::has_tensor_type() const {
7157	return _internal_has_tensor_type();
7158	}
7159	inline void TypeProto::set_has_tensor_type() {
7160	_oneof_case_[0] = kTensorType;
7161	}
7162	inline void TypeProto::clear_tensor_type() {
7163	if (_internal_has_tensor_type()) {
7164	if (GetArenaForAllocation() == nullptr) {
7165	delete value_.tensor_type_;
7166	}
7167	clear_has_value();
7168	}
7169	}
7170	inline ::opencv_onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
7171	// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.tensor_type)
7172	if (_internal_has_tensor_type()) {
7173	clear_has_value();
7174	::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
7175	if (GetArenaForAllocation() != nullptr) {
7176	temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(message: temp);
7177	}
7178	value_.tensor_type_ = nullptr;
7179	return temp;
7180	} else {
7181	return nullptr;
7182	}
7183	}
7184	inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::_internal_tensor_type() const {
7185	return _internal_has_tensor_type()
7186	? *value_.tensor_type_
7187	: reinterpret_cast< ::opencv_onnx::TypeProto_Tensor&>(::opencv_onnx::_TypeProto_Tensor_default_instance_);
7188	}
7189	inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
7190	// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.tensor_type)
7191	return _internal_tensor_type();
7192	}
7193	inline ::opencv_onnx::TypeProto_Tensor* TypeProto::unsafe_arena_release_tensor_type() {
7194	// @@protoc_insertion_point(field_unsafe_arena_release:opencv_onnx.TypeProto.tensor_type)
7195	if (_internal_has_tensor_type()) {
7196	clear_has_value();
7197	::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
7198	value_.tensor_type_ = nullptr;
7199	return temp;
7200	} else {
7201	return nullptr;
7202	}
7203	}
7204	inline void TypeProto::unsafe_arena_set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type) {
7205	clear_value();
7206	if (tensor_type) {
7207	set_has_tensor_type();
7208	value_.tensor_type_ = tensor_type;
7209	}
7210	// @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_onnx.TypeProto.tensor_type)
7211	}
7212	inline ::opencv_onnx::TypeProto_Tensor* TypeProto::_internal_mutable_tensor_type() {
7213	if (!_internal_has_tensor_type()) {
7214	clear_value();
7215	set_has_tensor_type();
7216	value_.tensor_type_ = CreateMaybeMessage< ::opencv_onnx::TypeProto_Tensor >(arena: GetArenaForAllocation());
7217	}
7218	return value_.tensor_type_;
7219	}
7220	inline ::opencv_onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
7221	::opencv_onnx::TypeProto_Tensor* _msg = _internal_mutable_tensor_type();
7222	// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.tensor_type)
7223	return _msg;
7224	}
7225
7226	// optional string denotation = 6;
7227	inline bool TypeProto::_internal_has_denotation() const {
7228	bool value = (_has_bits_[0] & 0x00000001u) != 0;
7229	return value;
7230	}
7231	inline bool TypeProto::has_denotation() const {
7232	return _internal_has_denotation();
7233	}
7234	inline void TypeProto::clear_denotation() {
7235	denotation_.ClearToEmpty();
7236	_has_bits_[0] &= ~0x00000001u;
7237	}
7238	inline const std::string& TypeProto::denotation() const {
7239	// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.denotation)
7240	return _internal_denotation();
7241	}
7242	template <typename ArgT0, typename... ArgT>
7243	inline PROTOBUF_ALWAYS_INLINE
7244	void TypeProto::set_denotation(ArgT0&& arg0, ArgT... args) {
7245	_has_bits_[0] |= 0x00000001u;
7246	denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7247	// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.denotation)
7248	}
7249	inline std::string* TypeProto::mutable_denotation() {
7250	std::string* _s = _internal_mutable_denotation();
7251	// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.denotation)
7252	return _s;
7253	}
7254	inline const std::string& TypeProto::_internal_denotation() const {
7255	return denotation_.Get();
7256	}
7257	inline void TypeProto::_internal_set_denotation(const std::string& value) {
7258	_has_bits_[0] |= 0x00000001u;
7259	denotation_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
7260	}
7261	inline std::string* TypeProto::_internal_mutable_denotation() {
7262	_has_bits_[0] |= 0x00000001u;
7263	return denotation_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
7264	}
7265	inline std::string* TypeProto::release_denotation() {
7266	// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.denotation)
7267	if (!_internal_has_denotation()) {
7268	return nullptr;
7269	}
7270	_has_bits_[0] &= ~0x00000001u;
7271	auto* p = denotation_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
7272	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7273	if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
7274	denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
7275	}
7276	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7277	return p;
7278	}
7279	inline void TypeProto::set_allocated_denotation(std::string* denotation) {
7280	if (denotation != nullptr) {
7281	_has_bits_[0] |= 0x00000001u;
7282	} else {
7283	_has_bits_[0] &= ~0x00000001u;
7284	}
7285	denotation_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: denotation,
7286	arena: GetArenaForAllocation());
7287	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7288	if (denotation_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
7289	denotation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
7290	}
7291	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7292	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.denotation)
7293	}
7294
7295	inline bool TypeProto::has_value() const {
7296	return value_case() != VALUE_NOT_SET;
7297	}
7298	inline void TypeProto::clear_has_value() {
7299	_oneof_case_[0] = VALUE_NOT_SET;
7300	}
7301	inline TypeProto::ValueCase TypeProto::value_case() const {
7302	return TypeProto::ValueCase(_oneof_case_[0]);
7303	}
7304	// -------------------------------------------------------------------
7305
7306	// OperatorSetIdProto
7307
7308	// optional string domain = 1;
7309	inline bool OperatorSetIdProto::_internal_has_domain() const {
7310	bool value = (_has_bits_[0] & 0x00000001u) != 0;
7311	return value;
7312	}
7313	inline bool OperatorSetIdProto::has_domain() const {
7314	return _internal_has_domain();
7315	}
7316	inline void OperatorSetIdProto::clear_domain() {
7317	domain_.ClearToEmpty();
7318	_has_bits_[0] &= ~0x00000001u;
7319	}
7320	inline const std::string& OperatorSetIdProto::domain() const {
7321	// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.domain)
7322	return _internal_domain();
7323	}
7324	template <typename ArgT0, typename... ArgT>
7325	inline PROTOBUF_ALWAYS_INLINE
7326	void OperatorSetIdProto::set_domain(ArgT0&& arg0, ArgT... args) {
7327	_has_bits_[0] |= 0x00000001u;
7328	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7329	// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.domain)
7330	}
7331	inline std::string* OperatorSetIdProto::mutable_domain() {
7332	std::string* _s = _internal_mutable_domain();
7333	// @@protoc_insertion_point(field_mutable:opencv_onnx.OperatorSetIdProto.domain)
7334	return _s;
7335	}
7336	inline const std::string& OperatorSetIdProto::_internal_domain() const {
7337	return domain_.Get();
7338	}
7339	inline void OperatorSetIdProto::_internal_set_domain(const std::string& value) {
7340	_has_bits_[0] |= 0x00000001u;
7341	domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, arena: GetArenaForAllocation());
7342	}
7343	inline std::string* OperatorSetIdProto::_internal_mutable_domain() {
7344	_has_bits_[0] |= 0x00000001u;
7345	return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, arena: GetArenaForAllocation());
7346	}
7347	inline std::string* OperatorSetIdProto::release_domain() {
7348	// @@protoc_insertion_point(field_release:opencv_onnx.OperatorSetIdProto.domain)
7349	if (!_internal_has_domain()) {
7350	return nullptr;
7351	}
7352	_has_bits_[0] &= ~0x00000001u;
7353	auto* p = domain_.ReleaseNonDefault(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), arena: GetArenaForAllocation());
7354	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7355	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
7356	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
7357	}
7358	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7359	return p;
7360	}
7361	inline void OperatorSetIdProto::set_allocated_domain(std::string* domain) {
7362	if (domain != nullptr) {
7363	_has_bits_[0] |= 0x00000001u;
7364	} else {
7365	_has_bits_[0] &= ~0x00000001u;
7366	}
7367	domain_.SetAllocated(default_value: &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value: domain,
7368	arena: GetArenaForAllocation());
7369	#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7370	if (domain_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
7371	domain_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
7372	}
7373	#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7374	// @@protoc_insertion_point(field_set_allocated:opencv_onnx.OperatorSetIdProto.domain)
7375	}
7376
7377	// optional int64 version = 2;
7378	inline bool OperatorSetIdProto::_internal_has_version() const {
7379	bool value = (_has_bits_[0] & 0x00000002u) != 0;
7380	return value;
7381	}
7382	inline bool OperatorSetIdProto::has_version() const {
7383	return _internal_has_version();
7384	}
7385	inline void OperatorSetIdProto::clear_version() {
7386	version_ = int64_t{0};
7387	_has_bits_[0] &= ~0x00000002u;
7388	}
7389	inline int64_t OperatorSetIdProto::_internal_version() const {
7390	return version_;
7391	}
7392	inline int64_t OperatorSetIdProto::version() const {
7393	// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.version)
7394	return _internal_version();
7395	}
7396	inline void OperatorSetIdProto::_internal_set_version(int64_t value) {
7397	_has_bits_[0] |= 0x00000002u;
7398	version_ = value;
7399	}
7400	inline void OperatorSetIdProto::set_version(int64_t value) {
7401	_internal_set_version(value);
7402	// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.version)
7403	}
7404
7405	#ifdef __GNUC__
7406	#pragma GCC diagnostic pop
7407	#endif // __GNUC__
7408	// -------------------------------------------------------------------
7409
7410	// -------------------------------------------------------------------
7411
7412	// -------------------------------------------------------------------
7413
7414	// -------------------------------------------------------------------
7415
7416	// -------------------------------------------------------------------
7417
7418	// -------------------------------------------------------------------
7419
7420	// -------------------------------------------------------------------
7421
7422	// -------------------------------------------------------------------
7423
7424	// -------------------------------------------------------------------
7425
7426	// -------------------------------------------------------------------
7427
7428	// -------------------------------------------------------------------
7429
7430	// -------------------------------------------------------------------
7431
7432
7433	// @@protoc_insertion_point(namespace_scope)
7434
7435	} // namespace opencv_onnx
7436
7437	PROTOBUF_NAMESPACE_OPEN
7438
7439	template <> struct is_proto_enum< ::opencv_onnx::AttributeProto_AttributeType> : ::std::true_type {};
7440	template <>
7441	inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::AttributeProto_AttributeType>() {
7442	return ::opencv_onnx::AttributeProto_AttributeType_descriptor();
7443	}
7444	template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataType> : ::std::true_type {};
7445	template <>
7446	inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::TensorProto_DataType>() {
7447	return ::opencv_onnx::TensorProto_DataType_descriptor();
7448	}
7449	template <> struct is_proto_enum< ::opencv_onnx::Version> : ::std::true_type {};
7450	template <>
7451	inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::Version>() {
7452	return ::opencv_onnx::Version_descriptor();
7453	}
7454
7455	PROTOBUF_NAMESPACE_CLOSE
7456
7457	// @@protoc_insertion_point(global_scope)
7458
7459	#include <google/protobuf/port_undef.inc>
7460	#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_opencv_2donnx_2eproto
7461