IMMessage.pb.m

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

#import "IMMessage.pb.h"
// @@protoc_insertion_point(imports)

@implementation ImmessageRoot
static PBExtensionRegistry* extensionRegistry = nil;
+ (PBExtensionRegistry*) extensionRegistry {
  return extensionRegistry;
}

+ (void) initialize {
  if (self == [ImmessageRoot class]) {
    PBMutableExtensionRegistry* registry = [PBMutableExtensionRegistry registry];
    [self registerAllExtensions:registry];
    [ImbaseDefineRoot registerAllExtensions:registry];
    extensionRegistry = registry;
  }
}
+ (void) registerAllExtensions:(PBMutableExtensionRegistry*) registry {
}
@end

@interface IMMsgData ()
@property UInt32 fromUserId;
@property UInt32 toSessionId;
@property UInt32 msgId;
@property UInt32 createTime;
@property MsgType msgType;
@property (strong) NSData* msgData;
@property (strong) NSData* attachData;
@end

@implementation IMMsgData

- (BOOL) hasFromUserId {
  return !!hasFromUserId_;
}
- (void) setHasFromUserId:(BOOL) value_ {
  hasFromUserId_ = !!value_;
}
@synthesize fromUserId;
- (BOOL) hasToSessionId {
  return !!hasToSessionId_;
}
- (void) setHasToSessionId:(BOOL) value_ {
  hasToSessionId_ = !!value_;
}
@synthesize toSessionId;
- (BOOL) hasMsgId {
  return !!hasMsgId_;
}
- (void) setHasMsgId:(BOOL) value_ {
  hasMsgId_ = !!value_;
}
@synthesize msgId;
- (BOOL) hasCreateTime {
  return !!hasCreateTime_;
}
- (void) setHasCreateTime:(BOOL) value_ {
  hasCreateTime_ = !!value_;
}
@synthesize createTime;
- (BOOL) hasMsgType {
  return !!hasMsgType_;
}
- (void) setHasMsgType:(BOOL) value_ {
  hasMsgType_ = !!value_;
}
@synthesize msgType;
- (BOOL) hasMsgData {
  return !!hasMsgData_;
}
- (void) setHasMsgData:(BOOL) value_ {
  hasMsgData_ = !!value_;
}
@synthesize msgData;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.msgData = nil;
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.fromUserId = 0;
    self.toSessionId = 0;
    self.msgId = 0;
    self.createTime = 0;
    self.msgType = MsgTypeMsgTypeSingleText;
    self.msgData = [NSData data];
    self.attachData = [NSData data];
  }
  return self;
}
static IMMsgData* defaultIMMsgDataInstance = nil;
+ (void) initialize {
  if (self == [IMMsgData class]) {
    defaultIMMsgDataInstance = [[IMMsgData alloc] init];
  }
}
+ (IMMsgData*) defaultInstance {
  return defaultIMMsgDataInstance;
}
- (IMMsgData*) defaultInstance {
  return defaultIMMsgDataInstance;
}
- (BOOL) isInitialized {
  if (!self.hasFromUserId) {
    return NO;
  }
  if (!self.hasToSessionId) {
    return NO;
  }
  if (!self.hasMsgId) {
    return NO;
  }
  if (!self.hasCreateTime) {
    return NO;
  }
  if (!self.hasMsgType) {
    return NO;
  }
  if (!self.hasMsgData) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasFromUserId) {
    [output writeUInt32:1 value:self.fromUserId];
  }
  if (self.hasToSessionId) {
    [output writeUInt32:2 value:self.toSessionId];
  }
  if (self.hasMsgId) {
    [output writeUInt32:3 value:self.msgId];
  }
  if (self.hasCreateTime) {
    [output writeUInt32:4 value:self.createTime];
  }
  if (self.hasMsgType) {
    [output writeEnum:5 value:self.msgType];
  }
  if (self.hasMsgData) {
    [output writeData:6 value:self.msgData];
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasFromUserId) {
    size_ += computeUInt32Size(1, self.fromUserId);
  }
  if (self.hasToSessionId) {
    size_ += computeUInt32Size(2, self.toSessionId);
  }
  if (self.hasMsgId) {
    size_ += computeUInt32Size(3, self.msgId);
  }
  if (self.hasCreateTime) {
    size_ += computeUInt32Size(4, self.createTime);
  }
  if (self.hasMsgType) {
    size_ += computeEnumSize(5, self.msgType);
  }
  if (self.hasMsgData) {
    size_ += computeDataSize(6, self.msgData);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMMsgData*) parseFromData:(NSData*) data {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromData:data] build];
}
+ (IMMsgData*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMMsgData*) parseFromInputStream:(NSInputStream*) input {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromInputStream:input] build];
}
+ (IMMsgData*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgData*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromCodedInputStream:input] build];
}
+ (IMMsgData*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgData*)[[[IMMsgData builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataBuilder*) builder {
  return [[IMMsgDataBuilder alloc] init];
}
+ (IMMsgDataBuilder*) builderWithPrototype:(IMMsgData*) prototype {
  return [[IMMsgData builder] mergeFrom:prototype];
}
- (IMMsgDataBuilder*) builder {
  return [IMMsgData builder];
}
- (IMMsgDataBuilder*) toBuilder {
  return [IMMsgData builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasFromUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"fromUserId", [NSNumber numberWithInteger:self.fromUserId]];
  }
  if (self.hasToSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"toSessionId", [NSNumber numberWithInteger:self.toSessionId]];
  }
  if (self.hasMsgId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgId", [NSNumber numberWithInteger:self.msgId]];
  }
  if (self.hasCreateTime) {
    [output appendFormat:@"%@%@: %@\n", indent, @"createTime", [NSNumber numberWithInteger:self.createTime]];
  }
  if (self.hasMsgType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"msgType", self.msgType];
  }
  if (self.hasMsgData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgData", self.msgData];
  }
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMMsgData class]]) {
    return NO;
  }
  IMMsgData *otherMessage = other;
  return
      self.hasFromUserId == otherMessage.hasFromUserId &&
      (!self.hasFromUserId || self.fromUserId == otherMessage.fromUserId) &&
      self.hasToSessionId == otherMessage.hasToSessionId &&
      (!self.hasToSessionId || self.toSessionId == otherMessage.toSessionId) &&
      self.hasMsgId == otherMessage.hasMsgId &&
      (!self.hasMsgId || self.msgId == otherMessage.msgId) &&
      self.hasCreateTime == otherMessage.hasCreateTime &&
      (!self.hasCreateTime || self.createTime == otherMessage.createTime) &&
      self.hasMsgType == otherMessage.hasMsgType &&
      (!self.hasMsgType || self.msgType == otherMessage.msgType) &&
      self.hasMsgData == otherMessage.hasMsgData &&
      (!self.hasMsgData || [self.msgData isEqual:otherMessage.msgData]) &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasFromUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.fromUserId] hash];
  }
  if (self.hasToSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.toSessionId] hash];
  }
  if (self.hasMsgId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgId] hash];
  }
  if (self.hasCreateTime) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.createTime] hash];
  }
  if (self.hasMsgType) {
    hashCode = hashCode * 31 + self.msgType;
  }
  if (self.hasMsgData) {
    hashCode = hashCode * 31 + [self.msgData hash];
  }
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMMsgDataBuilder()
@property (strong) IMMsgData* result;
@end

