File calculator_graph_template.pb.cc

File List > framework > tool > calculator_graph_template.pb.cc

Go to the documentation of this file

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mediapipe/framework/tool/calculator_graph_template.proto

#include "mediapipe/framework/tool/calculator_graph_template.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace mediapipe {
constexpr TemplateExpression::TemplateExpression(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arg_()
  , key_type_()
  , param_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , op_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , field_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , field_type_(0)
{}
struct TemplateExpressionDefaultTypeInternal {
  constexpr TemplateExpressionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TemplateExpressionDefaultTypeInternal() {}
  union {
    TemplateExpression _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TemplateExpressionDefaultTypeInternal _TemplateExpression_default_instance_;
constexpr CalculatorGraphTemplate::CalculatorGraphTemplate(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : rule_()
  , config_(nullptr){}
struct CalculatorGraphTemplateDefaultTypeInternal {
  constexpr CalculatorGraphTemplateDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CalculatorGraphTemplateDefaultTypeInternal() {}
  union {
    CalculatorGraphTemplate _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CalculatorGraphTemplateDefaultTypeInternal _CalculatorGraphTemplate_default_instance_;
constexpr TemplateArgument::TemplateArgument(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : element_()
  , _oneof_case_{}{}
struct TemplateArgumentDefaultTypeInternal {
  constexpr TemplateArgumentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TemplateArgumentDefaultTypeInternal() {}
  union {
    TemplateArgument _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TemplateArgumentDefaultTypeInternal _TemplateArgument_default_instance_;
constexpr TemplateDict_Parameter::TemplateDict_Parameter(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , value_(nullptr){}
struct TemplateDict_ParameterDefaultTypeInternal {
  constexpr TemplateDict_ParameterDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TemplateDict_ParameterDefaultTypeInternal() {}
  union {
    TemplateDict_Parameter _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TemplateDict_ParameterDefaultTypeInternal _TemplateDict_Parameter_default_instance_;
constexpr TemplateDict::TemplateDict(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : arg_(){}
struct TemplateDictDefaultTypeInternal {
  constexpr TemplateDictDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TemplateDictDefaultTypeInternal() {}
  union {
    TemplateDict _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TemplateDictDefaultTypeInternal _TemplateDict_default_instance_;
constexpr TemplateSubgraphOptions::TemplateSubgraphOptions(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : dict_(nullptr){}
struct TemplateSubgraphOptionsDefaultTypeInternal {
  constexpr TemplateSubgraphOptionsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TemplateSubgraphOptionsDefaultTypeInternal() {}
  union {
    TemplateSubgraphOptions _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TemplateSubgraphOptionsDefaultTypeInternal _TemplateSubgraphOptions_default_instance_;
}  // namespace mediapipe
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[6];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto = nullptr;

const uint32_t TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, param_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, op_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, arg_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, path_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, field_type_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, key_type_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateExpression, field_value_),
  0,
  1,
  ~0u,
  2,
  4,
  ~0u,
  3,
  PROTOBUF_FIELD_OFFSET(::mediapipe::CalculatorGraphTemplate, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::CalculatorGraphTemplate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::CalculatorGraphTemplate, config_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::CalculatorGraphTemplate, rule_),
  0,
  ~0u,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateArgument, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateArgument, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateArgument, element_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateArgument, param_value_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict_Parameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict_Parameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict_Parameter, key_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict_Parameter, value_),
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateDict, arg_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateSubgraphOptions, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateSubgraphOptions, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::mediapipe::TemplateSubgraphOptions, dict_),
  0,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 13, -1, sizeof(::mediapipe::TemplateExpression)},
  { 20, 28, -1, sizeof(::mediapipe::CalculatorGraphTemplate)},
  { 30, -1, -1, sizeof(::mediapipe::TemplateArgument)},
  { 41, 49, -1, sizeof(::mediapipe::TemplateDict_Parameter)},
  { 51, -1, -1, sizeof(::mediapipe::TemplateDict)},
  { 58, 65, -1, sizeof(::mediapipe::TemplateSubgraphOptions)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_TemplateExpression_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_CalculatorGraphTemplate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_TemplateArgument_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_TemplateDict_Parameter_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_TemplateDict_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_TemplateSubgraphOptions_default_instance_),
};

const char descriptor_table_protodef_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n8mediapipe/framework/tool/calculator_gr"
  "aph_template.proto\022\tmediapipe\032$mediapipe"
  "/framework/calculator.proto\032,mediapipe/f"
  "ramework/calculator_options.proto\032/media"
  "pipe/framework/deps/proto_descriptor.pro"
  "to\"\360\001\n\022TemplateExpression\022\r\n\005param\030\001 \001(\t"
  "\022\n\n\002op\030\002 \001(\t\022*\n\003arg\030\003 \003(\0132\035.mediapipe.Te"
  "mplateExpression\022\014\n\004path\030\004 \001(\t\0228\n\nfield_"
  "type\030\005 \001(\0162$.mediapipe.FieldDescriptorPr"
  "oto.Type\0226\n\010key_type\030\006 \003(\0162$.mediapipe.F"
  "ieldDescriptorProto.Type\022\023\n\013field_value\030"
  "\007 \001(\t\"x\n\027CalculatorGraphTemplate\0220\n\006conf"
  "ig\030\001 \001(\0132 .mediapipe.CalculatorGraphConf"
  "ig\022+\n\004rule\030\002 \003(\0132\035.mediapipe.TemplateExp"
  "ression\"\226\001\n\020TemplateArgument\022\r\n\003str\030\001 \001("
  "\tH\000\022\r\n\003num\030\002 \001(\001H\000\022\'\n\004dict\030\003 \001(\0132\027.media"
  "pipe.TemplateDictH\000\022,\n\007element\030\004 \003(\0132\033.m"
  "ediapipe.TemplateArgumentB\r\n\013param_value"
  "\"\204\001\n\014TemplateDict\022.\n\003arg\030\001 \003(\0132!.mediapi"
  "pe.TemplateDict.Parameter\032D\n\tParameter\022\013"
  "\n\003key\030\001 \001(\t\022*\n\005value\030\002 \001(\0132\033.mediapipe.T"
  "emplateArgument\"\222\001\n\027TemplateSubgraphOpti"
  "ons\022%\n\004dict\030\001 \001(\0132\027.mediapipe.TemplateDi"
  "ct2P\n\003ext\022\034.mediapipe.CalculatorOptions\030"
  "\365\374\276R \001(\0132\".mediapipe.TemplateSubgraphOpt"
  "ionsB0\n\032com.google.mediapipe.protoB\022Grap"
  "hTemplateProto"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_deps[3] = {
  &::descriptor_table_mediapipe_2fframework_2fcalculator_2eproto,
  &::descriptor_table_mediapipe_2fframework_2fcalculator_5foptions_2eproto,
  &::descriptor_table_mediapipe_2fframework_2fdeps_2fproto_5fdescriptor_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto = {
  false, false, 1054, descriptor_table_protodef_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto, "mediapipe/framework/tool/calculator_graph_template.proto", 
  &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once, descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_deps, 3, 6,
  schemas, file_default_instances, TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto::offsets,
  file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto, file_level_enum_descriptors_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto, file_level_service_descriptors_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter() {
  return &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto(&descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto);
namespace mediapipe {

// ===================================================================

class TemplateExpression::_Internal {
 public:
  using HasBits = decltype(std::declval<TemplateExpression>()._has_bits_);
  static void set_has_param(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_op(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_path(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_field_type(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_field_value(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

TemplateExpression::TemplateExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arg_(arena),
  key_type_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.TemplateExpression)
}
TemplateExpression::TemplateExpression(const TemplateExpression& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      arg_(from.arg_),
      key_type_(from.key_type_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_param()) {
    param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_param(), 
      GetArenaForAllocation());
  }
  op_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    op_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_op()) {
    op_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_op(), 
      GetArenaForAllocation());
  }
  path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_path()) {
    path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_path(), 
      GetArenaForAllocation());
  }
  field_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    field_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_field_value()) {
    field_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_field_value(), 
      GetArenaForAllocation());
  }
  field_type_ = from.field_type_;
  // @@protoc_insertion_point(copy_constructor:mediapipe.TemplateExpression)
}

inline void TemplateExpression::SharedCtor() {
param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
op_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  op_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
field_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  field_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
field_type_ = 0;
}

TemplateExpression::~TemplateExpression() {
  // @@protoc_insertion_point(destructor:mediapipe.TemplateExpression)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TemplateExpression::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  param_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  op_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  field_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void TemplateExpression::ArenaDtor(void* object) {
  TemplateExpression* _this = reinterpret_cast< TemplateExpression* >(object);
  (void)_this;
}
void TemplateExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TemplateExpression::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TemplateExpression::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.TemplateExpression)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  arg_.Clear();
  key_type_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      param_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      op_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      path_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000008u) {
      field_value_.ClearNonDefaultToEmpty();
    }
  }
  field_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TemplateExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string param = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_param();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateExpression.param");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string op = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_op();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateExpression.op");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .mediapipe.TemplateExpression arg = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_arg(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      // optional string path = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateExpression.path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.FieldDescriptorProto.Type field_type = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::mediapipe::FieldDescriptorProto_Type_IsValid(val))) {
            _internal_set_field_type(static_cast<::mediapipe::FieldDescriptorProto_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // repeated .mediapipe.FieldDescriptorProto.Type key_type = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          ptr -= 1;
          do {
            ptr += 1;
            uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::mediapipe::FieldDescriptorProto_Type_IsValid(val))) {
              _internal_add_key_type(static_cast<::mediapipe::FieldDescriptorProto_Type>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr));
        } else if (static_cast<uint8_t>(tag) == 50) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_key_type(), ptr, ctx, ::mediapipe::FieldDescriptorProto_Type_IsValid, &_internal_metadata_, 6);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string field_value = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          auto str = _internal_mutable_field_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateExpression.field_value");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TemplateExpression::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.TemplateExpression)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string param = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_param().data(), static_cast<int>(this->_internal_param().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.TemplateExpression.param");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_param(), target);
  }

  // optional string op = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_op().data(), static_cast<int>(this->_internal_op().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.TemplateExpression.op");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_op(), target);
  }

  // repeated .mediapipe.TemplateExpression arg = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_arg_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_arg(i), target, stream);
  }

  // optional string path = 4;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.TemplateExpression.path");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_path(), target);
  }

  // optional .mediapipe.FieldDescriptorProto.Type field_type = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_field_type(), target);
  }

  // repeated .mediapipe.FieldDescriptorProto.Type key_type = 6;
  for (int i = 0, n = this->_internal_key_type_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        6, this->_internal_key_type(i), target);
  }

  // optional string field_value = 7;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_field_value().data(), static_cast<int>(this->_internal_field_value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.TemplateExpression.field_value");
    target = stream->WriteStringMaybeAliased(
        7, this->_internal_field_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.TemplateExpression)
  return target;
}

