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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "messages_robocup_ssl_geometry.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.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)

namespace {

const ::google::protobuf::Descriptor* Vector2f_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Vector2f_reflection_ = NULL;
const ::google::protobuf::Descriptor* SSL_FieldLineSegment_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SSL_FieldLineSegment_reflection_ = NULL;
const ::google::protobuf::Descriptor* SSL_FieldCicularArc_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SSL_FieldCicularArc_reflection_ = NULL;
const ::google::protobuf::Descriptor* SSL_GeometryFieldSize_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SSL_GeometryFieldSize_reflection_ = NULL;
const ::google::protobuf::Descriptor* SSL_GeometryCameraCalibration_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SSL_GeometryCameraCalibration_reflection_ = NULL;
const ::google::protobuf::Descriptor* SSL_GeometryData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SSL_GeometryData_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_messages_5frobocup_5fssl_5fgeometry_2eproto() {
  protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "messages_robocup_ssl_geometry.proto");
  GOOGLE_CHECK(file != NULL);
  Vector2f_descriptor_ = file->message_type(0);
  static const int Vector2f_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Vector2f, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Vector2f, y_),
  };
  Vector2f_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Vector2f_descriptor_,
      Vector2f::default_instance_,
      Vector2f_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Vector2f, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Vector2f, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Vector2f));
  SSL_FieldLineSegment_descriptor_ = file->message_type(1);
  static const int SSL_FieldLineSegment_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, p1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, p2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, thickness_),
  };
  SSL_FieldLineSegment_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SSL_FieldLineSegment_descriptor_,
      SSL_FieldLineSegment::default_instance_,
      SSL_FieldLineSegment_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldLineSegment, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SSL_FieldLineSegment));
  SSL_FieldCicularArc_descriptor_ = file->message_type(2);
  static const int SSL_FieldCicularArc_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, center_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, radius_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, a1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, a2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, thickness_),
  };
  SSL_FieldCicularArc_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SSL_FieldCicularArc_descriptor_,
      SSL_FieldCicularArc::default_instance_,
      SSL_FieldCicularArc_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_FieldCicularArc, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SSL_FieldCicularArc));
  SSL_GeometryFieldSize_descriptor_ = file->message_type(3);
  static const int SSL_GeometryFieldSize_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, field_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, field_width_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, goal_width_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, goal_depth_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, boundary_width_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, field_lines_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, field_arcs_),
  };
  SSL_GeometryFieldSize_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SSL_GeometryFieldSize_descriptor_,
      SSL_GeometryFieldSize::default_instance_,
      SSL_GeometryFieldSize_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryFieldSize, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SSL_GeometryFieldSize));
  SSL_GeometryCameraCalibration_descriptor_ = file->message_type(4);
  static const int SSL_GeometryCameraCalibration_offsets_[15] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, camera_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, focal_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, principal_point_x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, principal_point_y_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, distortion_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, q0_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, q1_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, q2_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, q3_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, tx_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, ty_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, tz_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, derived_camera_world_tx_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, derived_camera_world_ty_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, derived_camera_world_tz_),
  };
  SSL_GeometryCameraCalibration_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SSL_GeometryCameraCalibration_descriptor_,
      SSL_GeometryCameraCalibration::default_instance_,
      SSL_GeometryCameraCalibration_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryCameraCalibration, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SSL_GeometryCameraCalibration));
  SSL_GeometryData_descriptor_ = file->message_type(5);
  static const int SSL_GeometryData_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryData, field_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryData, calib_),
  };
  SSL_GeometryData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SSL_GeometryData_descriptor_,
      SSL_GeometryData::default_instance_,
      SSL_GeometryData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SSL_GeometryData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SSL_GeometryData));
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_messages_5frobocup_5fssl_5fgeometry_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Vector2f_descriptor_, &Vector2f::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SSL_FieldLineSegment_descriptor_, &SSL_FieldLineSegment::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SSL_FieldCicularArc_descriptor_, &SSL_FieldCicularArc::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SSL_GeometryFieldSize_descriptor_, &SSL_GeometryFieldSize::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SSL_GeometryCameraCalibration_descriptor_, &SSL_GeometryCameraCalibration::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SSL_GeometryData_descriptor_, &SSL_GeometryData::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_messages_5frobocup_5fssl_5fgeometry_2eproto() {
  delete Vector2f::default_instance_;
  delete Vector2f_reflection_;
  delete SSL_FieldLineSegment::default_instance_;
  delete SSL_FieldLineSegment_reflection_;
  delete SSL_FieldCicularArc::default_instance_;
  delete SSL_FieldCicularArc_reflection_;
  delete SSL_GeometryFieldSize::default_instance_;
  delete SSL_GeometryFieldSize_reflection_;
  delete SSL_GeometryCameraCalibration::default_instance_;
  delete SSL_GeometryCameraCalibration_reflection_;
  delete SSL_GeometryData::default_instance_;
  delete SSL_GeometryData_reflection_;
}

void protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n#messages_robocup_ssl_geometry.proto\" \n"
    "\010Vector2f\022\t\n\001x\030\001 \002(\002\022\t\n\001y\030\002 \002(\002\"e\n\024SSL_F"
    "ieldLineSegment\022\014\n\004name\030\001 \002(\t\022\025\n\002p1\030\002 \002("
    "\0132\t.Vector2f\022\025\n\002p2\030\003 \002(\0132\t.Vector2f\022\021\n\tt"
    "hickness\030\004 \002(\002\"y\n\023SSL_FieldCicularArc\022\014\n"
    "\004name\030\001 \002(\t\022\031\n\006center\030\002 \002(\0132\t.Vector2f\022\016"
    "\n\006radius\030\003 \002(\002\022\n\n\002a1\030\004 \002(\002\022\n\n\002a2\030\005 \002(\002\022\021"
    "\n\tthickness\030\006 \002(\002\"\330\001\n\025SSL_GeometryFieldS"
    "ize\022\024\n\014field_length\030\001 \002(\005\022\023\n\013field_width"
    "\030\002 \002(\005\022\022\n\ngoal_width\030\003 \002(\005\022\022\n\ngoal_depth"
    "\030\004 \002(\005\022\026\n\016boundary_width\030\005 \002(\005\022*\n\013field_"
    "lines\030\006 \003(\0132\025.SSL_FieldLineSegment\022(\n\nfi"
    "eld_arcs\030\007 \003(\0132\024.SSL_FieldCicularArc\"\311\002\n"
    "\035SSL_GeometryCameraCalibration\022\021\n\tcamera"
    "_id\030\001 \002(\r\022\024\n\014focal_length\030\002 \002(\002\022\031\n\021princ"
    "ipal_point_x\030\003 \002(\002\022\031\n\021principal_point_y\030"
    "\004 \002(\002\022\022\n\ndistortion\030\005 \002(\002\022\n\n\002q0\030\006 \002(\002\022\n\n"
    "\002q1\030\007 \002(\002\022\n\n\002q2\030\010 \002(\002\022\n\n\002q3\030\t \002(\002\022\n\n\002tx\030"
    "\n \002(\002\022\n\n\002ty\030\013 \002(\002\022\n\n\002tz\030\014 \002(\002\022\037\n\027derived"
    "_camera_world_tx\030\r \001(\002\022\037\n\027derived_camera"
    "_world_ty\030\016 \001(\002\022\037\n\027derived_camera_world_"
    "tz\030\017 \001(\002\"h\n\020SSL_GeometryData\022%\n\005field\030\001 "
    "\002(\0132\026.SSL_GeometryFieldSize\022-\n\005calib\030\002 \003"
    "(\0132\036.SSL_GeometryCameraCalibration", 954);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "messages_robocup_ssl_geometry.proto", &protobuf_RegisterTypes);
  Vector2f::default_instance_ = new Vector2f();
  SSL_FieldLineSegment::default_instance_ = new SSL_FieldLineSegment();
  SSL_FieldCicularArc::default_instance_ = new SSL_FieldCicularArc();
  SSL_GeometryFieldSize::default_instance_ = new SSL_GeometryFieldSize();
  SSL_GeometryCameraCalibration::default_instance_ = new SSL_GeometryCameraCalibration();
  SSL_GeometryData::default_instance_ = new SSL_GeometryData();
  Vector2f::default_instance_->InitAsDefaultInstance();
  SSL_FieldLineSegment::default_instance_->InitAsDefaultInstance();
  SSL_FieldCicularArc::default_instance_->InitAsDefaultInstance();
  SSL_GeometryFieldSize::default_instance_->InitAsDefaultInstance();
  SSL_GeometryCameraCalibration::default_instance_->InitAsDefaultInstance();
  SSL_GeometryData::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_messages_5frobocup_5fssl_5fgeometry_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_messages_5frobocup_5fssl_5fgeometry_2eproto {
  StaticDescriptorInitializer_messages_5frobocup_5fssl_5fgeometry_2eproto() {
    protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  }
} static_descriptor_initializer_messages_5frobocup_5fssl_5fgeometry_2eproto_;

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

#ifndef _MSC_VER
const int Vector2f::kXFieldNumber;
const int Vector2f::kYFieldNumber;
#endif  // !_MSC_VER

Vector2f::Vector2f()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Vector2f)
}

void Vector2f::InitAsDefaultInstance() {
}

Vector2f::Vector2f(const Vector2f& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Vector2f)
}

void Vector2f::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Vector2f::~Vector2f() {
  // @@protoc_insertion_point(destructor:Vector2f)
  SharedDtor();
}

void Vector2f::SharedDtor() {
  if (this != default_instance_) {
  }
}

void Vector2f::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Vector2f::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Vector2f_descriptor_;
}

const Vector2f& Vector2f::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

Vector2f* Vector2f::default_instance_ = NULL;

Vector2f* Vector2f::New() const {
  return new Vector2f;
}

void Vector2f::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Vector2f*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(x_, y_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Vector2f::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Vector2f)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required float x = 1;
      case 1: {
        if (tag == 13) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(21)) goto parse_y;
        break;
      }

      // required float y = 2;
      case 2: {
        if (tag == 21) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Vector2f)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Vector2f)
  return false;
#undef DO_
}

void Vector2f::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Vector2f)
  // required float x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // required float y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Vector2f)
}

::google::protobuf::uint8* Vector2f::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Vector2f)
  // required float x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // required float y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Vector2f)
  return target;
}

