FishConfig/FishProtocol(捕鱼的proto参考用)/fish_activity2.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "fish_activity2.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 fish_protocols {

namespace {

const ::google::protobuf::Descriptor* packetc2l_get_crab_info_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_get_crab_info_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_syn_crab_info_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_syn_crab_info_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_req_attack_crab_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_req_attack_crab_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_req_attack_crab_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_req_attack_crab_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_req_crab_harm_rank_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_req_crab_harm_rank_reflection_ = NULL;
const ::google::protobuf::Descriptor* CrabRankInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CrabRankInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_req_crab_harm_rank_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_req_crab_harm_rank_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_req_cur_loop_act_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_req_cur_loop_act_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_req_cur_loop_act_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_req_cur_loop_act_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* grand_prix_rank_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  grand_prix_rank_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_get_grand_prix_rank_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_get_grand_prix_rank_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_get_grand_prix_rank_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_get_grand_prix_rank_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_req_activity_game_info_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_req_activity_game_info_reflection_ = NULL;
const ::google::protobuf::Descriptor* qualifyingRankInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  qualifyingRankInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_get_qualifying_info_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_get_qualifying_info_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_get_qualifying_info_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_get_qualifying_info_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_get_qualifying_rank_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_get_qualifying_rank_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_get_qualifying_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_get_qualifying_result_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetc2l_receive_qualifying_reward_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetc2l_receive_qualifying_reward_reflection_ = NULL;
const ::google::protobuf::Descriptor* packetl2c_receive_qualifying_info_result_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  packetl2c_receive_qualifying_info_result_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_fish_5factivity2_2eproto() {
  protobuf_AddDesc_fish_5factivity2_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "fish_activity2.proto");
  GOOGLE_CHECK(file != NULL);
  packetc2l_get_crab_info_descriptor_ = file->message_type(0);
  static const int packetc2l_get_crab_info_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_crab_info, packet_id_),
  };
  packetc2l_get_crab_info_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_get_crab_info_descriptor_,
      packetc2l_get_crab_info::default_instance_,
      packetc2l_get_crab_info_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_crab_info, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_crab_info, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_get_crab_info));
  packetl2c_syn_crab_info_descriptor_ = file->message_type(1);
  static const int packetl2c_syn_crab_info_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, starttime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, endtime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, curlifeid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, curlifevalue_),
  };
  packetl2c_syn_crab_info_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_syn_crab_info_descriptor_,
      packetl2c_syn_crab_info::default_instance_,
      packetl2c_syn_crab_info_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_syn_crab_info, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_syn_crab_info));
  packetc2l_req_attack_crab_descriptor_ = file->message_type(2);
  static const int packetc2l_req_attack_crab_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_attack_crab, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_attack_crab, attackop_),
  };
  packetc2l_req_attack_crab_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_req_attack_crab_descriptor_,
      packetc2l_req_attack_crab::default_instance_,
      packetc2l_req_attack_crab_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_attack_crab, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_attack_crab, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_req_attack_crab));
  packetl2c_req_attack_crab_result_descriptor_ = file->message_type(3);
  static const int packetl2c_req_attack_crab_result_offsets_[11] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, attackop_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, harmvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, isdie_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, curlifeid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, prelifeid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, rewardid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, rewardcount_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, result_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, curlife_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, killlist_),
  };
  packetl2c_req_attack_crab_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_req_attack_crab_result_descriptor_,
      packetl2c_req_attack_crab_result::default_instance_,
      packetl2c_req_attack_crab_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_attack_crab_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_req_attack_crab_result));
  packetc2l_req_crab_harm_rank_descriptor_ = file->message_type(4);
  static const int packetc2l_req_crab_harm_rank_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_crab_harm_rank, packet_id_),
  };
  packetc2l_req_crab_harm_rank_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_req_crab_harm_rank_descriptor_,
      packetc2l_req_crab_harm_rank::default_instance_,
      packetc2l_req_crab_harm_rank_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_crab_harm_rank, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_crab_harm_rank, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_req_crab_harm_rank));
  CrabRankInfo_descriptor_ = file->message_type(5);
  static const int CrabRankInfo_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, nickname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, harmvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, playerid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, rank_),
  };
  CrabRankInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CrabRankInfo_descriptor_,
      CrabRankInfo::default_instance_,
      CrabRankInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CrabRankInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CrabRankInfo));
  packetl2c_req_crab_harm_rank_result_descriptor_ = file->message_type(6);
  static const int packetl2c_req_crab_harm_rank_result_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, ranklist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, thresholdvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, selfharmvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, selfrank_),
  };
  packetl2c_req_crab_harm_rank_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_req_crab_harm_rank_result_descriptor_,
      packetl2c_req_crab_harm_rank_result::default_instance_,
      packetl2c_req_crab_harm_rank_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_crab_harm_rank_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_req_crab_harm_rank_result));
  packetc2l_req_cur_loop_act_descriptor_ = file->message_type(7);
  static const int packetc2l_req_cur_loop_act_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_cur_loop_act, packet_id_),
  };
  packetc2l_req_cur_loop_act_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_req_cur_loop_act_descriptor_,
      packetc2l_req_cur_loop_act::default_instance_,
      packetc2l_req_cur_loop_act_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_cur_loop_act, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_cur_loop_act, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_req_cur_loop_act));
  packetl2c_req_cur_loop_act_result_descriptor_ = file->message_type(8);
  static const int packetl2c_req_cur_loop_act_result_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, curactid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, starttime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, endtime_),
  };
  packetl2c_req_cur_loop_act_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_req_cur_loop_act_result_descriptor_,
      packetl2c_req_cur_loop_act_result::default_instance_,
      packetl2c_req_cur_loop_act_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_req_cur_loop_act_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_req_cur_loop_act_result));
  grand_prix_rank_descriptor_ = file->message_type(9);
  static const int grand_prix_rank_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, playerid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, nickname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, points_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, rank_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, headid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, frameid_),
  };
  grand_prix_rank_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      grand_prix_rank_descriptor_,
      grand_prix_rank::default_instance_,
      grand_prix_rank_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(grand_prix_rank, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(grand_prix_rank));
  packetc2l_get_grand_prix_rank_descriptor_ = file->message_type(10);
  static const int packetc2l_get_grand_prix_rank_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_grand_prix_rank, packet_id_),
  };
  packetc2l_get_grand_prix_rank_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_get_grand_prix_rank_descriptor_,
      packetc2l_get_grand_prix_rank::default_instance_,
      packetc2l_get_grand_prix_rank_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_grand_prix_rank, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_grand_prix_rank, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_get_grand_prix_rank));
  packetl2c_get_grand_prix_rank_result_descriptor_ = file->message_type(11);
  static const int packetl2c_get_grand_prix_rank_result_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, dailyranklist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, seasonranklist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, mydailyrank_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, myseasonrank_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, dailythresholdvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, seasonthresholdvalue_),
  };
  packetl2c_get_grand_prix_rank_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_get_grand_prix_rank_result_descriptor_,
      packetl2c_get_grand_prix_rank_result::default_instance_,
      packetl2c_get_grand_prix_rank_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_grand_prix_rank_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_get_grand_prix_rank_result));
  packetc2l_req_activity_game_info_descriptor_ = file->message_type(12);
  static const int packetc2l_req_activity_game_info_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_activity_game_info, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_activity_game_info, activityid_),
  };
  packetc2l_req_activity_game_info_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_req_activity_game_info_descriptor_,
      packetc2l_req_activity_game_info::default_instance_,
      packetc2l_req_activity_game_info_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_activity_game_info, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_req_activity_game_info, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_req_activity_game_info));
  qualifyingRankInfo_descriptor_ = file->message_type(13);
  static const int qualifyingRankInfo_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, playerid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, nickname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, vip_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, headid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, frameid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, score_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, division_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, rank_),
  };
  qualifyingRankInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      qualifyingRankInfo_descriptor_,
      qualifyingRankInfo::default_instance_,
      qualifyingRankInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(qualifyingRankInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(qualifyingRankInfo));
  packetc2l_get_qualifying_info_descriptor_ = file->message_type(14);
  static const int packetc2l_get_qualifying_info_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_info, packet_id_),
  };
  packetc2l_get_qualifying_info_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_get_qualifying_info_descriptor_,
      packetc2l_get_qualifying_info::default_instance_,
      packetc2l_get_qualifying_info_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_info, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_info, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_get_qualifying_info));
  packetl2c_get_qualifying_info_result_descriptor_ = file->message_type(15);
  static const int packetl2c_get_qualifying_info_result_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, starttime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, endtime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, score_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, season_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, divisionnormreceived_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, divisionadvanreceived_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, myrankinfo_),
  };
  packetl2c_get_qualifying_info_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_get_qualifying_info_result_descriptor_,
      packetl2c_get_qualifying_info_result::default_instance_,
      packetl2c_get_qualifying_info_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_info_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_get_qualifying_info_result));
  packetc2l_get_qualifying_rank_descriptor_ = file->message_type(16);
  static const int packetc2l_get_qualifying_rank_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_rank, packet_id_),
  };
  packetc2l_get_qualifying_rank_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_get_qualifying_rank_descriptor_,
      packetc2l_get_qualifying_rank::default_instance_,
      packetc2l_get_qualifying_rank_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_rank, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_get_qualifying_rank, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_get_qualifying_rank));
  packetl2c_get_qualifying_result_descriptor_ = file->message_type(17);
  static const int packetl2c_get_qualifying_result_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, ranklist_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, myrankinfo_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, thresholdvalue_),
  };
  packetl2c_get_qualifying_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_get_qualifying_result_descriptor_,
      packetl2c_get_qualifying_result::default_instance_,
      packetl2c_get_qualifying_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_get_qualifying_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_get_qualifying_result));
  packetc2l_receive_qualifying_reward_descriptor_ = file->message_type(18);
  static const int packetc2l_receive_qualifying_reward_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_receive_qualifying_reward, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_receive_qualifying_reward, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_receive_qualifying_reward, index_),
  };
  packetc2l_receive_qualifying_reward_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetc2l_receive_qualifying_reward_descriptor_,
      packetc2l_receive_qualifying_reward::default_instance_,
      packetc2l_receive_qualifying_reward_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_receive_qualifying_reward, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetc2l_receive_qualifying_reward, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetc2l_receive_qualifying_reward));
  packetl2c_receive_qualifying_info_result_descriptor_ = file->message_type(19);
  static const int packetl2c_receive_qualifying_info_result_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, packet_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, result_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, type_),
  };
  packetl2c_receive_qualifying_info_result_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      packetl2c_receive_qualifying_info_result_descriptor_,
      packetl2c_receive_qualifying_info_result::default_instance_,
      packetl2c_receive_qualifying_info_result_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(packetl2c_receive_qualifying_info_result, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(packetl2c_receive_qualifying_info_result));
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_get_crab_info_descriptor_, &packetc2l_get_crab_info::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_syn_crab_info_descriptor_, &packetl2c_syn_crab_info::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_req_attack_crab_descriptor_, &packetc2l_req_attack_crab::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_req_attack_crab_result_descriptor_, &packetl2c_req_attack_crab_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_req_crab_harm_rank_descriptor_, &packetc2l_req_crab_harm_rank::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CrabRankInfo_descriptor_, &CrabRankInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_req_crab_harm_rank_result_descriptor_, &packetl2c_req_crab_harm_rank_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_req_cur_loop_act_descriptor_, &packetc2l_req_cur_loop_act::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_req_cur_loop_act_result_descriptor_, &packetl2c_req_cur_loop_act_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    grand_prix_rank_descriptor_, &grand_prix_rank::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_get_grand_prix_rank_descriptor_, &packetc2l_get_grand_prix_rank::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_get_grand_prix_rank_result_descriptor_, &packetl2c_get_grand_prix_rank_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_req_activity_game_info_descriptor_, &packetc2l_req_activity_game_info::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    qualifyingRankInfo_descriptor_, &qualifyingRankInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_get_qualifying_info_descriptor_, &packetc2l_get_qualifying_info::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_get_qualifying_info_result_descriptor_, &packetl2c_get_qualifying_info_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_get_qualifying_rank_descriptor_, &packetc2l_get_qualifying_rank::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_get_qualifying_result_descriptor_, &packetl2c_get_qualifying_result::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetc2l_receive_qualifying_reward_descriptor_, &packetc2l_receive_qualifying_reward::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    packetl2c_receive_qualifying_info_result_descriptor_, &packetl2c_receive_qualifying_info_result::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_fish_5factivity2_2eproto() {
  delete packetc2l_get_crab_info::default_instance_;
  delete packetc2l_get_crab_info_reflection_;
  delete packetl2c_syn_crab_info::default_instance_;
  delete packetl2c_syn_crab_info_reflection_;
  delete packetc2l_req_attack_crab::default_instance_;
  delete packetc2l_req_attack_crab_reflection_;
  delete packetl2c_req_attack_crab_result::default_instance_;
  delete packetl2c_req_attack_crab_result_reflection_;
  delete packetc2l_req_crab_harm_rank::default_instance_;
  delete packetc2l_req_crab_harm_rank_reflection_;
  delete CrabRankInfo::default_instance_;
  delete CrabRankInfo_reflection_;
  delete packetl2c_req_crab_harm_rank_result::default_instance_;
  delete packetl2c_req_crab_harm_rank_result_reflection_;
  delete packetc2l_req_cur_loop_act::default_instance_;
  delete packetc2l_req_cur_loop_act_reflection_;
  delete packetl2c_req_cur_loop_act_result::default_instance_;
  delete packetl2c_req_cur_loop_act_result_reflection_;
  delete grand_prix_rank::default_instance_;
  delete grand_prix_rank_reflection_;
  delete packetc2l_get_grand_prix_rank::default_instance_;
  delete packetc2l_get_grand_prix_rank_reflection_;
  delete packetl2c_get_grand_prix_rank_result::default_instance_;
  delete packetl2c_get_grand_prix_rank_result_reflection_;
  delete packetc2l_req_activity_game_info::default_instance_;
  delete packetc2l_req_activity_game_info_reflection_;
  delete qualifyingRankInfo::default_instance_;
  delete qualifyingRankInfo_reflection_;
  delete packetc2l_get_qualifying_info::default_instance_;
  delete packetc2l_get_qualifying_info_reflection_;
  delete packetl2c_get_qualifying_info_result::default_instance_;
  delete packetl2c_get_qualifying_info_result_reflection_;
  delete packetc2l_get_qualifying_rank::default_instance_;
  delete packetc2l_get_qualifying_rank_reflection_;
  delete packetl2c_get_qualifying_result::default_instance_;
  delete packetl2c_get_qualifying_result_reflection_;
  delete packetc2l_receive_qualifying_reward::default_instance_;
  delete packetc2l_receive_qualifying_reward_reflection_;
  delete packetl2c_receive_qualifying_info_result::default_instance_;
  delete packetl2c_receive_qualifying_info_result_reflection_;
}

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

  ::fish_protocols::protobuf_AddDesc_fish_5fdef_2eproto();
  ::fish_protocols::protobuf_AddDesc_fish_5ftype_5fdef_2eproto();
  ::msg_type_def::protobuf_AddDesc_msg_5ftype_5fdef_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\024fish_activity2.proto\022\016fish_protocols\032\016"
    "fish_def.proto\032\023fish_type_def.proto\032\022msg"
    "_type_def.proto\"h\n\027packetc2l_get_crab_in"
    "fo\022M\n\tpacket_id\030\001 \001(\0162!.fish_protocols.e"
    "_server_msg_type:\027e_mst_c2l_get_crab_inf"
    "o\"\265\001\n\027packetl2c_syn_crab_info\022M\n\tpacket_"
    "id\030\001 \001(\0162!.fish_protocols.e_server_msg_t"
    "ype:\027e_mst_l2c_syn_crab_info\022\021\n\tstartTim"
    "e\030\002 \001(\005\022\017\n\007endTime\030\003 \001(\005\022\021\n\tcurLifeId\030\004 "
    "\001(\005\022\024\n\014curLifeValue\030\005 \001(\005\"~\n\031packetc2l_r"
    "eq_attack_crab\022O\n\tpacket_id\030\001 \001(\0162!.fish"
    "_protocols.e_server_msg_type:\031e_mst_c2l_"
    "req_attack_crab\022\020\n\010attackOp\030\002 \001(\005\"\256\002\n pa"
    "cketl2c_req_attack_crab_result\022V\n\tpacket"
    "_id\030\001 \001(\0162!.fish_protocols.e_server_msg_"
    "type: e_mst_l2c_req_attack_crab_result\022\020"
    "\n\010attackOp\030\002 \001(\005\022\021\n\tharmValue\030\003 \001(\005\022\r\n\005i"
    "sDie\030\004 \001(\010\022\021\n\tcurLifeId\030\005 \001(\005\022\021\n\tpreLife"
    "Id\030\006 \001(\005\022\020\n\010rewardId\030\007 \001(\005\022\023\n\013rewardCoun"
    "t\030\010 \001(\005\022\016\n\006result\030\t \001(\005\022\017\n\007curLife\030\n \001(\005"
    "\022\020\n\010killList\030\013 \003(\005\"r\n\034packetc2l_req_crab"
    "_harm_rank\022R\n\tpacket_id\030\001 \001(\0162!.fish_pro"
    "tocols.e_server_msg_type:\034e_mst_c2l_req_"
    "crab_harm_rank\"S\n\014CrabRankInfo\022\020\n\010nickNa"
    "me\030\001 \001(\t\022\021\n\tharmValue\030\002 \001(\005\022\020\n\010playerId\030"
    "\003 \001(\005\022\014\n\004rank\030\004 \001(\005\"\361\001\n#packetl2c_req_cr"
    "ab_harm_rank_result\022Y\n\tpacket_id\030\001 \001(\0162!"
    ".fish_protocols.e_server_msg_type:#e_mst"
    "_l2c_req_crab_harm_rank_result\022.\n\010rankLi"
    "st\030\002 \003(\0132\034.fish_protocols.CrabRankInfo\022\026"
    "\n\016thresholdvalue\030\003 \003(\005\022\025\n\rselfHarmValue\030"
    "\004 \001(\005\022\020\n\010selfRank\030\005 \001(\005\"n\n\032packetc2l_req"
    "_cur_loop_act\022P\n\tpacket_id\030\001 \001(\0162!.fish_"
    "protocols.e_server_msg_type:\032e_mst_c2l_r"
    "eq_cur_loop_act\"\262\001\n!packetl2c_req_cur_lo"
    "op_act_result\022W\n\tpacket_id\030\001 \001(\0162!.fish_"
    "protocols.e_server_msg_type:!e_mst_l2c_r"
    "eq_cur_loop_act_result\022\020\n\010curActId\030\002 \001(\005"
    "\022\021\n\tstartTime\030\003 \001(\005\022\017\n\007endTime\030\004 \001(\005\"t\n\017"
    "grand_prix_rank\022\020\n\010playerId\030\001 \001(\005\022\020\n\010nic"
    "kName\030\002 \001(\t\022\016\n\006points\030\003 \001(\003\022\014\n\004rank\030\004 \001("
    "\005\022\016\n\006headid\030\005 \001(\005\022\017\n\007frameid\030\006 \001(\005\"t\n\035pa"
    "cketc2l_get_grand_prix_rank\022S\n\tpacket_id"
    "\030\001 \001(\0162!.fish_protocols.e_server_msg_typ"
    "e:\035e_mst_c2l_get_grand_prix_rank\"\227\003\n$pac"
    "ketl2c_get_grand_prix_rank_result\022V\n\tpac"
    "ket_id\030\001 \001(\0162!.fish_protocols.e_server_m"
    "sg_type: e_mst_l2c_grand_prix_rank_resul"
    "t\0226\n\rdailyRankList\030\002 \003(\0132\037.fish_protocol"
    "s.grand_prix_rank\0227\n\016seasonRankList\030\003 \003("
    "\0132\037.fish_protocols.grand_prix_rank\0224\n\013my"
    "DailyRank\030\004 \001(\0132\037.fish_protocols.grand_p"
    "rix_rank\0225\n\014mySeasonRank\030\005 \001(\0132\037.fish_pr"
    "otocols.grand_prix_rank\022\033\n\023dailyThreshol"
    "dValue\030\006 \003(\003\022\034\n\024seasonThresholdValue\030\007 \003"
    "(\003\"\216\001\n packetc2l_req_activity_game_info\022"
    "V\n\tpacket_id\030\001 \001(\0162!.fish_protocols.e_se"
    "rver_msg_type: e_mst_c2l_req_activity_ga"
    "me_info\022\022\n\nactivityId\030\002 \001(\005\"\225\001\n\022qualifyi"
    "ngRankInfo\022\020\n\010playerId\030\001 \001(\005\022\020\n\010nickname"
    "\030\002 \001(\t\022\013\n\003vip\030\003 \001(\005\022\016\n\006headid\030\004 \001(\005\022\017\n\007f"
    "rameid\030\005 \001(\005\022\r\n\005score\030\006 \001(\003\022\020\n\010division\030"
    "\007 \001(\005\022\014\n\004rank\030\010 \001(\005\"t\n\035packetc2l_get_qua"
    "lifying_info\022S\n\tpacket_id\030\001 \001(\0162!.fish_p"
    "rotocols.e_server_msg_type:\035e_mst_c2l_ge"
    "t_qualifying_info\"\272\002\n$packetl2c_get_qual"
    "ifying_info_result\022Z\n\tpacket_id\030\001 \001(\0162!."
    "fish_protocols.e_server_msg_type:$e_mst_"
    "l2c_get_qualifying_info_result\022\021\n\tstartT"
    "ime\030\002 \001(\005\022\017\n\007endTime\030\003 \001(\005\022\r\n\005score\030\004 \001("
    "\003\022\016\n\006season\030\005 \001(\005\022\034\n\024divisionNormReceive"
    "d\030\006 \003(\010\022\035\n\025divisionAdvanReceived\030\007 \003(\010\0226"
    "\n\nmyRankInfo\030\010 \001(\0132\".fish_protocols.qual"
    "ifyingRankInfo\"t\n\035packetc2l_get_qualifyi"
    "ng_rank\022S\n\tpacket_id\030\001 \001(\0162!.fish_protoc"
    "ols.e_server_msg_type:\035e_mst_c2l_get_qua"
    "lifying_rank\"\376\001\n\037packetl2c_get_qualifyin"
    "g_result\022U\n\tpacket_id\030\001 \001(\0162!.fish_proto"
    "cols.e_server_msg_type:\037e_mst_l2c_get_qu"
    "alifying_result\0224\n\010rankList\030\002 \003(\0132\".fish"
    "_protocols.qualifyingRankInfo\0226\n\nmyRankI"
    "nfo\030\003 \001(\0132\".fish_protocols.qualifyingRan"
    "kInfo\022\026\n\016thresholdValue\030\004 \003(\003\"\235\001\n#packet"
    "c2l_receive_qualifying_reward\022Y\n\tpacket_"
    "id\030\001 \001(\0162!.fish_protocols.e_server_msg_t"
    "ype:#e_mst_c2l_receive_qualifying_reward"
    "\022\014\n\004type\030\002 \001(\005\022\r\n\005index\030\003 \001(\005\"\267\001\n(packet"
    "l2c_receive_qualifying_info_result\022^\n\tpa"
    "cket_id\030\001 \001(\0162!.fish_protocols.e_server_"
    "msg_type:(e_mst_l2c_receive_qualifying_i"
    "nfo_result\022\016\n\006result\030\002 \001(\005\022\r\n\005index\030\003 \001("
    "\005\022\014\n\004type\030\004 \001(\005", 3655);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "fish_activity2.proto", &protobuf_RegisterTypes);
  packetc2l_get_crab_info::default_instance_ = new packetc2l_get_crab_info();
  packetl2c_syn_crab_info::default_instance_ = new packetl2c_syn_crab_info();
  packetc2l_req_attack_crab::default_instance_ = new packetc2l_req_attack_crab();
  packetl2c_req_attack_crab_result::default_instance_ = new packetl2c_req_attack_crab_result();
  packetc2l_req_crab_harm_rank::default_instance_ = new packetc2l_req_crab_harm_rank();
  CrabRankInfo::default_instance_ = new CrabRankInfo();
  packetl2c_req_crab_harm_rank_result::default_instance_ = new packetl2c_req_crab_harm_rank_result();
  packetc2l_req_cur_loop_act::default_instance_ = new packetc2l_req_cur_loop_act();
  packetl2c_req_cur_loop_act_result::default_instance_ = new packetl2c_req_cur_loop_act_result();
  grand_prix_rank::default_instance_ = new grand_prix_rank();
  packetc2l_get_grand_prix_rank::default_instance_ = new packetc2l_get_grand_prix_rank();
  packetl2c_get_grand_prix_rank_result::default_instance_ = new packetl2c_get_grand_prix_rank_result();
  packetc2l_req_activity_game_info::default_instance_ = new packetc2l_req_activity_game_info();
  qualifyingRankInfo::default_instance_ = new qualifyingRankInfo();
  packetc2l_get_qualifying_info::default_instance_ = new packetc2l_get_qualifying_info();
  packetl2c_get_qualifying_info_result::default_instance_ = new packetl2c_get_qualifying_info_result();
  packetc2l_get_qualifying_rank::default_instance_ = new packetc2l_get_qualifying_rank();
  packetl2c_get_qualifying_result::default_instance_ = new packetl2c_get_qualifying_result();
  packetc2l_receive_qualifying_reward::default_instance_ = new packetc2l_receive_qualifying_reward();
  packetl2c_receive_qualifying_info_result::default_instance_ = new packetl2c_receive_qualifying_info_result();
  packetc2l_get_crab_info::default_instance_->InitAsDefaultInstance();
  packetl2c_syn_crab_info::default_instance_->InitAsDefaultInstance();
  packetc2l_req_attack_crab::default_instance_->InitAsDefaultInstance();
  packetl2c_req_attack_crab_result::default_instance_->InitAsDefaultInstance();
  packetc2l_req_crab_harm_rank::default_instance_->InitAsDefaultInstance();
  CrabRankInfo::default_instance_->InitAsDefaultInstance();
  packetl2c_req_crab_harm_rank_result::default_instance_->InitAsDefaultInstance();
  packetc2l_req_cur_loop_act::default_instance_->InitAsDefaultInstance();
  packetl2c_req_cur_loop_act_result::default_instance_->InitAsDefaultInstance();
  grand_prix_rank::default_instance_->InitAsDefaultInstance();
  packetc2l_get_grand_prix_rank::default_instance_->InitAsDefaultInstance();
  packetl2c_get_grand_prix_rank_result::default_instance_->InitAsDefaultInstance();
  packetc2l_req_activity_game_info::default_instance_->InitAsDefaultInstance();
  qualifyingRankInfo::default_instance_->InitAsDefaultInstance();
  packetc2l_get_qualifying_info::default_instance_->InitAsDefaultInstance();
  packetl2c_get_qualifying_info_result::default_instance_->InitAsDefaultInstance();
  packetc2l_get_qualifying_rank::default_instance_->InitAsDefaultInstance();
  packetl2c_get_qualifying_result::default_instance_->InitAsDefaultInstance();
  packetc2l_receive_qualifying_reward::default_instance_->InitAsDefaultInstance();
  packetl2c_receive_qualifying_info_result::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_fish_5factivity2_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_fish_5factivity2_2eproto {
  StaticDescriptorInitializer_fish_5factivity2_2eproto() {
    protobuf_AddDesc_fish_5factivity2_2eproto();
  }
} static_descriptor_initializer_fish_5factivity2_2eproto_;

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

