src/gen_proto/Setuptalk.pb.m

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

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

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

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

BOOL ST_PacketTypeIsValidValue(ST_PacketType value) {
  switch (value) {
    case ST_PacketTypePacketTypeInitSetup:
    case ST_PacketTypePacketTypeWifiScan:
    case ST_PacketTypePacketTypeWifiConnect:
    case ST_PacketTypePacketTypeJpakeBegin:
    case ST_PacketTypePacketTypeJpakeResponse:
    case ST_PacketTypePacketTypeDeviceInfo:
    case ST_PacketTypePacketTypeWifiScanList:
    case ST_PacketTypePacketTypeWifiConnectStatus:
      return YES;
    default:
      return NO;
  }
}
@interface ST_JpakeStep ()
@property (strong) NSData* gx;
@property (strong) NSData* gr;
@property (strong) NSData* b;
@end

@implementation ST_JpakeStep

- (BOOL) hasGx {
  return !!hasGx_;
}
- (void) setHasGx:(BOOL) value_ {
  hasGx_ = !!value_;
}
@synthesize gx;
- (BOOL) hasGr {
  return !!hasGr_;
}
- (void) setHasGr:(BOOL) value_ {
  hasGr_ = !!value_;
}
@synthesize gr;
- (BOOL) hasB {
  return !!hasB_;
}
- (void) setHasB:(BOOL) value_ {
  hasB_ = !!value_;
}
@synthesize b;
- (id) init {
  if ((self = [super init])) {
    self.gx = [NSData data];
    self.gr = [NSData data];
    self.b = [NSData data];
  }
  return self;
}
static ST_JpakeStep* defaultST_JpakeStepInstance = nil;
+ (void) initialize {
  if (self == [ST_JpakeStep class]) {
    defaultST_JpakeStepInstance = [[ST_JpakeStep alloc] init];
  }
}
+ (ST_JpakeStep*) defaultInstance {
  return defaultST_JpakeStepInstance;
}
- (ST_JpakeStep*) defaultInstance {
  return defaultST_JpakeStepInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasGx) {
    [output writeData:1 value:self.gx];
  }
  if (self.hasGr) {
    [output writeData:2 value:self.gr];
  }
  if (self.hasB) {
    [output writeData:3 value:self.b];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_JpakeStepBuilder()
@property (strong) ST_JpakeStep* result;
@end

@implementation ST_JpakeStepBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_JpakeStep alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_JpakeStepBuilder*) clear {
  self.result = [[ST_JpakeStep alloc] init];
  return self;
}
- (ST_JpakeStepBuilder*) clone {
  return [ST_JpakeStep builderWithPrototype:result];
}
- (ST_JpakeStep*) defaultInstance {
  return [ST_JpakeStep defaultInstance];
}
- (ST_JpakeStep*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_JpakeStep*) buildPartial {
  ST_JpakeStep* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_JpakeStepBuilder*) mergeFrom:(ST_JpakeStep*) other {
  if (other == [ST_JpakeStep defaultInstance]) {
    return self;
  }
  if (other.hasGx) {
    [self setGx:other.gx];
  }
  if (other.hasGr) {
    [self setGr:other.gr];
  }
  if (other.hasB) {
    [self setB:other.b];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_JpakeStepBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_JpakeStepBuilder*) 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 10: {
        [self setGx:[input readData]];
        break;
      }
      case 18: {
        [self setGr:[input readData]];
        break;
      }
      case 26: {
        [self setB:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasGx {
  return result.hasGx;
}
- (NSData*) gx {
  return result.gx;
}
- (ST_JpakeStepBuilder*) setGx:(NSData*) value {
  result.hasGx = YES;
  result.gx = value;
  return self;
}
- (ST_JpakeStepBuilder*) clearGx {
  result.hasGx = NO;
  result.gx = [NSData data];
  return self;
}
- (BOOL) hasGr {
  return result.hasGr;
}
- (NSData*) gr {
  return result.gr;
}
- (ST_JpakeStepBuilder*) setGr:(NSData*) value {
  result.hasGr = YES;
  result.gr = value;
  return self;
}
- (ST_JpakeStepBuilder*) clearGr {
  result.hasGr = NO;
  result.gr = [NSData data];
  return self;
}
- (BOOL) hasB {
  return result.hasB;
}
- (NSData*) b {
  return result.b;
}
- (ST_JpakeStepBuilder*) setB:(NSData*) value {
  result.hasB = YES;
  result.b = value;
  return self;
}
- (ST_JpakeStepBuilder*) clearB {
  result.hasB = NO;
  result.b = [NSData data];
  return self;
}
@end

@interface ST_JpakeBegin ()
@property (strong) ST_JpakeStep* astep1P1;
@property (strong) ST_JpakeStep* astep1P2;
@end

@implementation ST_JpakeBegin

- (BOOL) hasAstep1P1 {
  return !!hasAstep1P1_;
}
- (void) setHasAstep1P1:(BOOL) value_ {
  hasAstep1P1_ = !!value_;
}
@synthesize astep1P1;
- (BOOL) hasAstep1P2 {
  return !!hasAstep1P2_;
}
- (void) setHasAstep1P2:(BOOL) value_ {
  hasAstep1P2_ = !!value_;
}
@synthesize astep1P2;
- (id) init {
  if ((self = [super init])) {
    self.astep1P1 = [ST_JpakeStep defaultInstance];
    self.astep1P2 = [ST_JpakeStep defaultInstance];
  }
  return self;
}
static ST_JpakeBegin* defaultST_JpakeBeginInstance = nil;
+ (void) initialize {
  if (self == [ST_JpakeBegin class]) {
    defaultST_JpakeBeginInstance = [[ST_JpakeBegin alloc] init];
  }
}
+ (ST_JpakeBegin*) defaultInstance {
  return defaultST_JpakeBeginInstance;
}
- (ST_JpakeBegin*) defaultInstance {
  return defaultST_JpakeBeginInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasAstep1P1) {
    [output writeMessage:1 value:self.astep1P1];
  }
  if (self.hasAstep1P2) {
    [output writeMessage:2 value:self.astep1P2];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_JpakeBeginBuilder()
@property (strong) ST_JpakeBegin* result;
@end

@implementation ST_JpakeBeginBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_JpakeBegin alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_JpakeBeginBuilder*) clear {
  self.result = [[ST_JpakeBegin alloc] init];
  return self;
}
- (ST_JpakeBeginBuilder*) clone {
  return [ST_JpakeBegin builderWithPrototype:result];
}
- (ST_JpakeBegin*) defaultInstance {
  return [ST_JpakeBegin defaultInstance];
}
- (ST_JpakeBegin*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_JpakeBegin*) buildPartial {
  ST_JpakeBegin* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_JpakeBeginBuilder*) mergeFrom:(ST_JpakeBegin*) other {
  if (other == [ST_JpakeBegin defaultInstance]) {
    return self;
  }
  if (other.hasAstep1P1) {
    [self mergeAstep1P1:other.astep1P1];
  }
  if (other.hasAstep1P2) {
    [self mergeAstep1P2:other.astep1P2];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_JpakeBeginBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_JpakeBeginBuilder*) 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 10: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasAstep1P1) {
          [subBuilder mergeFrom:self.astep1P1];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAstep1P1:[subBuilder buildPartial]];
        break;
      }
      case 18: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasAstep1P2) {
          [subBuilder mergeFrom:self.astep1P2];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAstep1P2:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasAstep1P1 {
  return result.hasAstep1P1;
}
- (ST_JpakeStep*) astep1P1 {
  return result.astep1P1;
}
- (ST_JpakeBeginBuilder*) setAstep1P1:(ST_JpakeStep*) value {
  result.hasAstep1P1 = YES;
  result.astep1P1 = value;
  return self;
}
- (ST_JpakeBeginBuilder*) setAstep1P1Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setAstep1P1:[builderForValue build]];
}
- (ST_JpakeBeginBuilder*) mergeAstep1P1:(ST_JpakeStep*) value {
  if (result.hasAstep1P1 &&
      result.astep1P1 != [ST_JpakeStep defaultInstance]) {
    result.astep1P1 =
      [[[ST_JpakeStep builderWithPrototype:result.astep1P1] mergeFrom:value] buildPartial];
  } else {
    result.astep1P1 = value;
  }
  result.hasAstep1P1 = YES;
  return self;
}
- (ST_JpakeBeginBuilder*) clearAstep1P1 {
  result.hasAstep1P1 = NO;
  result.astep1P1 = [ST_JpakeStep defaultInstance];
  return self;
}
- (BOOL) hasAstep1P2 {
  return result.hasAstep1P2;
}
- (ST_JpakeStep*) astep1P2 {
  return result.astep1P2;
}
- (ST_JpakeBeginBuilder*) setAstep1P2:(ST_JpakeStep*) value {
  result.hasAstep1P2 = YES;
  result.astep1P2 = value;
  return self;
}
- (ST_JpakeBeginBuilder*) setAstep1P2Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setAstep1P2:[builderForValue build]];
}
- (ST_JpakeBeginBuilder*) mergeAstep1P2:(ST_JpakeStep*) value {
  if (result.hasAstep1P2 &&
      result.astep1P2 != [ST_JpakeStep defaultInstance]) {
    result.astep1P2 =
      [[[ST_JpakeStep builderWithPrototype:result.astep1P2] mergeFrom:value] buildPartial];
  } else {
    result.astep1P2 = value;
  }
  result.hasAstep1P2 = YES;
  return self;
}
- (ST_JpakeBeginBuilder*) clearAstep1P2 {
  result.hasAstep1P2 = NO;
  result.astep1P2 = [ST_JpakeStep defaultInstance];
  return self;
}
@end