size_t TemplateExpression::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.TemplateExpression)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.TemplateExpression arg = 3;
  total_size += 1UL * this->_internal_arg_size();
  for (const auto& msg : this->arg_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .mediapipe.FieldDescriptorProto.Type key_type = 6;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_key_type_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_key_type(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string param = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_param());
    }

    // optional string op = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_op());
    }

    // optional string path = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_path());
    }

    // optional string field_value = 7;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_field_value());
    }

    // optional .mediapipe.FieldDescriptorProto.Type field_type = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_field_type());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateExpression::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TemplateExpression::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateExpression::GetClassData() const { return &_class_data_; }

void TemplateExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TemplateExpression *>(to)->MergeFrom(
      static_cast<const TemplateExpression &>(from));
}


void TemplateExpression::MergeFrom(const TemplateExpression& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.TemplateExpression)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  arg_.MergeFrom(from.arg_);
  key_type_.MergeFrom(from.key_type_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_param(from._internal_param());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_op(from._internal_op());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_path(from._internal_path());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_set_field_value(from._internal_field_value());
    }
    if (cached_has_bits & 0x00000010u) {
      field_type_ = from.field_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TemplateExpression::CopyFrom(const TemplateExpression& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.TemplateExpression)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TemplateExpression::IsInitialized() const {
  return true;
}

void TemplateExpression::InternalSwap(TemplateExpression* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  arg_.InternalSwap(&other->arg_);
  key_type_.InternalSwap(&other->key_type_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &param_, lhs_arena,
      &other->param_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &op_, lhs_arena,
      &other->op_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &path_, lhs_arena,
      &other->path_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &field_value_, lhs_arena,
      &other->field_value_, rhs_arena
  );
  swap(field_type_, other->field_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TemplateExpression::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[0]);
}

// ===================================================================

class CalculatorGraphTemplate::_Internal {
 public:
  using HasBits = decltype(std::declval<CalculatorGraphTemplate>()._has_bits_);
  static const ::mediapipe::CalculatorGraphConfig& config(const CalculatorGraphTemplate* msg);
  static void set_has_config(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::mediapipe::CalculatorGraphConfig&
CalculatorGraphTemplate::_Internal::config(const CalculatorGraphTemplate* msg) {
  return *msg->config_;
}
void CalculatorGraphTemplate::clear_config() {
  if (config_ != nullptr) config_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
CalculatorGraphTemplate::CalculatorGraphTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  rule_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.CalculatorGraphTemplate)
}
CalculatorGraphTemplate::CalculatorGraphTemplate(const CalculatorGraphTemplate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      rule_(from.rule_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_config()) {
    config_ = new ::mediapipe::CalculatorGraphConfig(*from.config_);
  } else {
    config_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.CalculatorGraphTemplate)
}

inline void CalculatorGraphTemplate::SharedCtor() {
config_ = nullptr;
}

CalculatorGraphTemplate::~CalculatorGraphTemplate() {
  // @@protoc_insertion_point(destructor:mediapipe.CalculatorGraphTemplate)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void CalculatorGraphTemplate::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete config_;
}

void CalculatorGraphTemplate::ArenaDtor(void* object) {
  CalculatorGraphTemplate* _this = reinterpret_cast< CalculatorGraphTemplate* >(object);
  (void)_this;
}
void CalculatorGraphTemplate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CalculatorGraphTemplate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void CalculatorGraphTemplate::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.CalculatorGraphTemplate)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  rule_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(config_ != nullptr);
    config_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CalculatorGraphTemplate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.CalculatorGraphConfig config = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_config(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .mediapipe.TemplateExpression rule = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_rule(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CalculatorGraphTemplate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.CalculatorGraphTemplate)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.CalculatorGraphConfig config = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::config(this), target, stream);
  }

  // repeated .mediapipe.TemplateExpression rule = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_rule_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_rule(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.CalculatorGraphTemplate)
  return target;
}