int Vector2f::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required float x = 1;
    if (has_x()) {
      total_size += 1 + 4;
    }

    // required float y = 2;
    if (has_y()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Vector2f::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Vector2f* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Vector2f*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Vector2f::MergeFrom(const Vector2f& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Vector2f::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Vector2f::CopyFrom(const Vector2f& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Vector2f::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void Vector2f::Swap(Vector2f* other) {
  if (other != this) {
    std::swap(x_, other->x_);
    std::swap(y_, other->y_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Vector2f::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Vector2f_descriptor_;
  metadata.reflection = Vector2f_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SSL_FieldLineSegment::kNameFieldNumber;
const int SSL_FieldLineSegment::kP1FieldNumber;
const int SSL_FieldLineSegment::kP2FieldNumber;
const int SSL_FieldLineSegment::kThicknessFieldNumber;
#endif  // !_MSC_VER

SSL_FieldLineSegment::SSL_FieldLineSegment()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SSL_FieldLineSegment)
}

void SSL_FieldLineSegment::InitAsDefaultInstance() {
  p1_ = const_cast< ::Vector2f*>(&::Vector2f::default_instance());
  p2_ = const_cast< ::Vector2f*>(&::Vector2f::default_instance());
}

SSL_FieldLineSegment::SSL_FieldLineSegment(const SSL_FieldLineSegment& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SSL_FieldLineSegment)
}

void SSL_FieldLineSegment::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  p1_ = NULL;
  p2_ = NULL;
  thickness_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SSL_FieldLineSegment::~SSL_FieldLineSegment() {
  // @@protoc_insertion_point(destructor:SSL_FieldLineSegment)
  SharedDtor();
}

void SSL_FieldLineSegment::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (this != default_instance_) {
    delete p1_;
    delete p2_;
  }
}

void SSL_FieldLineSegment::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SSL_FieldLineSegment::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SSL_FieldLineSegment_descriptor_;
}

const SSL_FieldLineSegment& SSL_FieldLineSegment::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

SSL_FieldLineSegment* SSL_FieldLineSegment::default_instance_ = NULL;

SSL_FieldLineSegment* SSL_FieldLineSegment::New() const {
  return new SSL_FieldLineSegment;
}

void SSL_FieldLineSegment::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_p1()) {
      if (p1_ != NULL) p1_->::Vector2f::Clear();
    }
    if (has_p2()) {
      if (p2_ != NULL) p2_->::Vector2f::Clear();
    }
    thickness_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SSL_FieldLineSegment::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SSL_FieldLineSegment)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_p1;
        break;
      }

      // required .Vector2f p1 = 2;
      case 2: {
        if (tag == 18) {
         parse_p1:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_p1()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_p2;
        break;
      }

      // required .Vector2f p2 = 3;
      case 3: {
        if (tag == 26) {
         parse_p2:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_p2()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_thickness;
        break;
      }

      // required float thickness = 4;
      case 4: {
        if (tag == 37) {
         parse_thickness:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &thickness_)));
          set_has_thickness();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SSL_FieldLineSegment)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SSL_FieldLineSegment)
  return false;
#undef DO_
}

void SSL_FieldLineSegment::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SSL_FieldLineSegment)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // required .Vector2f p1 = 2;
  if (has_p1()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->p1(), output);
  }

  // required .Vector2f p2 = 3;
  if (has_p2()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->p2(), output);
  }

  // required float thickness = 4;
  if (has_thickness()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->thickness(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SSL_FieldLineSegment)
}

::google::protobuf::uint8* SSL_FieldLineSegment::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SSL_FieldLineSegment)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // required .Vector2f p1 = 2;
  if (has_p1()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->p1(), target);
  }

  // required .Vector2f p2 = 3;
  if (has_p2()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->p2(), target);
  }

  // required float thickness = 4;
  if (has_thickness()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->thickness(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SSL_FieldLineSegment)
  return target;
}

int SSL_FieldLineSegment::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required .Vector2f p1 = 2;
    if (has_p1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->p1());
    }

    // required .Vector2f p2 = 3;
    if (has_p2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->p2());
    }

    // required float thickness = 4;
    if (has_thickness()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SSL_FieldLineSegment::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SSL_FieldLineSegment* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SSL_FieldLineSegment*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SSL_FieldLineSegment::MergeFrom(const SSL_FieldLineSegment& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_p1()) {
      mutable_p1()->::Vector2f::MergeFrom(from.p1());
    }
    if (from.has_p2()) {
      mutable_p2()->::Vector2f::MergeFrom(from.p2());
    }
    if (from.has_thickness()) {
      set_thickness(from.thickness());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SSL_FieldLineSegment::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SSL_FieldLineSegment::CopyFrom(const SSL_FieldLineSegment& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SSL_FieldLineSegment::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_p1()) {
    if (!this->p1().IsInitialized()) return false;
  }
  if (has_p2()) {
    if (!this->p2().IsInitialized()) return false;
  }
  return true;
}

void SSL_FieldLineSegment::Swap(SSL_FieldLineSegment* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(p1_, other->p1_);
    std::swap(p2_, other->p2_);
    std::swap(thickness_, other->thickness_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SSL_FieldLineSegment::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SSL_FieldLineSegment_descriptor_;
  metadata.reflection = SSL_FieldLineSegment_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SSL_FieldCicularArc::kNameFieldNumber;
const int SSL_FieldCicularArc::kCenterFieldNumber;
const int SSL_FieldCicularArc::kRadiusFieldNumber;
const int SSL_FieldCicularArc::kA1FieldNumber;
const int SSL_FieldCicularArc::kA2FieldNumber;
const int SSL_FieldCicularArc::kThicknessFieldNumber;
#endif  // !_MSC_VER

SSL_FieldCicularArc::SSL_FieldCicularArc()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SSL_FieldCicularArc)
}

void SSL_FieldCicularArc::InitAsDefaultInstance() {
  center_ = const_cast< ::Vector2f*>(&::Vector2f::default_instance());
}

SSL_FieldCicularArc::SSL_FieldCicularArc(const SSL_FieldCicularArc& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SSL_FieldCicularArc)
}

void SSL_FieldCicularArc::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  center_ = NULL;
  radius_ = 0;
  a1_ = 0;
  a2_ = 0;
  thickness_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SSL_FieldCicularArc::~SSL_FieldCicularArc() {
  // @@protoc_insertion_point(destructor:SSL_FieldCicularArc)
  SharedDtor();
}

void SSL_FieldCicularArc::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (this != default_instance_) {
    delete center_;
  }
}

void SSL_FieldCicularArc::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SSL_FieldCicularArc::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SSL_FieldCicularArc_descriptor_;
}

const SSL_FieldCicularArc& SSL_FieldCicularArc::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

SSL_FieldCicularArc* SSL_FieldCicularArc::default_instance_ = NULL;

SSL_FieldCicularArc* SSL_FieldCicularArc::New() const {
  return new SSL_FieldCicularArc;
}