@interface ST_JpakeResponse ()
@property (strong) ST_JpakeStep* cstep1P1;
@property (strong) ST_JpakeStep* cstep1P2;
@property (strong) ST_JpakeStep* cstep2;
@end

@implementation ST_JpakeResponse

- (BOOL) hasCstep1P1 {
  return !!hasCstep1P1_;
}
- (void) setHasCstep1P1:(BOOL) value_ {
  hasCstep1P1_ = !!value_;
}
@synthesize cstep1P1;
- (BOOL) hasCstep1P2 {
  return !!hasCstep1P2_;
}
- (void) setHasCstep1P2:(BOOL) value_ {
  hasCstep1P2_ = !!value_;
}
@synthesize cstep1P2;
- (BOOL) hasCstep2 {
  return !!hasCstep2_;
}
- (void) setHasCstep2:(BOOL) value_ {
  hasCstep2_ = !!value_;
}
@synthesize cstep2;
- (id) init {
  if ((self = [super init])) {
    self.cstep1P1 = [ST_JpakeStep defaultInstance];
    self.cstep1P2 = [ST_JpakeStep defaultInstance];
    self.cstep2 = [ST_JpakeStep defaultInstance];
  }
  return self;
}
static ST_JpakeResponse* defaultST_JpakeResponseInstance = nil;
+ (void) initialize {
  if (self == [ST_JpakeResponse class]) {
    defaultST_JpakeResponseInstance = [[ST_JpakeResponse alloc] init];
  }
}
+ (ST_JpakeResponse*) defaultInstance {
  return defaultST_JpakeResponseInstance;
}
- (ST_JpakeResponse*) defaultInstance {
  return defaultST_JpakeResponseInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasCstep1P1) {
    [output writeMessage:1 value:self.cstep1P1];
  }
  if (self.hasCstep1P2) {
    [output writeMessage:2 value:self.cstep1P2];
  }
  if (self.hasCstep2) {
    [output writeMessage:3 value:self.cstep2];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_JpakeResponseBuilder()
@property (strong) ST_JpakeResponse* result;
@end

@implementation ST_JpakeResponseBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_JpakeResponse alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_JpakeResponseBuilder*) clear {
  self.result = [[ST_JpakeResponse alloc] init];
  return self;
}
- (ST_JpakeResponseBuilder*) clone {
  return [ST_JpakeResponse builderWithPrototype:result];
}
- (ST_JpakeResponse*) defaultInstance {
  return [ST_JpakeResponse defaultInstance];
}
- (ST_JpakeResponse*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_JpakeResponse*) buildPartial {
  ST_JpakeResponse* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_JpakeResponseBuilder*) mergeFrom:(ST_JpakeResponse*) other {
  if (other == [ST_JpakeResponse defaultInstance]) {
    return self;
  }
  if (other.hasCstep1P1) {
    [self mergeCstep1P1:other.cstep1P1];
  }
  if (other.hasCstep1P2) {
    [self mergeCstep1P2:other.cstep1P2];
  }
  if (other.hasCstep2) {
    [self mergeCstep2:other.cstep2];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_JpakeResponseBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_JpakeResponseBuilder*) 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 10: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasCstep1P1) {
          [subBuilder mergeFrom:self.cstep1P1];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setCstep1P1:[subBuilder buildPartial]];
        break;
      }
      case 18: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasCstep1P2) {
          [subBuilder mergeFrom:self.cstep1P2];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setCstep1P2:[subBuilder buildPartial]];
        break;
      }
      case 26: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasCstep2) {
          [subBuilder mergeFrom:self.cstep2];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setCstep2:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasCstep1P1 {
  return result.hasCstep1P1;
}
- (ST_JpakeStep*) cstep1P1 {
  return result.cstep1P1;
}
- (ST_JpakeResponseBuilder*) setCstep1P1:(ST_JpakeStep*) value {
  result.hasCstep1P1 = YES;
  result.cstep1P1 = value;
  return self;
}
- (ST_JpakeResponseBuilder*) setCstep1P1Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setCstep1P1:[builderForValue build]];
}
- (ST_JpakeResponseBuilder*) mergeCstep1P1:(ST_JpakeStep*) value {
  if (result.hasCstep1P1 &&
      result.cstep1P1 != [ST_JpakeStep defaultInstance]) {
    result.cstep1P1 =
      [[[ST_JpakeStep builderWithPrototype:result.cstep1P1] mergeFrom:value] buildPartial];
  } else {
    result.cstep1P1 = value;
  }
  result.hasCstep1P1 = YES;
  return self;
}
- (ST_JpakeResponseBuilder*) clearCstep1P1 {
  result.hasCstep1P1 = NO;
  result.cstep1P1 = [ST_JpakeStep defaultInstance];
  return self;
}
- (BOOL) hasCstep1P2 {
  return result.hasCstep1P2;
}
- (ST_JpakeStep*) cstep1P2 {
  return result.cstep1P2;
}
- (ST_JpakeResponseBuilder*) setCstep1P2:(ST_JpakeStep*) value {
  result.hasCstep1P2 = YES;
  result.cstep1P2 = value;
  return self;
}
- (ST_JpakeResponseBuilder*) setCstep1P2Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setCstep1P2:[builderForValue build]];
}
- (ST_JpakeResponseBuilder*) mergeCstep1P2:(ST_JpakeStep*) value {
  if (result.hasCstep1P2 &&
      result.cstep1P2 != [ST_JpakeStep defaultInstance]) {
    result.cstep1P2 =
      [[[ST_JpakeStep builderWithPrototype:result.cstep1P2] mergeFrom:value] buildPartial];
  } else {
    result.cstep1P2 = value;
  }
  result.hasCstep1P2 = YES;
  return self;
}
- (ST_JpakeResponseBuilder*) clearCstep1P2 {
  result.hasCstep1P2 = NO;
  result.cstep1P2 = [ST_JpakeStep defaultInstance];
  return self;
}
- (BOOL) hasCstep2 {
  return result.hasCstep2;
}
- (ST_JpakeStep*) cstep2 {
  return result.cstep2;
}
- (ST_JpakeResponseBuilder*) setCstep2:(ST_JpakeStep*) value {
  result.hasCstep2 = YES;
  result.cstep2 = value;
  return self;
}
- (ST_JpakeResponseBuilder*) setCstep2Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setCstep2:[builderForValue build]];
}
- (ST_JpakeResponseBuilder*) mergeCstep2:(ST_JpakeStep*) value {
  if (result.hasCstep2 &&
      result.cstep2 != [ST_JpakeStep defaultInstance]) {
    result.cstep2 =
      [[[ST_JpakeStep builderWithPrototype:result.cstep2] mergeFrom:value] buildPartial];
  } else {
    result.cstep2 = value;
  }
  result.hasCstep2 = YES;
  return self;
}
- (ST_JpakeResponseBuilder*) clearCstep2 {
  result.hasCstep2 = NO;
  result.cstep2 = [ST_JpakeStep defaultInstance];
  return self;
}
@end

