|  | @@ -0,0 +1,1434 @@
 | 
	
		
			
				|  |  | +// Generated by the protocol buffer compiler.  DO NOT EDIT!
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +#import "Route_guide.pb.h"
 | 
	
		
			
				|  |  | +// @@protoc_insertion_point(imports)
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RouteGuideRoot
 | 
	
		
			
				|  |  | +static PBExtensionRegistry* extensionRegistry = nil;
 | 
	
		
			
				|  |  | ++ (PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return extensionRegistry;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [RouteGuideRoot class]) {
 | 
	
		
			
				|  |  | +    PBMutableExtensionRegistry* registry = [PBMutableExtensionRegistry registry];
 | 
	
		
			
				|  |  | +    [self registerAllExtensions:registry];
 | 
	
		
			
				|  |  | +    extensionRegistry = registry;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (void) registerAllExtensions:(PBMutableExtensionRegistry*) registry {
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface Point ()
 | 
	
		
			
				|  |  | +@property SInt32 latitude;
 | 
	
		
			
				|  |  | +@property SInt32 longitude;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation Point
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +- (BOOL) hasLatitude {
 | 
	
		
			
				|  |  | +  return !!hasLatitude_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasLatitude:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasLatitude_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize latitude;
 | 
	
		
			
				|  |  | +- (BOOL) hasLongitude {
 | 
	
		
			
				|  |  | +  return !!hasLongitude_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasLongitude:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasLongitude_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize longitude;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.latitude = 0;
 | 
	
		
			
				|  |  | +    self.longitude = 0;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +static Point* defaultPointInstance = nil;
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [Point class]) {
 | 
	
		
			
				|  |  | +    defaultPointInstance = [[Point alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultPointInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultPointInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isInitialized {
 | 
	
		
			
				|  |  | +  return YES;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
 | 
	
		
			
				|  |  | +  if (self.hasLatitude) {
 | 
	
		
			
				|  |  | +    [output writeInt32:1 value:self.latitude];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLongitude) {
 | 
	
		
			
				|  |  | +    [output writeInt32:2 value:self.longitude];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeToCodedOutputStream:output];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) serializedSize {
 | 
	
		
			
				|  |  | +  __block SInt32 size_ = memoizedSerializedSize;
 | 
	
		
			
				|  |  | +  if (size_ != -1) {
 | 
	
		
			
				|  |  | +    return size_;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  size_ = 0;
 | 
	
		
			
				|  |  | +  if (self.hasLatitude) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(1, self.latitude);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLongitude) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(2, self.longitude);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  size_ += self.unknownFields.serializedSize;
 | 
	
		
			
				|  |  | +  memoizedSerializedSize = size_;
 | 
	
		
			
				|  |  | +  return size_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromData:(NSData*) data {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromData:data] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromInputStream:(NSInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromCodedInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Point*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Point*)[[[Point builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (PointBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [[PointBuilder alloc] init];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (PointBuilder*) builderWithPrototype:(Point*) prototype {
 | 
	
		
			
				|  |  | +  return [[Point builder] mergeFrom:prototype];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [Point builder];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) toBuilder {
 | 
	
		
			
				|  |  | +  return [Point builderWithPrototype:self];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
 | 
	
		
			
				|  |  | +  if (self.hasLatitude) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"latitude", [NSNumber numberWithInteger:self.latitude]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLongitude) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"longitude", [NSNumber numberWithInteger:self.longitude]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeDescriptionTo:output withIndent:indent];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isEqual:(id)other {
 | 
	
		
			
				|  |  | +  if (other == self) {
 | 
	
		
			
				|  |  | +    return YES;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (![other isKindOfClass:[Point class]]) {
 | 
	
		
			
				|  |  | +    return NO;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  Point *otherMessage = other;
 | 
	
		
			
				|  |  | +  return
 | 
	
		
			
				|  |  | +      self.hasLatitude == otherMessage.hasLatitude &&
 | 
	
		
			
				|  |  | +      (!self.hasLatitude || self.latitude == otherMessage.latitude) &&
 | 
	
		
			
				|  |  | +      self.hasLongitude == otherMessage.hasLongitude &&
 | 
	
		
			
				|  |  | +      (!self.hasLongitude || self.longitude == otherMessage.longitude) &&
 | 
	
		
			
				|  |  | +      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSUInteger) hash {
 | 
	
		
			
				|  |  | +  __block NSUInteger hashCode = 7;
 | 
	
		
			
				|  |  | +  if (self.hasLatitude) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.latitude] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLongitude) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.longitude] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  hashCode = hashCode * 31 + [self.unknownFields hash];
 | 
	
		
			
				|  |  | +  return hashCode;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface PointBuilder()
 | 
	
		
			
				|  |  | +@property (strong) Point* resultPoint;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation PointBuilder
 | 
	
		
			
				|  |  | +@synthesize resultPoint;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.resultPoint = [[Point alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PBGeneratedMessage*) internalGetResult {
 | 
	
		
			
				|  |  | +  return resultPoint;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) clear {
 | 
	
		
			
				|  |  | +  self.resultPoint = [[Point alloc] init];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) clone {
 | 
	
		
			
				|  |  | +  return [Point builderWithPrototype:resultPoint];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) defaultInstance {
 | 
	
		
			
				|  |  | +  return [Point defaultInstance];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) build {
 | 
	
		
			
				|  |  | +  [self checkInitialized];
 | 
	
		
			
				|  |  | +  return [self buildPartial];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) buildPartial {
 | 
	
		
			
				|  |  | +  Point* returnMe = resultPoint;
 | 
	
		
			
				|  |  | +  self.resultPoint = nil;
 | 
	
		
			
				|  |  | +  return returnMe;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) mergeFrom:(Point*) other {
 | 
	
		
			
				|  |  | +  if (other == [Point defaultInstance]) {
 | 
	
		
			
				|  |  | +    return self;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasLatitude) {
 | 
	
		
			
				|  |  | +    [self setLatitude:other.latitude];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasLongitude) {
 | 
	
		
			
				|  |  | +    [self setLongitude:other.longitude];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self mergeUnknownFields:other.unknownFields];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) 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 setLatitude:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 16: {
 | 
	
		
			
				|  |  | +        [self setLongitude:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasLatitude {
 | 
	
		
			
				|  |  | +  return resultPoint.hasLatitude;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) latitude {
 | 
	
		
			
				|  |  | +  return resultPoint.latitude;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) setLatitude:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultPoint.hasLatitude = YES;
 | 
	
		
			
				|  |  | +  resultPoint.latitude = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) clearLatitude {
 | 
	
		
			
				|  |  | +  resultPoint.hasLatitude = NO;
 | 
	
		
			
				|  |  | +  resultPoint.latitude = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasLongitude {
 | 
	
		
			
				|  |  | +  return resultPoint.hasLongitude;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) longitude {
 | 
	
		
			
				|  |  | +  return resultPoint.longitude;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) setLongitude:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultPoint.hasLongitude = YES;
 | 
	
		
			
				|  |  | +  resultPoint.longitude = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PointBuilder*) clearLongitude {
 | 
	
		
			
				|  |  | +  resultPoint.hasLongitude = NO;
 | 
	
		
			
				|  |  | +  resultPoint.longitude = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface Rectangle ()
 | 
	
		
			
				|  |  | +@property (strong) Point* lo;
 | 
	
		
			
				|  |  | +@property (strong) Point* hi;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation Rectangle
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +- (BOOL) hasLo {
 | 
	
		
			
				|  |  | +  return !!hasLo_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasLo:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasLo_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize lo;
 | 
	
		
			
				|  |  | +- (BOOL) hasHi {
 | 
	
		
			
				|  |  | +  return !!hasHi_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasHi:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasHi_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize hi;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.lo = [Point defaultInstance];
 | 
	
		
			
				|  |  | +    self.hi = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +static Rectangle* defaultRectangleInstance = nil;
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [Rectangle class]) {
 | 
	
		
			
				|  |  | +    defaultRectangleInstance = [[Rectangle alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRectangleInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRectangleInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isInitialized {
 | 
	
		
			
				|  |  | +  return YES;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
 | 
	
		
			
				|  |  | +  if (self.hasLo) {
 | 
	
		
			
				|  |  | +    [output writeMessage:1 value:self.lo];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasHi) {
 | 
	
		
			
				|  |  | +    [output writeMessage:2 value:self.hi];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeToCodedOutputStream:output];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) serializedSize {
 | 
	
		
			
				|  |  | +  __block SInt32 size_ = memoizedSerializedSize;
 | 
	
		
			
				|  |  | +  if (size_ != -1) {
 | 
	
		
			
				|  |  | +    return size_;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  size_ = 0;
 | 
	
		
			
				|  |  | +  if (self.hasLo) {
 | 
	
		
			
				|  |  | +    size_ += computeMessageSize(1, self.lo);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasHi) {
 | 
	
		
			
				|  |  | +    size_ += computeMessageSize(2, self.hi);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  size_ += self.unknownFields.serializedSize;
 | 
	
		
			
				|  |  | +  memoizedSerializedSize = size_;
 | 
	
		
			
				|  |  | +  return size_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromData:(NSData*) data {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromData:data] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromInputStream:(NSInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromCodedInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Rectangle*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Rectangle*)[[[Rectangle builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RectangleBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [[RectangleBuilder alloc] init];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RectangleBuilder*) builderWithPrototype:(Rectangle*) prototype {
 | 
	
		
			
				|  |  | +  return [[Rectangle builder] mergeFrom:prototype];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [Rectangle builder];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) toBuilder {
 | 
	
		
			
				|  |  | +  return [Rectangle builderWithPrototype:self];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
 | 
	
		
			
				|  |  | +  if (self.hasLo) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@ {\n", indent, @"lo"];
 | 
	
		
			
				|  |  | +    [self.lo writeDescriptionTo:output
 | 
	
		
			
				|  |  | +                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@}\n", indent];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasHi) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@ {\n", indent, @"hi"];
 | 
	
		
			
				|  |  | +    [self.hi 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:[Rectangle class]]) {
 | 
	
		
			
				|  |  | +    return NO;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  Rectangle *otherMessage = other;
 | 
	
		
			
				|  |  | +  return
 | 
	
		
			
				|  |  | +      self.hasLo == otherMessage.hasLo &&
 | 
	
		
			
				|  |  | +      (!self.hasLo || [self.lo isEqual:otherMessage.lo]) &&
 | 
	
		
			
				|  |  | +      self.hasHi == otherMessage.hasHi &&
 | 
	
		
			
				|  |  | +      (!self.hasHi || [self.hi isEqual:otherMessage.hi]) &&
 | 
	
		
			
				|  |  | +      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSUInteger) hash {
 | 
	
		
			
				|  |  | +  __block NSUInteger hashCode = 7;
 | 
	
		
			
				|  |  | +  if (self.hasLo) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.lo hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasHi) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.hi hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  hashCode = hashCode * 31 + [self.unknownFields hash];
 | 
	
		
			
				|  |  | +  return hashCode;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface RectangleBuilder()
 | 
	
		
			
				|  |  | +@property (strong) Rectangle* resultRectangle;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RectangleBuilder
 | 
	
		
			
				|  |  | +@synthesize resultRectangle;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.resultRectangle = [[Rectangle alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PBGeneratedMessage*) internalGetResult {
 | 
	
		
			
				|  |  | +  return resultRectangle;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) clear {
 | 
	
		
			
				|  |  | +  self.resultRectangle = [[Rectangle alloc] init];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) clone {
 | 
	
		
			
				|  |  | +  return [Rectangle builderWithPrototype:resultRectangle];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Rectangle*) defaultInstance {
 | 
	
		
			
				|  |  | +  return [Rectangle defaultInstance];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Rectangle*) build {
 | 
	
		
			
				|  |  | +  [self checkInitialized];
 | 
	
		
			
				|  |  | +  return [self buildPartial];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Rectangle*) buildPartial {
 | 
	
		
			
				|  |  | +  Rectangle* returnMe = resultRectangle;
 | 
	
		
			
				|  |  | +  self.resultRectangle = nil;
 | 
	
		
			
				|  |  | +  return returnMe;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) mergeFrom:(Rectangle*) other {
 | 
	
		
			
				|  |  | +  if (other == [Rectangle defaultInstance]) {
 | 
	
		
			
				|  |  | +    return self;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasLo) {
 | 
	
		
			
				|  |  | +    [self mergeLo:other.lo];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasHi) {
 | 
	
		
			
				|  |  | +    [self mergeHi:other.hi];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self mergeUnknownFields:other.unknownFields];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) 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: {
 | 
	
		
			
				|  |  | +        PointBuilder* subBuilder = [Point builder];
 | 
	
		
			
				|  |  | +        if (self.hasLo) {
 | 
	
		
			
				|  |  | +          [subBuilder mergeFrom:self.lo];
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
 | 
	
		
			
				|  |  | +        [self setLo:[subBuilder buildPartial]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 18: {
 | 
	
		
			
				|  |  | +        PointBuilder* subBuilder = [Point builder];
 | 
	
		
			
				|  |  | +        if (self.hasHi) {
 | 
	
		
			
				|  |  | +          [subBuilder mergeFrom:self.hi];
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
 | 
	
		
			
				|  |  | +        [self setHi:[subBuilder buildPartial]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasLo {
 | 
	
		
			
				|  |  | +  return resultRectangle.hasLo;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) lo {
 | 
	
		
			
				|  |  | +  return resultRectangle.lo;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) setLo:(Point*) value {
 | 
	
		
			
				|  |  | +  resultRectangle.hasLo = YES;
 | 
	
		
			
				|  |  | +  resultRectangle.lo = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) setLoBuilder:(PointBuilder*) builderForValue {
 | 
	
		
			
				|  |  | +  return [self setLo:[builderForValue build]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) mergeLo:(Point*) value {
 | 
	
		
			
				|  |  | +  if (resultRectangle.hasLo &&
 | 
	
		
			
				|  |  | +      resultRectangle.lo != [Point defaultInstance]) {
 | 
	
		
			
				|  |  | +    resultRectangle.lo =
 | 
	
		
			
				|  |  | +      [[[Point builderWithPrototype:resultRectangle.lo] mergeFrom:value] buildPartial];
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    resultRectangle.lo = value;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  resultRectangle.hasLo = YES;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) clearLo {
 | 
	
		
			
				|  |  | +  resultRectangle.hasLo = NO;
 | 
	
		
			
				|  |  | +  resultRectangle.lo = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasHi {
 | 
	
		
			
				|  |  | +  return resultRectangle.hasHi;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) hi {
 | 
	
		
			
				|  |  | +  return resultRectangle.hi;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) setHi:(Point*) value {
 | 
	
		
			
				|  |  | +  resultRectangle.hasHi = YES;
 | 
	
		
			
				|  |  | +  resultRectangle.hi = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) setHiBuilder:(PointBuilder*) builderForValue {
 | 
	
		
			
				|  |  | +  return [self setHi:[builderForValue build]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) mergeHi:(Point*) value {
 | 
	
		
			
				|  |  | +  if (resultRectangle.hasHi &&
 | 
	
		
			
				|  |  | +      resultRectangle.hi != [Point defaultInstance]) {
 | 
	
		
			
				|  |  | +    resultRectangle.hi =
 | 
	
		
			
				|  |  | +      [[[Point builderWithPrototype:resultRectangle.hi] mergeFrom:value] buildPartial];
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    resultRectangle.hi = value;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  resultRectangle.hasHi = YES;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RectangleBuilder*) clearHi {
 | 
	
		
			
				|  |  | +  resultRectangle.hasHi = NO;
 | 
	
		
			
				|  |  | +  resultRectangle.hi = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface Feature ()
 | 
	
		
			
				|  |  | +@property (strong) NSString* name;
 | 
	
		
			
				|  |  | +@property (strong) Point* location;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation Feature
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +- (BOOL) hasName {
 | 
	
		
			
				|  |  | +  return !!hasName_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasName:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasName_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize name;
 | 
	
		
			
				|  |  | +- (BOOL) hasLocation {
 | 
	
		
			
				|  |  | +  return !!hasLocation_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasLocation:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasLocation_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize location;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.name = @"";
 | 
	
		
			
				|  |  | +    self.location = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +static Feature* defaultFeatureInstance = nil;
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [Feature class]) {
 | 
	
		
			
				|  |  | +    defaultFeatureInstance = [[Feature alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultFeatureInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultFeatureInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isInitialized {
 | 
	
		
			
				|  |  | +  return YES;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
 | 
	
		
			
				|  |  | +  if (self.hasName) {
 | 
	
		
			
				|  |  | +    [output writeString:1 value:self.name];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    [output writeMessage:2 value:self.location];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeToCodedOutputStream:output];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) serializedSize {
 | 
	
		
			
				|  |  | +  __block SInt32 size_ = memoizedSerializedSize;
 | 
	
		
			
				|  |  | +  if (size_ != -1) {
 | 
	
		
			
				|  |  | +    return size_;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  size_ = 0;
 | 
	
		
			
				|  |  | +  if (self.hasName) {
 | 
	
		
			
				|  |  | +    size_ += computeStringSize(1, self.name);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    size_ += computeMessageSize(2, self.location);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  size_ += self.unknownFields.serializedSize;
 | 
	
		
			
				|  |  | +  memoizedSerializedSize = size_;
 | 
	
		
			
				|  |  | +  return size_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromData:(NSData*) data {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromData:data] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromInputStream:(NSInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromCodedInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (Feature*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (Feature*)[[[Feature builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (FeatureBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [[FeatureBuilder alloc] init];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (FeatureBuilder*) builderWithPrototype:(Feature*) prototype {
 | 
	
		
			
				|  |  | +  return [[Feature builder] mergeFrom:prototype];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [Feature builder];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) toBuilder {
 | 
	
		
			
				|  |  | +  return [Feature builderWithPrototype:self];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
 | 
	
		
			
				|  |  | +  if (self.hasName) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"name", self.name];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@ {\n", indent, @"location"];
 | 
	
		
			
				|  |  | +    [self.location 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:[Feature class]]) {
 | 
	
		
			
				|  |  | +    return NO;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  Feature *otherMessage = other;
 | 
	
		
			
				|  |  | +  return
 | 
	
		
			
				|  |  | +      self.hasName == otherMessage.hasName &&
 | 
	
		
			
				|  |  | +      (!self.hasName || [self.name isEqual:otherMessage.name]) &&
 | 
	
		
			
				|  |  | +      self.hasLocation == otherMessage.hasLocation &&
 | 
	
		
			
				|  |  | +      (!self.hasLocation || [self.location isEqual:otherMessage.location]) &&
 | 
	
		
			
				|  |  | +      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSUInteger) hash {
 | 
	
		
			
				|  |  | +  __block NSUInteger hashCode = 7;
 | 
	
		
			
				|  |  | +  if (self.hasName) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.name hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.location hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  hashCode = hashCode * 31 + [self.unknownFields hash];
 | 
	
		
			
				|  |  | +  return hashCode;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface FeatureBuilder()
 | 
	
		
			
				|  |  | +@property (strong) Feature* resultFeature;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation FeatureBuilder
 | 
	
		
			
				|  |  | +@synthesize resultFeature;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.resultFeature = [[Feature alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PBGeneratedMessage*) internalGetResult {
 | 
	
		
			
				|  |  | +  return resultFeature;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) clear {
 | 
	
		
			
				|  |  | +  self.resultFeature = [[Feature alloc] init];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) clone {
 | 
	
		
			
				|  |  | +  return [Feature builderWithPrototype:resultFeature];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Feature*) defaultInstance {
 | 
	
		
			
				|  |  | +  return [Feature defaultInstance];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Feature*) build {
 | 
	
		
			
				|  |  | +  [self checkInitialized];
 | 
	
		
			
				|  |  | +  return [self buildPartial];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Feature*) buildPartial {
 | 
	
		
			
				|  |  | +  Feature* returnMe = resultFeature;
 | 
	
		
			
				|  |  | +  self.resultFeature = nil;
 | 
	
		
			
				|  |  | +  return returnMe;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) mergeFrom:(Feature*) other {
 | 
	
		
			
				|  |  | +  if (other == [Feature defaultInstance]) {
 | 
	
		
			
				|  |  | +    return self;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasName) {
 | 
	
		
			
				|  |  | +    [self setName:other.name];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasLocation) {
 | 
	
		
			
				|  |  | +    [self mergeLocation:other.location];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self mergeUnknownFields:other.unknownFields];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) 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 setName:[input readString]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 18: {
 | 
	
		
			
				|  |  | +        PointBuilder* subBuilder = [Point builder];
 | 
	
		
			
				|  |  | +        if (self.hasLocation) {
 | 
	
		
			
				|  |  | +          [subBuilder mergeFrom:self.location];
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
 | 
	
		
			
				|  |  | +        [self setLocation:[subBuilder buildPartial]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasName {
 | 
	
		
			
				|  |  | +  return resultFeature.hasName;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSString*) name {
 | 
	
		
			
				|  |  | +  return resultFeature.name;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) setName:(NSString*) value {
 | 
	
		
			
				|  |  | +  resultFeature.hasName = YES;
 | 
	
		
			
				|  |  | +  resultFeature.name = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) clearName {
 | 
	
		
			
				|  |  | +  resultFeature.hasName = NO;
 | 
	
		
			
				|  |  | +  resultFeature.name = @"";
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasLocation {
 | 
	
		
			
				|  |  | +  return resultFeature.hasLocation;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) location {
 | 
	
		
			
				|  |  | +  return resultFeature.location;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) setLocation:(Point*) value {
 | 
	
		
			
				|  |  | +  resultFeature.hasLocation = YES;
 | 
	
		
			
				|  |  | +  resultFeature.location = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) setLocationBuilder:(PointBuilder*) builderForValue {
 | 
	
		
			
				|  |  | +  return [self setLocation:[builderForValue build]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) mergeLocation:(Point*) value {
 | 
	
		
			
				|  |  | +  if (resultFeature.hasLocation &&
 | 
	
		
			
				|  |  | +      resultFeature.location != [Point defaultInstance]) {
 | 
	
		
			
				|  |  | +    resultFeature.location =
 | 
	
		
			
				|  |  | +      [[[Point builderWithPrototype:resultFeature.location] mergeFrom:value] buildPartial];
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    resultFeature.location = value;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  resultFeature.hasLocation = YES;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (FeatureBuilder*) clearLocation {
 | 
	
		
			
				|  |  | +  resultFeature.hasLocation = NO;
 | 
	
		
			
				|  |  | +  resultFeature.location = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface RouteNote ()
 | 
	
		
			
				|  |  | +@property (strong) Point* location;
 | 
	
		
			
				|  |  | +@property (strong) NSString* message;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RouteNote
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +- (BOOL) hasLocation {
 | 
	
		
			
				|  |  | +  return !!hasLocation_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasLocation:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasLocation_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize location;
 | 
	
		
			
				|  |  | +- (BOOL) hasMessage {
 | 
	
		
			
				|  |  | +  return !!hasMessage_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasMessage:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasMessage_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize message;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.location = [Point defaultInstance];
 | 
	
		
			
				|  |  | +    self.message = @"";
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +static RouteNote* defaultRouteNoteInstance = nil;
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [RouteNote class]) {
 | 
	
		
			
				|  |  | +    defaultRouteNoteInstance = [[RouteNote alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRouteNoteInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRouteNoteInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isInitialized {
 | 
	
		
			
				|  |  | +  return YES;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    [output writeMessage:1 value:self.location];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasMessage) {
 | 
	
		
			
				|  |  | +    [output writeString:2 value:self.message];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeToCodedOutputStream:output];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) serializedSize {
 | 
	
		
			
				|  |  | +  __block SInt32 size_ = memoizedSerializedSize;
 | 
	
		
			
				|  |  | +  if (size_ != -1) {
 | 
	
		
			
				|  |  | +    return size_;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  size_ = 0;
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    size_ += computeMessageSize(1, self.location);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasMessage) {
 | 
	
		
			
				|  |  | +    size_ += computeStringSize(2, self.message);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  size_ += self.unknownFields.serializedSize;
 | 
	
		
			
				|  |  | +  memoizedSerializedSize = size_;
 | 
	
		
			
				|  |  | +  return size_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromData:(NSData*) data {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromData:data] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromInputStream:(NSInputStream*) input {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromCodedInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNote*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteNote*)[[[RouteNote builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNoteBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [[RouteNoteBuilder alloc] init];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteNoteBuilder*) builderWithPrototype:(RouteNote*) prototype {
 | 
	
		
			
				|  |  | +  return [[RouteNote builder] mergeFrom:prototype];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [RouteNote builder];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) toBuilder {
 | 
	
		
			
				|  |  | +  return [RouteNote builderWithPrototype:self];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@ {\n", indent, @"location"];
 | 
	
		
			
				|  |  | +    [self.location writeDescriptionTo:output
 | 
	
		
			
				|  |  | +                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@}\n", indent];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasMessage) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"message", self.message];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeDescriptionTo:output withIndent:indent];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isEqual:(id)other {
 | 
	
		
			
				|  |  | +  if (other == self) {
 | 
	
		
			
				|  |  | +    return YES;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (![other isKindOfClass:[RouteNote class]]) {
 | 
	
		
			
				|  |  | +    return NO;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  RouteNote *otherMessage = other;
 | 
	
		
			
				|  |  | +  return
 | 
	
		
			
				|  |  | +      self.hasLocation == otherMessage.hasLocation &&
 | 
	
		
			
				|  |  | +      (!self.hasLocation || [self.location isEqual:otherMessage.location]) &&
 | 
	
		
			
				|  |  | +      self.hasMessage == otherMessage.hasMessage &&
 | 
	
		
			
				|  |  | +      (!self.hasMessage || [self.message isEqual:otherMessage.message]) &&
 | 
	
		
			
				|  |  | +      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSUInteger) hash {
 | 
	
		
			
				|  |  | +  __block NSUInteger hashCode = 7;
 | 
	
		
			
				|  |  | +  if (self.hasLocation) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.location hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasMessage) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [self.message hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  hashCode = hashCode * 31 + [self.unknownFields hash];
 | 
	
		
			
				|  |  | +  return hashCode;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface RouteNoteBuilder()
 | 
	
		
			
				|  |  | +@property (strong) RouteNote* resultRouteNote;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RouteNoteBuilder
 | 
	
		
			
				|  |  | +@synthesize resultRouteNote;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.resultRouteNote = [[RouteNote alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PBGeneratedMessage*) internalGetResult {
 | 
	
		
			
				|  |  | +  return resultRouteNote;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) clear {
 | 
	
		
			
				|  |  | +  self.resultRouteNote = [[RouteNote alloc] init];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) clone {
 | 
	
		
			
				|  |  | +  return [RouteNote builderWithPrototype:resultRouteNote];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNote*) defaultInstance {
 | 
	
		
			
				|  |  | +  return [RouteNote defaultInstance];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNote*) build {
 | 
	
		
			
				|  |  | +  [self checkInitialized];
 | 
	
		
			
				|  |  | +  return [self buildPartial];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNote*) buildPartial {
 | 
	
		
			
				|  |  | +  RouteNote* returnMe = resultRouteNote;
 | 
	
		
			
				|  |  | +  self.resultRouteNote = nil;
 | 
	
		
			
				|  |  | +  return returnMe;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) mergeFrom:(RouteNote*) other {
 | 
	
		
			
				|  |  | +  if (other == [RouteNote defaultInstance]) {
 | 
	
		
			
				|  |  | +    return self;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasLocation) {
 | 
	
		
			
				|  |  | +    [self mergeLocation:other.location];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasMessage) {
 | 
	
		
			
				|  |  | +    [self setMessage:other.message];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self mergeUnknownFields:other.unknownFields];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) 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: {
 | 
	
		
			
				|  |  | +        PointBuilder* subBuilder = [Point builder];
 | 
	
		
			
				|  |  | +        if (self.hasLocation) {
 | 
	
		
			
				|  |  | +          [subBuilder mergeFrom:self.location];
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
 | 
	
		
			
				|  |  | +        [self setLocation:[subBuilder buildPartial]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 18: {
 | 
	
		
			
				|  |  | +        [self setMessage:[input readString]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasLocation {
 | 
	
		
			
				|  |  | +  return resultRouteNote.hasLocation;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (Point*) location {
 | 
	
		
			
				|  |  | +  return resultRouteNote.location;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) setLocation:(Point*) value {
 | 
	
		
			
				|  |  | +  resultRouteNote.hasLocation = YES;
 | 
	
		
			
				|  |  | +  resultRouteNote.location = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) setLocationBuilder:(PointBuilder*) builderForValue {
 | 
	
		
			
				|  |  | +  return [self setLocation:[builderForValue build]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) mergeLocation:(Point*) value {
 | 
	
		
			
				|  |  | +  if (resultRouteNote.hasLocation &&
 | 
	
		
			
				|  |  | +      resultRouteNote.location != [Point defaultInstance]) {
 | 
	
		
			
				|  |  | +    resultRouteNote.location =
 | 
	
		
			
				|  |  | +      [[[Point builderWithPrototype:resultRouteNote.location] mergeFrom:value] buildPartial];
 | 
	
		
			
				|  |  | +  } else {
 | 
	
		
			
				|  |  | +    resultRouteNote.location = value;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  resultRouteNote.hasLocation = YES;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) clearLocation {
 | 
	
		
			
				|  |  | +  resultRouteNote.hasLocation = NO;
 | 
	
		
			
				|  |  | +  resultRouteNote.location = [Point defaultInstance];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasMessage {
 | 
	
		
			
				|  |  | +  return resultRouteNote.hasMessage;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSString*) message {
 | 
	
		
			
				|  |  | +  return resultRouteNote.message;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) setMessage:(NSString*) value {
 | 
	
		
			
				|  |  | +  resultRouteNote.hasMessage = YES;
 | 
	
		
			
				|  |  | +  resultRouteNote.message = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteNoteBuilder*) clearMessage {
 | 
	
		
			
				|  |  | +  resultRouteNote.hasMessage = NO;
 | 
	
		
			
				|  |  | +  resultRouteNote.message = @"";
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface RouteSummary ()
 | 
	
		
			
				|  |  | +@property SInt32 pointCount;
 | 
	
		
			
				|  |  | +@property SInt32 featureCount;
 | 
	
		
			
				|  |  | +@property SInt32 distance;
 | 
	
		
			
				|  |  | +@property SInt32 elapsedTime;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RouteSummary
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +- (BOOL) hasPointCount {
 | 
	
		
			
				|  |  | +  return !!hasPointCount_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasPointCount:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasPointCount_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize pointCount;
 | 
	
		
			
				|  |  | +- (BOOL) hasFeatureCount {
 | 
	
		
			
				|  |  | +  return !!hasFeatureCount_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasFeatureCount:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasFeatureCount_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize featureCount;
 | 
	
		
			
				|  |  | +- (BOOL) hasDistance {
 | 
	
		
			
				|  |  | +  return !!hasDistance_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasDistance:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasDistance_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize distance;
 | 
	
		
			
				|  |  | +- (BOOL) hasElapsedTime {
 | 
	
		
			
				|  |  | +  return !!hasElapsedTime_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) setHasElapsedTime:(BOOL) _value_ {
 | 
	
		
			
				|  |  | +  hasElapsedTime_ = !!_value_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@synthesize elapsedTime;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.pointCount = 0;
 | 
	
		
			
				|  |  | +    self.featureCount = 0;
 | 
	
		
			
				|  |  | +    self.distance = 0;
 | 
	
		
			
				|  |  | +    self.elapsedTime = 0;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +static RouteSummary* defaultRouteSummaryInstance = nil;
 | 
	
		
			
				|  |  | ++ (void) initialize {
 | 
	
		
			
				|  |  | +  if (self == [RouteSummary class]) {
 | 
	
		
			
				|  |  | +    defaultRouteSummaryInstance = [[RouteSummary alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRouteSummaryInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (instancetype) defaultInstance {
 | 
	
		
			
				|  |  | +  return defaultRouteSummaryInstance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isInitialized {
 | 
	
		
			
				|  |  | +  return YES;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
 | 
	
		
			
				|  |  | +  if (self.hasPointCount) {
 | 
	
		
			
				|  |  | +    [output writeInt32:1 value:self.pointCount];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasFeatureCount) {
 | 
	
		
			
				|  |  | +    [output writeInt32:2 value:self.featureCount];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasDistance) {
 | 
	
		
			
				|  |  | +    [output writeInt32:3 value:self.distance];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasElapsedTime) {
 | 
	
		
			
				|  |  | +    [output writeInt32:4 value:self.elapsedTime];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeToCodedOutputStream:output];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) serializedSize {
 | 
	
		
			
				|  |  | +  __block SInt32 size_ = memoizedSerializedSize;
 | 
	
		
			
				|  |  | +  if (size_ != -1) {
 | 
	
		
			
				|  |  | +    return size_;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  size_ = 0;
 | 
	
		
			
				|  |  | +  if (self.hasPointCount) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(1, self.pointCount);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasFeatureCount) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(2, self.featureCount);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasDistance) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(3, self.distance);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasElapsedTime) {
 | 
	
		
			
				|  |  | +    size_ += computeInt32Size(4, self.elapsedTime);
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  size_ += self.unknownFields.serializedSize;
 | 
	
		
			
				|  |  | +  memoizedSerializedSize = size_;
 | 
	
		
			
				|  |  | +  return size_;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromData:(NSData*) data {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromData:data] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromInputStream:(NSInputStream*) input {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromCodedInputStream:input] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummary*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
 | 
	
		
			
				|  |  | +  return (RouteSummary*)[[[RouteSummary builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummaryBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [[RouteSummaryBuilder alloc] init];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | ++ (RouteSummaryBuilder*) builderWithPrototype:(RouteSummary*) prototype {
 | 
	
		
			
				|  |  | +  return [[RouteSummary builder] mergeFrom:prototype];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) builder {
 | 
	
		
			
				|  |  | +  return [RouteSummary builder];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) toBuilder {
 | 
	
		
			
				|  |  | +  return [RouteSummary builderWithPrototype:self];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
 | 
	
		
			
				|  |  | +  if (self.hasPointCount) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"pointCount", [NSNumber numberWithInteger:self.pointCount]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasFeatureCount) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"featureCount", [NSNumber numberWithInteger:self.featureCount]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasDistance) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"distance", [NSNumber numberWithInteger:self.distance]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasElapsedTime) {
 | 
	
		
			
				|  |  | +    [output appendFormat:@"%@%@: %@\n", indent, @"elapsedTime", [NSNumber numberWithInteger:self.elapsedTime]];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self.unknownFields writeDescriptionTo:output withIndent:indent];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) isEqual:(id)other {
 | 
	
		
			
				|  |  | +  if (other == self) {
 | 
	
		
			
				|  |  | +    return YES;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (![other isKindOfClass:[RouteSummary class]]) {
 | 
	
		
			
				|  |  | +    return NO;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  RouteSummary *otherMessage = other;
 | 
	
		
			
				|  |  | +  return
 | 
	
		
			
				|  |  | +      self.hasPointCount == otherMessage.hasPointCount &&
 | 
	
		
			
				|  |  | +      (!self.hasPointCount || self.pointCount == otherMessage.pointCount) &&
 | 
	
		
			
				|  |  | +      self.hasFeatureCount == otherMessage.hasFeatureCount &&
 | 
	
		
			
				|  |  | +      (!self.hasFeatureCount || self.featureCount == otherMessage.featureCount) &&
 | 
	
		
			
				|  |  | +      self.hasDistance == otherMessage.hasDistance &&
 | 
	
		
			
				|  |  | +      (!self.hasDistance || self.distance == otherMessage.distance) &&
 | 
	
		
			
				|  |  | +      self.hasElapsedTime == otherMessage.hasElapsedTime &&
 | 
	
		
			
				|  |  | +      (!self.hasElapsedTime || self.elapsedTime == otherMessage.elapsedTime) &&
 | 
	
		
			
				|  |  | +      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (NSUInteger) hash {
 | 
	
		
			
				|  |  | +  __block NSUInteger hashCode = 7;
 | 
	
		
			
				|  |  | +  if (self.hasPointCount) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.pointCount] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasFeatureCount) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.featureCount] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasDistance) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.distance] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (self.hasElapsedTime) {
 | 
	
		
			
				|  |  | +    hashCode = hashCode * 31 + [[NSNumber numberWithInteger:self.elapsedTime] hash];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  hashCode = hashCode * 31 + [self.unknownFields hash];
 | 
	
		
			
				|  |  | +  return hashCode;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@interface RouteSummaryBuilder()
 | 
	
		
			
				|  |  | +@property (strong) RouteSummary* resultRouteSummary;
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +@implementation RouteSummaryBuilder
 | 
	
		
			
				|  |  | +@synthesize resultRouteSummary;
 | 
	
		
			
				|  |  | +- (instancetype) init {
 | 
	
		
			
				|  |  | +  if ((self = [super init])) {
 | 
	
		
			
				|  |  | +    self.resultRouteSummary = [[RouteSummary alloc] init];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (PBGeneratedMessage*) internalGetResult {
 | 
	
		
			
				|  |  | +  return resultRouteSummary;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clear {
 | 
	
		
			
				|  |  | +  self.resultRouteSummary = [[RouteSummary alloc] init];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clone {
 | 
	
		
			
				|  |  | +  return [RouteSummary builderWithPrototype:resultRouteSummary];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummary*) defaultInstance {
 | 
	
		
			
				|  |  | +  return [RouteSummary defaultInstance];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummary*) build {
 | 
	
		
			
				|  |  | +  [self checkInitialized];
 | 
	
		
			
				|  |  | +  return [self buildPartial];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummary*) buildPartial {
 | 
	
		
			
				|  |  | +  RouteSummary* returnMe = resultRouteSummary;
 | 
	
		
			
				|  |  | +  self.resultRouteSummary = nil;
 | 
	
		
			
				|  |  | +  return returnMe;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) mergeFrom:(RouteSummary*) other {
 | 
	
		
			
				|  |  | +  if (other == [RouteSummary defaultInstance]) {
 | 
	
		
			
				|  |  | +    return self;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasPointCount) {
 | 
	
		
			
				|  |  | +    [self setPointCount:other.pointCount];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasFeatureCount) {
 | 
	
		
			
				|  |  | +    [self setFeatureCount:other.featureCount];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasDistance) {
 | 
	
		
			
				|  |  | +    [self setDistance:other.distance];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  if (other.hasElapsedTime) {
 | 
	
		
			
				|  |  | +    [self setElapsedTime:other.elapsedTime];
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  [self mergeUnknownFields:other.unknownFields];
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
 | 
	
		
			
				|  |  | +  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) 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 setPointCount:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 16: {
 | 
	
		
			
				|  |  | +        [self setFeatureCount:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 24: {
 | 
	
		
			
				|  |  | +        [self setDistance:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      case 32: {
 | 
	
		
			
				|  |  | +        [self setElapsedTime:[input readInt32]];
 | 
	
		
			
				|  |  | +        break;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasPointCount {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.hasPointCount;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) pointCount {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.pointCount;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) setPointCount:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasPointCount = YES;
 | 
	
		
			
				|  |  | +  resultRouteSummary.pointCount = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clearPointCount {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasPointCount = NO;
 | 
	
		
			
				|  |  | +  resultRouteSummary.pointCount = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasFeatureCount {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.hasFeatureCount;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) featureCount {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.featureCount;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) setFeatureCount:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasFeatureCount = YES;
 | 
	
		
			
				|  |  | +  resultRouteSummary.featureCount = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clearFeatureCount {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasFeatureCount = NO;
 | 
	
		
			
				|  |  | +  resultRouteSummary.featureCount = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasDistance {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.hasDistance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) distance {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.distance;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) setDistance:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasDistance = YES;
 | 
	
		
			
				|  |  | +  resultRouteSummary.distance = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clearDistance {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasDistance = NO;
 | 
	
		
			
				|  |  | +  resultRouteSummary.distance = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (BOOL) hasElapsedTime {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.hasElapsedTime;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (SInt32) elapsedTime {
 | 
	
		
			
				|  |  | +  return resultRouteSummary.elapsedTime;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) setElapsedTime:(SInt32) value {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasElapsedTime = YES;
 | 
	
		
			
				|  |  | +  resultRouteSummary.elapsedTime = value;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +- (RouteSummaryBuilder*) clearElapsedTime {
 | 
	
		
			
				|  |  | +  resultRouteSummary.hasElapsedTime = NO;
 | 
	
		
			
				|  |  | +  resultRouteSummary.elapsedTime = 0;
 | 
	
		
			
				|  |  | +  return self;
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +@end
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +// @@protoc_insertion_point(global_scope)
 |