void SSL_FieldCicularArc::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<SSL_FieldCicularArc*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(radius_, thickness_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_center()) {
      if (center_ != NULL) center_->::Vector2f::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SSL_FieldCicularArc::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SSL_FieldCicularArc)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_center;
        break;
      }

      // required .Vector2f center = 2;
      case 2: {
        if (tag == 18) {
         parse_center:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_center()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(29)) goto parse_radius;
        break;
      }

      // required float radius = 3;
      case 3: {
        if (tag == 29) {
         parse_radius:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &radius_)));
          set_has_radius();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_a1;
        break;
      }

      // required float a1 = 4;
      case 4: {
        if (tag == 37) {
         parse_a1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &a1_)));
          set_has_a1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_a2;
        break;
      }

      // required float a2 = 5;
      case 5: {
        if (tag == 45) {
         parse_a2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &a2_)));
          set_has_a2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(53)) goto parse_thickness;
        break;
      }

      // required float thickness = 6;
      case 6: {
        if (tag == 53) {
         parse_thickness:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &thickness_)));
          set_has_thickness();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SSL_FieldCicularArc)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SSL_FieldCicularArc)
  return false;
#undef DO_
}

void SSL_FieldCicularArc::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SSL_FieldCicularArc)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // required .Vector2f center = 2;
  if (has_center()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->center(), output);
  }

  // required float radius = 3;
  if (has_radius()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->radius(), output);
  }

  // required float a1 = 4;
  if (has_a1()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->a1(), output);
  }

  // required float a2 = 5;
  if (has_a2()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->a2(), output);
  }

  // required float thickness = 6;
  if (has_thickness()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->thickness(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SSL_FieldCicularArc)
}

::google::protobuf::uint8* SSL_FieldCicularArc::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SSL_FieldCicularArc)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // required .Vector2f center = 2;
  if (has_center()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->center(), target);
  }

  // required float radius = 3;
  if (has_radius()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->radius(), target);
  }

  // required float a1 = 4;
  if (has_a1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->a1(), target);
  }

  // required float a2 = 5;
  if (has_a2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->a2(), target);
  }

  // required float thickness = 6;
  if (has_thickness()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->thickness(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SSL_FieldCicularArc)
  return target;
}

int SSL_FieldCicularArc::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required .Vector2f center = 2;
    if (has_center()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->center());
    }

    // required float radius = 3;
    if (has_radius()) {
      total_size += 1 + 4;
    }

    // required float a1 = 4;
    if (has_a1()) {
      total_size += 1 + 4;
    }

    // required float a2 = 5;
    if (has_a2()) {
      total_size += 1 + 4;
    }

    // required float thickness = 6;
    if (has_thickness()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SSL_FieldCicularArc::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SSL_FieldCicularArc* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SSL_FieldCicularArc*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SSL_FieldCicularArc::MergeFrom(const SSL_FieldCicularArc& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_center()) {
      mutable_center()->::Vector2f::MergeFrom(from.center());
    }
    if (from.has_radius()) {
      set_radius(from.radius());
    }
    if (from.has_a1()) {
      set_a1(from.a1());
    }
    if (from.has_a2()) {
      set_a2(from.a2());
    }
    if (from.has_thickness()) {
      set_thickness(from.thickness());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SSL_FieldCicularArc::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SSL_FieldCicularArc::CopyFrom(const SSL_FieldCicularArc& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SSL_FieldCicularArc::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  if (has_center()) {
    if (!this->center().IsInitialized()) return false;
  }
  return true;
}

void SSL_FieldCicularArc::Swap(SSL_FieldCicularArc* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(center_, other->center_);
    std::swap(radius_, other->radius_);
    std::swap(a1_, other->a1_);
    std::swap(a2_, other->a2_);
    std::swap(thickness_, other->thickness_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SSL_FieldCicularArc::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SSL_FieldCicularArc_descriptor_;
  metadata.reflection = SSL_FieldCicularArc_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SSL_GeometryFieldSize::kFieldLengthFieldNumber;
const int SSL_GeometryFieldSize::kFieldWidthFieldNumber;
const int SSL_GeometryFieldSize::kGoalWidthFieldNumber;
const int SSL_GeometryFieldSize::kGoalDepthFieldNumber;
const int SSL_GeometryFieldSize::kBoundaryWidthFieldNumber;
const int SSL_GeometryFieldSize::kFieldLinesFieldNumber;
const int SSL_GeometryFieldSize::kFieldArcsFieldNumber;
#endif  // !_MSC_VER

SSL_GeometryFieldSize::SSL_GeometryFieldSize()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SSL_GeometryFieldSize)
}

void SSL_GeometryFieldSize::InitAsDefaultInstance() {
}

SSL_GeometryFieldSize::SSL_GeometryFieldSize(const SSL_GeometryFieldSize& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SSL_GeometryFieldSize)
}

void SSL_GeometryFieldSize::SharedCtor() {
  _cached_size_ = 0;
  field_length_ = 0;
  field_width_ = 0;
  goal_width_ = 0;
  goal_depth_ = 0;
  boundary_width_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SSL_GeometryFieldSize::~SSL_GeometryFieldSize() {
  // @@protoc_insertion_point(destructor:SSL_GeometryFieldSize)
  SharedDtor();
}

void SSL_GeometryFieldSize::SharedDtor() {
  if (this != default_instance_) {
  }
}

void SSL_GeometryFieldSize::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SSL_GeometryFieldSize::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SSL_GeometryFieldSize_descriptor_;
}

const SSL_GeometryFieldSize& SSL_GeometryFieldSize::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

SSL_GeometryFieldSize* SSL_GeometryFieldSize::default_instance_ = NULL;

SSL_GeometryFieldSize* SSL_GeometryFieldSize::New() const {
  return new SSL_GeometryFieldSize;
}

void SSL_GeometryFieldSize::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<SSL_GeometryFieldSize*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(field_length_, goal_depth_);
    boundary_width_ = 0;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  field_lines_.Clear();
  field_arcs_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SSL_GeometryFieldSize::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SSL_GeometryFieldSize)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 field_length = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &field_length_)));
          set_has_field_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_field_width;
        break;
      }

      // required int32 field_width = 2;
      case 2: {
        if (tag == 16) {
         parse_field_width:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &field_width_)));
          set_has_field_width();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_goal_width;
        break;
      }

      // required int32 goal_width = 3;
      case 3: {
        if (tag == 24) {
         parse_goal_width:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &goal_width_)));
          set_has_goal_width();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_goal_depth;
        break;
      }

      // required int32 goal_depth = 4;
      case 4: {
        if (tag == 32) {
         parse_goal_depth:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &goal_depth_)));
          set_has_goal_depth();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_boundary_width;
        break;
      }

      // required int32 boundary_width = 5;
      case 5: {
        if (tag == 40) {
         parse_boundary_width:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &boundary_width_)));
          set_has_boundary_width();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_field_lines;
        break;
      }

      // repeated .SSL_FieldLineSegment field_lines = 6;
      case 6: {
        if (tag == 50) {
         parse_field_lines:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_field_lines()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_field_lines;
        if (input->ExpectTag(58)) goto parse_field_arcs;
        break;
      }

      // repeated .SSL_FieldCicularArc field_arcs = 7;
      case 7: {
        if (tag == 58) {
         parse_field_arcs:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_field_arcs()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_field_arcs;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SSL_GeometryFieldSize)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SSL_GeometryFieldSize)
  return false;
#undef DO_
}