@implementation IMMsgDataBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMMsgData alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMMsgDataBuilder*) clear {
  self.result = [[IMMsgData alloc] init];
  return self;
}
- (IMMsgDataBuilder*) clone {
  return [IMMsgData builderWithPrototype:result];
}
- (IMMsgData*) defaultInstance {
  return [IMMsgData defaultInstance];
}
- (IMMsgData*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMMsgData*) buildPartial {
  IMMsgData* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMMsgDataBuilder*) mergeFrom:(IMMsgData*) other {
  if (other == [IMMsgData defaultInstance]) {
    return self;
  }
  if (other.hasFromUserId) {
    [self setFromUserId:other.fromUserId];
  }
  if (other.hasToSessionId) {
    [self setToSessionId:other.toSessionId];
  }
  if (other.hasMsgId) {
    [self setMsgId:other.msgId];
  }
  if (other.hasCreateTime) {
    [self setCreateTime:other.createTime];
  }
  if (other.hasMsgType) {
    [self setMsgType:other.msgType];
  }
  if (other.hasMsgData) {
    [self setMsgData:other.msgData];
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMMsgDataBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMMsgDataBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setFromUserId:[input readUInt32]];
        break;
      }
      case 16: {
        [self setToSessionId:[input readUInt32]];
        break;
      }
      case 24: {
        [self setMsgId:[input readUInt32]];
        break;
      }
      case 32: {
        [self setCreateTime:[input readUInt32]];
        break;
      }
      case 40: {
        MsgType value = (MsgType)[input readEnum];
        if (MsgTypeIsValidValue(value)) {
          [self setMsgType:value];
        } else {
          [unknownFields mergeVarintField:5 value:value];
        }
        break;
      }
      case 50: {
        [self setMsgData:[input readData]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasFromUserId {
  return result.hasFromUserId;
}
- (UInt32) fromUserId {
  return result.fromUserId;
}
- (IMMsgDataBuilder*) setFromUserId:(UInt32) value {
  result.hasFromUserId = YES;
  result.fromUserId = value;
  return self;
}
- (IMMsgDataBuilder*) clearFromUserId {
  result.hasFromUserId = NO;
  result.fromUserId = 0;
  return self;
}
- (BOOL) hasToSessionId {
  return result.hasToSessionId;
}
- (UInt32) toSessionId {
  return result.toSessionId;
}
- (IMMsgDataBuilder*) setToSessionId:(UInt32) value {
  result.hasToSessionId = YES;
  result.toSessionId = value;
  return self;
}
- (IMMsgDataBuilder*) clearToSessionId {
  result.hasToSessionId = NO;
  result.toSessionId = 0;
  return self;
}
- (BOOL) hasMsgId {
  return result.hasMsgId;
}
- (UInt32) msgId {
  return result.msgId;
}
- (IMMsgDataBuilder*) setMsgId:(UInt32) value {
  result.hasMsgId = YES;
  result.msgId = value;
  return self;
}
- (IMMsgDataBuilder*) clearMsgId {
  result.hasMsgId = NO;
  result.msgId = 0;
  return self;
}
- (BOOL) hasCreateTime {
  return result.hasCreateTime;
}
- (UInt32) createTime {
  return result.createTime;
}
- (IMMsgDataBuilder*) setCreateTime:(UInt32) value {
  result.hasCreateTime = YES;
  result.createTime = value;
  return self;
}
- (IMMsgDataBuilder*) clearCreateTime {
  result.hasCreateTime = NO;
  result.createTime = 0;
  return self;
}
- (BOOL) hasMsgType {
  return result.hasMsgType;
}
- (MsgType) msgType {
  return result.msgType;
}
- (IMMsgDataBuilder*) setMsgType:(MsgType) value {
  result.hasMsgType = YES;
  result.msgType = value;
  return self;
}
- (IMMsgDataBuilder*) clearMsgType {
  result.hasMsgType = NO;
  result.msgType = MsgTypeMsgTypeSingleText;
  return self;
}
- (BOOL) hasMsgData {
  return result.hasMsgData;
}
- (NSData*) msgData {
  return result.msgData;
}
- (IMMsgDataBuilder*) setMsgData:(NSData*) value {
  result.hasMsgData = YES;
  result.msgData = value;
  return self;
}
- (IMMsgDataBuilder*) clearMsgData {
  result.hasMsgData = NO;
  result.msgData = [NSData data];
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMMsgDataBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMMsgDataBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMMsgDataAck ()
@property UInt32 userId;
@property UInt32 sessionId;
@property UInt32 msgId;
@property SessionType sessionType;
@end

@implementation IMMsgDataAck

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasMsgId {
  return !!hasMsgId_;
}
- (void) setHasMsgId:(BOOL) value_ {
  hasMsgId_ = !!value_;
}
@synthesize msgId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (void) dealloc {
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionId = 0;
    self.msgId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
  }
  return self;
}
static IMMsgDataAck* defaultIMMsgDataAckInstance = nil;
+ (void) initialize {
  if (self == [IMMsgDataAck class]) {
    defaultIMMsgDataAckInstance = [[IMMsgDataAck alloc] init];
  }
}
+ (IMMsgDataAck*) defaultInstance {
  return defaultIMMsgDataAckInstance;
}
- (IMMsgDataAck*) defaultInstance {
  return defaultIMMsgDataAckInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasMsgId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionId) {
    [output writeUInt32:2 value:self.sessionId];
  }
  if (self.hasMsgId) {
    [output writeUInt32:3 value:self.msgId];
  }
  if (self.hasSessionType) {
    [output writeEnum:4 value:self.sessionType];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(2, self.sessionId);
  }
  if (self.hasMsgId) {
    size_ += computeUInt32Size(3, self.msgId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(4, self.sessionType);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMMsgDataAck*) parseFromData:(NSData*) data {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromData:data] build];
}
+ (IMMsgDataAck*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataAck*) parseFromInputStream:(NSInputStream*) input {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromInputStream:input] build];
}
+ (IMMsgDataAck*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataAck*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromCodedInputStream:input] build];
}
+ (IMMsgDataAck*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataAck*)[[[IMMsgDataAck builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataAckBuilder*) builder {
  return [[IMMsgDataAckBuilder alloc] init];
}
+ (IMMsgDataAckBuilder*) builderWithPrototype:(IMMsgDataAck*) prototype {
  return [[IMMsgDataAck builder] mergeFrom:prototype];
}
- (IMMsgDataAckBuilder*) builder {
  return [IMMsgDataAck builder];
}
- (IMMsgDataAckBuilder*) toBuilder {
  return [IMMsgDataAck builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasMsgId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgId", [NSNumber numberWithInteger:self.msgId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMMsgDataAck class]]) {
    return NO;
  }
  IMMsgDataAck *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasMsgId == otherMessage.hasMsgId &&
      (!self.hasMsgId || self.msgId == otherMessage.msgId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasMsgId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMMsgDataAckBuilder()
@property (strong) IMMsgDataAck* result;
@end

@implementation IMMsgDataAckBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMMsgDataAck alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMMsgDataAckBuilder*) clear {
  self.result = [[IMMsgDataAck alloc] init];
  return self;
}
- (IMMsgDataAckBuilder*) clone {
  return [IMMsgDataAck builderWithPrototype:result];
}
- (IMMsgDataAck*) defaultInstance {
  return [IMMsgDataAck defaultInstance];
}
- (IMMsgDataAck*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMMsgDataAck*) buildPartial {
  IMMsgDataAck* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMMsgDataAckBuilder*) mergeFrom:(IMMsgDataAck*) other {
  if (other == [IMMsgDataAck defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasMsgId) {
    [self setMsgId:other.msgId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMMsgDataAckBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMMsgDataAckBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 24: {
        [self setMsgId:[input readUInt32]];
        break;
      }
      case 32: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:4 value:value];
        }
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMMsgDataAckBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMMsgDataAckBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMMsgDataAckBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMMsgDataAckBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasMsgId {
  return result.hasMsgId;
}
- (UInt32) msgId {
  return result.msgId;
}
- (IMMsgDataAckBuilder*) setMsgId:(UInt32) value {
  result.hasMsgId = YES;
  result.msgId = value;
  return self;
}
- (IMMsgDataAckBuilder*) clearMsgId {
  result.hasMsgId = NO;
  result.msgId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMMsgDataAckBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMMsgDataAckBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
@end

@interface IMMsgDataReadAck ()
@property UInt32 userId;
@property UInt32 sessionId;
@property UInt32 msgId;
@property SessionType sessionType;
@end

@implementation IMMsgDataReadAck

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasMsgId {
  return !!hasMsgId_;
}
- (void) setHasMsgId:(BOOL) value_ {
  hasMsgId_ = !!value_;
}
@synthesize msgId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (void) dealloc {
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionId = 0;
    self.msgId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
  }
  return self;
}
static IMMsgDataReadAck* defaultIMMsgDataReadAckInstance = nil;
+ (void) initialize {
  if (self == [IMMsgDataReadAck class]) {
    defaultIMMsgDataReadAckInstance = [[IMMsgDataReadAck alloc] init];
  }
}
+ (IMMsgDataReadAck*) defaultInstance {
  return defaultIMMsgDataReadAckInstance;
}
- (IMMsgDataReadAck*) defaultInstance {
  return defaultIMMsgDataReadAckInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasMsgId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionId) {
    [output writeUInt32:2 value:self.sessionId];
  }
  if (self.hasMsgId) {
    [output writeUInt32:3 value:self.msgId];
  }
  if (self.hasSessionType) {
    [output writeEnum:4 value:self.sessionType];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(2, self.sessionId);
  }
  if (self.hasMsgId) {
    size_ += computeUInt32Size(3, self.msgId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(4, self.sessionType);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMMsgDataReadAck*) parseFromData:(NSData*) data {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromData:data] build];
}
+ (IMMsgDataReadAck*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadAck*) parseFromInputStream:(NSInputStream*) input {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromInputStream:input] build];
}
+ (IMMsgDataReadAck*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadAck*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromCodedInputStream:input] build];
}
+ (IMMsgDataReadAck*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadAck*)[[[IMMsgDataReadAck builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadAckBuilder*) builder {
  return [[IMMsgDataReadAckBuilder alloc] init];
}
+ (IMMsgDataReadAckBuilder*) builderWithPrototype:(IMMsgDataReadAck*) prototype {
  return [[IMMsgDataReadAck builder] mergeFrom:prototype];
}
- (IMMsgDataReadAckBuilder*) builder {
  return [IMMsgDataReadAck builder];
}
- (IMMsgDataReadAckBuilder*) toBuilder {
  return [IMMsgDataReadAck builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasMsgId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgId", [NSNumber numberWithInteger:self.msgId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMMsgDataReadAck class]]) {
    return NO;
  }
  IMMsgDataReadAck *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasMsgId == otherMessage.hasMsgId &&
      (!self.hasMsgId || self.msgId == otherMessage.msgId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasMsgId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMMsgDataReadAckBuilder()
@property (strong) IMMsgDataReadAck* result;
@end

@implementation IMMsgDataReadAckBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMMsgDataReadAck alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMMsgDataReadAckBuilder*) clear {
  self.result = [[IMMsgDataReadAck alloc] init];
  return self;
}
- (IMMsgDataReadAckBuilder*) clone {
  return [IMMsgDataReadAck builderWithPrototype:result];
}
- (IMMsgDataReadAck*) defaultInstance {
  return [IMMsgDataReadAck defaultInstance];
}
- (IMMsgDataReadAck*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMMsgDataReadAck*) buildPartial {
  IMMsgDataReadAck* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMMsgDataReadAckBuilder*) mergeFrom:(IMMsgDataReadAck*) other {
  if (other == [IMMsgDataReadAck defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasMsgId) {
    [self setMsgId:other.msgId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMMsgDataReadAckBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMMsgDataReadAckBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 24: {
        [self setMsgId:[input readUInt32]];
        break;
      }
      case 32: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:4 value:value];
        }
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMMsgDataReadAckBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMMsgDataReadAckBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMMsgDataReadAckBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMMsgDataReadAckBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasMsgId {
  return result.hasMsgId;
}
- (UInt32) msgId {
  return result.msgId;
}
- (IMMsgDataReadAckBuilder*) setMsgId:(UInt32) value {
  result.hasMsgId = YES;
  result.msgId = value;
  return self;
}
- (IMMsgDataReadAckBuilder*) clearMsgId {
  result.hasMsgId = NO;
  result.msgId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMMsgDataReadAckBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMMsgDataReadAckBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
@end

@interface IMMsgDataReadNotify ()
@property UInt32 userId;
@property UInt32 sessionId;
@property UInt32 msgId;
@property SessionType sessionType;
@end

@implementation IMMsgDataReadNotify

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasMsgId {
  return !!hasMsgId_;
}
- (void) setHasMsgId:(BOOL) value_ {
  hasMsgId_ = !!value_;
}
@synthesize msgId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (void) dealloc {
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionId = 0;
    self.msgId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
  }
  return self;
}
static IMMsgDataReadNotify* defaultIMMsgDataReadNotifyInstance = nil;
+ (void) initialize {
  if (self == [IMMsgDataReadNotify class]) {
    defaultIMMsgDataReadNotifyInstance = [[IMMsgDataReadNotify alloc] init];
  }
}
+ (IMMsgDataReadNotify*) defaultInstance {
  return defaultIMMsgDataReadNotifyInstance;
}
- (IMMsgDataReadNotify*) defaultInstance {
  return defaultIMMsgDataReadNotifyInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasMsgId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionId) {
    [output writeUInt32:2 value:self.sessionId];
  }
  if (self.hasMsgId) {
    [output writeUInt32:3 value:self.msgId];
  }
  if (self.hasSessionType) {
    [output writeEnum:4 value:self.sessionType];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(2, self.sessionId);
  }
  if (self.hasMsgId) {
    size_ += computeUInt32Size(3, self.msgId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(4, self.sessionType);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMMsgDataReadNotify*) parseFromData:(NSData*) data {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromData:data] build];
}
+ (IMMsgDataReadNotify*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadNotify*) parseFromInputStream:(NSInputStream*) input {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromInputStream:input] build];
}
+ (IMMsgDataReadNotify*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadNotify*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromCodedInputStream:input] build];
}
+ (IMMsgDataReadNotify*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMMsgDataReadNotify*)[[[IMMsgDataReadNotify builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMMsgDataReadNotifyBuilder*) builder {
  return [[IMMsgDataReadNotifyBuilder alloc] init];
}
+ (IMMsgDataReadNotifyBuilder*) builderWithPrototype:(IMMsgDataReadNotify*) prototype {
  return [[IMMsgDataReadNotify builder] mergeFrom:prototype];
}
- (IMMsgDataReadNotifyBuilder*) builder {
  return [IMMsgDataReadNotify builder];
}
- (IMMsgDataReadNotifyBuilder*) toBuilder {
  return [IMMsgDataReadNotify builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasMsgId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgId", [NSNumber numberWithInteger:self.msgId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMMsgDataReadNotify class]]) {
    return NO;
  }
  IMMsgDataReadNotify *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasMsgId == otherMessage.hasMsgId &&
      (!self.hasMsgId || self.msgId == otherMessage.msgId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasMsgId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMMsgDataReadNotifyBuilder()
@property (strong) IMMsgDataReadNotify* result;
@end

@implementation IMMsgDataReadNotifyBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMMsgDataReadNotify alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMMsgDataReadNotifyBuilder*) clear {
  self.result = [[IMMsgDataReadNotify alloc] init];
  return self;
}
- (IMMsgDataReadNotifyBuilder*) clone {
  return [IMMsgDataReadNotify builderWithPrototype:result];
}
- (IMMsgDataReadNotify*) defaultInstance {
  return [IMMsgDataReadNotify defaultInstance];
}
- (IMMsgDataReadNotify*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMMsgDataReadNotify*) buildPartial {
  IMMsgDataReadNotify* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMMsgDataReadNotifyBuilder*) mergeFrom:(IMMsgDataReadNotify*) other {
  if (other == [IMMsgDataReadNotify defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasMsgId) {
    [self setMsgId:other.msgId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMMsgDataReadNotifyBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMMsgDataReadNotifyBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 24: {
        [self setMsgId:[input readUInt32]];
        break;
      }
      case 32: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:4 value:value];
        }
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMMsgDataReadNotifyBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMMsgDataReadNotifyBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMMsgDataReadNotifyBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMMsgDataReadNotifyBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasMsgId {
  return result.hasMsgId;
}
- (UInt32) msgId {
  return result.msgId;
}
- (IMMsgDataReadNotifyBuilder*) setMsgId:(UInt32) value {
  result.hasMsgId = YES;
  result.msgId = value;
  return self;
}
- (IMMsgDataReadNotifyBuilder*) clearMsgId {
  result.hasMsgId = NO;
  result.msgId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMMsgDataReadNotifyBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMMsgDataReadNotifyBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
@end

@interface IMClientTimeReq ()
@end

@implementation IMClientTimeReq

- (void) dealloc {
}
- (id) init {
  if ((self = [super init])) {
  }
  return self;
}
static IMClientTimeReq* defaultIMClientTimeReqInstance = nil;
+ (void) initialize {
  if (self == [IMClientTimeReq class]) {
    defaultIMClientTimeReqInstance = [[IMClientTimeReq alloc] init];
  }
}
+ (IMClientTimeReq*) defaultInstance {
  return defaultIMClientTimeReqInstance;
}
- (IMClientTimeReq*) defaultInstance {
  return defaultIMClientTimeReqInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMClientTimeReq*) parseFromData:(NSData*) data {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromData:data] build];
}
+ (IMClientTimeReq*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeReq*) parseFromInputStream:(NSInputStream*) input {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromInputStream:input] build];
}
+ (IMClientTimeReq*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeReq*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromCodedInputStream:input] build];
}
+ (IMClientTimeReq*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeReq*)[[[IMClientTimeReq builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeReqBuilder*) builder {
  return [[IMClientTimeReqBuilder alloc] init];
}
+ (IMClientTimeReqBuilder*) builderWithPrototype:(IMClientTimeReq*) prototype {
  return [[IMClientTimeReq builder] mergeFrom:prototype];
}
- (IMClientTimeReqBuilder*) builder {
  return [IMClientTimeReq builder];
}
- (IMClientTimeReqBuilder*) toBuilder {
  return [IMClientTimeReq builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMClientTimeReq class]]) {
    return NO;
  }
  IMClientTimeReq *otherMessage = other;
  return
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMClientTimeReqBuilder()
@property (strong) IMClientTimeReq* result;
@end

@implementation IMClientTimeReqBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMClientTimeReq alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMClientTimeReqBuilder*) clear {
  self.result = [[IMClientTimeReq alloc] init];
  return self;
}
- (IMClientTimeReqBuilder*) clone {
  return [IMClientTimeReq builderWithPrototype:result];
}
- (IMClientTimeReq*) defaultInstance {
  return [IMClientTimeReq defaultInstance];
}
- (IMClientTimeReq*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMClientTimeReq*) buildPartial {
  IMClientTimeReq* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMClientTimeReqBuilder*) mergeFrom:(IMClientTimeReq*) other {
  if (other == [IMClientTimeReq defaultInstance]) {
    return self;
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMClientTimeReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMClientTimeReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
    }
  }
}
@end

