text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: google/protobuf/wrappers.proto
  
  #import "GPBProtocolBuffers_RuntimeSupport.h"
  #import "google/protobuf/Wrappers.pbobjc.h"
  // @@protoc_insertion_point(imports)
  
  #pragma mark - GPBWrappersRoot
  
  @implementation GPBWrappersRoot
  
  @end
  
  #pragma mark - GPBWrappersRoot_FileDescriptor
  
  static GPBFileDescriptor *GPBWrappersRoot_FileDescriptor(void) {
    // This is called by +initialize so there is no need to worry
    // about thread safety of the singleton.
    static GPBFileDescriptor *descriptor = NULL;
    if (!descriptor) {
      GPBDebugCheckRuntimeVersion();
      descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
                                                       syntax:GPBFileSyntaxProto3];
    }
    return descriptor;
  }
  
  #pragma mark - GPBDoubleValue
  
  @implementation GPBDoubleValue
  
  @dynamic value;
  
  typedef struct GPBDoubleValue__storage_ {
    uint32_t _has_storage_[1];
    double value;
  } GPBDoubleValue__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBDoubleValue_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeDouble,
          .offset = offsetof(GPBDoubleValue__storage_, value),
          .defaultValue.valueDouble = 0,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBDoubleValue class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBDoubleValue__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBFloatValue
  
  @implementation GPBFloatValue
  
  @dynamic value;
  
  typedef struct GPBFloatValue__storage_ {
    uint32_t _has_storage_[1];
    float value;
  } GPBFloatValue__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBFloatValue_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeFloat,
          .offset = offsetof(GPBFloatValue__storage_, value),
          .defaultValue.valueFloat = 0,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBFloatValue class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBFloatValue__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBInt64Value
  
  @implementation GPBInt64Value
  
  @dynamic value;
  
  typedef struct GPBInt64Value__storage_ {
    uint32_t _has_storage_[1];
    int64_t value;
  } GPBInt64Value__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBInt64Value_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeInt64,
          .offset = offsetof(GPBInt64Value__storage_, value),
          .defaultValue.valueInt64 = 0LL,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBInt64Value class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBInt64Value__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBUInt64Value
  
  @implementation GPBUInt64Value
  
  @dynamic value;
  
  typedef struct GPBUInt64Value__storage_ {
    uint32_t _has_storage_[1];
    uint64_t value;
  } GPBUInt64Value__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBUInt64Value_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeUInt64,
          .offset = offsetof(GPBUInt64Value__storage_, value),
          .defaultValue.valueUInt64 = 0ULL,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBUInt64Value class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBUInt64Value__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBInt32Value
  
  @implementation GPBInt32Value
  
  @dynamic value;
  
  typedef struct GPBInt32Value__storage_ {
    uint32_t _has_storage_[1];
    int32_t value;
  } GPBInt32Value__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBInt32Value_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeInt32,
          .offset = offsetof(GPBInt32Value__storage_, value),
          .defaultValue.valueInt32 = 0,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBInt32Value class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBInt32Value__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBUInt32Value
  
  @implementation GPBUInt32Value
  
  @dynamic value;
  
  typedef struct GPBUInt32Value__storage_ {
    uint32_t _has_storage_[1];
    uint32_t value;
  } GPBUInt32Value__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBUInt32Value_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeUInt32,
          .offset = offsetof(GPBUInt32Value__storage_, value),
          .defaultValue.valueUInt32 = 0U,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBUInt32Value class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBUInt32Value__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBBoolValue
  
  @implementation GPBBoolValue
  
  @dynamic value;
  
  typedef struct GPBBoolValue__storage_ {
    uint32_t _has_storage_[1];
    BOOL value;
  } GPBBoolValue__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBBoolValue_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeBool,
          .offset = offsetof(GPBBoolValue__storage_, value),
          .defaultValue.valueBool = NO,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBBoolValue class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBBoolValue__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBStringValue
  
  @implementation GPBStringValue
  
  @dynamic value;
  
  typedef struct GPBStringValue__storage_ {
    uint32_t _has_storage_[1];
    NSString *value;
  } GPBStringValue__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBStringValue_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeString,
          .offset = offsetof(GPBStringValue__storage_, value),
          .defaultValue.valueString = nil,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBStringValue class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBStringValue__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  #pragma mark - GPBBytesValue
  
  @implementation GPBBytesValue
  
  @dynamic value;
  
  typedef struct GPBBytesValue__storage_ {
    uint32_t _has_storage_[1];
    NSData *value;
  } GPBBytesValue__storage_;
  
  // This method is threadsafe because it is initially called
  // in +initialize for each subclass.
  + (GPBDescriptor *)descriptor {
    static GPBDescriptor *descriptor = nil;
    if (!descriptor) {
      static GPBMessageFieldDescription fields[] = {
        {
          .name = "value",
          .number = GPBBytesValue_FieldNumber_Value,
          .hasIndex = 0,
          .flags = GPBFieldOptional,
          .dataType = GPBDataTypeBytes,
          .offset = offsetof(GPBBytesValue__storage_, value),
          .defaultValue.valueData = nil,
          .dataTypeSpecific.className = NULL,
          .fieldOptions = NULL,
        },
      };
      GPBDescriptor *localDescriptor =
          [GPBDescriptor allocDescriptorForClass:[GPBBytesValue class]
                                       rootClass:[GPBWrappersRoot class]
                                            file:GPBWrappersRoot_FileDescriptor()
                                          fields:fields
                                      fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                          oneofs:NULL
                                      oneofCount:0
                                           enums:NULL
                                       enumCount:0
                                          ranges:NULL
                                      rangeCount:0
                                     storageSize:sizeof(GPBBytesValue__storage_)
                                      wireFormat:NO];
      NSAssert(descriptor == nil, @"Startup recursed!");
      descriptor = localDescriptor;
    }
    return descriptor;
  }
  
  @end
  
  
  // @@protoc_insertion_point(global_scope)
  