void SSL_GeometryFieldSize::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SSL_GeometryFieldSize)
  // required int32 field_length = 1;
  if (has_field_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->field_length(), output);
  }

  // required int32 field_width = 2;
  if (has_field_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->field_width(), output);
  }

  // required int32 goal_width = 3;
  if (has_goal_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->goal_width(), output);
  }

  // required int32 goal_depth = 4;
  if (has_goal_depth()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->goal_depth(), output);
  }

  // required int32 boundary_width = 5;
  if (has_boundary_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->boundary_width(), output);
  }

  // repeated .SSL_FieldLineSegment field_lines = 6;
  for (int i = 0; i < this->field_lines_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->field_lines(i), output);
  }

  // repeated .SSL_FieldCicularArc field_arcs = 7;
  for (int i = 0; i < this->field_arcs_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->field_arcs(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SSL_GeometryFieldSize)
}

::google::protobuf::uint8* SSL_GeometryFieldSize::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SSL_GeometryFieldSize)
  // required int32 field_length = 1;
  if (has_field_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->field_length(), target);
  }

  // required int32 field_width = 2;
  if (has_field_width()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->field_width(), target);
  }

  // required int32 goal_width = 3;
  if (has_goal_width()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->goal_width(), target);
  }

  // required int32 goal_depth = 4;
  if (has_goal_depth()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->goal_depth(), target);
  }

  // required int32 boundary_width = 5;
  if (has_boundary_width()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->boundary_width(), target);
  }

  // repeated .SSL_FieldLineSegment field_lines = 6;
  for (int i = 0; i < this->field_lines_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->field_lines(i), target);
  }

  // repeated .SSL_FieldCicularArc field_arcs = 7;
  for (int i = 0; i < this->field_arcs_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->field_arcs(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SSL_GeometryFieldSize)
  return target;
}