@interface IMClientTimeRsp ()
@property UInt32 serverTime;
@end

@implementation IMClientTimeRsp

- (BOOL) hasServerTime {
  return !!hasServerTime_;
}
- (void) setHasServerTime:(BOOL) value_ {
  hasServerTime_ = !!value_;
}
@synthesize serverTime;
- (void) dealloc {
}
- (id) init {
  if ((self = [super init])) {
    self.serverTime = 0;
  }
  return self;
}
static IMClientTimeRsp* defaultIMClientTimeRspInstance = nil;
+ (void) initialize {
  if (self == [IMClientTimeRsp class]) {
    defaultIMClientTimeRspInstance = [[IMClientTimeRsp alloc] init];
  }
}
+ (IMClientTimeRsp*) defaultInstance {
  return defaultIMClientTimeRspInstance;
}
- (IMClientTimeRsp*) defaultInstance {
  return defaultIMClientTimeRspInstance;
}
- (BOOL) isInitialized {
  if (!self.hasServerTime) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasServerTime) {
    [output writeUInt32:1 value:self.serverTime];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasServerTime) {
    size_ += computeUInt32Size(1, self.serverTime);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMClientTimeRsp*) parseFromData:(NSData*) data {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromData:data] build];
}
+ (IMClientTimeRsp*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeRsp*) parseFromInputStream:(NSInputStream*) input {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromInputStream:input] build];
}
+ (IMClientTimeRsp*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromCodedInputStream:input] build];
}
+ (IMClientTimeRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMClientTimeRsp*)[[[IMClientTimeRsp builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMClientTimeRspBuilder*) builder {
  return [[IMClientTimeRspBuilder alloc] init];
}
+ (IMClientTimeRspBuilder*) builderWithPrototype:(IMClientTimeRsp*) prototype {
  return [[IMClientTimeRsp builder] mergeFrom:prototype];
}
- (IMClientTimeRspBuilder*) builder {
  return [IMClientTimeRsp builder];
}
- (IMClientTimeRspBuilder*) toBuilder {
  return [IMClientTimeRsp builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasServerTime) {
    [output appendFormat:@"%@%@: %@\n", indent, @"serverTime", [NSNumber numberWithInteger:self.serverTime]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMClientTimeRsp class]]) {
    return NO;
  }
  IMClientTimeRsp *otherMessage = other;
  return
      self.hasServerTime == otherMessage.hasServerTime &&
      (!self.hasServerTime || self.serverTime == otherMessage.serverTime) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasServerTime) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.serverTime] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMClientTimeRspBuilder()