size_t CalculatorGraphTemplate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.CalculatorGraphTemplate)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.TemplateExpression rule = 2;
  total_size += 1UL * this->_internal_rule_size();
  for (const auto& msg : this->rule_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional .mediapipe.CalculatorGraphConfig config = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *config_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CalculatorGraphTemplate::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    CalculatorGraphTemplate::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CalculatorGraphTemplate::GetClassData() const { return &_class_data_; }

void CalculatorGraphTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<CalculatorGraphTemplate *>(to)->MergeFrom(
      static_cast<const CalculatorGraphTemplate &>(from));
}


void CalculatorGraphTemplate::MergeFrom(const CalculatorGraphTemplate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.CalculatorGraphTemplate)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  rule_.MergeFrom(from.rule_);
  if (from._internal_has_config()) {
    _internal_mutable_config()->::mediapipe::CalculatorGraphConfig::MergeFrom(from._internal_config());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CalculatorGraphTemplate::CopyFrom(const CalculatorGraphTemplate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.CalculatorGraphTemplate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CalculatorGraphTemplate::IsInitialized() const {
  if (_internal_has_config()) {
    if (!config_->IsInitialized()) return false;
  }
  return true;
}

void CalculatorGraphTemplate::InternalSwap(CalculatorGraphTemplate* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  rule_.InternalSwap(&other->rule_);
  swap(config_, other->config_);
}

::PROTOBUF_NAMESPACE_ID::Metadata CalculatorGraphTemplate::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[1]);
}