int SSL_GeometryFieldSize::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 field_length = 1;
    if (has_field_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->field_length());
    }

    // required int32 field_width = 2;
    if (has_field_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->field_width());
    }

    // required int32 goal_width = 3;
    if (has_goal_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->goal_width());
    }

    // required int32 goal_depth = 4;
    if (has_goal_depth()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->goal_depth());
    }

    // required int32 boundary_width = 5;
    if (has_boundary_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->boundary_width());
    }

  }
  // repeated .SSL_FieldLineSegment field_lines = 6;
  total_size += 1 * this->field_lines_size();
  for (int i = 0; i < this->field_lines_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->field_lines(i));
  }

  // repeated .SSL_FieldCicularArc field_arcs = 7;
  total_size += 1 * this->field_arcs_size();
  for (int i = 0; i < this->field_arcs_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->field_arcs(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SSL_GeometryFieldSize::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SSL_GeometryFieldSize* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SSL_GeometryFieldSize*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SSL_GeometryFieldSize::MergeFrom(const SSL_GeometryFieldSize& from) {
  GOOGLE_CHECK_NE(&from, this);
  field_lines_.MergeFrom(from.field_lines_);
  field_arcs_.MergeFrom(from.field_arcs_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_field_length()) {
      set_field_length(from.field_length());
    }
    if (from.has_field_width()) {
      set_field_width(from.field_width());
    }
    if (from.has_goal_width()) {
      set_goal_width(from.goal_width());
    }
    if (from.has_goal_depth()) {
      set_goal_depth(from.goal_depth());
    }
    if (from.has_boundary_width()) {
      set_boundary_width(from.boundary_width());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SSL_GeometryFieldSize::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SSL_GeometryFieldSize::CopyFrom(const SSL_GeometryFieldSize& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SSL_GeometryFieldSize::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->field_lines())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->field_arcs())) return false;
  return true;
}

void SSL_GeometryFieldSize::Swap(SSL_GeometryFieldSize* other) {
  if (other != this) {
    std::swap(field_length_, other->field_length_);
    std::swap(field_width_, other->field_width_);
    std::swap(goal_width_, other->goal_width_);
    std::swap(goal_depth_, other->goal_depth_);
    std::swap(boundary_width_, other->boundary_width_);
    field_lines_.Swap(&other->field_lines_);
    field_arcs_.Swap(&other->field_arcs_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SSL_GeometryFieldSize::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SSL_GeometryFieldSize_descriptor_;
  metadata.reflection = SSL_GeometryFieldSize_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SSL_GeometryCameraCalibration::kCameraIdFieldNumber;
const int SSL_GeometryCameraCalibration::kFocalLengthFieldNumber;
const int SSL_GeometryCameraCalibration::kPrincipalPointXFieldNumber;
const int SSL_GeometryCameraCalibration::kPrincipalPointYFieldNumber;
const int SSL_GeometryCameraCalibration::kDistortionFieldNumber;
const int SSL_GeometryCameraCalibration::kQ0FieldNumber;
const int SSL_GeometryCameraCalibration::kQ1FieldNumber;
const int SSL_GeometryCameraCalibration::kQ2FieldNumber;
const int SSL_GeometryCameraCalibration::kQ3FieldNumber;
const int SSL_GeometryCameraCalibration::kTxFieldNumber;
const int SSL_GeometryCameraCalibration::kTyFieldNumber;
const int SSL_GeometryCameraCalibration::kTzFieldNumber;
const int SSL_GeometryCameraCalibration::kDerivedCameraWorldTxFieldNumber;
const int SSL_GeometryCameraCalibration::kDerivedCameraWorldTyFieldNumber;
const int SSL_GeometryCameraCalibration::kDerivedCameraWorldTzFieldNumber;
#endif  // !_MSC_VER

SSL_GeometryCameraCalibration::SSL_GeometryCameraCalibration()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SSL_GeometryCameraCalibration)
}

void SSL_GeometryCameraCalibration::InitAsDefaultInstance() {
}

SSL_GeometryCameraCalibration::SSL_GeometryCameraCalibration(const SSL_GeometryCameraCalibration& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SSL_GeometryCameraCalibration)
}

void SSL_GeometryCameraCalibration::SharedCtor() {
  _cached_size_ = 0;
  camera_id_ = 0u;
  focal_length_ = 0;
  principal_point_x_ = 0;
  principal_point_y_ = 0;
  distortion_ = 0;
  q0_ = 0;
  q1_ = 0;
  q2_ = 0;
  q3_ = 0;
  tx_ = 0;
  ty_ = 0;
  tz_ = 0;
  derived_camera_world_tx_ = 0;
  derived_camera_world_ty_ = 0;
  derived_camera_world_tz_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SSL_GeometryCameraCalibration::~SSL_GeometryCameraCalibration() {
  // @@protoc_insertion_point(destructor:SSL_GeometryCameraCalibration)
  SharedDtor();
}

void SSL_GeometryCameraCalibration::SharedDtor() {
  if (this != default_instance_) {
  }
}

void SSL_GeometryCameraCalibration::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SSL_GeometryCameraCalibration::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SSL_GeometryCameraCalibration_descriptor_;
}

const SSL_GeometryCameraCalibration& SSL_GeometryCameraCalibration::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

SSL_GeometryCameraCalibration* SSL_GeometryCameraCalibration::default_instance_ = NULL;

SSL_GeometryCameraCalibration* SSL_GeometryCameraCalibration::New() const {
  return new SSL_GeometryCameraCalibration;
}

void SSL_GeometryCameraCalibration::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<SSL_GeometryCameraCalibration*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(camera_id_, q2_);
  }
  if (_has_bits_[8 / 32] & 32512) {
    ZR_(q3_, derived_camera_world_tz_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SSL_GeometryCameraCalibration::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SSL_GeometryCameraCalibration)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 camera_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &camera_id_)));
          set_has_camera_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(21)) goto parse_focal_length;
        break;
      }

      // required float focal_length = 2;
      case 2: {
        if (tag == 21) {
         parse_focal_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &focal_length_)));
          set_has_focal_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(29)) goto parse_principal_point_x;
        break;
      }

      // required float principal_point_x = 3;
      case 3: {
        if (tag == 29) {
         parse_principal_point_x:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &principal_point_x_)));
          set_has_principal_point_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_principal_point_y;
        break;
      }

      // required float principal_point_y = 4;
      case 4: {
        if (tag == 37) {
         parse_principal_point_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &principal_point_y_)));
          set_has_principal_point_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_distortion;
        break;
      }

      // required float distortion = 5;
      case 5: {
        if (tag == 45) {
         parse_distortion:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &distortion_)));
          set_has_distortion();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(53)) goto parse_q0;
        break;
      }

      // required float q0 = 6;
      case 6: {
        if (tag == 53) {
         parse_q0:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &q0_)));
          set_has_q0();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_q1;
        break;
      }

      // required float q1 = 7;
      case 7: {
        if (tag == 61) {
         parse_q1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &q1_)));
          set_has_q1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_q2;
        break;
      }

      // required float q2 = 8;
      case 8: {
        if (tag == 69) {
         parse_q2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &q2_)));
          set_has_q2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(77)) goto parse_q3;
        break;
      }

      // required float q3 = 9;
      case 9: {
        if (tag == 77) {
         parse_q3:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &q3_)));
          set_has_q3();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(85)) goto parse_tx;
        break;
      }

      // required float tx = 10;
      case 10: {
        if (tag == 85) {
         parse_tx:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tx_)));
          set_has_tx();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(93)) goto parse_ty;
        break;
      }

      // required float ty = 11;
      case 11: {
        if (tag == 93) {
         parse_ty:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &ty_)));
          set_has_ty();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(101)) goto parse_tz;
        break;
      }

      // required float tz = 12;
      case 12: {
        if (tag == 101) {
         parse_tz:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tz_)));
          set_has_tz();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(109)) goto parse_derived_camera_world_tx;
        break;
      }

      // optional float derived_camera_world_tx = 13;
      case 13: {
        if (tag == 109) {
         parse_derived_camera_world_tx:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &derived_camera_world_tx_)));
          set_has_derived_camera_world_tx();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(117)) goto parse_derived_camera_world_ty;
        break;
      }

      // optional float derived_camera_world_ty = 14;
      case 14: {
        if (tag == 117) {
         parse_derived_camera_world_ty:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &derived_camera_world_ty_)));
          set_has_derived_camera_world_ty();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(125)) goto parse_derived_camera_world_tz;
        break;
      }

      // optional float derived_camera_world_tz = 15;
      case 15: {
        if (tag == 125) {
         parse_derived_camera_world_tz:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &derived_camera_world_tz_)));
          set_has_derived_camera_world_tz();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SSL_GeometryCameraCalibration)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SSL_GeometryCameraCalibration)
  return false;