@property (strong) IMClientTimeRsp* result;
@end

@implementation IMClientTimeRspBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMClientTimeRsp alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMClientTimeRspBuilder*) clear {
  self.result = [[IMClientTimeRsp alloc] init];
  return self;
}
- (IMClientTimeRspBuilder*) clone {
  return [IMClientTimeRsp builderWithPrototype:result];
}
- (IMClientTimeRsp*) defaultInstance {
  return [IMClientTimeRsp defaultInstance];
}
- (IMClientTimeRsp*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMClientTimeRsp*) buildPartial {
  IMClientTimeRsp* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMClientTimeRspBuilder*) mergeFrom:(IMClientTimeRsp*) other {
  if (other == [IMClientTimeRsp defaultInstance]) {
    return self;
  }
  if (other.hasServerTime) {
    [self setServerTime:other.serverTime];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMClientTimeRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMClientTimeRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setServerTime:[input readUInt32]];
        break;
      }
    }
  }
}
- (BOOL) hasServerTime {
  return result.hasServerTime;
}
- (UInt32) serverTime {
  return result.serverTime;
}
- (IMClientTimeRspBuilder*) setServerTime:(UInt32) value {
  result.hasServerTime = YES;
  result.serverTime = value;
  return self;
}
- (IMClientTimeRspBuilder*) clearServerTime {
  result.hasServerTime = NO;
  result.serverTime = 0;
  return self;
}
@end

@interface IMUnreadMsgCntReq ()
@property UInt32 userId;
@property (strong) NSData* attachData;
@end

@implementation IMUnreadMsgCntReq

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMUnreadMsgCntReq* defaultIMUnreadMsgCntReqInstance = nil;
+ (void) initialize {
  if (self == [IMUnreadMsgCntReq class]) {
    defaultIMUnreadMsgCntReqInstance = [[IMUnreadMsgCntReq alloc] init];
  }
}
+ (IMUnreadMsgCntReq*) defaultInstance {
  return defaultIMUnreadMsgCntReqInstance;
}
- (IMUnreadMsgCntReq*) defaultInstance {
  return defaultIMUnreadMsgCntReqInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMUnreadMsgCntReq*) parseFromData:(NSData*) data {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromData:data] build];
}
+ (IMUnreadMsgCntReq*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntReq*) parseFromInputStream:(NSInputStream*) input {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromInputStream:input] build];
}
+ (IMUnreadMsgCntReq*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntReq*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromCodedInputStream:input] build];
}
+ (IMUnreadMsgCntReq*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntReq*)[[[IMUnreadMsgCntReq builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntReqBuilder*) builder {
  return [[IMUnreadMsgCntReqBuilder alloc] init];
}
+ (IMUnreadMsgCntReqBuilder*) builderWithPrototype:(IMUnreadMsgCntReq*) prototype {
  return [[IMUnreadMsgCntReq builder] mergeFrom:prototype];
}
- (IMUnreadMsgCntReqBuilder*) builder {
  return [IMUnreadMsgCntReq builder];
}
- (IMUnreadMsgCntReqBuilder*) toBuilder {
  return [IMUnreadMsgCntReq builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMUnreadMsgCntReq class]]) {
    return NO;
  }
  IMUnreadMsgCntReq *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMUnreadMsgCntReqBuilder()
@property (strong) IMUnreadMsgCntReq* result;
@end

@implementation IMUnreadMsgCntReqBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMUnreadMsgCntReq alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMUnreadMsgCntReqBuilder*) clear {
  self.result = [[IMUnreadMsgCntReq alloc] init];
  return self;
}
- (IMUnreadMsgCntReqBuilder*) clone {
  return [IMUnreadMsgCntReq builderWithPrototype:result];
}
- (IMUnreadMsgCntReq*) defaultInstance {
  return [IMUnreadMsgCntReq defaultInstance];
}
- (IMUnreadMsgCntReq*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMUnreadMsgCntReq*) buildPartial {
  IMUnreadMsgCntReq* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMUnreadMsgCntReqBuilder*) mergeFrom:(IMUnreadMsgCntReq*) other {
  if (other == [IMUnreadMsgCntReq defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMUnreadMsgCntReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMUnreadMsgCntReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMUnreadMsgCntReqBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMUnreadMsgCntReqBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMUnreadMsgCntReqBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMUnreadMsgCntReqBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMUnreadMsgCntRsp ()
@property UInt32 userId;
@property UInt32 totalCnt;
@property (strong) NSMutableArray * unreadinfoListArray;
@property (strong) NSData* attachData;
@end

@implementation IMUnreadMsgCntRsp

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasTotalCnt {
  return !!hasTotalCnt_;
}
- (void) setHasTotalCnt:(BOOL) value_ {
  hasTotalCnt_ = !!value_;
}
@synthesize totalCnt;
@synthesize unreadinfoListArray;
@dynamic unreadinfoList;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.unreadinfoListArray = nil;
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.totalCnt = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMUnreadMsgCntRsp* defaultIMUnreadMsgCntRspInstance = nil;
+ (void) initialize {
  if (self == [IMUnreadMsgCntRsp class]) {
    defaultIMUnreadMsgCntRspInstance = [[IMUnreadMsgCntRsp alloc] init];
  }
}
+ (IMUnreadMsgCntRsp*) defaultInstance {
  return defaultIMUnreadMsgCntRspInstance;
}
- (IMUnreadMsgCntRsp*) defaultInstance {
  return defaultIMUnreadMsgCntRspInstance;
}
- (NSArray *)unreadinfoList {
  return unreadinfoListArray;
}
- (UnreadInfo*)unreadinfoListAtIndex:(NSUInteger)index {
  return [unreadinfoListArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasTotalCnt) {
    return NO;
  }
  __block BOOL isInitunreadinfoList = YES;
   [self.unreadinfoList enumerateObjectsUsingBlock:^(UnreadInfo *element, NSUInteger idx, BOOL *stop) {
    if (!element.isInitialized) {
      isInitunreadinfoList = NO;
      *stop = YES;
    }
  }];
  if (!isInitunreadinfoList) return isInitunreadinfoList;
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasTotalCnt) {
    [output writeUInt32:2 value:self.totalCnt];
  }
  [self.unreadinfoListArray enumerateObjectsUsingBlock:^(UnreadInfo *element, NSUInteger idx, BOOL *stop) {
    [output writeMessage:3 value:element];
  }];
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasTotalCnt) {
    size_ += computeUInt32Size(2, self.totalCnt);
  }
  [self.unreadinfoListArray enumerateObjectsUsingBlock:^(UnreadInfo *element, NSUInteger idx, BOOL *stop) {
    size_ += computeMessageSize(3, element);
  }];
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMUnreadMsgCntRsp*) parseFromData:(NSData*) data {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromData:data] build];
}
+ (IMUnreadMsgCntRsp*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntRsp*) parseFromInputStream:(NSInputStream*) input {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromInputStream:input] build];
}
+ (IMUnreadMsgCntRsp*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromCodedInputStream:input] build];
}
+ (IMUnreadMsgCntRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMUnreadMsgCntRsp*)[[[IMUnreadMsgCntRsp builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMUnreadMsgCntRspBuilder*) builder {
  return [[IMUnreadMsgCntRspBuilder alloc] init];
}
+ (IMUnreadMsgCntRspBuilder*) builderWithPrototype:(IMUnreadMsgCntRsp*) prototype {
  return [[IMUnreadMsgCntRsp builder] mergeFrom:prototype];
}
- (IMUnreadMsgCntRspBuilder*) builder {
  return [IMUnreadMsgCntRsp builder];
}
- (IMUnreadMsgCntRspBuilder*) toBuilder {
  return [IMUnreadMsgCntRsp builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasTotalCnt) {
    [output appendFormat:@"%@%@: %@\n", indent, @"totalCnt", [NSNumber numberWithInteger:self.totalCnt]];
  }
  [self.unreadinfoListArray enumerateObjectsUsingBlock:^(UnreadInfo *element, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@ {\n", indent, @"unreadinfoList"];
    [element writeDescriptionTo:output
                     withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }];
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMUnreadMsgCntRsp class]]) {
    return NO;
  }
  IMUnreadMsgCntRsp *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasTotalCnt == otherMessage.hasTotalCnt &&
      (!self.hasTotalCnt || self.totalCnt == otherMessage.totalCnt) &&
      [self.unreadinfoListArray isEqualToArray:otherMessage.unreadinfoListArray] &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasTotalCnt) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.totalCnt] hash];
  }
  [self.unreadinfoListArray enumerateObjectsUsingBlock:^(UnreadInfo *element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMUnreadMsgCntRspBuilder()
@property (strong) IMUnreadMsgCntRsp* result;
@end

@implementation IMUnreadMsgCntRspBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMUnreadMsgCntRsp alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMUnreadMsgCntRspBuilder*) clear {
  self.result = [[IMUnreadMsgCntRsp alloc] init];
  return self;
}
- (IMUnreadMsgCntRspBuilder*) clone {
  return [IMUnreadMsgCntRsp builderWithPrototype:result];
}
- (IMUnreadMsgCntRsp*) defaultInstance {
  return [IMUnreadMsgCntRsp defaultInstance];
}
- (IMUnreadMsgCntRsp*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMUnreadMsgCntRsp*) buildPartial {
  IMUnreadMsgCntRsp* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMUnreadMsgCntRspBuilder*) mergeFrom:(IMUnreadMsgCntRsp*) other {
  if (other == [IMUnreadMsgCntRsp defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasTotalCnt) {
    [self setTotalCnt:other.totalCnt];
  }
  if (other.unreadinfoListArray.count > 0) {
    if (result.unreadinfoListArray == nil) {
      result.unreadinfoListArray = [[NSMutableArray alloc] initWithArray:other.unreadinfoListArray];
    } else {
      [result.unreadinfoListArray addObjectsFromArray:other.unreadinfoListArray];
    }
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMUnreadMsgCntRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMUnreadMsgCntRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        [self setTotalCnt:[input readUInt32]];
        break;
      }
      case 26: {
        UnreadInfoBuilder* subBuilder = [UnreadInfo builder];
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self addUnreadinfoList:[subBuilder buildPartial]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMUnreadMsgCntRspBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMUnreadMsgCntRspBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasTotalCnt {
  return result.hasTotalCnt;
}
- (UInt32) totalCnt {
  return result.totalCnt;
}
- (IMUnreadMsgCntRspBuilder*) setTotalCnt:(UInt32) value {
  result.hasTotalCnt = YES;
  result.totalCnt = value;
  return self;
}
- (IMUnreadMsgCntRspBuilder*) clearTotalCnt {
  result.hasTotalCnt = NO;
  result.totalCnt = 0;
  return self;
}
- (NSMutableArray *)unreadinfoList {
  return result.unreadinfoListArray;
}
- (UnreadInfo*)unreadinfoListAtIndex:(NSUInteger)index {
  return [result unreadinfoListAtIndex:index];
}
- (IMUnreadMsgCntRspBuilder *)addUnreadinfoList:(UnreadInfo*)value {
  if (result.unreadinfoListArray == nil) {
    result.unreadinfoListArray = [[NSMutableArray alloc]init];
  }
  [result.unreadinfoListArray addObject:value];
  return self;
}
- (IMUnreadMsgCntRspBuilder *)setUnreadinfoListArray:(NSArray *)array {
  result.unreadinfoListArray = [[NSMutableArray alloc]initWithArray:array];
  return self;
}
- (IMUnreadMsgCntRspBuilder *)clearUnreadinfoList {
  result.unreadinfoListArray = nil;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMUnreadMsgCntRspBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMUnreadMsgCntRspBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetMsgListReq ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property UInt32 msgIdBegin;
@property UInt32 msgCnt;
@property (strong) NSData* attachData;
@end

@implementation IMGetMsgListReq

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasMsgIdBegin {
  return !!hasMsgIdBegin_;
}
- (void) setHasMsgIdBegin:(BOOL) value_ {
  hasMsgIdBegin_ = !!value_;
}
@synthesize msgIdBegin;
- (BOOL) hasMsgCnt {
  return !!hasMsgCnt_;
}
- (void) setHasMsgCnt:(BOOL) value_ {
  hasMsgCnt_ = !!value_;
}
@synthesize msgCnt;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.msgIdBegin = 0;
    self.msgCnt = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetMsgListReq* defaultIMGetMsgListReqInstance = nil;
+ (void) initialize {
  if (self == [IMGetMsgListReq class]) {
    defaultIMGetMsgListReqInstance = [[IMGetMsgListReq alloc] init];
  }
}
+ (IMGetMsgListReq*) defaultInstance {
  return defaultIMGetMsgListReqInstance;
}
- (IMGetMsgListReq*) defaultInstance {
  return defaultIMGetMsgListReqInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasMsgIdBegin) {
    return NO;
  }
  if (!self.hasMsgCnt) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  if (self.hasMsgIdBegin) {
    [output writeUInt32:4 value:self.msgIdBegin];
  }
  if (self.hasMsgCnt) {
    [output writeUInt32:5 value:self.msgCnt];
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  if (self.hasMsgIdBegin) {
    size_ += computeUInt32Size(4, self.msgIdBegin);
  }
  if (self.hasMsgCnt) {
    size_ += computeUInt32Size(5, self.msgCnt);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetMsgListReq*) parseFromData:(NSData*) data {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromData:data] build];
}
+ (IMGetMsgListReq*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListReq*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromInputStream:input] build];
}
+ (IMGetMsgListReq*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListReq*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetMsgListReq*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListReq*)[[[IMGetMsgListReq builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListReqBuilder*) builder {
  return [[IMGetMsgListReqBuilder alloc] init];
}
+ (IMGetMsgListReqBuilder*) builderWithPrototype:(IMGetMsgListReq*) prototype {
  return [[IMGetMsgListReq builder] mergeFrom:prototype];
}
- (IMGetMsgListReqBuilder*) builder {
  return [IMGetMsgListReq builder];
}
- (IMGetMsgListReqBuilder*) toBuilder {
  return [IMGetMsgListReq builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasMsgIdBegin) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgIdBegin", [NSNumber numberWithInteger:self.msgIdBegin]];
  }
  if (self.hasMsgCnt) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgCnt", [NSNumber numberWithInteger:self.msgCnt]];
  }
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetMsgListReq class]]) {
    return NO;
  }
  IMGetMsgListReq *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasMsgIdBegin == otherMessage.hasMsgIdBegin &&
      (!self.hasMsgIdBegin || self.msgIdBegin == otherMessage.msgIdBegin) &&
      self.hasMsgCnt == otherMessage.hasMsgCnt &&
      (!self.hasMsgCnt || self.msgCnt == otherMessage.msgCnt) &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasMsgIdBegin) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgIdBegin] hash];
  }
  if (self.hasMsgCnt) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgCnt] hash];
  }
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetMsgListReqBuilder()
@property (strong) IMGetMsgListReq* result;
@end