// ===================================================================

class TemplateArgument::_Internal {
 public:
  static const ::mediapipe::TemplateDict& dict(const TemplateArgument* msg);
};

const ::mediapipe::TemplateDict&
TemplateArgument::_Internal::dict(const TemplateArgument* msg) {
  return *msg->param_value_.dict_;
}
void TemplateArgument::set_allocated_dict(::mediapipe::TemplateDict* dict) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_param_value();
  if (dict) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::TemplateDict>::GetOwningArena(dict);
    if (message_arena != submessage_arena) {
      dict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dict, submessage_arena);
    }
    set_has_dict();
    param_value_.dict_ = dict;
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateArgument.dict)
}
TemplateArgument::TemplateArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  element_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.TemplateArgument)
}
TemplateArgument::TemplateArgument(const TemplateArgument& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      element_(from.element_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_param_value();
  switch (from.param_value_case()) {
    case kStr: {
      _internal_set_str(from._internal_str());
      break;
    }
    case kNum: {
      _internal_set_num(from._internal_num());
      break;
    }
    case kDict: {
      _internal_mutable_dict()->::mediapipe::TemplateDict::MergeFrom(from._internal_dict());
      break;
    }
    case PARAM_VALUE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.TemplateArgument)
}

inline void TemplateArgument::SharedCtor() {
clear_has_param_value();
}

TemplateArgument::~TemplateArgument() {
  // @@protoc_insertion_point(destructor:mediapipe.TemplateArgument)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TemplateArgument::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_param_value()) {
    clear_param_value();
  }
}