#undef DO_
}

void SSL_GeometryCameraCalibration::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SSL_GeometryCameraCalibration)
  // required uint32 camera_id = 1;
  if (has_camera_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->camera_id(), output);
  }

  // required float focal_length = 2;
  if (has_focal_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->focal_length(), output);
  }

  // required float principal_point_x = 3;
  if (has_principal_point_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->principal_point_x(), output);
  }

  // required float principal_point_y = 4;
  if (has_principal_point_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->principal_point_y(), output);
  }

  // required float distortion = 5;
  if (has_distortion()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->distortion(), output);
  }

  // required float q0 = 6;
  if (has_q0()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->q0(), output);
  }

  // required float q1 = 7;
  if (has_q1()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->q1(), output);
  }

  // required float q2 = 8;
  if (has_q2()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->q2(), output);
  }

  // required float q3 = 9;
  if (has_q3()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->q3(), output);
  }

  // required float tx = 10;
  if (has_tx()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->tx(), output);
  }

  // required float ty = 11;
  if (has_ty()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->ty(), output);
  }

  // required float tz = 12;
  if (has_tz()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->tz(), output);
  }

  // optional float derived_camera_world_tx = 13;
  if (has_derived_camera_world_tx()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->derived_camera_world_tx(), output);
  }

  // optional float derived_camera_world_ty = 14;
  if (has_derived_camera_world_ty()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(14, this->derived_camera_world_ty(), output);
  }

  // optional float derived_camera_world_tz = 15;
  if (has_derived_camera_world_tz()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(15, this->derived_camera_world_tz(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SSL_GeometryCameraCalibration)
}

::google::protobuf::uint8* SSL_GeometryCameraCalibration::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SSL_GeometryCameraCalibration)
  // required uint32 camera_id = 1;
  if (has_camera_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->camera_id(), target);
  }

  // required float focal_length = 2;
  if (has_focal_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->focal_length(), target);
  }

  // required float principal_point_x = 3;
  if (has_principal_point_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->principal_point_x(), target);
  }

  // required float principal_point_y = 4;
  if (has_principal_point_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->principal_point_y(), target);
  }

  // required float distortion = 5;
  if (has_distortion()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->distortion(), target);
  }

  // required float q0 = 6;
  if (has_q0()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->q0(), target);
  }

  // required float q1 = 7;
  if (has_q1()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->q1(), target);
  }

  // required float q2 = 8;
  if (has_q2()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->q2(), target);
  }

  // required float q3 = 9;
  if (has_q3()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->q3(), target);
  }

  // required float tx = 10;
  if (has_tx()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->tx(), target);
  }

  // required float ty = 11;
  if (has_ty()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->ty(), target);
  }

  // required float tz = 12;
  if (has_tz()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->tz(), target);
  }

  // optional float derived_camera_world_tx = 13;
  if (has_derived_camera_world_tx()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->derived_camera_world_tx(), target);
  }

  // optional float derived_camera_world_ty = 14;
  if (has_derived_camera_world_ty()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(14, this->derived_camera_world_ty(), target);
  }

  // optional float derived_camera_world_tz = 15;
  if (has_derived_camera_world_tz()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(15, this->derived_camera_world_tz(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SSL_GeometryCameraCalibration)
  return target;
}

int SSL_GeometryCameraCalibration::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 camera_id = 1;
    if (has_camera_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->camera_id());
    }

    // required float focal_length = 2;
    if (has_focal_length()) {
      total_size += 1 + 4;
    }

    // required float principal_point_x = 3;
    if (has_principal_point_x()) {
      total_size += 1 + 4;
    }

    // required float principal_point_y = 4;
    if (has_principal_point_y()) {
      total_size += 1 + 4;
    }

    // required float distortion = 5;
    if (has_distortion()) {
      total_size += 1 + 4;
    }

    // required float q0 = 6;
    if (has_q0()) {
      total_size += 1 + 4;
    }

    // required float q1 = 7;
    if (has_q1()) {
      total_size += 1 + 4;
    }

    // required float q2 = 8;
    if (has_q2()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // required float q3 = 9;
    if (has_q3()) {
      total_size += 1 + 4;
    }

    // required float tx = 10;
    if (has_tx()) {
      total_size += 1 + 4;
    }

    // required float ty = 11;
    if (has_ty()) {
      total_size += 1 + 4;
    }

    // required float tz = 12;
    if (has_tz()) {
      total_size += 1 + 4;
    }

    // optional float derived_camera_world_tx = 13;
    if (has_derived_camera_world_tx()) {
      total_size += 1 + 4;
    }

    // optional float derived_camera_world_ty = 14;
    if (has_derived_camera_world_ty()) {
      total_size += 1 + 4;
    }

    // optional float derived_camera_world_tz = 15;
    if (has_derived_camera_world_tz()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SSL_GeometryCameraCalibration::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SSL_GeometryCameraCalibration* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SSL_GeometryCameraCalibration*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SSL_GeometryCameraCalibration::MergeFrom(const SSL_GeometryCameraCalibration& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_camera_id()) {
      set_camera_id(from.camera_id());
    }
    if (from.has_focal_length()) {
      set_focal_length(from.focal_length());
    }
    if (from.has_principal_point_x()) {
      set_principal_point_x(from.principal_point_x());
    }
    if (from.has_principal_point_y()) {
      set_principal_point_y(from.principal_point_y());
    }
    if (from.has_distortion()) {
      set_distortion(from.distortion());
    }
    if (from.has_q0()) {
      set_q0(from.q0());
    }
    if (from.has_q1()) {
      set_q1(from.q1());
    }
    if (from.has_q2()) {
      set_q2(from.q2());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_q3()) {
      set_q3(from.q3());
    }
    if (from.has_tx()) {
      set_tx(from.tx());
    }
    if (from.has_ty()) {
      set_ty(from.ty());
    }
    if (from.has_tz()) {
      set_tz(from.tz());
    }
    if (from.has_derived_camera_world_tx()) {
      set_derived_camera_world_tx(from.derived_camera_world_tx());
    }
    if (from.has_derived_camera_world_ty()) {
      set_derived_camera_world_ty(from.derived_camera_world_ty());
    }
    if (from.has_derived_camera_world_tz()) {
      set_derived_camera_world_tz(from.derived_camera_world_tz());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SSL_GeometryCameraCalibration::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SSL_GeometryCameraCalibration::CopyFrom(const SSL_GeometryCameraCalibration& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SSL_GeometryCameraCalibration::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000fff) != 0x00000fff) return false;

  return true;
}

void SSL_GeometryCameraCalibration::Swap(SSL_GeometryCameraCalibration* other) {
  if (other != this) {
    std::swap(camera_id_, other->camera_id_);
    std::swap(focal_length_, other->focal_length_);
    std::swap(principal_point_x_, other->principal_point_x_);
    std::swap(principal_point_y_, other->principal_point_y_);
    std::swap(distortion_, other->distortion_);
    std::swap(q0_, other->q0_);
    std::swap(q1_, other->q1_);
    std::swap(q2_, other->q2_);
    std::swap(q3_, other->q3_);
    std::swap(tx_, other->tx_);
    std::swap(ty_, other->ty_);
    std::swap(tz_, other->tz_);
    std::swap(derived_camera_world_tx_, other->derived_camera_world_tx_);
    std::swap(derived_camera_world_ty_, other->derived_camera_world_ty_);
    std::swap(derived_camera_world_tz_, other->derived_camera_world_tz_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SSL_GeometryCameraCalibration::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SSL_GeometryCameraCalibration_descriptor_;
  metadata.reflection = SSL_GeometryCameraCalibration_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SSL_GeometryData::kFieldFieldNumber;
const int SSL_GeometryData::kCalibFieldNumber;
#endif  // !_MSC_VER

SSL_GeometryData::SSL_GeometryData()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SSL_GeometryData)
}

void SSL_GeometryData::InitAsDefaultInstance() {
  field_ = const_cast< ::SSL_GeometryFieldSize*>(&::SSL_GeometryFieldSize::default_instance());
}

SSL_GeometryData::SSL_GeometryData(const SSL_GeometryData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SSL_GeometryData)
}

void SSL_GeometryData::SharedCtor() {
  _cached_size_ = 0;
  field_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SSL_GeometryData::~SSL_GeometryData() {
  // @@protoc_insertion_point(destructor:SSL_GeometryData)
  SharedDtor();
}

void SSL_GeometryData::SharedDtor() {
  if (this != default_instance_) {
    delete field_;
  }
}

void SSL_GeometryData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SSL_GeometryData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SSL_GeometryData_descriptor_;
}

const SSL_GeometryData& SSL_GeometryData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_messages_5frobocup_5fssl_5fgeometry_2eproto();
  return *default_instance_;
}