@implementation IMGetMsgListReqBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetMsgListReq alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetMsgListReqBuilder*) clear {
  self.result = [[IMGetMsgListReq alloc] init];
  return self;
}
- (IMGetMsgListReqBuilder*) clone {
  return [IMGetMsgListReq builderWithPrototype:result];
}
- (IMGetMsgListReq*) defaultInstance {
  return [IMGetMsgListReq defaultInstance];
}
- (IMGetMsgListReq*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetMsgListReq*) buildPartial {
  IMGetMsgListReq* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetMsgListReqBuilder*) mergeFrom:(IMGetMsgListReq*) other {
  if (other == [IMGetMsgListReq defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasMsgIdBegin) {
    [self setMsgIdBegin:other.msgIdBegin];
  }
  if (other.hasMsgCnt) {
    [self setMsgCnt:other.msgCnt];
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetMsgListReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetMsgListReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 32: {
        [self setMsgIdBegin:[input readUInt32]];
        break;
      }
      case 40: {
        [self setMsgCnt:[input readUInt32]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetMsgListReqBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetMsgListReqBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetMsgListReqBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasMsgIdBegin {
  return result.hasMsgIdBegin;
}
- (UInt32) msgIdBegin {
  return result.msgIdBegin;
}
- (IMGetMsgListReqBuilder*) setMsgIdBegin:(UInt32) value {
  result.hasMsgIdBegin = YES;
  result.msgIdBegin = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearMsgIdBegin {
  result.hasMsgIdBegin = NO;
  result.msgIdBegin = 0;
  return self;
}
- (BOOL) hasMsgCnt {
  return result.hasMsgCnt;
}
- (UInt32) msgCnt {
  return result.msgCnt;
}
- (IMGetMsgListReqBuilder*) setMsgCnt:(UInt32) value {
  result.hasMsgCnt = YES;
  result.msgCnt = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearMsgCnt {
  result.hasMsgCnt = NO;
  result.msgCnt = 0;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetMsgListReqBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetMsgListReqBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetMsgListRsp ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property UInt32 msgIdBegin;
@property (strong) NSMutableArray * msgListArray;
@property (strong) NSData* attachData;
@end

@implementation IMGetMsgListRsp

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasMsgIdBegin {
  return !!hasMsgIdBegin_;
}
- (void) setHasMsgIdBegin:(BOOL) value_ {
  hasMsgIdBegin_ = !!value_;
}
@synthesize msgIdBegin;
@synthesize msgListArray;
@dynamic msgList;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.msgListArray = nil;
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.msgIdBegin = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetMsgListRsp* defaultIMGetMsgListRspInstance = nil;
+ (void) initialize {
  if (self == [IMGetMsgListRsp class]) {
    defaultIMGetMsgListRspInstance = [[IMGetMsgListRsp alloc] init];
  }
}
+ (IMGetMsgListRsp*) defaultInstance {
  return defaultIMGetMsgListRspInstance;
}
- (IMGetMsgListRsp*) defaultInstance {
  return defaultIMGetMsgListRspInstance;
}
- (NSArray *)msgList {
  return msgListArray;
}
- (MsgInfo*)msgListAtIndex:(NSUInteger)index {
  return [msgListArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasMsgIdBegin) {
    return NO;
  }
  __block BOOL isInitmsgList = YES;
   [self.msgList enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    if (!element.isInitialized) {
      isInitmsgList = NO;
      *stop = YES;
    }
  }];
  if (!isInitmsgList) return isInitmsgList;
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  if (self.hasMsgIdBegin) {
    [output writeUInt32:4 value:self.msgIdBegin];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    [output writeMessage:5 value:element];
  }];
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  if (self.hasMsgIdBegin) {
    size_ += computeUInt32Size(4, self.msgIdBegin);
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    size_ += computeMessageSize(5, element);
  }];
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetMsgListRsp*) parseFromData:(NSData*) data {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromData:data] build];
}
+ (IMGetMsgListRsp*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListRsp*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromInputStream:input] build];
}
+ (IMGetMsgListRsp*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetMsgListRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgListRsp*)[[[IMGetMsgListRsp builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgListRspBuilder*) builder {
  return [[IMGetMsgListRspBuilder alloc] init];
}
+ (IMGetMsgListRspBuilder*) builderWithPrototype:(IMGetMsgListRsp*) prototype {
  return [[IMGetMsgListRsp builder] mergeFrom:prototype];
}
- (IMGetMsgListRspBuilder*) builder {
  return [IMGetMsgListRsp builder];
}
- (IMGetMsgListRspBuilder*) toBuilder {
  return [IMGetMsgListRsp builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasMsgIdBegin) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgIdBegin", [NSNumber numberWithInteger:self.msgIdBegin]];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@ {\n", indent, @"msgList"];
    [element writeDescriptionTo:output
                     withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }];
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetMsgListRsp class]]) {
    return NO;
  }
  IMGetMsgListRsp *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasMsgIdBegin == otherMessage.hasMsgIdBegin &&
      (!self.hasMsgIdBegin || self.msgIdBegin == otherMessage.msgIdBegin) &&
      [self.msgListArray isEqualToArray:otherMessage.msgListArray] &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasMsgIdBegin) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.msgIdBegin] hash];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetMsgListRspBuilder()