void TemplateArgument::ArenaDtor(void* object) {
  TemplateArgument* _this = reinterpret_cast< TemplateArgument* >(object);
  (void)_this;
}
void TemplateArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TemplateArgument::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TemplateArgument::clear_param_value() {
// @@protoc_insertion_point(one_of_clear_start:mediapipe.TemplateArgument)
  switch (param_value_case()) {
    case kStr: {
      param_value_.str_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      break;
    }
    case kNum: {
      // No need to clear
      break;
    }
    case kDict: {
      if (GetArenaForAllocation() == nullptr) {
        delete param_value_.dict_;
      }
      break;
    }
    case PARAM_VALUE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = PARAM_VALUE_NOT_SET;
}


void TemplateArgument::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.TemplateArgument)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  element_.Clear();
  clear_param_value();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TemplateArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string str = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_str();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateArgument.str");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // double num = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _internal_set_num(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // .mediapipe.TemplateDict dict = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_dict(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .mediapipe.TemplateArgument element = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_element(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TemplateArgument::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.TemplateArgument)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (param_value_case()) {
    case kStr: {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
        this->_internal_str().data(), static_cast<int>(this->_internal_str().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
        "mediapipe.TemplateArgument.str");
      target = stream->WriteStringMaybeAliased(
          1, this->_internal_str(), target);
      break;
    }
    case kNum: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_num(), target);
      break;
    }
    case kDict: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::dict(this), target, stream);
      break;
    }
    default: ;
  }
  // repeated .mediapipe.TemplateArgument element = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_element_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_element(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.TemplateArgument)
  return target;
}

size_t TemplateArgument::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.TemplateArgument)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.TemplateArgument element = 4;
  total_size += 1UL * this->_internal_element_size();
  for (const auto& msg : this->element_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  switch (param_value_case()) {
    // string str = 1;
    case kStr: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_str());
      break;
    }
    // double num = 2;
    case kNum: {
      total_size += 1 + 8;
      break;
    }
    // .mediapipe.TemplateDict dict = 3;
    case kDict: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *param_value_.dict_);
      break;
    }
    case PARAM_VALUE_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateArgument::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TemplateArgument::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateArgument::GetClassData() const { return &_class_data_; }

void TemplateArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TemplateArgument *>(to)->MergeFrom(
      static_cast<const TemplateArgument &>(from));
}


void TemplateArgument::MergeFrom(const TemplateArgument& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.TemplateArgument)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  element_.MergeFrom(from.element_);
  switch (from.param_value_case()) {
    case kStr: {
      _internal_set_str(from._internal_str());
      break;
    }
    case kNum: {
      _internal_set_num(from._internal_num());
      break;
    }
    case kDict: {
      _internal_mutable_dict()->::mediapipe::TemplateDict::MergeFrom(from._internal_dict());
      break;
    }
    case PARAM_VALUE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TemplateArgument::CopyFrom(const TemplateArgument& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.TemplateArgument)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TemplateArgument::IsInitialized() const {
  return true;
}

void TemplateArgument::InternalSwap(TemplateArgument* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  element_.InternalSwap(&other->element_);
  swap(param_value_, other->param_value_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata TemplateArgument::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[2]);
}

// ===================================================================

class TemplateDict_Parameter::_Internal {
 public:
  using HasBits = decltype(std::declval<TemplateDict_Parameter>()._has_bits_);
  static void set_has_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::mediapipe::TemplateArgument& value(const TemplateDict_Parameter* msg);
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::mediapipe::TemplateArgument&
TemplateDict_Parameter::_Internal::value(const TemplateDict_Parameter* msg) {
  return *msg->value_;
}
TemplateDict_Parameter::TemplateDict_Parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.TemplateDict.Parameter)
}
TemplateDict_Parameter::TemplateDict_Parameter(const TemplateDict_Parameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_key()) {
    key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_value()) {
    value_ = new ::mediapipe::TemplateArgument(*from.value_);
  } else {
    value_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.TemplateDict.Parameter)
}