#ifndef _MSC_VER
const int packetc2l_get_crab_info::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_get_crab_info::InitAsDefaultInstance() {
}

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

void packetc2l_get_crab_info::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10180;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_get_crab_info& packetc2l_get_crab_info::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_get_crab_info* packetc2l_get_crab_info::default_instance_ = NULL;

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

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

bool packetc2l_get_crab_info::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_crab_info];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_get_crab_info::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_crab_info];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_get_crab_info::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_crab_info];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_crab_info];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_get_crab_info::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_get_crab_info* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_get_crab_info*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_get_crab_info::MergeFrom(const packetc2l_get_crab_info& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_get_crab_info::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_syn_crab_info::kPacketIdFieldNumber;
const int packetl2c_syn_crab_info::kStartTimeFieldNumber;
const int packetl2c_syn_crab_info::kEndTimeFieldNumber;
const int packetl2c_syn_crab_info::kCurLifeIdFieldNumber;
const int packetl2c_syn_crab_info::kCurLifeValueFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_syn_crab_info::InitAsDefaultInstance() {
}

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

void packetl2c_syn_crab_info::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16174;
  starttime_ = 0;
  endtime_ = 0;
  curlifeid_ = 0;
  curlifevalue_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetl2c_syn_crab_info& packetl2c_syn_crab_info::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_syn_crab_info* packetl2c_syn_crab_info::default_instance_ = NULL;

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

void packetl2c_syn_crab_info::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16174;
    starttime_ = 0;
    endtime_ = 0;
    curlifeid_ = 0;
    curlifevalue_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_syn_crab_info::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_syn_crab_info];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_startTime;
        break;
      }

      // optional int32 startTime = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_startTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &starttime_)));
          set_has_starttime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_endTime;
        break;
      }

      // optional int32 endTime = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_endTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &endtime_)));
          set_has_endtime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_curLifeId;
        break;
      }

      // optional int32 curLifeId = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_curLifeId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &curlifeid_)));
          set_has_curlifeid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_curLifeValue;
        break;
      }

      // optional int32 curLifeValue = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_curLifeValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &curlifevalue_)));
          set_has_curlifevalue();
        } 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 packetl2c_syn_crab_info::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_syn_crab_info];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 startTime = 2;
  if (has_starttime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->starttime(), output);
  }

  // optional int32 endTime = 3;
  if (has_endtime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->endtime(), output);
  }

  // optional int32 curLifeId = 4;
  if (has_curlifeid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->curlifeid(), output);
  }

  // optional int32 curLifeValue = 5;
  if (has_curlifevalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->curlifevalue(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_syn_crab_info::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_syn_crab_info];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 startTime = 2;
  if (has_starttime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->starttime(), target);
  }

  // optional int32 endTime = 3;
  if (has_endtime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->endtime(), target);
  }

  // optional int32 curLifeId = 4;
  if (has_curlifeid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->curlifeid(), target);
  }

  // optional int32 curLifeValue = 5;
  if (has_curlifevalue()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->curlifevalue(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_syn_crab_info];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 startTime = 2;
    if (has_starttime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->starttime());
    }

    // optional int32 endTime = 3;
    if (has_endtime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->endtime());
    }

    // optional int32 curLifeId = 4;
    if (has_curlifeid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->curlifeid());
    }

    // optional int32 curLifeValue = 5;
    if (has_curlifevalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->curlifevalue());
    }

  }
  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 packetl2c_syn_crab_info::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_syn_crab_info* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_syn_crab_info*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_syn_crab_info::MergeFrom(const packetl2c_syn_crab_info& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_starttime()) {
      set_starttime(from.starttime());
    }
    if (from.has_endtime()) {
      set_endtime(from.endtime());
    }
    if (from.has_curlifeid()) {
      set_curlifeid(from.curlifeid());
    }
    if (from.has_curlifevalue()) {
      set_curlifevalue(from.curlifevalue());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_syn_crab_info::IsInitialized() const {

  return true;
}

void packetl2c_syn_crab_info::Swap(packetl2c_syn_crab_info* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(starttime_, other->starttime_);
    std::swap(endtime_, other->endtime_);
    std::swap(curlifeid_, other->curlifeid_);
    std::swap(curlifevalue_, other->curlifevalue_);
    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 packetl2c_syn_crab_info::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_syn_crab_info_descriptor_;
  metadata.reflection = packetl2c_syn_crab_info_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_req_attack_crab::kPacketIdFieldNumber;
const int packetc2l_req_attack_crab::kAttackOpFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_req_attack_crab::InitAsDefaultInstance() {
}

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

void packetc2l_req_attack_crab::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10181;
  attackop_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_req_attack_crab& packetc2l_req_attack_crab::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_req_attack_crab* packetc2l_req_attack_crab::default_instance_ = NULL;

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

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

bool packetc2l_req_attack_crab::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_attack_crab];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_attackOp;
        break;
      }

      // optional int32 attackOp = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_attackOp:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &attackop_)));
          set_has_attackop();
        } 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 packetc2l_req_attack_crab::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_attack_crab];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 attackOp = 2;
  if (has_attackop()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->attackop(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_req_attack_crab::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_attack_crab];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 attackOp = 2;
  if (has_attackop()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->attackop(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_attack_crab];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 attackOp = 2;
    if (has_attackop()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->attackop());
    }

  }
  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 packetc2l_req_attack_crab::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_req_attack_crab* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_req_attack_crab*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_req_attack_crab::MergeFrom(const packetc2l_req_attack_crab& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_attackop()) {
      set_attackop(from.attackop());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_req_attack_crab::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_req_attack_crab_result::kPacketIdFieldNumber;
const int packetl2c_req_attack_crab_result::kAttackOpFieldNumber;
const int packetl2c_req_attack_crab_result::kHarmValueFieldNumber;
const int packetl2c_req_attack_crab_result::kIsDieFieldNumber;
const int packetl2c_req_attack_crab_result::kCurLifeIdFieldNumber;
const int packetl2c_req_attack_crab_result::kPreLifeIdFieldNumber;
const int packetl2c_req_attack_crab_result::kRewardIdFieldNumber;
const int packetl2c_req_attack_crab_result::kRewardCountFieldNumber;
const int packetl2c_req_attack_crab_result::kResultFieldNumber;
const int packetl2c_req_attack_crab_result::kCurLifeFieldNumber;
const int packetl2c_req_attack_crab_result::kKillListFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_req_attack_crab_result::InitAsDefaultInstance() {
}

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

void packetl2c_req_attack_crab_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16173;
  attackop_ = 0;
  harmvalue_ = 0;
  isdie_ = false;
  curlifeid_ = 0;
  prelifeid_ = 0;
  rewardid_ = 0;
  rewardcount_ = 0;
  result_ = 0;
  curlife_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetl2c_req_attack_crab_result& packetl2c_req_attack_crab_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_req_attack_crab_result* packetl2c_req_attack_crab_result::default_instance_ = NULL;

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

void packetl2c_req_attack_crab_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16173;
    attackop_ = 0;
    harmvalue_ = 0;
    isdie_ = false;
    curlifeid_ = 0;
    prelifeid_ = 0;
    rewardid_ = 0;
    rewardcount_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    result_ = 0;
    curlife_ = 0;
  }
  killlist_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_req_attack_crab_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_attack_crab_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_attackOp;
        break;
      }

      // optional int32 attackOp = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_attackOp:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &attackop_)));
          set_has_attackop();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_harmValue;
        break;
      }

      // optional int32 harmValue = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_harmValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &harmvalue_)));
          set_has_harmvalue();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_isDie;
        break;
      }

      // optional bool isDie = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_isDie:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isdie_)));
          set_has_isdie();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_curLifeId;
        break;
      }

      // optional int32 curLifeId = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_curLifeId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &curlifeid_)));
          set_has_curlifeid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_preLifeId;
        break;
      }

      // optional int32 preLifeId = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_preLifeId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &prelifeid_)));
          set_has_prelifeid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_rewardId;
        break;
      }

      // optional int32 rewardId = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rewardId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rewardid_)));
          set_has_rewardid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_rewardCount;
        break;
      }

      // optional int32 rewardCount = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rewardCount:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rewardcount_)));
          set_has_rewardcount();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_result;
        break;
      }

      // optional int32 result = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_result:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &result_)));
          set_has_result();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_curLife;
        break;
      }

      // optional int32 curLife = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_curLife:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &curlife_)));
          set_has_curlife();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_killList;
        break;
      }

      // repeated int32 killList = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_killList:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 88, input, this->mutable_killlist())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_killlist())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_killList;
        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 packetl2c_req_attack_crab_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_attack_crab_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 attackOp = 2;
  if (has_attackop()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->attackop(), output);
  }

  // optional int32 harmValue = 3;
  if (has_harmvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->harmvalue(), output);
  }

  // optional bool isDie = 4;
  if (has_isdie()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->isdie(), output);
  }

  // optional int32 curLifeId = 5;
  if (has_curlifeid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->curlifeid(), output);
  }

  // optional int32 preLifeId = 6;
  if (has_prelifeid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->prelifeid(), output);
  }

  // optional int32 rewardId = 7;
  if (has_rewardid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->rewardid(), output);
  }

  // optional int32 rewardCount = 8;
  if (has_rewardcount()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->rewardcount(), output);
  }

  // optional int32 result = 9;
  if (has_result()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->result(), output);
  }

  // optional int32 curLife = 10;
  if (has_curlife()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->curlife(), output);
  }

  // repeated int32 killList = 11;
  for (int i = 0; i < this->killlist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      11, this->killlist(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_req_attack_crab_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_attack_crab_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 attackOp = 2;
  if (has_attackop()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->attackop(), target);
  }

  // optional int32 harmValue = 3;
  if (has_harmvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->harmvalue(), target);
  }

  // optional bool isDie = 4;
  if (has_isdie()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->isdie(), target);
  }

  // optional int32 curLifeId = 5;
  if (has_curlifeid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->curlifeid(), target);
  }

  // optional int32 preLifeId = 6;
  if (has_prelifeid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->prelifeid(), target);
  }

  // optional int32 rewardId = 7;
  if (has_rewardid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->rewardid(), target);
  }

  // optional int32 rewardCount = 8;
  if (has_rewardcount()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->rewardcount(), target);
  }

  // optional int32 result = 9;
  if (has_result()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->result(), target);
  }

  // optional int32 curLife = 10;
  if (has_curlife()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->curlife(), target);
  }

  // repeated int32 killList = 11;
  for (int i = 0; i < this->killlist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(11, this->killlist(i), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_attack_crab_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 attackOp = 2;
    if (has_attackop()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->attackop());
    }

    // optional int32 harmValue = 3;
    if (has_harmvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->harmvalue());
    }

    // optional bool isDie = 4;
    if (has_isdie()) {
      total_size += 1 + 1;
    }

    // optional int32 curLifeId = 5;
    if (has_curlifeid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->curlifeid());
    }

    // optional int32 preLifeId = 6;
    if (has_prelifeid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->prelifeid());
    }

    // optional int32 rewardId = 7;
    if (has_rewardid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rewardid());
    }

    // optional int32 rewardCount = 8;
    if (has_rewardcount()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rewardcount());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 result = 9;
    if (has_result()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->result());
    }

    // optional int32 curLife = 10;
    if (has_curlife()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->curlife());
    }

  }
  // repeated int32 killList = 11;
  {
    int data_size = 0;
    for (int i = 0; i < this->killlist_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->killlist(i));
    }
    total_size += 1 * this->killlist_size() + data_size;
  }

  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 packetl2c_req_attack_crab_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_req_attack_crab_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_req_attack_crab_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_req_attack_crab_result::MergeFrom(const packetl2c_req_attack_crab_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  killlist_.MergeFrom(from.killlist_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_attackop()) {
      set_attackop(from.attackop());
    }
    if (from.has_harmvalue()) {
      set_harmvalue(from.harmvalue());
    }
    if (from.has_isdie()) {
      set_isdie(from.isdie());
    }
    if (from.has_curlifeid()) {
      set_curlifeid(from.curlifeid());
    }
    if (from.has_prelifeid()) {
      set_prelifeid(from.prelifeid());
    }
    if (from.has_rewardid()) {
      set_rewardid(from.rewardid());
    }
    if (from.has_rewardcount()) {
      set_rewardcount(from.rewardcount());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_result()) {
      set_result(from.result());
    }
    if (from.has_curlife()) {
      set_curlife(from.curlife());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_req_attack_crab_result::IsInitialized() const {

  return true;
}

void packetl2c_req_attack_crab_result::Swap(packetl2c_req_attack_crab_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(attackop_, other->attackop_);
    std::swap(harmvalue_, other->harmvalue_);
    std::swap(isdie_, other->isdie_);
    std::swap(curlifeid_, other->curlifeid_);
    std::swap(prelifeid_, other->prelifeid_);
    std::swap(rewardid_, other->rewardid_);
    std::swap(rewardcount_, other->rewardcount_);
    std::swap(result_, other->result_);
    std::swap(curlife_, other->curlife_);
    killlist_.Swap(&other->killlist_);
    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 packetl2c_req_attack_crab_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_req_attack_crab_result_descriptor_;
  metadata.reflection = packetl2c_req_attack_crab_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_req_crab_harm_rank::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_req_crab_harm_rank::InitAsDefaultInstance() {
}

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

void packetc2l_req_crab_harm_rank::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10212;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_req_crab_harm_rank& packetc2l_req_crab_harm_rank::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_req_crab_harm_rank* packetc2l_req_crab_harm_rank::default_instance_ = NULL;

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

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

bool packetc2l_req_crab_harm_rank::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_crab_harm_rank];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_req_crab_harm_rank::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_crab_harm_rank];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_req_crab_harm_rank::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_crab_harm_rank];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_crab_harm_rank];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_req_crab_harm_rank::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_req_crab_harm_rank* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_req_crab_harm_rank*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_req_crab_harm_rank::MergeFrom(const packetc2l_req_crab_harm_rank& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_req_crab_harm_rank::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int CrabRankInfo::kNickNameFieldNumber;
const int CrabRankInfo::kHarmValueFieldNumber;
const int CrabRankInfo::kPlayerIdFieldNumber;
const int CrabRankInfo::kRankFieldNumber;
#endif  // !_MSC_VER

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

void CrabRankInfo::InitAsDefaultInstance() {
}

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

void CrabRankInfo::SharedCtor() {
  _cached_size_ = 0;
  nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  harmvalue_ = 0;
  playerid_ = 0;
  rank_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void CrabRankInfo::SharedDtor() {
  if (nickname_ != &::google::protobuf::internal::kEmptyString) {
    delete nickname_;
  }
  if (this != default_instance_) {
  }
}

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

const CrabRankInfo& CrabRankInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

CrabRankInfo* CrabRankInfo::default_instance_ = NULL;

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

void CrabRankInfo::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_nickname()) {
      if (nickname_ != &::google::protobuf::internal::kEmptyString) {
        nickname_->clear();
      }
    }
    harmvalue_ = 0;
    playerid_ = 0;
    rank_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CrabRankInfo::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)) {
      // optional string nickName = 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_nickname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->nickname().data(), this->nickname().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_harmValue;
        break;
      }

      // optional int32 harmValue = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_harmValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &harmvalue_)));
          set_has_harmvalue();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_playerId;
        break;
      }

      // optional int32 playerId = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_rank;
        break;
      }

      // optional int32 rank = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rank:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rank_)));
          set_has_rank();
        } 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 CrabRankInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string nickName = 1;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->nickname(), output);
  }

  // optional int32 harmValue = 2;
  if (has_harmvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->harmvalue(), output);
  }

  // optional int32 playerId = 3;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->playerid(), output);
  }

  // optional int32 rank = 4;
  if (has_rank()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->rank(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CrabRankInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string nickName = 1;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->nickname(), target);
  }

  // optional int32 harmValue = 2;
  if (has_harmvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->harmvalue(), target);
  }

  // optional int32 playerId = 3;
  if (has_playerid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->playerid(), target);
  }

  // optional int32 rank = 4;
  if (has_rank()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->rank(), target);
  }

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

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

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

    // optional int32 harmValue = 2;
    if (has_harmvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->harmvalue());
    }

    // optional int32 playerId = 3;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->playerid());
    }

    // optional int32 rank = 4;
    if (has_rank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rank());
    }

  }
  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 CrabRankInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CrabRankInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CrabRankInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CrabRankInfo::MergeFrom(const CrabRankInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_nickname()) {
      set_nickname(from.nickname());
    }
    if (from.has_harmvalue()) {
      set_harmvalue(from.harmvalue());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_rank()) {
      set_rank(from.rank());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CrabRankInfo::IsInitialized() const {

  return true;
}

void CrabRankInfo::Swap(CrabRankInfo* other) {
  if (other != this) {
    std::swap(nickname_, other->nickname_);
    std::swap(harmvalue_, other->harmvalue_);
    std::swap(playerid_, other->playerid_);
    std::swap(rank_, other->rank_);
    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 CrabRankInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CrabRankInfo_descriptor_;
  metadata.reflection = CrabRankInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetl2c_req_crab_harm_rank_result::kPacketIdFieldNumber;
const int packetl2c_req_crab_harm_rank_result::kRankListFieldNumber;
const int packetl2c_req_crab_harm_rank_result::kThresholdvalueFieldNumber;
const int packetl2c_req_crab_harm_rank_result::kSelfHarmValueFieldNumber;
const int packetl2c_req_crab_harm_rank_result::kSelfRankFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_req_crab_harm_rank_result::InitAsDefaultInstance() {
}

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

void packetl2c_req_crab_harm_rank_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16212;
  selfharmvalue_ = 0;
  selfrank_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetl2c_req_crab_harm_rank_result& packetl2c_req_crab_harm_rank_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_req_crab_harm_rank_result* packetl2c_req_crab_harm_rank_result::default_instance_ = NULL;

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

void packetl2c_req_crab_harm_rank_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16212;
    selfharmvalue_ = 0;
    selfrank_ = 0;
  }
  ranklist_.Clear();
  thresholdvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_req_crab_harm_rank_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_crab_harm_rank_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_rankList;
        break;
      }

      // repeated .fish_protocols.CrabRankInfo rankList = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_rankList:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_ranklist()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_rankList;
        if (input->ExpectTag(24)) goto parse_thresholdvalue;
        break;
      }

      // repeated int32 thresholdvalue = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_thresholdvalue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_thresholdvalue())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_thresholdvalue())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_thresholdvalue;
        if (input->ExpectTag(32)) goto parse_selfHarmValue;
        break;
      }

      // optional int32 selfHarmValue = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_selfHarmValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &selfharmvalue_)));
          set_has_selfharmvalue();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_selfRank;
        break;
      }

      // optional int32 selfRank = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_selfRank:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &selfrank_)));
          set_has_selfrank();
        } 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 packetl2c_req_crab_harm_rank_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_crab_harm_rank_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // repeated .fish_protocols.CrabRankInfo rankList = 2;
  for (int i = 0; i < this->ranklist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->ranklist(i), output);
  }

  // repeated int32 thresholdvalue = 3;
  for (int i = 0; i < this->thresholdvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->thresholdvalue(i), output);
  }

  // optional int32 selfHarmValue = 4;
  if (has_selfharmvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->selfharmvalue(), output);
  }

  // optional int32 selfRank = 5;
  if (has_selfrank()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->selfrank(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_req_crab_harm_rank_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_crab_harm_rank_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // repeated .fish_protocols.CrabRankInfo rankList = 2;
  for (int i = 0; i < this->ranklist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->ranklist(i), target);
  }

  // repeated int32 thresholdvalue = 3;
  for (int i = 0; i < this->thresholdvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->thresholdvalue(i), target);
  }

  // optional int32 selfHarmValue = 4;
  if (has_selfharmvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->selfharmvalue(), target);
  }

  // optional int32 selfRank = 5;
  if (has_selfrank()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->selfrank(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_crab_harm_rank_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 selfHarmValue = 4;
    if (has_selfharmvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->selfharmvalue());
    }

    // optional int32 selfRank = 5;
    if (has_selfrank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->selfrank());
    }

  }
  // repeated .fish_protocols.CrabRankInfo rankList = 2;
  total_size += 1 * this->ranklist_size();
  for (int i = 0; i < this->ranklist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->ranklist(i));
  }

  // repeated int32 thresholdvalue = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->thresholdvalue_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->thresholdvalue(i));
    }
    total_size += 1 * this->thresholdvalue_size() + data_size;
  }

  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 packetl2c_req_crab_harm_rank_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_req_crab_harm_rank_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_req_crab_harm_rank_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_req_crab_harm_rank_result::MergeFrom(const packetl2c_req_crab_harm_rank_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  ranklist_.MergeFrom(from.ranklist_);
  thresholdvalue_.MergeFrom(from.thresholdvalue_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_selfharmvalue()) {
      set_selfharmvalue(from.selfharmvalue());
    }
    if (from.has_selfrank()) {
      set_selfrank(from.selfrank());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_req_crab_harm_rank_result::IsInitialized() const {

  return true;
}

void packetl2c_req_crab_harm_rank_result::Swap(packetl2c_req_crab_harm_rank_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    ranklist_.Swap(&other->ranklist_);
    thresholdvalue_.Swap(&other->thresholdvalue_);
    std::swap(selfharmvalue_, other->selfharmvalue_);
    std::swap(selfrank_, other->selfrank_);
    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 packetl2c_req_crab_harm_rank_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_req_crab_harm_rank_result_descriptor_;
  metadata.reflection = packetl2c_req_crab_harm_rank_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_req_cur_loop_act::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_req_cur_loop_act::InitAsDefaultInstance() {
}

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

void packetc2l_req_cur_loop_act::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10182;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_req_cur_loop_act& packetc2l_req_cur_loop_act::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_req_cur_loop_act* packetc2l_req_cur_loop_act::default_instance_ = NULL;

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

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

bool packetc2l_req_cur_loop_act::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_cur_loop_act];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_req_cur_loop_act::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_cur_loop_act];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_req_cur_loop_act::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_cur_loop_act];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_cur_loop_act];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_req_cur_loop_act::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_req_cur_loop_act* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_req_cur_loop_act*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_req_cur_loop_act::MergeFrom(const packetc2l_req_cur_loop_act& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_req_cur_loop_act::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_req_cur_loop_act_result::kPacketIdFieldNumber;
const int packetl2c_req_cur_loop_act_result::kCurActIdFieldNumber;
const int packetl2c_req_cur_loop_act_result::kStartTimeFieldNumber;
const int packetl2c_req_cur_loop_act_result::kEndTimeFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_req_cur_loop_act_result::InitAsDefaultInstance() {
}

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

void packetl2c_req_cur_loop_act_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16176;
  curactid_ = 0;
  starttime_ = 0;
  endtime_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetl2c_req_cur_loop_act_result& packetl2c_req_cur_loop_act_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_req_cur_loop_act_result* packetl2c_req_cur_loop_act_result::default_instance_ = NULL;

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

void packetl2c_req_cur_loop_act_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16176;
    curactid_ = 0;
    starttime_ = 0;
    endtime_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_req_cur_loop_act_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_cur_loop_act_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_curActId;
        break;
      }

      // optional int32 curActId = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_curActId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &curactid_)));
          set_has_curactid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_startTime;
        break;
      }

      // optional int32 startTime = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_startTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &starttime_)));
          set_has_starttime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_endTime;
        break;
      }

      // optional int32 endTime = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_endTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &endtime_)));
          set_has_endtime();
        } 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 packetl2c_req_cur_loop_act_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_cur_loop_act_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 curActId = 2;
  if (has_curactid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->curactid(), output);
  }

  // optional int32 startTime = 3;
  if (has_starttime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->starttime(), output);
  }

  // optional int32 endTime = 4;
  if (has_endtime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->endtime(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_req_cur_loop_act_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_cur_loop_act_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 curActId = 2;
  if (has_curactid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->curactid(), target);
  }

  // optional int32 startTime = 3;
  if (has_starttime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->starttime(), target);
  }

  // optional int32 endTime = 4;
  if (has_endtime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->endtime(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_req_cur_loop_act_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 curActId = 2;
    if (has_curactid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->curactid());
    }

    // optional int32 startTime = 3;
    if (has_starttime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->starttime());
    }

    // optional int32 endTime = 4;
    if (has_endtime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->endtime());
    }

  }
  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 packetl2c_req_cur_loop_act_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_req_cur_loop_act_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_req_cur_loop_act_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_req_cur_loop_act_result::MergeFrom(const packetl2c_req_cur_loop_act_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_curactid()) {
      set_curactid(from.curactid());
    }
    if (from.has_starttime()) {
      set_starttime(from.starttime());
    }
    if (from.has_endtime()) {
      set_endtime(from.endtime());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_req_cur_loop_act_result::IsInitialized() const {

  return true;
}

void packetl2c_req_cur_loop_act_result::Swap(packetl2c_req_cur_loop_act_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(curactid_, other->curactid_);
    std::swap(starttime_, other->starttime_);
    std::swap(endtime_, other->endtime_);
    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 packetl2c_req_cur_loop_act_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_req_cur_loop_act_result_descriptor_;
  metadata.reflection = packetl2c_req_cur_loop_act_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int grand_prix_rank::kPlayerIdFieldNumber;
const int grand_prix_rank::kNickNameFieldNumber;
const int grand_prix_rank::kPointsFieldNumber;
const int grand_prix_rank::kRankFieldNumber;
const int grand_prix_rank::kHeadidFieldNumber;
const int grand_prix_rank::kFrameidFieldNumber;
#endif  // !_MSC_VER

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

void grand_prix_rank::InitAsDefaultInstance() {
}

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

void grand_prix_rank::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0;
  nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  points_ = GOOGLE_LONGLONG(0);
  rank_ = 0;
  headid_ = 0;
  frameid_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void grand_prix_rank::SharedDtor() {
  if (nickname_ != &::google::protobuf::internal::kEmptyString) {
    delete nickname_;
  }
  if (this != default_instance_) {
  }
}

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

const grand_prix_rank& grand_prix_rank::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

grand_prix_rank* grand_prix_rank::default_instance_ = NULL;

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

void grand_prix_rank::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    playerid_ = 0;
    if (has_nickname()) {
      if (nickname_ != &::google::protobuf::internal::kEmptyString) {
        nickname_->clear();
      }
    }
    points_ = GOOGLE_LONGLONG(0);
    rank_ = 0;
    headid_ = 0;
    frameid_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool grand_prix_rank::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)) {
      // optional int32 playerId = 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, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_nickName;
        break;
      }

      // optional string nickName = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_nickName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_nickname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->nickname().data(), this->nickname().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_points;
        break;
      }

      // optional int64 points = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_points:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &points_)));
          set_has_points();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_rank;
        break;
      }

      // optional int32 rank = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rank:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rank_)));
          set_has_rank();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_headid;
        break;
      }

      // optional int32 headid = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_headid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &headid_)));
          set_has_headid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_frameid;
        break;
      }

      // optional int32 frameid = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_frameid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &frameid_)));
          set_has_frameid();
        } 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 grand_prix_rank::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->playerid(), output);
  }

  // optional string nickName = 2;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->nickname(), output);
  }

  // optional int64 points = 3;
  if (has_points()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->points(), output);
  }

  // optional int32 rank = 4;
  if (has_rank()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->rank(), output);
  }

  // optional int32 headid = 5;
  if (has_headid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->headid(), output);
  }

  // optional int32 frameid = 6;
  if (has_frameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->frameid(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* grand_prix_rank::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 playerId = 1;
  if (has_playerid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->playerid(), target);
  }

  // optional string nickName = 2;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->nickname(), target);
  }

  // optional int64 points = 3;
  if (has_points()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->points(), target);
  }

  // optional int32 rank = 4;
  if (has_rank()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->rank(), target);
  }

  // optional int32 headid = 5;
  if (has_headid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->headid(), target);
  }

  // optional int32 frameid = 6;
  if (has_frameid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->frameid(), target);
  }

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

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

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

    // optional string nickName = 2;
    if (has_nickname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->nickname());
    }

    // optional int64 points = 3;
    if (has_points()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->points());
    }

    // optional int32 rank = 4;
    if (has_rank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rank());
    }

    // optional int32 headid = 5;
    if (has_headid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->headid());
    }

    // optional int32 frameid = 6;
    if (has_frameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->frameid());
    }

  }
  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 grand_prix_rank::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const grand_prix_rank* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const grand_prix_rank*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void grand_prix_rank::MergeFrom(const grand_prix_rank& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_nickname()) {
      set_nickname(from.nickname());
    }
    if (from.has_points()) {
      set_points(from.points());
    }
    if (from.has_rank()) {
      set_rank(from.rank());
    }
    if (from.has_headid()) {
      set_headid(from.headid());
    }
    if (from.has_frameid()) {
      set_frameid(from.frameid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool grand_prix_rank::IsInitialized() const {

  return true;
}

void grand_prix_rank::Swap(grand_prix_rank* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(nickname_, other->nickname_);
    std::swap(points_, other->points_);
    std::swap(rank_, other->rank_);
    std::swap(headid_, other->headid_);
    std::swap(frameid_, other->frameid_);
    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 grand_prix_rank::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = grand_prix_rank_descriptor_;
  metadata.reflection = grand_prix_rank_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_get_grand_prix_rank::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_get_grand_prix_rank::InitAsDefaultInstance() {
}

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

void packetc2l_get_grand_prix_rank::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10179;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_get_grand_prix_rank& packetc2l_get_grand_prix_rank::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_get_grand_prix_rank* packetc2l_get_grand_prix_rank::default_instance_ = NULL;

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

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

bool packetc2l_get_grand_prix_rank::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_grand_prix_rank];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_get_grand_prix_rank::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_grand_prix_rank];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_get_grand_prix_rank::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_grand_prix_rank];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_grand_prix_rank];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_get_grand_prix_rank::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_get_grand_prix_rank* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_get_grand_prix_rank*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_get_grand_prix_rank::MergeFrom(const packetc2l_get_grand_prix_rank& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_get_grand_prix_rank::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_get_grand_prix_rank_result::kPacketIdFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kDailyRankListFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kSeasonRankListFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kMyDailyRankFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kMySeasonRankFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kDailyThresholdValueFieldNumber;
const int packetl2c_get_grand_prix_rank_result::kSeasonThresholdValueFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_get_grand_prix_rank_result::InitAsDefaultInstance() {
  mydailyrank_ = const_cast< ::fish_protocols::grand_prix_rank*>(&::fish_protocols::grand_prix_rank::default_instance());
  myseasonrank_ = const_cast< ::fish_protocols::grand_prix_rank*>(&::fish_protocols::grand_prix_rank::default_instance());
}

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

void packetl2c_get_grand_prix_rank_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16147;
  mydailyrank_ = NULL;
  myseasonrank_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void packetl2c_get_grand_prix_rank_result::SharedDtor() {
  if (this != default_instance_) {
    delete mydailyrank_;
    delete myseasonrank_;
  }
}

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

const packetl2c_get_grand_prix_rank_result& packetl2c_get_grand_prix_rank_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_get_grand_prix_rank_result* packetl2c_get_grand_prix_rank_result::default_instance_ = NULL;

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

void packetl2c_get_grand_prix_rank_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16147;
    if (has_mydailyrank()) {
      if (mydailyrank_ != NULL) mydailyrank_->::fish_protocols::grand_prix_rank::Clear();
    }
    if (has_myseasonrank()) {
      if (myseasonrank_ != NULL) myseasonrank_->::fish_protocols::grand_prix_rank::Clear();
    }
  }
  dailyranklist_.Clear();
  seasonranklist_.Clear();
  dailythresholdvalue_.Clear();
  seasonthresholdvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_get_grand_prix_rank_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_grand_prix_rank_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_dailyRankList;
        break;
      }

      // repeated .fish_protocols.grand_prix_rank dailyRankList = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_dailyRankList:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_dailyranklist()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_dailyRankList;
        if (input->ExpectTag(26)) goto parse_seasonRankList;
        break;
      }

      // repeated .fish_protocols.grand_prix_rank seasonRankList = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_seasonRankList:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_seasonranklist()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_seasonRankList;
        if (input->ExpectTag(34)) goto parse_myDailyRank;
        break;
      }

      // optional .fish_protocols.grand_prix_rank myDailyRank = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_myDailyRank:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_mydailyrank()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_mySeasonRank;
        break;
      }

      // optional .fish_protocols.grand_prix_rank mySeasonRank = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_mySeasonRank:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_myseasonrank()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_dailyThresholdValue;
        break;
      }

      // repeated int64 dailyThresholdValue = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_dailyThresholdValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 48, input, this->mutable_dailythresholdvalue())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_dailythresholdvalue())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_dailyThresholdValue;
        if (input->ExpectTag(56)) goto parse_seasonThresholdValue;
        break;
      }

      // repeated int64 seasonThresholdValue = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_seasonThresholdValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 56, input, this->mutable_seasonthresholdvalue())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_seasonthresholdvalue())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_seasonThresholdValue;
        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 packetl2c_get_grand_prix_rank_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_grand_prix_rank_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // repeated .fish_protocols.grand_prix_rank dailyRankList = 2;
  for (int i = 0; i < this->dailyranklist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->dailyranklist(i), output);
  }

  // repeated .fish_protocols.grand_prix_rank seasonRankList = 3;
  for (int i = 0; i < this->seasonranklist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->seasonranklist(i), output);
  }

  // optional .fish_protocols.grand_prix_rank myDailyRank = 4;
  if (has_mydailyrank()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->mydailyrank(), output);
  }

  // optional .fish_protocols.grand_prix_rank mySeasonRank = 5;
  if (has_myseasonrank()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->myseasonrank(), output);
  }

  // repeated int64 dailyThresholdValue = 6;
  for (int i = 0; i < this->dailythresholdvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(
      6, this->dailythresholdvalue(i), output);
  }

  // repeated int64 seasonThresholdValue = 7;
  for (int i = 0; i < this->seasonthresholdvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(
      7, this->seasonthresholdvalue(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_get_grand_prix_rank_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_grand_prix_rank_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // repeated .fish_protocols.grand_prix_rank dailyRankList = 2;
  for (int i = 0; i < this->dailyranklist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->dailyranklist(i), target);
  }

  // repeated .fish_protocols.grand_prix_rank seasonRankList = 3;
  for (int i = 0; i < this->seasonranklist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->seasonranklist(i), target);
  }

  // optional .fish_protocols.grand_prix_rank myDailyRank = 4;
  if (has_mydailyrank()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->mydailyrank(), target);
  }

  // optional .fish_protocols.grand_prix_rank mySeasonRank = 5;
  if (has_myseasonrank()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->myseasonrank(), target);
  }

  // repeated int64 dailyThresholdValue = 6;
  for (int i = 0; i < this->dailythresholdvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64ToArray(6, this->dailythresholdvalue(i), target);
  }

  // repeated int64 seasonThresholdValue = 7;
  for (int i = 0; i < this->seasonthresholdvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64ToArray(7, this->seasonthresholdvalue(i), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_grand_prix_rank_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional .fish_protocols.grand_prix_rank myDailyRank = 4;
    if (has_mydailyrank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->mydailyrank());
    }

    // optional .fish_protocols.grand_prix_rank mySeasonRank = 5;
    if (has_myseasonrank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->myseasonrank());
    }

  }
  // repeated .fish_protocols.grand_prix_rank dailyRankList = 2;
  total_size += 1 * this->dailyranklist_size();
  for (int i = 0; i < this->dailyranklist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->dailyranklist(i));
  }

  // repeated .fish_protocols.grand_prix_rank seasonRankList = 3;
  total_size += 1 * this->seasonranklist_size();
  for (int i = 0; i < this->seasonranklist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->seasonranklist(i));
  }

  // repeated int64 dailyThresholdValue = 6;
  {
    int data_size = 0;
    for (int i = 0; i < this->dailythresholdvalue_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int64Size(this->dailythresholdvalue(i));
    }
    total_size += 1 * this->dailythresholdvalue_size() + data_size;
  }

  // repeated int64 seasonThresholdValue = 7;
  {
    int data_size = 0;
    for (int i = 0; i < this->seasonthresholdvalue_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int64Size(this->seasonthresholdvalue(i));
    }
    total_size += 1 * this->seasonthresholdvalue_size() + data_size;
  }

  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 packetl2c_get_grand_prix_rank_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_get_grand_prix_rank_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_get_grand_prix_rank_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_get_grand_prix_rank_result::MergeFrom(const packetl2c_get_grand_prix_rank_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  dailyranklist_.MergeFrom(from.dailyranklist_);
  seasonranklist_.MergeFrom(from.seasonranklist_);
  dailythresholdvalue_.MergeFrom(from.dailythresholdvalue_);
  seasonthresholdvalue_.MergeFrom(from.seasonthresholdvalue_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_mydailyrank()) {
      mutable_mydailyrank()->::fish_protocols::grand_prix_rank::MergeFrom(from.mydailyrank());
    }
    if (from.has_myseasonrank()) {
      mutable_myseasonrank()->::fish_protocols::grand_prix_rank::MergeFrom(from.myseasonrank());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_get_grand_prix_rank_result::IsInitialized() const {

  return true;
}

void packetl2c_get_grand_prix_rank_result::Swap(packetl2c_get_grand_prix_rank_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    dailyranklist_.Swap(&other->dailyranklist_);
    seasonranklist_.Swap(&other->seasonranklist_);
    std::swap(mydailyrank_, other->mydailyrank_);
    std::swap(myseasonrank_, other->myseasonrank_);
    dailythresholdvalue_.Swap(&other->dailythresholdvalue_);
    seasonthresholdvalue_.Swap(&other->seasonthresholdvalue_);
    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 packetl2c_get_grand_prix_rank_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_get_grand_prix_rank_result_descriptor_;
  metadata.reflection = packetl2c_get_grand_prix_rank_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_req_activity_game_info::kPacketIdFieldNumber;
const int packetc2l_req_activity_game_info::kActivityIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_req_activity_game_info::InitAsDefaultInstance() {
}

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

void packetc2l_req_activity_game_info::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10191;
  activityid_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_req_activity_game_info& packetc2l_req_activity_game_info::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_req_activity_game_info* packetc2l_req_activity_game_info::default_instance_ = NULL;

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

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

bool packetc2l_req_activity_game_info::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_activity_game_info];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_activityId;
        break;
      }

      // optional int32 activityId = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_activityId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &activityid_)));
          set_has_activityid();
        } 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 packetc2l_req_activity_game_info::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_activity_game_info];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 activityId = 2;
  if (has_activityid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->activityid(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_req_activity_game_info::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_activity_game_info];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 activityId = 2;
  if (has_activityid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->activityid(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_req_activity_game_info];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 activityId = 2;
    if (has_activityid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->activityid());
    }

  }
  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 packetc2l_req_activity_game_info::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_req_activity_game_info* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_req_activity_game_info*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_req_activity_game_info::MergeFrom(const packetc2l_req_activity_game_info& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_activityid()) {
      set_activityid(from.activityid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_req_activity_game_info::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int qualifyingRankInfo::kPlayerIdFieldNumber;
const int qualifyingRankInfo::kNicknameFieldNumber;
const int qualifyingRankInfo::kVipFieldNumber;
const int qualifyingRankInfo::kHeadidFieldNumber;
const int qualifyingRankInfo::kFrameidFieldNumber;
const int qualifyingRankInfo::kScoreFieldNumber;
const int qualifyingRankInfo::kDivisionFieldNumber;
const int qualifyingRankInfo::kRankFieldNumber;
#endif  // !_MSC_VER

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

void qualifyingRankInfo::InitAsDefaultInstance() {
}

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

void qualifyingRankInfo::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0;
  nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  vip_ = 0;
  headid_ = 0;
  frameid_ = 0;
  score_ = GOOGLE_LONGLONG(0);
  division_ = 0;
  rank_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void qualifyingRankInfo::SharedDtor() {
  if (nickname_ != &::google::protobuf::internal::kEmptyString) {
    delete nickname_;
  }
  if (this != default_instance_) {
  }
}

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

const qualifyingRankInfo& qualifyingRankInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

qualifyingRankInfo* qualifyingRankInfo::default_instance_ = NULL;

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

void qualifyingRankInfo::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    playerid_ = 0;
    if (has_nickname()) {
      if (nickname_ != &::google::protobuf::internal::kEmptyString) {
        nickname_->clear();
      }
    }
    vip_ = 0;
    headid_ = 0;
    frameid_ = 0;
    score_ = GOOGLE_LONGLONG(0);
    division_ = 0;
    rank_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool qualifyingRankInfo::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)) {
      // optional int32 playerId = 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, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_nickname;
        break;
      }

      // optional string nickname = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_nickname:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_nickname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->nickname().data(), this->nickname().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_vip;
        break;
      }

      // optional int32 vip = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_vip:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &vip_)));
          set_has_vip();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_headid;
        break;
      }

      // optional int32 headid = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_headid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &headid_)));
          set_has_headid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_frameid;
        break;
      }

      // optional int32 frameid = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_frameid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &frameid_)));
          set_has_frameid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_score;
        break;
      }

      // optional int64 score = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_score:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &score_)));
          set_has_score();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_division;
        break;
      }

      // optional int32 division = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_division:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &division_)));
          set_has_division();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_rank;
        break;
      }

      // optional int32 rank = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rank:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rank_)));
          set_has_rank();
        } 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 qualifyingRankInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->playerid(), output);
  }

  // optional string nickname = 2;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->nickname(), output);
  }

  // optional int32 vip = 3;
  if (has_vip()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->vip(), output);
  }

  // optional int32 headid = 4;
  if (has_headid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->headid(), output);
  }

  // optional int32 frameid = 5;
  if (has_frameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->frameid(), output);
  }

  // optional int64 score = 6;
  if (has_score()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->score(), output);
  }

  // optional int32 division = 7;
  if (has_division()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->division(), output);
  }

  // optional int32 rank = 8;
  if (has_rank()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->rank(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* qualifyingRankInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 playerId = 1;
  if (has_playerid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->playerid(), target);
  }

  // optional string nickname = 2;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->nickname().data(), this->nickname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->nickname(), target);
  }

  // optional int32 vip = 3;
  if (has_vip()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->vip(), target);
  }

  // optional int32 headid = 4;
  if (has_headid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->headid(), target);
  }

  // optional int32 frameid = 5;
  if (has_frameid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->frameid(), target);
  }

  // optional int64 score = 6;
  if (has_score()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->score(), target);
  }

  // optional int32 division = 7;
  if (has_division()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->division(), target);
  }

  // optional int32 rank = 8;
  if (has_rank()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->rank(), target);
  }

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

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

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

    // optional string nickname = 2;
    if (has_nickname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->nickname());
    }

    // optional int32 vip = 3;
    if (has_vip()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->vip());
    }

    // optional int32 headid = 4;
    if (has_headid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->headid());
    }

    // optional int32 frameid = 5;
    if (has_frameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->frameid());
    }

    // optional int64 score = 6;
    if (has_score()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->score());
    }

    // optional int32 division = 7;
    if (has_division()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->division());
    }

    // optional int32 rank = 8;
    if (has_rank()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rank());
    }

  }
  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 qualifyingRankInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const qualifyingRankInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const qualifyingRankInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void qualifyingRankInfo::MergeFrom(const qualifyingRankInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_nickname()) {
      set_nickname(from.nickname());
    }
    if (from.has_vip()) {
      set_vip(from.vip());
    }
    if (from.has_headid()) {
      set_headid(from.headid());
    }
    if (from.has_frameid()) {
      set_frameid(from.frameid());
    }
    if (from.has_score()) {
      set_score(from.score());
    }
    if (from.has_division()) {
      set_division(from.division());
    }
    if (from.has_rank()) {
      set_rank(from.rank());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool qualifyingRankInfo::IsInitialized() const {

  return true;
}

void qualifyingRankInfo::Swap(qualifyingRankInfo* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(nickname_, other->nickname_);
    std::swap(vip_, other->vip_);
    std::swap(headid_, other->headid_);
    std::swap(frameid_, other->frameid_);
    std::swap(score_, other->score_);
    std::swap(division_, other->division_);
    std::swap(rank_, other->rank_);
    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 qualifyingRankInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = qualifyingRankInfo_descriptor_;
  metadata.reflection = qualifyingRankInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_get_qualifying_info::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_get_qualifying_info::InitAsDefaultInstance() {
}

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

void packetc2l_get_qualifying_info::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10216;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_get_qualifying_info& packetc2l_get_qualifying_info::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_get_qualifying_info* packetc2l_get_qualifying_info::default_instance_ = NULL;

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

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

bool packetc2l_get_qualifying_info::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_info];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_get_qualifying_info::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_info];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_get_qualifying_info::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_info];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_info];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_get_qualifying_info::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_get_qualifying_info* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_get_qualifying_info*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_get_qualifying_info::MergeFrom(const packetc2l_get_qualifying_info& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_get_qualifying_info::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_get_qualifying_info_result::kPacketIdFieldNumber;
const int packetl2c_get_qualifying_info_result::kStartTimeFieldNumber;
const int packetl2c_get_qualifying_info_result::kEndTimeFieldNumber;
const int packetl2c_get_qualifying_info_result::kScoreFieldNumber;
const int packetl2c_get_qualifying_info_result::kSeasonFieldNumber;
const int packetl2c_get_qualifying_info_result::kDivisionNormReceivedFieldNumber;
const int packetl2c_get_qualifying_info_result::kDivisionAdvanReceivedFieldNumber;
const int packetl2c_get_qualifying_info_result::kMyRankInfoFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_get_qualifying_info_result::InitAsDefaultInstance() {
  myrankinfo_ = const_cast< ::fish_protocols::qualifyingRankInfo*>(&::fish_protocols::qualifyingRankInfo::default_instance());
}

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

void packetl2c_get_qualifying_info_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16221;
  starttime_ = 0;
  endtime_ = 0;
  score_ = GOOGLE_LONGLONG(0);
  season_ = 0;
  myrankinfo_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void packetl2c_get_qualifying_info_result::SharedDtor() {
  if (this != default_instance_) {
    delete myrankinfo_;
  }
}

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

const packetl2c_get_qualifying_info_result& packetl2c_get_qualifying_info_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_get_qualifying_info_result* packetl2c_get_qualifying_info_result::default_instance_ = NULL;

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

void packetl2c_get_qualifying_info_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16221;
    starttime_ = 0;
    endtime_ = 0;
    score_ = GOOGLE_LONGLONG(0);
    season_ = 0;
    if (has_myrankinfo()) {
      if (myrankinfo_ != NULL) myrankinfo_->::fish_protocols::qualifyingRankInfo::Clear();
    }
  }
  divisionnormreceived_.Clear();
  divisionadvanreceived_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_get_qualifying_info_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_info_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_startTime;
        break;
      }

      // optional int32 startTime = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_startTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &starttime_)));
          set_has_starttime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_endTime;
        break;
      }

      // optional int32 endTime = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_endTime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &endtime_)));
          set_has_endtime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_score;
        break;
      }

      // optional int64 score = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_score:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &score_)));
          set_has_score();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_season;
        break;
      }

      // optional int32 season = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_season:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &season_)));
          set_has_season();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_divisionNormReceived;
        break;
      }

      // repeated bool divisionNormReceived = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_divisionNormReceived:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 1, 48, input, this->mutable_divisionnormreceived())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, this->mutable_divisionnormreceived())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_divisionNormReceived;
        if (input->ExpectTag(56)) goto parse_divisionAdvanReceived;
        break;
      }

      // repeated bool divisionAdvanReceived = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_divisionAdvanReceived:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 1, 56, input, this->mutable_divisionadvanreceived())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, this->mutable_divisionadvanreceived())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_divisionAdvanReceived;
        if (input->ExpectTag(66)) goto parse_myRankInfo;
        break;
      }

      // optional .fish_protocols.qualifyingRankInfo myRankInfo = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_myRankInfo:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_myrankinfo()));
        } 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 packetl2c_get_qualifying_info_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_info_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 startTime = 2;
  if (has_starttime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->starttime(), output);
  }

  // optional int32 endTime = 3;
  if (has_endtime()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->endtime(), output);
  }

  // optional int64 score = 4;
  if (has_score()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->score(), output);
  }

  // optional int32 season = 5;
  if (has_season()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->season(), output);
  }

  // repeated bool divisionNormReceived = 6;
  for (int i = 0; i < this->divisionnormreceived_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(
      6, this->divisionnormreceived(i), output);
  }

  // repeated bool divisionAdvanReceived = 7;
  for (int i = 0; i < this->divisionadvanreceived_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(
      7, this->divisionadvanreceived(i), output);
  }

  // optional .fish_protocols.qualifyingRankInfo myRankInfo = 8;
  if (has_myrankinfo()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->myrankinfo(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_get_qualifying_info_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_info_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 startTime = 2;
  if (has_starttime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->starttime(), target);
  }

  // optional int32 endTime = 3;
  if (has_endtime()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->endtime(), target);
  }

  // optional int64 score = 4;
  if (has_score()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(4, this->score(), target);
  }

  // optional int32 season = 5;
  if (has_season()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->season(), target);
  }

  // repeated bool divisionNormReceived = 6;
  for (int i = 0; i < this->divisionnormreceived_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBoolToArray(6, this->divisionnormreceived(i), target);
  }

  // repeated bool divisionAdvanReceived = 7;
  for (int i = 0; i < this->divisionadvanreceived_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBoolToArray(7, this->divisionadvanreceived(i), target);
  }

  // optional .fish_protocols.qualifyingRankInfo myRankInfo = 8;
  if (has_myrankinfo()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, this->myrankinfo(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_info_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 startTime = 2;
    if (has_starttime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->starttime());
    }

    // optional int32 endTime = 3;
    if (has_endtime()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->endtime());
    }

    // optional int64 score = 4;
    if (has_score()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->score());
    }

    // optional int32 season = 5;
    if (has_season()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->season());
    }

    // optional .fish_protocols.qualifyingRankInfo myRankInfo = 8;
    if (has_myrankinfo()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->myrankinfo());
    }

  }
  // repeated bool divisionNormReceived = 6;
  {
    int data_size = 0;
    data_size = 1 * this->divisionnormreceived_size();
    total_size += 1 * this->divisionnormreceived_size() + data_size;
  }

  // repeated bool divisionAdvanReceived = 7;
  {
    int data_size = 0;
    data_size = 1 * this->divisionadvanreceived_size();
    total_size += 1 * this->divisionadvanreceived_size() + data_size;
  }

  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 packetl2c_get_qualifying_info_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_get_qualifying_info_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_get_qualifying_info_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_get_qualifying_info_result::MergeFrom(const packetl2c_get_qualifying_info_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  divisionnormreceived_.MergeFrom(from.divisionnormreceived_);
  divisionadvanreceived_.MergeFrom(from.divisionadvanreceived_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_starttime()) {
      set_starttime(from.starttime());
    }
    if (from.has_endtime()) {
      set_endtime(from.endtime());
    }
    if (from.has_score()) {
      set_score(from.score());
    }
    if (from.has_season()) {
      set_season(from.season());
    }
    if (from.has_myrankinfo()) {
      mutable_myrankinfo()->::fish_protocols::qualifyingRankInfo::MergeFrom(from.myrankinfo());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_get_qualifying_info_result::IsInitialized() const {

  return true;
}

void packetl2c_get_qualifying_info_result::Swap(packetl2c_get_qualifying_info_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(starttime_, other->starttime_);
    std::swap(endtime_, other->endtime_);
    std::swap(score_, other->score_);
    std::swap(season_, other->season_);
    divisionnormreceived_.Swap(&other->divisionnormreceived_);
    divisionadvanreceived_.Swap(&other->divisionadvanreceived_);
    std::swap(myrankinfo_, other->myrankinfo_);
    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 packetl2c_get_qualifying_info_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_get_qualifying_info_result_descriptor_;
  metadata.reflection = packetl2c_get_qualifying_info_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_get_qualifying_rank::kPacketIdFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_get_qualifying_rank::InitAsDefaultInstance() {
}

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

void packetc2l_get_qualifying_rank::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10217;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_get_qualifying_rank& packetc2l_get_qualifying_rank::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_get_qualifying_rank* packetc2l_get_qualifying_rank::default_instance_ = NULL;

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

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

bool packetc2l_get_qualifying_rank::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_rank];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(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 packetc2l_get_qualifying_rank::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_rank];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_get_qualifying_rank::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_rank];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_get_qualifying_rank];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

  }
  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 packetc2l_get_qualifying_rank::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_get_qualifying_rank* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_get_qualifying_rank*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_get_qualifying_rank::MergeFrom(const packetc2l_get_qualifying_rank& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_get_qualifying_rank::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int packetl2c_get_qualifying_result::kPacketIdFieldNumber;
const int packetl2c_get_qualifying_result::kRankListFieldNumber;
const int packetl2c_get_qualifying_result::kMyRankInfoFieldNumber;
const int packetl2c_get_qualifying_result::kThresholdValueFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_get_qualifying_result::InitAsDefaultInstance() {
  myrankinfo_ = const_cast< ::fish_protocols::qualifyingRankInfo*>(&::fish_protocols::qualifyingRankInfo::default_instance());
}

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

void packetl2c_get_qualifying_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16222;
  myrankinfo_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void packetl2c_get_qualifying_result::SharedDtor() {
  if (this != default_instance_) {
    delete myrankinfo_;
  }
}

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

const packetl2c_get_qualifying_result& packetl2c_get_qualifying_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_get_qualifying_result* packetl2c_get_qualifying_result::default_instance_ = NULL;

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

void packetl2c_get_qualifying_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16222;
    if (has_myrankinfo()) {
      if (myrankinfo_ != NULL) myrankinfo_->::fish_protocols::qualifyingRankInfo::Clear();
    }
  }
  ranklist_.Clear();
  thresholdvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_get_qualifying_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_rankList;
        break;
      }

      // repeated .fish_protocols.qualifyingRankInfo rankList = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_rankList:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_ranklist()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_rankList;
        if (input->ExpectTag(26)) goto parse_myRankInfo;
        break;
      }

      // optional .fish_protocols.qualifyingRankInfo myRankInfo = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_myRankInfo:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_myrankinfo()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_thresholdValue;
        break;
      }

      // repeated int64 thresholdValue = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_thresholdValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 32, input, this->mutable_thresholdvalue())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_thresholdvalue())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_thresholdValue;
        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 packetl2c_get_qualifying_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // repeated .fish_protocols.qualifyingRankInfo rankList = 2;
  for (int i = 0; i < this->ranklist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->ranklist(i), output);
  }

  // optional .fish_protocols.qualifyingRankInfo myRankInfo = 3;
  if (has_myrankinfo()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->myrankinfo(), output);
  }

  // repeated int64 thresholdValue = 4;
  for (int i = 0; i < this->thresholdvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(
      4, this->thresholdvalue(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_get_qualifying_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // repeated .fish_protocols.qualifyingRankInfo rankList = 2;
  for (int i = 0; i < this->ranklist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->ranklist(i), target);
  }

  // optional .fish_protocols.qualifyingRankInfo myRankInfo = 3;
  if (has_myrankinfo()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->myrankinfo(), target);
  }

  // repeated int64 thresholdValue = 4;
  for (int i = 0; i < this->thresholdvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64ToArray(4, this->thresholdvalue(i), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_get_qualifying_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional .fish_protocols.qualifyingRankInfo myRankInfo = 3;
    if (has_myrankinfo()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->myrankinfo());
    }

  }
  // repeated .fish_protocols.qualifyingRankInfo rankList = 2;
  total_size += 1 * this->ranklist_size();
  for (int i = 0; i < this->ranklist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->ranklist(i));
  }

  // repeated int64 thresholdValue = 4;
  {
    int data_size = 0;
    for (int i = 0; i < this->thresholdvalue_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int64Size(this->thresholdvalue(i));
    }
    total_size += 1 * this->thresholdvalue_size() + data_size;
  }

  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 packetl2c_get_qualifying_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_get_qualifying_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_get_qualifying_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_get_qualifying_result::MergeFrom(const packetl2c_get_qualifying_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  ranklist_.MergeFrom(from.ranklist_);
  thresholdvalue_.MergeFrom(from.thresholdvalue_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_myrankinfo()) {
      mutable_myrankinfo()->::fish_protocols::qualifyingRankInfo::MergeFrom(from.myrankinfo());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_get_qualifying_result::IsInitialized() const {

  return true;
}

void packetl2c_get_qualifying_result::Swap(packetl2c_get_qualifying_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    ranklist_.Swap(&other->ranklist_);
    std::swap(myrankinfo_, other->myrankinfo_);
    thresholdvalue_.Swap(&other->thresholdvalue_);
    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 packetl2c_get_qualifying_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_get_qualifying_result_descriptor_;
  metadata.reflection = packetl2c_get_qualifying_result_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetc2l_receive_qualifying_reward::kPacketIdFieldNumber;
const int packetc2l_receive_qualifying_reward::kTypeFieldNumber;
const int packetc2l_receive_qualifying_reward::kIndexFieldNumber;
#endif  // !_MSC_VER

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

void packetc2l_receive_qualifying_reward::InitAsDefaultInstance() {
}

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

void packetc2l_receive_qualifying_reward::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 10218;
  type_ = 0;
  index_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetc2l_receive_qualifying_reward& packetc2l_receive_qualifying_reward::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetc2l_receive_qualifying_reward* packetc2l_receive_qualifying_reward::default_instance_ = NULL;

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

void packetc2l_receive_qualifying_reward::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 10218;
    type_ = 0;
    index_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetc2l_receive_qualifying_reward::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_receive_qualifying_reward];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_type;
        break;
      }

      // optional int32 type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_index;
        break;
      }

      // optional int32 index = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &index_)));
          set_has_index();
        } 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 packetc2l_receive_qualifying_reward::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_receive_qualifying_reward];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 type = 2;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->type(), output);
  }

  // optional int32 index = 3;
  if (has_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->index(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetc2l_receive_qualifying_reward::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_receive_qualifying_reward];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 type = 2;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->type(), target);
  }

  // optional int32 index = 3;
  if (has_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->index(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_c2l_receive_qualifying_reward];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }

    // optional int32 index = 3;
    if (has_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->index());
    }

  }
  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 packetc2l_receive_qualifying_reward::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetc2l_receive_qualifying_reward* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetc2l_receive_qualifying_reward*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetc2l_receive_qualifying_reward::MergeFrom(const packetc2l_receive_qualifying_reward& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_index()) {
      set_index(from.index());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetc2l_receive_qualifying_reward::IsInitialized() const {

  return true;
}

void packetc2l_receive_qualifying_reward::Swap(packetc2l_receive_qualifying_reward* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(type_, other->type_);
    std::swap(index_, other->index_);
    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 packetc2l_receive_qualifying_reward::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetc2l_receive_qualifying_reward_descriptor_;
  metadata.reflection = packetc2l_receive_qualifying_reward_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int packetl2c_receive_qualifying_info_result::kPacketIdFieldNumber;
const int packetl2c_receive_qualifying_info_result::kResultFieldNumber;
const int packetl2c_receive_qualifying_info_result::kIndexFieldNumber;
const int packetl2c_receive_qualifying_info_result::kTypeFieldNumber;
#endif  // !_MSC_VER

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

void packetl2c_receive_qualifying_info_result::InitAsDefaultInstance() {
}

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

void packetl2c_receive_qualifying_info_result::SharedCtor() {
  _cached_size_ = 0;
  packet_id_ = 16223;
  result_ = 0;
  index_ = 0;
  type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const packetl2c_receive_qualifying_info_result& packetl2c_receive_qualifying_info_result::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_fish_5factivity2_2eproto();
  return *default_instance_;
}

packetl2c_receive_qualifying_info_result* packetl2c_receive_qualifying_info_result::default_instance_ = NULL;

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

void packetl2c_receive_qualifying_info_result::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    packet_id_ = 16223;
    result_ = 0;
    index_ = 0;
    type_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool packetl2c_receive_qualifying_info_result::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)) {
      // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_receive_qualifying_info_result];
      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 (::fish_protocols::e_server_msg_type_IsValid(value)) {
            set_packet_id(static_cast< ::fish_protocols::e_server_msg_type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_result;
        break;
      }

      // optional int32 result = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_result:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &result_)));
          set_has_result();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_index;
        break;
      }

      // optional int32 index = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &index_)));
          set_has_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_type;
        break;
      }

      // optional int32 type = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } 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 packetl2c_receive_qualifying_info_result::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_receive_qualifying_info_result];
  if (has_packet_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->packet_id(), output);
  }

  // optional int32 result = 2;
  if (has_result()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->result(), output);
  }

  // optional int32 index = 3;
  if (has_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->index(), output);
  }

  // optional int32 type = 4;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->type(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* packetl2c_receive_qualifying_info_result::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_receive_qualifying_info_result];
  if (has_packet_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->packet_id(), target);
  }

  // optional int32 result = 2;
  if (has_result()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->result(), target);
  }

  // optional int32 index = 3;
  if (has_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->index(), target);
  }

  // optional int32 type = 4;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->type(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .fish_protocols.e_server_msg_type packet_id = 1 [default = e_mst_l2c_receive_qualifying_info_result];
    if (has_packet_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->packet_id());
    }

    // optional int32 result = 2;
    if (has_result()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->result());
    }

    // optional int32 index = 3;
    if (has_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->index());
    }

    // optional int32 type = 4;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }

  }
  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 packetl2c_receive_qualifying_info_result::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const packetl2c_receive_qualifying_info_result* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const packetl2c_receive_qualifying_info_result*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void packetl2c_receive_qualifying_info_result::MergeFrom(const packetl2c_receive_qualifying_info_result& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_packet_id()) {
      set_packet_id(from.packet_id());
    }
    if (from.has_result()) {
      set_result(from.result());
    }
    if (from.has_index()) {
      set_index(from.index());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool packetl2c_receive_qualifying_info_result::IsInitialized() const {

  return true;
}

void packetl2c_receive_qualifying_info_result::Swap(packetl2c_receive_qualifying_info_result* other) {
  if (other != this) {
    std::swap(packet_id_, other->packet_id_);
    std::swap(result_, other->result_);
    std::swap(index_, other->index_);
    std::swap(type_, other->type_);
    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 packetl2c_receive_qualifying_info_result::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = packetl2c_receive_qualifying_info_result_descriptor_;
  metadata.reflection = packetl2c_receive_qualifying_info_result_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace fish_protocols

// @@protoc_insertion_point(global_scope)