// Generated by the protocol buffer compiler.  DO NOT EDIT!

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "ctrl.pb.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/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace ril_proto {

namespace {

const ::google::protobuf::Descriptor* CtrlReqRadioState_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlReqRadioState_reflection_ = NULL;
const ::google::protobuf::Descriptor* CtrlRspRadioState_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlRspRadioState_reflection_ = NULL;
const ::google::protobuf::Descriptor* CtrlReqSetMTCall_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlReqSetMTCall_reflection_ = NULL;
const ::google::protobuf::Descriptor* CtrlHangupConnRemote_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlHangupConnRemote_reflection_ = NULL;
const ::google::protobuf::Descriptor* CtrlSetCallTransitionFlag_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlSetCallTransitionFlag_reflection_ = NULL;
const ::google::protobuf::Descriptor* CtrlReqAddDialingCall_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CtrlReqAddDialingCall_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* CtrlCmd_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* CtrlStatus_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_ctrl_2eproto() {
  protobuf_AddDesc_ctrl_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "ctrl.proto");
  GOOGLE_CHECK(file != NULL);
  CtrlReqRadioState_descriptor_ = file->message_type(0);
  static const int CtrlReqRadioState_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, state_),
  };
  CtrlReqRadioState_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlReqRadioState_descriptor_,
      CtrlReqRadioState::default_instance_,
      CtrlReqRadioState_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqRadioState, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlReqRadioState));
  CtrlRspRadioState_descriptor_ = file->message_type(1);
  static const int CtrlRspRadioState_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, state_),
  };
  CtrlRspRadioState_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlRspRadioState_descriptor_,
      CtrlRspRadioState::default_instance_,
      CtrlRspRadioState_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlRspRadioState, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlRspRadioState));
  CtrlReqSetMTCall_descriptor_ = file->message_type(2);
  static const int CtrlReqSetMTCall_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, phone_number_),
  };
  CtrlReqSetMTCall_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlReqSetMTCall_descriptor_,
      CtrlReqSetMTCall::default_instance_,
      CtrlReqSetMTCall_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqSetMTCall, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlReqSetMTCall));
  CtrlHangupConnRemote_descriptor_ = file->message_type(3);
  static const int CtrlHangupConnRemote_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, connection_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, call_fail_cause_),
  };
  CtrlHangupConnRemote_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlHangupConnRemote_descriptor_,
      CtrlHangupConnRemote::default_instance_,
      CtrlHangupConnRemote_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlHangupConnRemote, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlHangupConnRemote));
  CtrlSetCallTransitionFlag_descriptor_ = file->message_type(4);
  static const int CtrlSetCallTransitionFlag_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, flag_),
  };
  CtrlSetCallTransitionFlag_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlSetCallTransitionFlag_descriptor_,
      CtrlSetCallTransitionFlag::default_instance_,
      CtrlSetCallTransitionFlag_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlSetCallTransitionFlag, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlSetCallTransitionFlag));
  CtrlReqAddDialingCall_descriptor_ = file->message_type(5);
  static const int CtrlReqAddDialingCall_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, phone_number_),
  };
  CtrlReqAddDialingCall_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CtrlReqAddDialingCall_descriptor_,
      CtrlReqAddDialingCall::default_instance_,
      CtrlReqAddDialingCall_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CtrlReqAddDialingCall, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CtrlReqAddDialingCall));
  CtrlCmd_descriptor_ = file->enum_type(0);
  CtrlStatus_descriptor_ = file->enum_type(1);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlReqRadioState_descriptor_, &CtrlReqRadioState::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlRspRadioState_descriptor_, &CtrlRspRadioState::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlReqSetMTCall_descriptor_, &CtrlReqSetMTCall::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlHangupConnRemote_descriptor_, &CtrlHangupConnRemote::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlSetCallTransitionFlag_descriptor_, &CtrlSetCallTransitionFlag::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CtrlReqAddDialingCall_descriptor_, &CtrlReqAddDialingCall::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_ctrl_2eproto() {
  delete CtrlReqRadioState::default_instance_;
  delete CtrlReqRadioState_reflection_;
  delete CtrlRspRadioState::default_instance_;
  delete CtrlRspRadioState_reflection_;
  delete CtrlReqSetMTCall::default_instance_;
  delete CtrlReqSetMTCall_reflection_;
  delete CtrlHangupConnRemote::default_instance_;
  delete CtrlHangupConnRemote_reflection_;
  delete CtrlSetCallTransitionFlag::default_instance_;
  delete CtrlSetCallTransitionFlag_reflection_;
  delete CtrlReqAddDialingCall::default_instance_;
  delete CtrlReqAddDialingCall_reflection_;
}

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

  ::ril_proto::protobuf_AddDesc_ril_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\nctrl.proto\022\tril_proto\032\tril.proto\"9\n\021Ct"
    "rlReqRadioState\022$\n\005state\030\001 \002(\0162\025.ril_pro"
    "to.RadioState\"9\n\021CtrlRspRadioState\022$\n\005st"
    "ate\030\001 \002(\0162\025.ril_proto.RadioState\"(\n\020Ctrl"
    "ReqSetMTCall\022\024\n\014phone_number\030\001 \002(\t\"F\n\024Ct"
    "rlHangupConnRemote\022\025\n\rconnection_id\030\001 \002("
    "\005\022\027\n\017call_fail_cause\030\002 \002(\005\")\n\031CtrlSetCal"
    "lTransitionFlag\022\014\n\004flag\030\001 \002(\010\"-\n\025CtrlReq"
    "AddDialingCall\022\024\n\014phone_number\030\001 \002(\t*\232\002\n"
    "\007CtrlCmd\022\021\n\rCTRL_CMD_ECHO\020\000\022\034\n\030CTRL_CMD_"
    "GET_RADIO_STATE\020\001\022\034\n\030CTRL_CMD_SET_RADIO_"
    "STATE\020\002\022\031\n\024CTRL_CMD_SET_MT_CALL\020\351\007\022 \n\033CT"
    "RL_CMD_HANGUP_CONN_REMOTE\020\352\007\022&\n!CTRL_CMD"
    "_SET_CALL_TRANSITION_FLAG\020\353\007\022\034\n\027CTRL_CMD"
    "_SET_CALL_ALERT\020\354\007\022\035\n\030CTRL_CMD_SET_CALL_"
    "ACTIVE\020\355\007\022\036\n\031CTRL_CMD_ADD_DIALING_CALL\020\356"
    "\007*5\n\nCtrlStatus\022\022\n\016CTRL_STATUS_OK\020\000\022\023\n\017C"
    "TRL_STATUS_ERR\020\001B7\n(com.android.internal"
    ".telephony.ril_protoB\013RilCtrlCmds", 753);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "ctrl.proto", &protobuf_RegisterTypes);
  CtrlReqRadioState::default_instance_ = new CtrlReqRadioState();
  CtrlRspRadioState::default_instance_ = new CtrlRspRadioState();
  CtrlReqSetMTCall::default_instance_ = new CtrlReqSetMTCall();
  CtrlHangupConnRemote::default_instance_ = new CtrlHangupConnRemote();
  CtrlSetCallTransitionFlag::default_instance_ = new CtrlSetCallTransitionFlag();
  CtrlReqAddDialingCall::default_instance_ = new CtrlReqAddDialingCall();
  CtrlReqRadioState::default_instance_->InitAsDefaultInstance();
  CtrlRspRadioState::default_instance_->InitAsDefaultInstance();
  CtrlReqSetMTCall::default_instance_->InitAsDefaultInstance();
  CtrlHangupConnRemote::default_instance_->InitAsDefaultInstance();
  CtrlSetCallTransitionFlag::default_instance_->InitAsDefaultInstance();
  CtrlReqAddDialingCall::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ctrl_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_ctrl_2eproto {
  StaticDescriptorInitializer_ctrl_2eproto() {
    protobuf_AddDesc_ctrl_2eproto();
  }
} static_descriptor_initializer_ctrl_2eproto_;