inline void TemplateDict_Parameter::SharedCtor() {
key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
value_ = nullptr;
}

TemplateDict_Parameter::~TemplateDict_Parameter() {
  // @@protoc_insertion_point(destructor:mediapipe.TemplateDict.Parameter)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TemplateDict_Parameter::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete value_;
}

void TemplateDict_Parameter::ArenaDtor(void* object) {
  TemplateDict_Parameter* _this = reinterpret_cast< TemplateDict_Parameter* >(object);
  (void)_this;
}
void TemplateDict_Parameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TemplateDict_Parameter::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TemplateDict_Parameter::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.TemplateDict.Parameter)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      key_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(value_ != nullptr);
      value_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TemplateDict_Parameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "mediapipe.TemplateDict.Parameter.key");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .mediapipe.TemplateArgument value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TemplateDict_Parameter::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.TemplateDict.Parameter)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string key = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_key().data(), static_cast<int>(this->_internal_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "mediapipe.TemplateDict.Parameter.key");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_key(), target);
  }

  // optional .mediapipe.TemplateArgument value = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::value(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.TemplateDict.Parameter)
  return target;
}

size_t TemplateDict_Parameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.TemplateDict.Parameter)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string key = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_key());
    }

    // optional .mediapipe.TemplateArgument value = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *value_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateDict_Parameter::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TemplateDict_Parameter::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateDict_Parameter::GetClassData() const { return &_class_data_; }

void TemplateDict_Parameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TemplateDict_Parameter *>(to)->MergeFrom(
      static_cast<const TemplateDict_Parameter &>(from));
}


void TemplateDict_Parameter::MergeFrom(const TemplateDict_Parameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.TemplateDict.Parameter)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_key(from._internal_key());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_value()->::mediapipe::TemplateArgument::MergeFrom(from._internal_value());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TemplateDict_Parameter::CopyFrom(const TemplateDict_Parameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.TemplateDict.Parameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TemplateDict_Parameter::IsInitialized() const {
  return true;
}

void TemplateDict_Parameter::InternalSwap(TemplateDict_Parameter* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &key_, lhs_arena,
      &other->key_, rhs_arena
  );
  swap(value_, other->value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TemplateDict_Parameter::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[3]);
}

// ===================================================================

class TemplateDict::_Internal {
 public:
};

TemplateDict::TemplateDict(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  arg_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.TemplateDict)
}
TemplateDict::TemplateDict(const TemplateDict& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      arg_(from.arg_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:mediapipe.TemplateDict)
}

inline void TemplateDict::SharedCtor() {
}

TemplateDict::~TemplateDict() {
  // @@protoc_insertion_point(destructor:mediapipe.TemplateDict)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TemplateDict::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void TemplateDict::ArenaDtor(void* object) {
  TemplateDict* _this = reinterpret_cast< TemplateDict* >(object);
  (void)_this;
}
void TemplateDict::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TemplateDict::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TemplateDict::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.TemplateDict)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  arg_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TemplateDict::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .mediapipe.TemplateDict.Parameter arg = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_arg(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TemplateDict::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.TemplateDict)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .mediapipe.TemplateDict.Parameter arg = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_arg_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_arg(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.TemplateDict)
  return target;
}

size_t TemplateDict::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.TemplateDict)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .mediapipe.TemplateDict.Parameter arg = 1;
  total_size += 1UL * this->_internal_arg_size();
  for (const auto& msg : this->arg_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateDict::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TemplateDict::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateDict::GetClassData() const { return &_class_data_; }

void TemplateDict::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TemplateDict *>(to)->MergeFrom(
      static_cast<const TemplateDict &>(from));
}


