// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: VisionFeaturePrint.proto

#include "VisionFeaturePrint.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/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace CoreML {
namespace Specification {
namespace CoreMLModels {
constexpr VisionFeaturePrint_Scene::VisionFeaturePrint_Scene(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : version_(0)
{}
struct VisionFeaturePrint_SceneDefaultTypeInternal {
  constexpr VisionFeaturePrint_SceneDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~VisionFeaturePrint_SceneDefaultTypeInternal() {}
  union {
    VisionFeaturePrint_Scene _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VisionFeaturePrint_SceneDefaultTypeInternal _VisionFeaturePrint_Scene_default_instance_;
constexpr VisionFeaturePrint_Objects::VisionFeaturePrint_Objects(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : output_()
  , version_(0)
{}
struct VisionFeaturePrint_ObjectsDefaultTypeInternal {
  constexpr VisionFeaturePrint_ObjectsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~VisionFeaturePrint_ObjectsDefaultTypeInternal() {}
  union {
    VisionFeaturePrint_Objects _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VisionFeaturePrint_ObjectsDefaultTypeInternal _VisionFeaturePrint_Objects_default_instance_;
constexpr VisionFeaturePrint::VisionFeaturePrint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct VisionFeaturePrintDefaultTypeInternal {
  constexpr VisionFeaturePrintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~VisionFeaturePrintDefaultTypeInternal() {}
  union {
    VisionFeaturePrint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VisionFeaturePrintDefaultTypeInternal _VisionFeaturePrint_default_instance_;
}  // namespace CoreMLModels
}  // namespace Specification
}  // namespace CoreML
namespace CoreML {
namespace Specification {
namespace CoreMLModels {
bool VisionFeaturePrint_Scene_SceneVersion_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VisionFeaturePrint_Scene_SceneVersion_strings[3] = {};

static const char VisionFeaturePrint_Scene_SceneVersion_names[] =
  "SCENE_VERSION_1"
  "SCENE_VERSION_2"
  "SCENE_VERSION_INVALID";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VisionFeaturePrint_Scene_SceneVersion_entries[] = {
  { {VisionFeaturePrint_Scene_SceneVersion_names + 0, 15}, 1 },
  { {VisionFeaturePrint_Scene_SceneVersion_names + 15, 15}, 2 },
  { {VisionFeaturePrint_Scene_SceneVersion_names + 30, 21}, 0 },
};

static const int VisionFeaturePrint_Scene_SceneVersion_entries_by_number[] = {
  2, // 0 -> SCENE_VERSION_INVALID
  0, // 1 -> SCENE_VERSION_1
  1, // 2 -> SCENE_VERSION_2
};

const std::string& VisionFeaturePrint_Scene_SceneVersion_Name(
    VisionFeaturePrint_Scene_SceneVersion value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          VisionFeaturePrint_Scene_SceneVersion_entries,
          VisionFeaturePrint_Scene_SceneVersion_entries_by_number,
          3, VisionFeaturePrint_Scene_SceneVersion_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      VisionFeaturePrint_Scene_SceneVersion_entries,
      VisionFeaturePrint_Scene_SceneVersion_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     VisionFeaturePrint_Scene_SceneVersion_strings[idx].get();
}
bool VisionFeaturePrint_Scene_SceneVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VisionFeaturePrint_Scene_SceneVersion* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      VisionFeaturePrint_Scene_SceneVersion_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<VisionFeaturePrint_Scene_SceneVersion>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VisionFeaturePrint_Scene_SceneVersion VisionFeaturePrint_Scene::SCENE_VERSION_INVALID;
constexpr VisionFeaturePrint_Scene_SceneVersion VisionFeaturePrint_Scene::SCENE_VERSION_1;
constexpr VisionFeaturePrint_Scene_SceneVersion VisionFeaturePrint_Scene::SCENE_VERSION_2;
constexpr VisionFeaturePrint_Scene_SceneVersion VisionFeaturePrint_Scene::SceneVersion_MIN;
constexpr VisionFeaturePrint_Scene_SceneVersion VisionFeaturePrint_Scene::SceneVersion_MAX;
constexpr int VisionFeaturePrint_Scene::SceneVersion_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VisionFeaturePrint_Objects_ObjectsVersion_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VisionFeaturePrint_Objects_ObjectsVersion_strings[2] = {};

static const char VisionFeaturePrint_Objects_ObjectsVersion_names[] =
  "OBJECTS_VERSION_1"
  "OBJECTS_VERSION_INVALID";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VisionFeaturePrint_Objects_ObjectsVersion_entries[] = {
  { {VisionFeaturePrint_Objects_ObjectsVersion_names + 0, 17}, 1 },
  { {VisionFeaturePrint_Objects_ObjectsVersion_names + 17, 23}, 0 },
};

static const int VisionFeaturePrint_Objects_ObjectsVersion_entries_by_number[] = {
  1, // 0 -> OBJECTS_VERSION_INVALID
  0, // 1 -> OBJECTS_VERSION_1
};

const std::string& VisionFeaturePrint_Objects_ObjectsVersion_Name(
    VisionFeaturePrint_Objects_ObjectsVersion value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          VisionFeaturePrint_Objects_ObjectsVersion_entries,
          VisionFeaturePrint_Objects_ObjectsVersion_entries_by_number,
          2, VisionFeaturePrint_Objects_ObjectsVersion_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      VisionFeaturePrint_Objects_ObjectsVersion_entries,
      VisionFeaturePrint_Objects_ObjectsVersion_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     VisionFeaturePrint_Objects_ObjectsVersion_strings[idx].get();
}
bool VisionFeaturePrint_Objects_ObjectsVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VisionFeaturePrint_Objects_ObjectsVersion* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      VisionFeaturePrint_Objects_ObjectsVersion_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<VisionFeaturePrint_Objects_ObjectsVersion>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VisionFeaturePrint_Objects_ObjectsVersion VisionFeaturePrint_Objects::OBJECTS_VERSION_INVALID;
constexpr VisionFeaturePrint_Objects_ObjectsVersion VisionFeaturePrint_Objects::OBJECTS_VERSION_1;
constexpr VisionFeaturePrint_Objects_ObjectsVersion VisionFeaturePrint_Objects::ObjectsVersion_MIN;
constexpr VisionFeaturePrint_Objects_ObjectsVersion VisionFeaturePrint_Objects::ObjectsVersion_MAX;
constexpr int VisionFeaturePrint_Objects::ObjectsVersion_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class VisionFeaturePrint_Scene::_Internal {
 public:
};

VisionFeaturePrint_Scene::VisionFeaturePrint_Scene(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
}
VisionFeaturePrint_Scene::VisionFeaturePrint_Scene(const VisionFeaturePrint_Scene& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  version_ = from.version_;
  // @@protoc_insertion_point(copy_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
}

inline void VisionFeaturePrint_Scene::SharedCtor() {
version_ = 0;
}

VisionFeaturePrint_Scene::~VisionFeaturePrint_Scene() {
  // @@protoc_insertion_point(destructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

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

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

void VisionFeaturePrint_Scene::Clear() {
// @@protoc_insertion_point(message_clear_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  version_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* VisionFeaturePrint_Scene::_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) {
      // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene.SceneVersion version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_version(static_cast<::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene_SceneVersion>(val));
        } 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<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* VisionFeaturePrint_Scene::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene.SceneVersion version = 1;
  if (this->_internal_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  return target;
}

size_t VisionFeaturePrint_Scene::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  size_t total_size = 0;

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

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene.SceneVersion version = 1;
  if (this->_internal_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_version());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VisionFeaturePrint_Scene::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const VisionFeaturePrint_Scene*>(
      &from));
}

void VisionFeaturePrint_Scene::MergeFrom(const VisionFeaturePrint_Scene& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_version() != 0) {
    _internal_set_version(from._internal_version());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void VisionFeaturePrint_Scene::CopyFrom(const VisionFeaturePrint_Scene& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void VisionFeaturePrint_Scene::InternalSwap(VisionFeaturePrint_Scene* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(version_, other->version_);
}

std::string VisionFeaturePrint_Scene::GetTypeName() const {
  return "CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene";
}


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

class VisionFeaturePrint_Objects::_Internal {
 public:
};

VisionFeaturePrint_Objects::VisionFeaturePrint_Objects(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
  output_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
}
VisionFeaturePrint_Objects::VisionFeaturePrint_Objects(const VisionFeaturePrint_Objects& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      output_(from.output_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  version_ = from.version_;
  // @@protoc_insertion_point(copy_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
}

inline void VisionFeaturePrint_Objects::SharedCtor() {
version_ = 0;
}

VisionFeaturePrint_Objects::~VisionFeaturePrint_Objects() {
  // @@protoc_insertion_point(destructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

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

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

void VisionFeaturePrint_Objects::Clear() {
// @@protoc_insertion_point(message_clear_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  output_.Clear();
  version_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* VisionFeaturePrint_Objects::_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) {
      // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects.ObjectsVersion version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_version(static_cast<::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects_ObjectsVersion>(val));
        } else
          goto handle_unusual;
        continue;
      // repeated string output = 100;
      case 100:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr -= 2;
          do {
            ptr += 2;
            auto str = _internal_add_output();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<802>(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<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* VisionFeaturePrint_Objects::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects.ObjectsVersion version = 1;
  if (this->_internal_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_version(), target);
  }

  // repeated string output = 100;
  for (int i = 0, n = this->_internal_output_size(); i < n; i++) {
    const auto& s = this->_internal_output(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects.output");
    target = stream->WriteString(100, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  return target;
}

size_t VisionFeaturePrint_Objects::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  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 string output = 100;
  total_size += 2 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size());
  for (int i = 0, n = output_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      output_.Get(i));
  }

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects.ObjectsVersion version = 1;
  if (this->_internal_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_version());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VisionFeaturePrint_Objects::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const VisionFeaturePrint_Objects*>(
      &from));
}

void VisionFeaturePrint_Objects::MergeFrom(const VisionFeaturePrint_Objects& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  output_.MergeFrom(from.output_);
  if (from._internal_version() != 0) {
    _internal_set_version(from._internal_version());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void VisionFeaturePrint_Objects::CopyFrom(const VisionFeaturePrint_Objects& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void VisionFeaturePrint_Objects::InternalSwap(VisionFeaturePrint_Objects* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  output_.InternalSwap(&other->output_);
  swap(version_, other->version_);
}

std::string VisionFeaturePrint_Objects::GetTypeName() const {
  return "CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects";
}


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

class VisionFeaturePrint::_Internal {
 public:
  static const ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene& scene(const VisionFeaturePrint* msg);
  static const ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects& objects(const VisionFeaturePrint* msg);
};

const ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene&
VisionFeaturePrint::_Internal::scene(const VisionFeaturePrint* msg) {
  return *msg->VisionFeaturePrintType_.scene_;
}
const ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects&
VisionFeaturePrint::_Internal::objects(const VisionFeaturePrint* msg) {
  return *msg->VisionFeaturePrintType_.objects_;
}
void VisionFeaturePrint::set_allocated_scene(::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene* scene) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_VisionFeaturePrintType();
  if (scene) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene>::GetOwningArena(scene);
    if (message_arena != submessage_arena) {
      scene = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scene, submessage_arena);
    }
    set_has_scene();
    VisionFeaturePrintType_.scene_ = scene;
  }
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.CoreMLModels.VisionFeaturePrint.scene)
}
void VisionFeaturePrint::set_allocated_objects(::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects* objects) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_VisionFeaturePrintType();
  if (objects) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects>::GetOwningArena(objects);
    if (message_arena != submessage_arena) {
      objects = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, objects, submessage_arena);
    }
    set_has_objects();
    VisionFeaturePrintType_.objects_ = objects;
  }
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.CoreMLModels.VisionFeaturePrint.objects)
}
VisionFeaturePrint::VisionFeaturePrint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
}
VisionFeaturePrint::VisionFeaturePrint(const VisionFeaturePrint& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_VisionFeaturePrintType();
  switch (from.VisionFeaturePrintType_case()) {
    case kScene: {
      _internal_mutable_scene()->::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene::MergeFrom(from._internal_scene());
      break;
    }
    case kObjects: {
      _internal_mutable_objects()->::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects::MergeFrom(from._internal_objects());
      break;
    }
    case VISIONFEATUREPRINTTYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
}

inline void VisionFeaturePrint::SharedCtor() {
clear_has_VisionFeaturePrintType();
}

VisionFeaturePrint::~VisionFeaturePrint() {
  // @@protoc_insertion_point(destructor:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void VisionFeaturePrint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_VisionFeaturePrintType()) {
    clear_VisionFeaturePrintType();
  }
}

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

void VisionFeaturePrint::clear_VisionFeaturePrintType() {
// @@protoc_insertion_point(one_of_clear_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  switch (VisionFeaturePrintType_case()) {
    case kScene: {
      if (GetArenaForAllocation() == nullptr) {
        delete VisionFeaturePrintType_.scene_;
      }
      break;
    }
    case kObjects: {
      if (GetArenaForAllocation() == nullptr) {
        delete VisionFeaturePrintType_.objects_;
      }
      break;
    }
    case VISIONFEATUREPRINTTYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = VISIONFEATUREPRINTTYPE_NOT_SET;
}


void VisionFeaturePrint::Clear() {
// @@protoc_insertion_point(message_clear_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_VisionFeaturePrintType();
  _internal_metadata_.Clear<std::string>();
}

const char* VisionFeaturePrint::_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) {
      // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene scene = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_scene(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects objects = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_objects(), 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<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene scene = 20;
  if (_internal_has_scene()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::scene(this), target, stream);
  }

  // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects objects = 21;
  if (_internal_has_objects()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        21, _Internal::objects(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  return target;
}

size_t VisionFeaturePrint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  size_t total_size = 0;

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

  switch (VisionFeaturePrintType_case()) {
    // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Scene scene = 20;
    case kScene: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *VisionFeaturePrintType_.scene_);
      break;
    }
    // .CoreML.Specification.CoreMLModels.VisionFeaturePrint.Objects objects = 21;
    case kObjects: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *VisionFeaturePrintType_.objects_);
      break;
    }
    case VISIONFEATUREPRINTTYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VisionFeaturePrint::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const VisionFeaturePrint*>(
      &from));
}

void VisionFeaturePrint::MergeFrom(const VisionFeaturePrint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.VisionFeaturePrintType_case()) {
    case kScene: {
      _internal_mutable_scene()->::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene::MergeFrom(from._internal_scene());
      break;
    }
    case kObjects: {
      _internal_mutable_objects()->::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects::MergeFrom(from._internal_objects());
      break;
    }
    case VISIONFEATUREPRINTTYPE_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void VisionFeaturePrint::CopyFrom(const VisionFeaturePrint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:CoreML.Specification.CoreMLModels.VisionFeaturePrint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string VisionFeaturePrint::GetTypeName() const {
  return "CoreML.Specification.CoreMLModels.VisionFeaturePrint";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace CoreMLModels
}  // namespace Specification
}  // namespace CoreML
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene* Arena::CreateMaybeMessage< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Scene >(arena);
}
template<> PROTOBUF_NOINLINE ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects* Arena::CreateMaybeMessage< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint_Objects >(arena);
}
template<> PROTOBUF_NOINLINE ::CoreML::Specification::CoreMLModels::VisionFeaturePrint* Arena::CreateMaybeMessage< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CoreML::Specification::CoreMLModels::VisionFeaturePrint >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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