@property (strong) IMGetMsgListRsp* result;
@end

@implementation IMGetMsgListRspBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetMsgListRsp alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetMsgListRspBuilder*) clear {
  self.result = [[IMGetMsgListRsp alloc] init];
  return self;
}
- (IMGetMsgListRspBuilder*) clone {
  return [IMGetMsgListRsp builderWithPrototype:result];
}
- (IMGetMsgListRsp*) defaultInstance {
  return [IMGetMsgListRsp defaultInstance];
}
- (IMGetMsgListRsp*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetMsgListRsp*) buildPartial {
  IMGetMsgListRsp* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetMsgListRspBuilder*) mergeFrom:(IMGetMsgListRsp*) other {
  if (other == [IMGetMsgListRsp defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasMsgIdBegin) {
    [self setMsgIdBegin:other.msgIdBegin];
  }
  if (other.msgListArray.count > 0) {
    if (result.msgListArray == nil) {
      result.msgListArray = [[NSMutableArray alloc] initWithArray:other.msgListArray];
    } else {
      [result.msgListArray addObjectsFromArray:other.msgListArray];
    }
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetMsgListRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetMsgListRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 32: {
        [self setMsgIdBegin:[input readUInt32]];
        break;
      }
      case 42: {
        MsgInfoBuilder* subBuilder = [MsgInfo builder];
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self addMsgList:[subBuilder buildPartial]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetMsgListRspBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetMsgListRspBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetMsgListRspBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetMsgListRspBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetMsgListRspBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetMsgListRspBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasMsgIdBegin {
  return result.hasMsgIdBegin;
}
- (UInt32) msgIdBegin {
  return result.msgIdBegin;
}
- (IMGetMsgListRspBuilder*) setMsgIdBegin:(UInt32) value {
  result.hasMsgIdBegin = YES;
  result.msgIdBegin = value;
  return self;
}
- (IMGetMsgListRspBuilder*) clearMsgIdBegin {
  result.hasMsgIdBegin = NO;
  result.msgIdBegin = 0;
  return self;
}
- (NSMutableArray *)msgList {
  return result.msgListArray;
}
- (MsgInfo*)msgListAtIndex:(NSUInteger)index {
  return [result msgListAtIndex:index];
}
- (IMGetMsgListRspBuilder *)addMsgList:(MsgInfo*)value {
  if (result.msgListArray == nil) {
    result.msgListArray = [[NSMutableArray alloc]init];
  }
  [result.msgListArray addObject:value];
  return self;
}
- (IMGetMsgListRspBuilder *)setMsgListArray:(NSArray *)array {
  result.msgListArray = [[NSMutableArray alloc]initWithArray:array];
  return self;
}
- (IMGetMsgListRspBuilder *)clearMsgList {
  result.msgListArray = nil;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetMsgListRspBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetMsgListRspBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetLatestMsgIdReq ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property (strong) NSData* attachData;
@end

@implementation IMGetLatestMsgIdReq

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetLatestMsgIdReq* defaultIMGetLatestMsgIdReqInstance = nil;
+ (void) initialize {
  if (self == [IMGetLatestMsgIdReq class]) {
    defaultIMGetLatestMsgIdReqInstance = [[IMGetLatestMsgIdReq alloc] init];
  }
}
+ (IMGetLatestMsgIdReq*) defaultInstance {
  return defaultIMGetLatestMsgIdReqInstance;
}
- (IMGetLatestMsgIdReq*) defaultInstance {
  return defaultIMGetLatestMsgIdReqInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetLatestMsgIdReq*) parseFromData:(NSData*) data {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromData:data] build];
}
+ (IMGetLatestMsgIdReq*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdReq*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromInputStream:input] build];
}
+ (IMGetLatestMsgIdReq*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdReq*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetLatestMsgIdReq*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdReq*)[[[IMGetLatestMsgIdReq builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdReqBuilder*) builder {
  return [[IMGetLatestMsgIdReqBuilder alloc] init];
}
+ (IMGetLatestMsgIdReqBuilder*) builderWithPrototype:(IMGetLatestMsgIdReq*) prototype {
  return [[IMGetLatestMsgIdReq builder] mergeFrom:prototype];
}
- (IMGetLatestMsgIdReqBuilder*) builder {
  return [IMGetLatestMsgIdReq builder];
}
- (IMGetLatestMsgIdReqBuilder*) toBuilder {
  return [IMGetLatestMsgIdReq builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetLatestMsgIdReq class]]) {
    return NO;
  }
  IMGetLatestMsgIdReq *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetLatestMsgIdReqBuilder()
@property (strong) IMGetLatestMsgIdReq* result;
@end

@implementation IMGetLatestMsgIdReqBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetLatestMsgIdReq alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetLatestMsgIdReqBuilder*) clear {
  self.result = [[IMGetLatestMsgIdReq alloc] init];
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) clone {
  return [IMGetLatestMsgIdReq builderWithPrototype:result];
}
- (IMGetLatestMsgIdReq*) defaultInstance {
  return [IMGetLatestMsgIdReq defaultInstance];
}
- (IMGetLatestMsgIdReq*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetLatestMsgIdReq*) buildPartial {
  IMGetLatestMsgIdReq* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetLatestMsgIdReqBuilder*) mergeFrom:(IMGetLatestMsgIdReq*) other {
  if (other == [IMGetLatestMsgIdReq defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetLatestMsgIdReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetLatestMsgIdReqBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetLatestMsgIdReqBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetLatestMsgIdReqBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetLatestMsgIdReqBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetLatestMsgIdReqBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetLatestMsgIdRsp ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property UInt32 latestMsgId;
@property (strong) NSData* attachData;
@end

@implementation IMGetLatestMsgIdRsp

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
- (BOOL) hasLatestMsgId {
  return !!hasLatestMsgId_;
}
- (void) setHasLatestMsgId:(BOOL) value_ {
  hasLatestMsgId_ = !!value_;
}
@synthesize latestMsgId;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.latestMsgId = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetLatestMsgIdRsp* defaultIMGetLatestMsgIdRspInstance = nil;
+ (void) initialize {
  if (self == [IMGetLatestMsgIdRsp class]) {
    defaultIMGetLatestMsgIdRspInstance = [[IMGetLatestMsgIdRsp alloc] init];
  }
}
+ (IMGetLatestMsgIdRsp*) defaultInstance {
  return defaultIMGetLatestMsgIdRspInstance;
}
- (IMGetLatestMsgIdRsp*) defaultInstance {
  return defaultIMGetLatestMsgIdRspInstance;
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  if (!self.hasLatestMsgId) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  if (self.hasLatestMsgId) {
    [output writeUInt32:4 value:self.latestMsgId];
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  if (self.hasLatestMsgId) {
    size_ += computeUInt32Size(4, self.latestMsgId);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetLatestMsgIdRsp*) parseFromData:(NSData*) data {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromData:data] build];
}
+ (IMGetLatestMsgIdRsp*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdRsp*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromInputStream:input] build];
}
+ (IMGetLatestMsgIdRsp*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetLatestMsgIdRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetLatestMsgIdRsp*)[[[IMGetLatestMsgIdRsp builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetLatestMsgIdRspBuilder*) builder {
  return [[IMGetLatestMsgIdRspBuilder alloc] init];
}
+ (IMGetLatestMsgIdRspBuilder*) builderWithPrototype:(IMGetLatestMsgIdRsp*) prototype {
  return [[IMGetLatestMsgIdRsp builder] mergeFrom:prototype];
}
- (IMGetLatestMsgIdRspBuilder*) builder {
  return [IMGetLatestMsgIdRsp builder];
}
- (IMGetLatestMsgIdRspBuilder*) toBuilder {
  return [IMGetLatestMsgIdRsp builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  if (self.hasLatestMsgId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"latestMsgId", [NSNumber numberWithInteger:self.latestMsgId]];
  }
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetLatestMsgIdRsp class]]) {
    return NO;
  }
  IMGetLatestMsgIdRsp *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      self.hasLatestMsgId == otherMessage.hasLatestMsgId &&
      (!self.hasLatestMsgId || self.latestMsgId == otherMessage.latestMsgId) &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  if (self.hasLatestMsgId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.latestMsgId] hash];
  }
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetLatestMsgIdRspBuilder()
@property (strong) IMGetLatestMsgIdRsp* result;
@end

@implementation IMGetLatestMsgIdRspBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetLatestMsgIdRsp alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetLatestMsgIdRspBuilder*) clear {
  self.result = [[IMGetLatestMsgIdRsp alloc] init];
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clone {
  return [IMGetLatestMsgIdRsp builderWithPrototype:result];
}
- (IMGetLatestMsgIdRsp*) defaultInstance {
  return [IMGetLatestMsgIdRsp defaultInstance];
}
- (IMGetLatestMsgIdRsp*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetLatestMsgIdRsp*) buildPartial {
  IMGetLatestMsgIdRsp* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetLatestMsgIdRspBuilder*) mergeFrom:(IMGetLatestMsgIdRsp*) other {
  if (other == [IMGetLatestMsgIdRsp defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.hasLatestMsgId) {
    [self setLatestMsgId:other.latestMsgId];
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetLatestMsgIdRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 32: {
        [self setLatestMsgId:[input readUInt32]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetLatestMsgIdRspBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetLatestMsgIdRspBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetLatestMsgIdRspBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (BOOL) hasLatestMsgId {
  return result.hasLatestMsgId;
}
- (UInt32) latestMsgId {
  return result.latestMsgId;
}
- (IMGetLatestMsgIdRspBuilder*) setLatestMsgId:(UInt32) value {
  result.hasLatestMsgId = YES;
  result.latestMsgId = value;
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clearLatestMsgId {
  result.hasLatestMsgId = NO;
  result.latestMsgId = 0;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetLatestMsgIdRspBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetLatestMsgIdRspBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetMsgByIdReq ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property (strong) PBAppendableArray * msgIdListArray;
@property (strong) NSData* attachData;
@end

@implementation IMGetMsgByIdReq

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
@synthesize msgIdListArray;
@dynamic msgIdList;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.msgIdListArray = nil;
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetMsgByIdReq* defaultIMGetMsgByIdReqInstance = nil;
+ (void) initialize {
  if (self == [IMGetMsgByIdReq class]) {
    defaultIMGetMsgByIdReqInstance = [[IMGetMsgByIdReq alloc] init];
  }
}
+ (IMGetMsgByIdReq*) defaultInstance {
  return defaultIMGetMsgByIdReqInstance;
}
- (IMGetMsgByIdReq*) defaultInstance {
  return defaultIMGetMsgByIdReqInstance;
}
- (PBArray *)msgIdList {
  return msgIdListArray;
}
- (UInt32)msgIdListAtIndex:(NSUInteger)index {
  return [msgIdListArray uint32AtIndex:index];
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  const NSUInteger msgIdListArrayCount = self.msgIdListArray.count;
  if (msgIdListArrayCount > 0) {
    const UInt32 *values = (const UInt32 *)self.msgIdListArray.data;
    for (NSUInteger i = 0; i < msgIdListArrayCount; ++i) {
      [output writeUInt32:4 value:values[i]];
    }
  }
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  {
    __block SInt32 dataSize = 0;
    const NSUInteger count = self.msgIdListArray.count;
    const UInt32 *values = (const UInt32 *)self.msgIdListArray.data;
    for (NSUInteger i = 0; i < count; ++i) {
      dataSize += computeUInt32SizeNoTag(values[i]);
    }
    size_ += dataSize;
    size_ += (SInt32)(1 * count);
  }
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetMsgByIdReq*) parseFromData:(NSData*) data {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromData:data] build];
}
+ (IMGetMsgByIdReq*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdReq*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromInputStream:input] build];
}
+ (IMGetMsgByIdReq*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdReq*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetMsgByIdReq*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdReq*)[[[IMGetMsgByIdReq builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdReqBuilder*) builder {
  return [[IMGetMsgByIdReqBuilder alloc] init];
}
+ (IMGetMsgByIdReqBuilder*) builderWithPrototype:(IMGetMsgByIdReq*) prototype {
  return [[IMGetMsgByIdReq builder] mergeFrom:prototype];
}
- (IMGetMsgByIdReqBuilder*) builder {
  return [IMGetMsgByIdReq builder];
}
- (IMGetMsgByIdReqBuilder*) toBuilder {
  return [IMGetMsgByIdReq builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  [self.msgIdListArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@: %@\n", indent, @"msgIdList", obj];
  }];
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetMsgByIdReq class]]) {
    return NO;
  }
  IMGetMsgByIdReq *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      [self.msgIdListArray isEqualToArray:otherMessage.msgIdListArray] &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  [self.msgIdListArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [obj longValue];
  }];
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetMsgByIdReqBuilder()
@property (strong) IMGetMsgByIdReq* result;
@end

@implementation IMGetMsgByIdReqBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetMsgByIdReq alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetMsgByIdReqBuilder*) clear {
  self.result = [[IMGetMsgByIdReq alloc] init];
  return self;
}
- (IMGetMsgByIdReqBuilder*) clone {
  return [IMGetMsgByIdReq builderWithPrototype:result];
}
- (IMGetMsgByIdReq*) defaultInstance {
  return [IMGetMsgByIdReq defaultInstance];
}
- (IMGetMsgByIdReq*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetMsgByIdReq*) buildPartial {
  IMGetMsgByIdReq* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetMsgByIdReqBuilder*) mergeFrom:(IMGetMsgByIdReq*) other {
  if (other == [IMGetMsgByIdReq defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.msgIdListArray.count > 0) {
    if (result.msgIdListArray == nil) {
      result.msgIdListArray = [other.msgIdListArray copy];
    } else {
      [result.msgIdListArray appendArray:other.msgIdListArray];
    }
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetMsgByIdReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetMsgByIdReqBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 32: {
        [self addMsgIdList:[input readUInt32]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetMsgByIdReqBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetMsgByIdReqBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetMsgByIdReqBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetMsgByIdReqBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetMsgByIdReqBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetMsgByIdReqBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (PBAppendableArray *)msgIdList {
  return result.msgIdListArray;
}
- (UInt32)msgIdListAtIndex:(NSUInteger)index {
  return [result msgIdListAtIndex:index];
}
- (IMGetMsgByIdReqBuilder *)addMsgIdList:(UInt32)value {
  if (result.msgIdListArray == nil) {
    result.msgIdListArray = [PBAppendableArray arrayWithValueType:PBArrayValueTypeUInt32];
  }
  [result.msgIdListArray addUint32:value];
  return self;
}
- (IMGetMsgByIdReqBuilder *)setMsgIdListArray:(NSArray *)array {
  result.msgIdListArray = [PBAppendableArray arrayWithArray:array valueType:PBArrayValueTypeUInt32];
  return self;
}
- (IMGetMsgByIdReqBuilder *)setMsgIdListValues:(const UInt32 *)values count:(NSUInteger)count {
  result.msgIdListArray = [PBAppendableArray arrayWithValues:values count:count valueType:PBArrayValueTypeUInt32];
  return self;
}
- (IMGetMsgByIdReqBuilder *)clearMsgIdList {
  result.msgIdListArray = nil;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetMsgByIdReqBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetMsgByIdReqBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end

@interface IMGetMsgByIdRsp ()
@property UInt32 userId;
@property SessionType sessionType;
@property UInt32 sessionId;
@property (strong) NSMutableArray * msgListArray;
@property (strong) NSData* attachData;
@end

@implementation IMGetMsgByIdRsp

- (BOOL) hasUserId {
  return !!hasUserId_;
}
- (void) setHasUserId:(BOOL) value_ {
  hasUserId_ = !!value_;
}
@synthesize userId;
- (BOOL) hasSessionType {
  return !!hasSessionType_;
}
- (void) setHasSessionType:(BOOL) value_ {
  hasSessionType_ = !!value_;
}
@synthesize sessionType;
- (BOOL) hasSessionId {
  return !!hasSessionId_;
}
- (void) setHasSessionId:(BOOL) value_ {
  hasSessionId_ = !!value_;
}
@synthesize sessionId;
@synthesize msgListArray;
@dynamic msgList;
- (BOOL) hasAttachData {
  return !!hasAttachData_;
}
- (void) setHasAttachData:(BOOL) value_ {
  hasAttachData_ = !!value_;
}
@synthesize attachData;
- (void) dealloc {
  self.msgListArray = nil;
  self.attachData = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.userId = 0;
    self.sessionType = SessionTypeSessionTypeSingle;
    self.sessionId = 0;
    self.attachData = [NSData data];
  }
  return self;
}
static IMGetMsgByIdRsp* defaultIMGetMsgByIdRspInstance = nil;
+ (void) initialize {
  if (self == [IMGetMsgByIdRsp class]) {
    defaultIMGetMsgByIdRspInstance = [[IMGetMsgByIdRsp alloc] init];
  }
}
+ (IMGetMsgByIdRsp*) defaultInstance {
  return defaultIMGetMsgByIdRspInstance;
}
- (IMGetMsgByIdRsp*) defaultInstance {
  return defaultIMGetMsgByIdRspInstance;
}
- (NSArray *)msgList {
  return msgListArray;
}
- (MsgInfo*)msgListAtIndex:(NSUInteger)index {
  return [msgListArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  if (!self.hasUserId) {
    return NO;
  }
  if (!self.hasSessionType) {
    return NO;
  }
  if (!self.hasSessionId) {
    return NO;
  }
  __block BOOL isInitmsgList = YES;
   [self.msgList enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    if (!element.isInitialized) {
      isInitmsgList = NO;
      *stop = YES;
    }
  }];
  if (!isInitmsgList) return isInitmsgList;
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasUserId) {
    [output writeUInt32:1 value:self.userId];
  }
  if (self.hasSessionType) {
    [output writeEnum:2 value:self.sessionType];
  }
  if (self.hasSessionId) {
    [output writeUInt32:3 value:self.sessionId];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    [output writeMessage:4 value:element];
  }];
  if (self.hasAttachData) {
    [output writeData:20 value:self.attachData];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasUserId) {
    size_ += computeUInt32Size(1, self.userId);
  }
  if (self.hasSessionType) {
    size_ += computeEnumSize(2, self.sessionType);
  }
  if (self.hasSessionId) {
    size_ += computeUInt32Size(3, self.sessionId);
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    size_ += computeMessageSize(4, element);
  }];
  if (self.hasAttachData) {
    size_ += computeDataSize(20, self.attachData);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (IMGetMsgByIdRsp*) parseFromData:(NSData*) data {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromData:data] build];
}
+ (IMGetMsgByIdRsp*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdRsp*) parseFromInputStream:(NSInputStream*) input {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromInputStream:input] build];
}
+ (IMGetMsgByIdRsp*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromCodedInputStream:input] build];
}
+ (IMGetMsgByIdRsp*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (IMGetMsgByIdRsp*)[[[IMGetMsgByIdRsp builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (IMGetMsgByIdRspBuilder*) builder {
  return [[IMGetMsgByIdRspBuilder alloc] init];
}
+ (IMGetMsgByIdRspBuilder*) builderWithPrototype:(IMGetMsgByIdRsp*) prototype {
  return [[IMGetMsgByIdRsp builder] mergeFrom:prototype];
}
- (IMGetMsgByIdRspBuilder*) builder {
  return [IMGetMsgByIdRsp builder];
}
- (IMGetMsgByIdRspBuilder*) toBuilder {
  return [IMGetMsgByIdRsp builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasUserId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"userId", [NSNumber numberWithInteger:self.userId]];
  }
  if (self.hasSessionType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"sessionType", self.sessionType];
  }
  if (self.hasSessionId) {
    [output appendFormat:@"%@%@: %@\n", indent, @"sessionId", [NSNumber numberWithInteger:self.sessionId]];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@ {\n", indent, @"msgList"];
    [element writeDescriptionTo:output
                     withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }];
  if (self.hasAttachData) {
    [output appendFormat:@"%@%@: %@\n", indent, @"attachData", self.attachData];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[IMGetMsgByIdRsp class]]) {
    return NO;
  }
  IMGetMsgByIdRsp *otherMessage = other;
  return
      self.hasUserId == otherMessage.hasUserId &&
      (!self.hasUserId || self.userId == otherMessage.userId) &&
      self.hasSessionType == otherMessage.hasSessionType &&
      (!self.hasSessionType || self.sessionType == otherMessage.sessionType) &&
      self.hasSessionId == otherMessage.hasSessionId &&
      (!self.hasSessionId || self.sessionId == otherMessage.sessionId) &&
      [self.msgListArray isEqualToArray:otherMessage.msgListArray] &&
      self.hasAttachData == otherMessage.hasAttachData &&
      (!self.hasAttachData || [self.attachData isEqual:otherMessage.attachData]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasUserId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.userId] hash];
  }
  if (self.hasSessionType) {
    hashCode = hashCode * 31 + self.sessionType;
  }
  if (self.hasSessionId) {
    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.sessionId] hash];
  }
  [self.msgListArray enumerateObjectsUsingBlock:^(MsgInfo *element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasAttachData) {
    hashCode = hashCode * 31 + [self.attachData hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface IMGetMsgByIdRspBuilder()
@property (strong) IMGetMsgByIdRsp* result;
@end

@implementation IMGetMsgByIdRspBuilder
@synthesize result;
- (void) dealloc {
  self.result = nil;
}
- (id) init {
  if ((self = [super init])) {
    self.result = [[IMGetMsgByIdRsp alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (IMGetMsgByIdRspBuilder*) clear {
  self.result = [[IMGetMsgByIdRsp alloc] init];
  return self;
}
- (IMGetMsgByIdRspBuilder*) clone {
  return [IMGetMsgByIdRsp builderWithPrototype:result];
}
- (IMGetMsgByIdRsp*) defaultInstance {
  return [IMGetMsgByIdRsp defaultInstance];
}
- (IMGetMsgByIdRsp*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (IMGetMsgByIdRsp*) buildPartial {
  IMGetMsgByIdRsp* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (IMGetMsgByIdRspBuilder*) mergeFrom:(IMGetMsgByIdRsp*) other {
  if (other == [IMGetMsgByIdRsp defaultInstance]) {
    return self;
  }
  if (other.hasUserId) {
    [self setUserId:other.userId];
  }
  if (other.hasSessionType) {
    [self setSessionType:other.sessionType];
  }
  if (other.hasSessionId) {
    [self setSessionId:other.sessionId];
  }
  if (other.msgListArray.count > 0) {
    if (result.msgListArray == nil) {
      result.msgListArray = [[NSMutableArray alloc] initWithArray:other.msgListArray];
    } else {
      [result.msgListArray addObjectsFromArray:other.msgListArray];
    }
  }
  if (other.hasAttachData) {
    [self setAttachData:other.attachData];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (IMGetMsgByIdRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (IMGetMsgByIdRspBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        [self setUserId:[input readUInt32]];
        break;
      }
      case 16: {
        SessionType value = (SessionType)[input readEnum];
        if (SessionTypeIsValidValue(value)) {
          [self setSessionType:value];
        } else {
          [unknownFields mergeVarintField:2 value:value];
        }
        break;
      }
      case 24: {
        [self setSessionId:[input readUInt32]];
        break;
      }
      case 34: {
        MsgInfoBuilder* subBuilder = [MsgInfo builder];
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self addMsgList:[subBuilder buildPartial]];
        break;
      }
      case 162: {
        [self setAttachData:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasUserId {
  return result.hasUserId;
}
- (UInt32) userId {
  return result.userId;
}
- (IMGetMsgByIdRspBuilder*) setUserId:(UInt32) value {
  result.hasUserId = YES;
  result.userId = value;
  return self;
}
- (IMGetMsgByIdRspBuilder*) clearUserId {
  result.hasUserId = NO;
  result.userId = 0;
  return self;
}
- (BOOL) hasSessionType {
  return result.hasSessionType;
}
- (SessionType) sessionType {
  return result.sessionType;
}
- (IMGetMsgByIdRspBuilder*) setSessionType:(SessionType) value {
  result.hasSessionType = YES;
  result.sessionType = value;
  return self;
}
- (IMGetMsgByIdRspBuilder*) clearSessionType {
  result.hasSessionType = NO;
  result.sessionType = SessionTypeSessionTypeSingle;
  return self;
}
- (BOOL) hasSessionId {
  return result.hasSessionId;
}
- (UInt32) sessionId {
  return result.sessionId;
}
- (IMGetMsgByIdRspBuilder*) setSessionId:(UInt32) value {
  result.hasSessionId = YES;
  result.sessionId = value;
  return self;
}
- (IMGetMsgByIdRspBuilder*) clearSessionId {
  result.hasSessionId = NO;
  result.sessionId = 0;
  return self;
}
- (NSMutableArray *)msgList {
  return result.msgListArray;
}
- (MsgInfo*)msgListAtIndex:(NSUInteger)index {
  return [result msgListAtIndex:index];
}
- (IMGetMsgByIdRspBuilder *)addMsgList:(MsgInfo*)value {
  if (result.msgListArray == nil) {
    result.msgListArray = [[NSMutableArray alloc]init];
  }
  [result.msgListArray addObject:value];
  return self;
}
- (IMGetMsgByIdRspBuilder *)setMsgListArray:(NSArray *)array {
  result.msgListArray = [[NSMutableArray alloc]initWithArray:array];
  return self;
}
- (IMGetMsgByIdRspBuilder *)clearMsgList {
  result.msgListArray = nil;
  return self;
}
- (BOOL) hasAttachData {
  return result.hasAttachData;
}
- (NSData*) attachData {
  return result.attachData;
}
- (IMGetMsgByIdRspBuilder*) setAttachData:(NSData*) value {
  result.hasAttachData = YES;
  result.attachData = value;
  return self;
}
- (IMGetMsgByIdRspBuilder*) clearAttachData {
  result.hasAttachData = NO;
  result.attachData = [NSData data];
  return self;
}
@end


// @@protoc_insertion_point(global_scope)