void TemplateDict::MergeFrom(const TemplateDict& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.TemplateDict)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  arg_.MergeFrom(from.arg_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TemplateDict::CopyFrom(const TemplateDict& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.TemplateDict)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TemplateDict::IsInitialized() const {
  return true;
}

void TemplateDict::InternalSwap(TemplateDict* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  arg_.InternalSwap(&other->arg_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TemplateDict::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[4]);
}

// ===================================================================

class TemplateSubgraphOptions::_Internal {
 public:
  using HasBits = decltype(std::declval<TemplateSubgraphOptions>()._has_bits_);
  static const ::mediapipe::TemplateDict& dict(const TemplateSubgraphOptions* msg);
  static void set_has_dict(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::mediapipe::TemplateDict&
TemplateSubgraphOptions::_Internal::dict(const TemplateSubgraphOptions* msg) {
  return *msg->dict_;
}
TemplateSubgraphOptions::TemplateSubgraphOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:mediapipe.TemplateSubgraphOptions)
}
TemplateSubgraphOptions::TemplateSubgraphOptions(const TemplateSubgraphOptions& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_dict()) {
    dict_ = new ::mediapipe::TemplateDict(*from.dict_);
  } else {
    dict_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:mediapipe.TemplateSubgraphOptions)
}

inline void TemplateSubgraphOptions::SharedCtor() {
dict_ = nullptr;
}

TemplateSubgraphOptions::~TemplateSubgraphOptions() {
  // @@protoc_insertion_point(destructor:mediapipe.TemplateSubgraphOptions)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TemplateSubgraphOptions::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete dict_;
}

void TemplateSubgraphOptions::ArenaDtor(void* object) {
  TemplateSubgraphOptions* _this = reinterpret_cast< TemplateSubgraphOptions* >(object);
  (void)_this;
}
void TemplateSubgraphOptions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TemplateSubgraphOptions::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TemplateSubgraphOptions::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.TemplateSubgraphOptions)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(dict_ != nullptr);
    dict_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TemplateSubgraphOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .mediapipe.TemplateDict dict = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_dict(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* TemplateSubgraphOptions::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:mediapipe.TemplateSubgraphOptions)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mediapipe.TemplateDict dict = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::dict(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:mediapipe.TemplateSubgraphOptions)
  return target;
}

size_t TemplateSubgraphOptions::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.TemplateSubgraphOptions)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .mediapipe.TemplateDict dict = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *dict_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateSubgraphOptions::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TemplateSubgraphOptions::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateSubgraphOptions::GetClassData() const { return &_class_data_; }

void TemplateSubgraphOptions::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<TemplateSubgraphOptions *>(to)->MergeFrom(
      static_cast<const TemplateSubgraphOptions &>(from));
}


void TemplateSubgraphOptions::MergeFrom(const TemplateSubgraphOptions& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.TemplateSubgraphOptions)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_dict()) {
    _internal_mutable_dict()->::mediapipe::TemplateDict::MergeFrom(from._internal_dict());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TemplateSubgraphOptions::CopyFrom(const TemplateSubgraphOptions& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.TemplateSubgraphOptions)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TemplateSubgraphOptions::IsInitialized() const {
  return true;
}

void TemplateSubgraphOptions::InternalSwap(TemplateSubgraphOptions* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(dict_, other->dict_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TemplateSubgraphOptions::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_getter, &descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto_once,
      file_level_metadata_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto[5]);
}
#if !defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)
const int TemplateSubgraphOptions::kExtFieldNumber;
#endif
PROTOBUF_ATTRIBUTE_INIT_PRIORITY ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::mediapipe::CalculatorOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::mediapipe::TemplateSubgraphOptions >, 11, false >
  TemplateSubgraphOptions::ext(kExtFieldNumber, ::mediapipe::TemplateSubgraphOptions::default_instance());

// @@protoc_insertion_point(namespace_scope)
}  // namespace mediapipe
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::mediapipe::TemplateExpression* Arena::CreateMaybeMessage< ::mediapipe::TemplateExpression >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::TemplateExpression >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::CalculatorGraphTemplate* Arena::CreateMaybeMessage< ::mediapipe::CalculatorGraphTemplate >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::CalculatorGraphTemplate >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::TemplateArgument* Arena::CreateMaybeMessage< ::mediapipe::TemplateArgument >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::TemplateArgument >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::TemplateDict_Parameter* Arena::CreateMaybeMessage< ::mediapipe::TemplateDict_Parameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::TemplateDict_Parameter >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::TemplateDict* Arena::CreateMaybeMessage< ::mediapipe::TemplateDict >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::TemplateDict >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::TemplateSubgraphOptions* Arena::CreateMaybeMessage< ::mediapipe::TemplateSubgraphOptions >(Arena* arena) {
  return Arena::CreateMessageInternal< ::mediapipe::TemplateSubgraphOptions >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>