const ::google::protobuf::EnumDescriptor* CtrlCmd_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CtrlCmd_descriptor_;
}
bool CtrlCmd_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 1001:
    case 1002:
    case 1003:
    case 1004:
    case 1005:
    case 1006:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* CtrlStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CtrlStatus_descriptor_;
}
bool CtrlStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int CtrlReqRadioState::kStateFieldNumber;
#endif  // !_MSC_VER

CtrlReqRadioState::CtrlReqRadioState()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlReqRadioState::InitAsDefaultInstance() {
}

CtrlReqRadioState::CtrlReqRadioState(const CtrlReqRadioState& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlReqRadioState::SharedCtor() {
  _cached_size_ = 0;
  state_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlReqRadioState::~CtrlReqRadioState() {
  SharedDtor();
}

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

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

const CtrlReqRadioState& CtrlReqRadioState::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlReqRadioState* CtrlReqRadioState::default_instance_ = NULL;

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

void CtrlReqRadioState::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    state_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlReqRadioState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ril_proto.RadioState state = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (ril_proto::RadioState_IsValid(value)) {
            set_state(static_cast< ril_proto::RadioState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlReqRadioState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ril_proto.RadioState state = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlReqRadioState::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .ril_proto.RadioState state = 1;
  if (_has_bit(0)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->state(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlReqRadioState::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ril_proto.RadioState state = 1;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }
    
  }
  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 CtrlReqRadioState::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlReqRadioState* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqRadioState*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlReqRadioState::MergeFrom(const CtrlReqRadioState& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_state(from.state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlReqRadioState::Swap(CtrlReqRadioState* other) {
  if (other != this) {
    std::swap(state_, other->state_);
    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 CtrlReqRadioState::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlReqRadioState_descriptor_;
  metadata.reflection = CtrlReqRadioState_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CtrlRspRadioState::kStateFieldNumber;
#endif  // !_MSC_VER

CtrlRspRadioState::CtrlRspRadioState()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlRspRadioState::InitAsDefaultInstance() {
}

CtrlRspRadioState::CtrlRspRadioState(const CtrlRspRadioState& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlRspRadioState::SharedCtor() {
  _cached_size_ = 0;
  state_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlRspRadioState::~CtrlRspRadioState() {
  SharedDtor();
}

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

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

const CtrlRspRadioState& CtrlRspRadioState::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlRspRadioState* CtrlRspRadioState::default_instance_ = NULL;

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

void CtrlRspRadioState::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    state_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlRspRadioState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ril_proto.RadioState state = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (ril_proto::RadioState_IsValid(value)) {
            set_state(static_cast< ril_proto::RadioState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlRspRadioState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ril_proto.RadioState state = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlRspRadioState::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .ril_proto.RadioState state = 1;
  if (_has_bit(0)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->state(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlRspRadioState::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ril_proto.RadioState state = 1;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }
    
  }
  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 CtrlRspRadioState::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlRspRadioState* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlRspRadioState*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlRspRadioState::MergeFrom(const CtrlRspRadioState& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_state(from.state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlRspRadioState::Swap(CtrlRspRadioState* other) {
  if (other != this) {
    std::swap(state_, other->state_);
    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 CtrlRspRadioState::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlRspRadioState_descriptor_;
  metadata.reflection = CtrlRspRadioState_reflection_;
  return metadata;
}


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

const ::std::string CtrlReqSetMTCall::_default_phone_number_;
#ifndef _MSC_VER
const int CtrlReqSetMTCall::kPhoneNumberFieldNumber;
#endif  // !_MSC_VER

CtrlReqSetMTCall::CtrlReqSetMTCall()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlReqSetMTCall::InitAsDefaultInstance() {
}

CtrlReqSetMTCall::CtrlReqSetMTCall(const CtrlReqSetMTCall& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlReqSetMTCall::SharedCtor() {
  _cached_size_ = 0;
  phone_number_ = const_cast< ::std::string*>(&_default_phone_number_);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlReqSetMTCall::~CtrlReqSetMTCall() {
  SharedDtor();
}

void CtrlReqSetMTCall::SharedDtor() {
  if (phone_number_ != &_default_phone_number_) {
    delete phone_number_;
  }
  if (this != default_instance_) {
  }
}

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

const CtrlReqSetMTCall& CtrlReqSetMTCall::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlReqSetMTCall* CtrlReqSetMTCall::default_instance_ = NULL;

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

void CtrlReqSetMTCall::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (_has_bit(0)) {
      if (phone_number_ != &_default_phone_number_) {
        phone_number_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlReqSetMTCall::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string phone_number = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_phone_number()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->phone_number().data(), this->phone_number().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlReqSetMTCall::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string phone_number = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->phone_number().data(), this->phone_number().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->phone_number(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlReqSetMTCall::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string phone_number = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->phone_number().data(), this->phone_number().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->phone_number(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlReqSetMTCall::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string phone_number = 1;
    if (has_phone_number()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->phone_number());
    }
    
  }
  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 CtrlReqSetMTCall::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlReqSetMTCall* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqSetMTCall*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlReqSetMTCall::MergeFrom(const CtrlReqSetMTCall& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_phone_number(from.phone_number());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlReqSetMTCall::Swap(CtrlReqSetMTCall* other) {
  if (other != this) {
    std::swap(phone_number_, other->phone_number_);
    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 CtrlReqSetMTCall::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlReqSetMTCall_descriptor_;
  metadata.reflection = CtrlReqSetMTCall_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CtrlHangupConnRemote::kConnectionIdFieldNumber;
const int CtrlHangupConnRemote::kCallFailCauseFieldNumber;
#endif  // !_MSC_VER

CtrlHangupConnRemote::CtrlHangupConnRemote()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlHangupConnRemote::InitAsDefaultInstance() {
}

CtrlHangupConnRemote::CtrlHangupConnRemote(const CtrlHangupConnRemote& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlHangupConnRemote::SharedCtor() {
  _cached_size_ = 0;
  connection_id_ = 0;
  call_fail_cause_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlHangupConnRemote::~CtrlHangupConnRemote() {
  SharedDtor();
}

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

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

const CtrlHangupConnRemote& CtrlHangupConnRemote::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlHangupConnRemote* CtrlHangupConnRemote::default_instance_ = NULL;

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

void CtrlHangupConnRemote::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    connection_id_ = 0;
    call_fail_cause_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlHangupConnRemote::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 connection_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &connection_id_)));
          _set_bit(0);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_call_fail_cause;
        break;
      }
      
      // required int32 call_fail_cause = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_call_fail_cause:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &call_fail_cause_)));
          _set_bit(1);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlHangupConnRemote::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 connection_id = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->connection_id(), output);
  }
  
  // required int32 call_fail_cause = 2;
  if (_has_bit(1)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->call_fail_cause(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlHangupConnRemote::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required int32 connection_id = 1;
  if (_has_bit(0)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->connection_id(), target);
  }
  
  // required int32 call_fail_cause = 2;
  if (_has_bit(1)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->call_fail_cause(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlHangupConnRemote::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 connection_id = 1;
    if (has_connection_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->connection_id());
    }
    
    // required int32 call_fail_cause = 2;
    if (has_call_fail_cause()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->call_fail_cause());
    }
    
  }
  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 CtrlHangupConnRemote::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlHangupConnRemote* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlHangupConnRemote*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlHangupConnRemote::MergeFrom(const CtrlHangupConnRemote& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_connection_id(from.connection_id());
    }
    if (from._has_bit(1)) {
      set_call_fail_cause(from.call_fail_cause());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlHangupConnRemote::Swap(CtrlHangupConnRemote* other) {
  if (other != this) {
    std::swap(connection_id_, other->connection_id_);
    std::swap(call_fail_cause_, other->call_fail_cause_);
    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 CtrlHangupConnRemote::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlHangupConnRemote_descriptor_;
  metadata.reflection = CtrlHangupConnRemote_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CtrlSetCallTransitionFlag::kFlagFieldNumber;
#endif  // !_MSC_VER

CtrlSetCallTransitionFlag::CtrlSetCallTransitionFlag()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlSetCallTransitionFlag::InitAsDefaultInstance() {
}

CtrlSetCallTransitionFlag::CtrlSetCallTransitionFlag(const CtrlSetCallTransitionFlag& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlSetCallTransitionFlag::SharedCtor() {
  _cached_size_ = 0;
  flag_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlSetCallTransitionFlag::~CtrlSetCallTransitionFlag() {
  SharedDtor();
}

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

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

const CtrlSetCallTransitionFlag& CtrlSetCallTransitionFlag::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlSetCallTransitionFlag* CtrlSetCallTransitionFlag::default_instance_ = NULL;

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

void CtrlSetCallTransitionFlag::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    flag_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlSetCallTransitionFlag::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bool flag = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &flag_)));
          _set_bit(0);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlSetCallTransitionFlag::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required bool flag = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->flag(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlSetCallTransitionFlag::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required bool flag = 1;
  if (_has_bit(0)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->flag(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlSetCallTransitionFlag::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bool flag = 1;
    if (has_flag()) {
      total_size += 1 + 1;
    }
    
  }
  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 CtrlSetCallTransitionFlag::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlSetCallTransitionFlag* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlSetCallTransitionFlag*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlSetCallTransitionFlag::MergeFrom(const CtrlSetCallTransitionFlag& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_flag(from.flag());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlSetCallTransitionFlag::Swap(CtrlSetCallTransitionFlag* other) {
  if (other != this) {
    std::swap(flag_, other->flag_);
    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 CtrlSetCallTransitionFlag::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlSetCallTransitionFlag_descriptor_;
  metadata.reflection = CtrlSetCallTransitionFlag_reflection_;
  return metadata;
}


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

const ::std::string CtrlReqAddDialingCall::_default_phone_number_;
#ifndef _MSC_VER
const int CtrlReqAddDialingCall::kPhoneNumberFieldNumber;
#endif  // !_MSC_VER

CtrlReqAddDialingCall::CtrlReqAddDialingCall()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CtrlReqAddDialingCall::InitAsDefaultInstance() {
}

CtrlReqAddDialingCall::CtrlReqAddDialingCall(const CtrlReqAddDialingCall& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CtrlReqAddDialingCall::SharedCtor() {
  _cached_size_ = 0;
  phone_number_ = const_cast< ::std::string*>(&_default_phone_number_);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CtrlReqAddDialingCall::~CtrlReqAddDialingCall() {
  SharedDtor();
}

void CtrlReqAddDialingCall::SharedDtor() {
  if (phone_number_ != &_default_phone_number_) {
    delete phone_number_;
  }
  if (this != default_instance_) {
  }
}

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

const CtrlReqAddDialingCall& CtrlReqAddDialingCall::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ctrl_2eproto();  return *default_instance_;
}

CtrlReqAddDialingCall* CtrlReqAddDialingCall::default_instance_ = NULL;

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

void CtrlReqAddDialingCall::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (_has_bit(0)) {
      if (phone_number_ != &_default_phone_number_) {
        phone_number_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CtrlReqAddDialingCall::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string phone_number = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_phone_number()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->phone_number().data(), this->phone_number().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CtrlReqAddDialingCall::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string phone_number = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->phone_number().data(), this->phone_number().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->phone_number(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CtrlReqAddDialingCall::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string phone_number = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->phone_number().data(), this->phone_number().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->phone_number(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int CtrlReqAddDialingCall::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string phone_number = 1;
    if (has_phone_number()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->phone_number());
    }
    
  }
  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 CtrlReqAddDialingCall::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CtrlReqAddDialingCall* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CtrlReqAddDialingCall*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CtrlReqAddDialingCall::MergeFrom(const CtrlReqAddDialingCall& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_phone_number(from.phone_number());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void CtrlReqAddDialingCall::Swap(CtrlReqAddDialingCall* other) {
  if (other != this) {
    std::swap(phone_number_, other->phone_number_);
    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 CtrlReqAddDialingCall::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CtrlReqAddDialingCall_descriptor_;
  metadata.reflection = CtrlReqAddDialingCall_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace ril_proto

// @@protoc_insertion_point(global_scope)