SSL_GeometryData* SSL_GeometryData::default_instance_ = NULL;

SSL_GeometryData* SSL_GeometryData::New() const {
  return new SSL_GeometryData;
}

void SSL_GeometryData::Clear() {
  if (has_field()) {
    if (field_ != NULL) field_->::SSL_GeometryFieldSize::Clear();
  }
  calib_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SSL_GeometryData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SSL_GeometryData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .SSL_GeometryFieldSize field = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_field()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_calib;
        break;
      }

      // repeated .SSL_GeometryCameraCalibration calib = 2;
      case 2: {
        if (tag == 18) {
         parse_calib:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_calib()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_calib;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SSL_GeometryData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SSL_GeometryData)
  return false;
#undef DO_
}

void SSL_GeometryData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SSL_GeometryData)
  // required .SSL_GeometryFieldSize field = 1;
  if (has_field()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->field(), output);
  }

  // repeated .SSL_GeometryCameraCalibration calib = 2;
  for (int i = 0; i < this->calib_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->calib(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SSL_GeometryData)
}

::google::protobuf::uint8* SSL_GeometryData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SSL_GeometryData)
  // required .SSL_GeometryFieldSize field = 1;
  if (has_field()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->field(), target);
  }

  // repeated .SSL_GeometryCameraCalibration calib = 2;
  for (int i = 0; i < this->calib_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->calib(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SSL_GeometryData)
  return target;
}

int SSL_GeometryData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .SSL_GeometryFieldSize field = 1;
    if (has_field()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->field());
    }

  }
  // repeated .SSL_GeometryCameraCalibration calib = 2;
  total_size += 1 * this->calib_size();
  for (int i = 0; i < this->calib_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->calib(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SSL_GeometryData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SSL_GeometryData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SSL_GeometryData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SSL_GeometryData::MergeFrom(const SSL_GeometryData& from) {
  GOOGLE_CHECK_NE(&from, this);
  calib_.MergeFrom(from.calib_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_field()) {
      mutable_field()->::SSL_GeometryFieldSize::MergeFrom(from.field());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SSL_GeometryData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SSL_GeometryData::CopyFrom(const SSL_GeometryData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SSL_GeometryData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_field()) {
    if (!this->field().IsInitialized()) return false;
  }
  if (!::google::protobuf::internal::AllAreInitialized(this->calib())) return false;
  return true;
}

void SSL_GeometryData::Swap(SSL_GeometryData* other) {
  if (other != this) {
    std::swap(field_, other->field_);
    calib_.Swap(&other->calib_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata SSL_GeometryData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SSL_GeometryData_descriptor_;
  metadata.reflection = SSL_GeometryData_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)