@interface ST_InitSetup ()
@property (strong) ST_JpakeStep* astep2;
@property (strong) NSData* step3A;
@end

@implementation ST_InitSetup

- (BOOL) hasAstep2 {
  return !!hasAstep2_;
}
- (void) setHasAstep2:(BOOL) value_ {
  hasAstep2_ = !!value_;
}
@synthesize astep2;
- (BOOL) hasStep3A {
  return !!hasStep3A_;
}
- (void) setHasStep3A:(BOOL) value_ {
  hasStep3A_ = !!value_;
}
@synthesize step3A;
- (id) init {
  if ((self = [super init])) {
    self.astep2 = [ST_JpakeStep defaultInstance];
    self.step3A = [NSData data];
  }
  return self;
}
static ST_InitSetup* defaultST_InitSetupInstance = nil;
+ (void) initialize {
  if (self == [ST_InitSetup class]) {
    defaultST_InitSetupInstance = [[ST_InitSetup alloc] init];
  }
}
+ (ST_InitSetup*) defaultInstance {
  return defaultST_InitSetupInstance;
}
- (ST_InitSetup*) defaultInstance {
  return defaultST_InitSetupInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasAstep2) {
    [output writeMessage:1 value:self.astep2];
  }
  if (self.hasStep3A) {
    [output writeData:2 value:self.step3A];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_InitSetupBuilder()
@property (strong) ST_InitSetup* result;
@end

@implementation ST_InitSetupBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_InitSetup alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_InitSetupBuilder*) clear {
  self.result = [[ST_InitSetup alloc] init];
  return self;
}
- (ST_InitSetupBuilder*) clone {
  return [ST_InitSetup builderWithPrototype:result];
}
- (ST_InitSetup*) defaultInstance {
  return [ST_InitSetup defaultInstance];
}
- (ST_InitSetup*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_InitSetup*) buildPartial {
  ST_InitSetup* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_InitSetupBuilder*) mergeFrom:(ST_InitSetup*) other {
  if (other == [ST_InitSetup defaultInstance]) {
    return self;
  }
  if (other.hasAstep2) {
    [self mergeAstep2:other.astep2];
  }
  if (other.hasStep3A) {
    [self setStep3A:other.step3A];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_InitSetupBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_InitSetupBuilder*) 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 10: {
        ST_JpakeStepBuilder* subBuilder = [ST_JpakeStep builder];
        if (self.hasAstep2) {
          [subBuilder mergeFrom:self.astep2];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setAstep2:[subBuilder buildPartial]];
        break;
      }
      case 18: {
        [self setStep3A:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasAstep2 {
  return result.hasAstep2;
}
- (ST_JpakeStep*) astep2 {
  return result.astep2;
}
- (ST_InitSetupBuilder*) setAstep2:(ST_JpakeStep*) value {
  result.hasAstep2 = YES;
  result.astep2 = value;
  return self;
}
- (ST_InitSetupBuilder*) setAstep2Builder:(ST_JpakeStepBuilder*) builderForValue {
  return [self setAstep2:[builderForValue build]];
}
- (ST_InitSetupBuilder*) mergeAstep2:(ST_JpakeStep*) value {
  if (result.hasAstep2 &&
      result.astep2 != [ST_JpakeStep defaultInstance]) {
    result.astep2 =
      [[[ST_JpakeStep builderWithPrototype:result.astep2] mergeFrom:value] buildPartial];
  } else {
    result.astep2 = value;
  }
  result.hasAstep2 = YES;
  return self;
}
- (ST_InitSetupBuilder*) clearAstep2 {
  result.hasAstep2 = NO;
  result.astep2 = [ST_JpakeStep defaultInstance];
  return self;
}
- (BOOL) hasStep3A {
  return result.hasStep3A;
}
- (NSData*) step3A {
  return result.step3A;
}
- (ST_InitSetupBuilder*) setStep3A:(NSData*) value {
  result.hasStep3A = YES;
  result.step3A = value;
  return self;
}
- (ST_InitSetupBuilder*) clearStep3A {
  result.hasStep3A = NO;
  result.step3A = [NSData data];
  return self;
}
@end

@interface ST_DeviceInfo ()
@property (strong) NSData* nonce;
@property (strong) NSData* token;
@property (strong) NSData* flags;
@property (strong) NSData* step3B;
@end

@implementation ST_DeviceInfo

- (BOOL) hasNonce {
  return !!hasNonce_;
}
- (void) setHasNonce:(BOOL) value_ {
  hasNonce_ = !!value_;
}
@synthesize nonce;
- (BOOL) hasToken {
  return !!hasToken_;
}
- (void) setHasToken:(BOOL) value_ {
  hasToken_ = !!value_;
}
@synthesize token;
- (BOOL) hasFlags {
  return !!hasFlags_;
}
- (void) setHasFlags:(BOOL) value_ {
  hasFlags_ = !!value_;
}
@synthesize flags;
- (BOOL) hasStep3B {
  return !!hasStep3B_;
}
- (void) setHasStep3B:(BOOL) value_ {
  hasStep3B_ = !!value_;
}
@synthesize step3B;
- (id) init {
  if ((self = [super init])) {
    self.nonce = [NSData data];
    self.token = [NSData data];
    self.flags = [NSData data];
    self.step3B = [NSData data];
  }
  return self;
}
static ST_DeviceInfo* defaultST_DeviceInfoInstance = nil;
+ (void) initialize {
  if (self == [ST_DeviceInfo class]) {
    defaultST_DeviceInfoInstance = [[ST_DeviceInfo alloc] init];
  }
}
+ (ST_DeviceInfo*) defaultInstance {
  return defaultST_DeviceInfoInstance;
}
- (ST_DeviceInfo*) defaultInstance {
  return defaultST_DeviceInfoInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasNonce) {
    [output writeData:1 value:self.nonce];
  }
  if (self.hasToken) {
    [output writeData:2 value:self.token];
  }
  if (self.hasFlags) {
    [output writeData:3 value:self.flags];
  }
  if (self.hasStep3B) {
    [output writeData:4 value:self.step3B];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasNonce) {
    size_ += computeDataSize(1, self.nonce);
  }
  if (self.hasToken) {
    size_ += computeDataSize(2, self.token);
  }
  if (self.hasFlags) {
    size_ += computeDataSize(3, self.flags);
  }
  if (self.hasStep3B) {
    size_ += computeDataSize(4, self.step3B);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (ST_DeviceInfo*) parseFromData:(NSData*) data {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromData:data] build];
}
+ (ST_DeviceInfo*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (ST_DeviceInfo*) parseFromInputStream:(NSInputStream*) input {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromInputStream:input] build];
}
+ (ST_DeviceInfo*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ST_DeviceInfo*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromCodedInputStream:input] build];
}
+ (ST_DeviceInfo*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_DeviceInfo*)[[[ST_DeviceInfo builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ST_DeviceInfoBuilder*) builder {
  return [[ST_DeviceInfoBuilder alloc] init];
}
+ (ST_DeviceInfoBuilder*) builderWithPrototype:(ST_DeviceInfo*) prototype {
  return [[ST_DeviceInfo builder] mergeFrom:prototype];
}
- (ST_DeviceInfoBuilder*) builder {
  return [ST_DeviceInfo builder];
}
- (ST_DeviceInfoBuilder*) toBuilder {
  return [ST_DeviceInfo builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasNonce) {
    [output appendFormat:@"%@%@: %@\n", indent, @"nonce", self.nonce];
  }
  if (self.hasToken) {
    [output appendFormat:@"%@%@: %@\n", indent, @"token", self.token];
  }
  if (self.hasFlags) {
    [output appendFormat:@"%@%@: %@\n", indent, @"flags", self.flags];
  }
  if (self.hasStep3B) {
    [output appendFormat:@"%@%@: %@\n", indent, @"step3B", self.step3B];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[ST_DeviceInfo class]]) {
    return NO;
  }
  ST_DeviceInfo *otherMessage = other;
  return
      self.hasNonce == otherMessage.hasNonce &&
      (!self.hasNonce || [self.nonce isEqual:otherMessage.nonce]) &&
      self.hasToken == otherMessage.hasToken &&
      (!self.hasToken || [self.token isEqual:otherMessage.token]) &&
      self.hasFlags == otherMessage.hasFlags &&
      (!self.hasFlags || [self.flags isEqual:otherMessage.flags]) &&
      self.hasStep3B == otherMessage.hasStep3B &&
      (!self.hasStep3B || [self.step3B isEqual:otherMessage.step3B]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasNonce) {
    hashCode = hashCode * 31 + [self.nonce hash];
  }
  if (self.hasToken) {
    hashCode = hashCode * 31 + [self.token hash];
  }
  if (self.hasFlags) {
    hashCode = hashCode * 31 + [self.flags hash];
  }
  if (self.hasStep3B) {
    hashCode = hashCode * 31 + [self.step3B hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface ST_DeviceInfoBuilder()
@property (strong) ST_DeviceInfo* result;
@end

@implementation ST_DeviceInfoBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_DeviceInfo alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_DeviceInfoBuilder*) clear {
  self.result = [[ST_DeviceInfo alloc] init];
  return self;
}
- (ST_DeviceInfoBuilder*) clone {
  return [ST_DeviceInfo builderWithPrototype:result];
}
- (ST_DeviceInfo*) defaultInstance {
  return [ST_DeviceInfo defaultInstance];
}
- (ST_DeviceInfo*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_DeviceInfo*) buildPartial {
  ST_DeviceInfo* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_DeviceInfoBuilder*) mergeFrom:(ST_DeviceInfo*) other {
  if (other == [ST_DeviceInfo defaultInstance]) {
    return self;
  }
  if (other.hasNonce) {
    [self setNonce:other.nonce];
  }
  if (other.hasToken) {
    [self setToken:other.token];
  }
  if (other.hasFlags) {
    [self setFlags:other.flags];
  }
  if (other.hasStep3B) {
    [self setStep3B:other.step3B];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_DeviceInfoBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_DeviceInfoBuilder*) 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 10: {
        [self setNonce:[input readData]];
        break;
      }
      case 18: {
        [self setToken:[input readData]];
        break;
      }
      case 26: {
        [self setFlags:[input readData]];
        break;
      }
      case 34: {
        [self setStep3B:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasNonce {
  return result.hasNonce;
}
- (NSData*) nonce {
  return result.nonce;
}
- (ST_DeviceInfoBuilder*) setNonce:(NSData*) value {
  result.hasNonce = YES;
  result.nonce = value;
  return self;
}
- (ST_DeviceInfoBuilder*) clearNonce {
  result.hasNonce = NO;
  result.nonce = [NSData data];
  return self;
}
- (BOOL) hasToken {
  return result.hasToken;
}
- (NSData*) token {
  return result.token;
}
- (ST_DeviceInfoBuilder*) setToken:(NSData*) value {
  result.hasToken = YES;
  result.token = value;
  return self;
}
- (ST_DeviceInfoBuilder*) clearToken {
  result.hasToken = NO;
  result.token = [NSData data];
  return self;
}
- (BOOL) hasFlags {
  return result.hasFlags;
}
- (NSData*) flags {
  return result.flags;
}
- (ST_DeviceInfoBuilder*) setFlags:(NSData*) value {
  result.hasFlags = YES;
  result.flags = value;
  return self;
}
- (ST_DeviceInfoBuilder*) clearFlags {
  result.hasFlags = NO;
  result.flags = [NSData data];
  return self;
}
- (BOOL) hasStep3B {
  return result.hasStep3B;
}
- (NSData*) step3B {
  return result.step3B;
}
- (ST_DeviceInfoBuilder*) setStep3B:(NSData*) value {
  result.hasStep3B = YES;
  result.step3B = value;
  return self;
}
- (ST_DeviceInfoBuilder*) clearStep3B {
  result.hasStep3B = NO;
  result.step3B = [NSData data];
  return self;
}
@end

@interface ST_WifiScan ()
@property (strong) NSData* authTag;
@end

@implementation ST_WifiScan

- (BOOL) hasAuthTag {
  return !!hasAuthTag_;
}
- (void) setHasAuthTag:(BOOL) value_ {
  hasAuthTag_ = !!value_;
}
@synthesize authTag;
- (id) init {
  if ((self = [super init])) {
    self.authTag = [NSData data];
  }
  return self;
}
static ST_WifiScan* defaultST_WifiScanInstance = nil;
+ (void) initialize {
  if (self == [ST_WifiScan class]) {
    defaultST_WifiScanInstance = [[ST_WifiScan alloc] init];
  }
}
+ (ST_WifiScan*) defaultInstance {
  return defaultST_WifiScanInstance;
}
- (ST_WifiScan*) defaultInstance {
  return defaultST_WifiScanInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasAuthTag) {
    [output writeData:1 value:self.authTag];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_WifiScanBuilder()
@property (strong) ST_WifiScan* result;
@end

@implementation ST_WifiScanBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_WifiScan alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_WifiScanBuilder*) clear {
  self.result = [[ST_WifiScan alloc] init];
  return self;
}
- (ST_WifiScanBuilder*) clone {
  return [ST_WifiScan builderWithPrototype:result];
}
- (ST_WifiScan*) defaultInstance {
  return [ST_WifiScan defaultInstance];
}
- (ST_WifiScan*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_WifiScan*) buildPartial {
  ST_WifiScan* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_WifiScanBuilder*) mergeFrom:(ST_WifiScan*) other {
  if (other == [ST_WifiScan defaultInstance]) {
    return self;
  }
  if (other.hasAuthTag) {
    [self setAuthTag:other.authTag];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_WifiScanBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_WifiScanBuilder*) 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 10: {
        [self setAuthTag:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasAuthTag {
  return result.hasAuthTag;
}
- (NSData*) authTag {
  return result.authTag;
}
- (ST_WifiScanBuilder*) setAuthTag:(NSData*) value {
  result.hasAuthTag = YES;
  result.authTag = value;
  return self;
}
- (ST_WifiScanBuilder*) clearAuthTag {
  result.hasAuthTag = NO;
  result.authTag = [NSData data];
  return self;
}
@end

@interface ST_WifiConnect ()
@property (strong) NSString* bssid;
@property (strong) NSString* ssid;
@property (strong) NSData* encryptedPassword;
@property ST_WifiConnectNetworkSecurityType type;
@property BOOL isManual;
@property (strong) NSData* authTag;
@property (strong) NSData* jpakeHmac;
@end

@implementation ST_WifiConnect

- (BOOL) hasBssid {
  return !!hasBssid_;
}
- (void) setHasBssid:(BOOL) value_ {
  hasBssid_ = !!value_;
}
@synthesize bssid;
- (BOOL) hasSsid {
  return !!hasSsid_;
}
- (void) setHasSsid:(BOOL) value_ {
  hasSsid_ = !!value_;
}
@synthesize ssid;
- (BOOL) hasEncryptedPassword {
  return !!hasEncryptedPassword_;
}
- (void) setHasEncryptedPassword:(BOOL) value_ {
  hasEncryptedPassword_ = !!value_;
}
@synthesize encryptedPassword;
- (BOOL) hasType {
  return !!hasType_;
}
- (void) setHasType:(BOOL) value_ {
  hasType_ = !!value_;
}
@synthesize type;
- (BOOL) hasIsManual {
  return !!hasIsManual_;
}
- (void) setHasIsManual:(BOOL) value_ {
  hasIsManual_ = !!value_;
}
- (BOOL) isManual {
  return !!isManual_;
}
- (void) setIsManual:(BOOL) value_ {
  isManual_ = !!value_;
}
- (BOOL) hasAuthTag {
  return !!hasAuthTag_;
}
- (void) setHasAuthTag:(BOOL) value_ {
  hasAuthTag_ = !!value_;
}
@synthesize authTag;
- (BOOL) hasJpakeHmac {
  return !!hasJpakeHmac_;
}
- (void) setHasJpakeHmac:(BOOL) value_ {
  hasJpakeHmac_ = !!value_;
}
@synthesize jpakeHmac;
- (id) init {
  if ((self = [super init])) {
    self.bssid = @"";
    self.ssid = @"";
    self.encryptedPassword = [NSData data];
    self.type = ST_WifiConnectNetworkSecurityTypeNone;
    self.isManual = NO;
    self.authTag = [NSData data];
    self.jpakeHmac = [NSData data];
  }
  return self;
}
static ST_WifiConnect* defaultST_WifiConnectInstance = nil;
+ (void) initialize {
  if (self == [ST_WifiConnect class]) {
    defaultST_WifiConnectInstance = [[ST_WifiConnect alloc] init];
  }
}
+ (ST_WifiConnect*) defaultInstance {
  return defaultST_WifiConnectInstance;
}
- (ST_WifiConnect*) defaultInstance {
  return defaultST_WifiConnectInstance;
}
- (BOOL) isInitialized {
  if (!self.hasType) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasBssid) {
    [output writeString:1 value:self.bssid];
  }
  if (self.hasSsid) {
    [output writeString:2 value:self.ssid];
  }
  if (self.hasEncryptedPassword) {
    [output writeData:3 value:self.encryptedPassword];
  }
  if (self.hasType) {
    [output writeEnum:4 value:self.type];
  }
  if (self.hasIsManual) {
    [output writeBool:5 value:self.isManual];
  }
  if (self.hasAuthTag) {
    [output writeData:6 value:self.authTag];
  }
  if (self.hasJpakeHmac) {
    [output writeData:7 value:self.jpakeHmac];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasBssid) {
    size_ += computeStringSize(1, self.bssid);
  }
  if (self.hasSsid) {
    size_ += computeStringSize(2, self.ssid);
  }
  if (self.hasEncryptedPassword) {
    size_ += computeDataSize(3, self.encryptedPassword);
  }
  if (self.hasType) {
    size_ += computeEnumSize(4, self.type);
  }
  if (self.hasIsManual) {
    size_ += computeBoolSize(5, self.isManual);
  }
  if (self.hasAuthTag) {
    size_ += computeDataSize(6, self.authTag);
  }
  if (self.hasJpakeHmac) {
    size_ += computeDataSize(7, self.jpakeHmac);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (ST_WifiConnect*) parseFromData:(NSData*) data {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromData:data] build];
}
+ (ST_WifiConnect*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (ST_WifiConnect*) parseFromInputStream:(NSInputStream*) input {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromInputStream:input] build];
}
+ (ST_WifiConnect*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ST_WifiConnect*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromCodedInputStream:input] build];
}
+ (ST_WifiConnect*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ST_WifiConnect*)[[[ST_WifiConnect builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ST_WifiConnectBuilder*) builder {
  return [[ST_WifiConnectBuilder alloc] init];
}
+ (ST_WifiConnectBuilder*) builderWithPrototype:(ST_WifiConnect*) prototype {
  return [[ST_WifiConnect builder] mergeFrom:prototype];
}
- (ST_WifiConnectBuilder*) builder {
  return [ST_WifiConnect builder];
}
- (ST_WifiConnectBuilder*) toBuilder {
  return [ST_WifiConnect builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasBssid) {
    [output appendFormat:@"%@%@: %@\n", indent, @"bssid", self.bssid];
  }
  if (self.hasSsid) {
    [output appendFormat:@"%@%@: %@\n", indent, @"ssid", self.ssid];
  }
  if (self.hasEncryptedPassword) {
    [output appendFormat:@"%@%@: %@\n", indent, @"encryptedPassword", self.encryptedPassword];
  }
  if (self.hasType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"type", self.type];
  }
  if (self.hasIsManual) {
    [output appendFormat:@"%@%@: %@\n", indent, @"isManual", [NSNumber numberWithBool:self.isManual]];
  }
  if (self.hasAuthTag) {
    [output appendFormat:@"%@%@: %@\n", indent, @"authTag", self.authTag];
  }
  if (self.hasJpakeHmac) {
    [output appendFormat:@"%@%@: %@\n", indent, @"jpakeHmac", self.jpakeHmac];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[ST_WifiConnect class]]) {
    return NO;
  }
  ST_WifiConnect *otherMessage = other;
  return
      self.hasBssid == otherMessage.hasBssid &&
      (!self.hasBssid || [self.bssid isEqual:otherMessage.bssid]) &&
      self.hasSsid == otherMessage.hasSsid &&
      (!self.hasSsid || [self.ssid isEqual:otherMessage.ssid]) &&
      self.hasEncryptedPassword == otherMessage.hasEncryptedPassword &&
      (!self.hasEncryptedPassword || [self.encryptedPassword isEqual:otherMessage.encryptedPassword]) &&
      self.hasType == otherMessage.hasType &&
      (!self.hasType || self.type == otherMessage.type) &&
      self.hasIsManual == otherMessage.hasIsManual &&
      (!self.hasIsManual || self.isManual == otherMessage.isManual) &&
      self.hasAuthTag == otherMessage.hasAuthTag &&
      (!self.hasAuthTag || [self.authTag isEqual:otherMessage.authTag]) &&
      self.hasJpakeHmac == otherMessage.hasJpakeHmac &&
      (!self.hasJpakeHmac || [self.jpakeHmac isEqual:otherMessage.jpakeHmac]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasBssid) {
    hashCode = hashCode * 31 + [self.bssid hash];
  }
  if (self.hasSsid) {
    hashCode = hashCode * 31 + [self.ssid hash];
  }
  if (self.hasEncryptedPassword) {
    hashCode = hashCode * 31 + [self.encryptedPassword hash];
  }
  if (self.hasType) {
    hashCode = hashCode * 31 + self.type;
  }
  if (self.hasIsManual) {
    hashCode = hashCode * 31 + [[NSNumber numberWithBool:self.isManual] hash];
  }
  if (self.hasAuthTag) {
    hashCode = hashCode * 31 + [self.authTag hash];
  }
  if (self.hasJpakeHmac) {
    hashCode = hashCode * 31 + [self.jpakeHmac hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL ST_WifiConnectNetworkSecurityTypeIsValidValue(ST_WifiConnectNetworkSecurityType value) {
  switch (value) {
    case ST_WifiConnectNetworkSecurityTypeNone:
    case ST_WifiConnectNetworkSecurityTypeWep:
    case ST_WifiConnectNetworkSecurityTypeWpaPersonal:
      return YES;
    default:
      return NO;
  }
}
@interface ST_WifiConnectBuilder()
@property (strong) ST_WifiConnect* result;
@end

@implementation ST_WifiConnectBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_WifiConnect alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_WifiConnectBuilder*) clear {
  self.result = [[ST_WifiConnect alloc] init];
  return self;
}
- (ST_WifiConnectBuilder*) clone {
  return [ST_WifiConnect builderWithPrototype:result];
}
- (ST_WifiConnect*) defaultInstance {
  return [ST_WifiConnect defaultInstance];
}
- (ST_WifiConnect*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_WifiConnect*) buildPartial {
  ST_WifiConnect* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_WifiConnectBuilder*) mergeFrom:(ST_WifiConnect*) other {
  if (other == [ST_WifiConnect defaultInstance]) {
    return self;
  }
  if (other.hasBssid) {
    [self setBssid:other.bssid];
  }
  if (other.hasSsid) {
    [self setSsid:other.ssid];
  }
  if (other.hasEncryptedPassword) {
    [self setEncryptedPassword:other.encryptedPassword];
  }
  if (other.hasType) {
    [self setType:other.type];
  }
  if (other.hasIsManual) {
    [self setIsManual:other.isManual];
  }
  if (other.hasAuthTag) {
    [self setAuthTag:other.authTag];
  }
  if (other.hasJpakeHmac) {
    [self setJpakeHmac:other.jpakeHmac];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_WifiConnectBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_WifiConnectBuilder*) 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 10: {
        [self setBssid:[input readString]];
        break;
      }
      case 18: {
        [self setSsid:[input readString]];
        break;
      }
      case 26: {
        [self setEncryptedPassword:[input readData]];
        break;
      }
      case 32: {
        ST_WifiConnectNetworkSecurityType value = (ST_WifiConnectNetworkSecurityType)[input readEnum];
        if (ST_WifiConnectNetworkSecurityTypeIsValidValue(value)) {
          [self setType:value];
        } else {
          [unknownFields mergeVarintField:4 value:value];
        }
        break;
      }
      case 40: {
        [self setIsManual:[input readBool]];
        break;
      }
      case 50: {
        [self setAuthTag:[input readData]];
        break;
      }
      case 58: {
        [self setJpakeHmac:[input readData]];
        break;
      }
    }
  }
}
- (BOOL) hasBssid {
  return result.hasBssid;
}
- (NSString*) bssid {
  return result.bssid;
}
- (ST_WifiConnectBuilder*) setBssid:(NSString*) value {
  result.hasBssid = YES;
  result.bssid = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearBssid {
  result.hasBssid = NO;
  result.bssid = @"";
  return self;
}
- (BOOL) hasSsid {
  return result.hasSsid;
}
- (NSString*) ssid {
  return result.ssid;
}
- (ST_WifiConnectBuilder*) setSsid:(NSString*) value {
  result.hasSsid = YES;
  result.ssid = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearSsid {
  result.hasSsid = NO;
  result.ssid = @"";
  return self;
}
- (BOOL) hasEncryptedPassword {
  return result.hasEncryptedPassword;
}
- (NSData*) encryptedPassword {
  return result.encryptedPassword;
}
- (ST_WifiConnectBuilder*) setEncryptedPassword:(NSData*) value {
  result.hasEncryptedPassword = YES;
  result.encryptedPassword = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearEncryptedPassword {
  result.hasEncryptedPassword = NO;
  result.encryptedPassword = [NSData data];
  return self;
}
- (BOOL) hasType {
  return result.hasType;
}
- (ST_WifiConnectNetworkSecurityType) type {
  return result.type;
}
- (ST_WifiConnectBuilder*) setType:(ST_WifiConnectNetworkSecurityType) value {
  result.hasType = YES;
  result.type = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearType {
  result.hasType = NO;
  result.type = ST_WifiConnectNetworkSecurityTypeNone;
  return self;
}
- (BOOL) hasIsManual {
  return result.hasIsManual;
}
- (BOOL) isManual {
  return result.isManual;
}
- (ST_WifiConnectBuilder*) setIsManual:(BOOL) value {
  result.hasIsManual = YES;
  result.isManual = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearIsManual {
  result.hasIsManual = NO;
  result.isManual = NO;
  return self;
}
- (BOOL) hasAuthTag {
  return result.hasAuthTag;
}
- (NSData*) authTag {
  return result.authTag;
}
- (ST_WifiConnectBuilder*) setAuthTag:(NSData*) value {
  result.hasAuthTag = YES;
  result.authTag = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearAuthTag {
  result.hasAuthTag = NO;
  result.authTag = [NSData data];
  return self;
}
- (BOOL) hasJpakeHmac {
  return result.hasJpakeHmac;
}
- (NSData*) jpakeHmac {
  return result.jpakeHmac;
}
- (ST_WifiConnectBuilder*) setJpakeHmac:(NSData*) value {
  result.hasJpakeHmac = YES;
  result.jpakeHmac = value;
  return self;
}
- (ST_WifiConnectBuilder*) clearJpakeHmac {
  result.hasJpakeHmac = NO;
  result.jpakeHmac = [NSData data];
  return self;
}
@end

@interface ST_WifiScanList ()
@property (strong) NSString* list;
@end

@implementation ST_WifiScanList

- (BOOL) hasList {
  return !!hasList_;
}
- (void) setHasList:(BOOL) value_ {
  hasList_ = !!value_;
}
@synthesize list;
- (id) init {
  if ((self = [super init])) {
    self.list = @"";
  }
  return self;
}
static ST_WifiScanList* defaultST_WifiScanListInstance = nil;
+ (void) initialize {
  if (self == [ST_WifiScanList class]) {
    defaultST_WifiScanListInstance = [[ST_WifiScanList alloc] init];
  }
}
+ (ST_WifiScanList*) defaultInstance {
  return defaultST_WifiScanListInstance;
}
- (ST_WifiScanList*) defaultInstance {
  return defaultST_WifiScanListInstance;
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasList) {
    [output writeString:1 value:self.list];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

@interface ST_WifiScanListBuilder()
@property (strong) ST_WifiScanList* result;
@end

@implementation ST_WifiScanListBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_WifiScanList alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_WifiScanListBuilder*) clear {
  self.result = [[ST_WifiScanList alloc] init];
  return self;
}
- (ST_WifiScanListBuilder*) clone {
  return [ST_WifiScanList builderWithPrototype:result];
}
- (ST_WifiScanList*) defaultInstance {
  return [ST_WifiScanList defaultInstance];
}
- (ST_WifiScanList*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_WifiScanList*) buildPartial {
  ST_WifiScanList* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_WifiScanListBuilder*) mergeFrom:(ST_WifiScanList*) other {
  if (other == [ST_WifiScanList defaultInstance]) {
    return self;
  }
  if (other.hasList) {
    [self setList:other.list];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_WifiScanListBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_WifiScanListBuilder*) 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 10: {
        [self setList:[input readString]];
        break;
      }
    }
  }
}
- (BOOL) hasList {
  return result.hasList;
}
- (NSString*) list {
  return result.list;
}
- (ST_WifiScanListBuilder*) setList:(NSString*) value {
  result.hasList = YES;
  result.list = value;
  return self;
}
- (ST_WifiScanListBuilder*) clearList {
  result.hasList = NO;
  result.list = @"";
  return self;
}
@end

@interface ST_WifiConnectStatus ()
@property ST_WifiConnectStatusResult connectResult;
@property (strong) NSString* debugLog;
@end

@implementation ST_WifiConnectStatus

- (BOOL) hasConnectResult {
  return !!hasConnectResult_;
}
- (void) setHasConnectResult:(BOOL) value_ {
  hasConnectResult_ = !!value_;
}
@synthesize connectResult;
- (BOOL) hasDebugLog {
  return !!hasDebugLog_;
}
- (void) setHasDebugLog:(BOOL) value_ {
  hasDebugLog_ = !!value_;
}
@synthesize debugLog;
- (id) init {
  if ((self = [super init])) {
    self.connectResult = ST_WifiConnectStatusResultSuccess;
    self.debugLog = @"";
  }
  return self;
}
static ST_WifiConnectStatus* defaultST_WifiConnectStatusInstance = nil;
+ (void) initialize {
  if (self == [ST_WifiConnectStatus class]) {
    defaultST_WifiConnectStatusInstance = [[ST_WifiConnectStatus alloc] init];
  }
}
+ (ST_WifiConnectStatus*) defaultInstance {
  return defaultST_WifiConnectStatusInstance;
}
- (ST_WifiConnectStatus*) defaultInstance {
  return defaultST_WifiConnectStatusInstance;
}
- (BOOL) isInitialized {
  if (!self.hasConnectResult) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasConnectResult) {
    [output writeEnum:1 value:self.connectResult];
  }
  if (self.hasDebugLog) {
    [output writeString:2 value:self.debugLog];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

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

BOOL ST_WifiConnectStatusResultIsValidValue(ST_WifiConnectStatusResult value) {
  switch (value) {
    case ST_WifiConnectStatusResultSuccess:
    case ST_WifiConnectStatusResultBadPassword:
    case ST_WifiConnectStatusResultNetworkNotFound:
    case ST_WifiConnectStatusResultNoDhcp:
    case ST_WifiConnectStatusResultNoInternet:
    case ST_WifiConnectStatusResultNoAuth:
      return YES;
    default:
      return NO;
  }
}
@interface ST_WifiConnectStatusBuilder()
@property (strong) ST_WifiConnectStatus* result;
@end

@implementation ST_WifiConnectStatusBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ST_WifiConnectStatus alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ST_WifiConnectStatusBuilder*) clear {
  self.result = [[ST_WifiConnectStatus alloc] init];
  return self;
}
- (ST_WifiConnectStatusBuilder*) clone {
  return [ST_WifiConnectStatus builderWithPrototype:result];
}
- (ST_WifiConnectStatus*) defaultInstance {
  return [ST_WifiConnectStatus defaultInstance];
}
- (ST_WifiConnectStatus*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ST_WifiConnectStatus*) buildPartial {
  ST_WifiConnectStatus* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ST_WifiConnectStatusBuilder*) mergeFrom:(ST_WifiConnectStatus*) other {
  if (other == [ST_WifiConnectStatus defaultInstance]) {
    return self;
  }
  if (other.hasConnectResult) {
    [self setConnectResult:other.connectResult];
  }
  if (other.hasDebugLog) {
    [self setDebugLog:other.debugLog];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ST_WifiConnectStatusBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ST_WifiConnectStatusBuilder*) 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: {
        ST_WifiConnectStatusResult value = (ST_WifiConnectStatusResult)[input readEnum];
        if (ST_WifiConnectStatusResultIsValidValue(value)) {
          [self setConnectResult:value];
        } else {
          [unknownFields mergeVarintField:1 value:value];
        }
        break;
      }
      case 18: {
        [self setDebugLog:[input readString]];
        break;
      }
    }
  }
}
- (BOOL) hasConnectResult {
  return result.hasConnectResult;
}
- (ST_WifiConnectStatusResult) connectResult {
  return result.connectResult;
}
- (ST_WifiConnectStatusBuilder*) setConnectResult:(ST_WifiConnectStatusResult) value {
  result.hasConnectResult = YES;
  result.connectResult = value;
  return self;
}
- (ST_WifiConnectStatusBuilder*) clearConnectResult {
  result.hasConnectResult = NO;
  result.connectResult = ST_WifiConnectStatusResultSuccess;
  return self;
}
- (BOOL) hasDebugLog {
  return result.hasDebugLog;
}
- (NSString*) debugLog {
  return result.debugLog;
}
- (ST_WifiConnectStatusBuilder*) setDebugLog:(NSString*) value {
  result.hasDebugLog = YES;
  result.debugLog = value;
  return self;
}
- (ST_WifiConnectStatusBuilder*) clearDebugLog {
  result.hasDebugLog = NO;
  result.debugLog = @"";
  return self;
}
@end


// @@protoc_insertion_point(global_scope)