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

// This CPP symbol can be defined to use imports that match up to the framework
// imports needed when using CocoaPods.
#if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
 #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
#endif

#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
 #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
#else
 #import "GPBProtocolBuffers_RuntimeSupport.h"
#endif

#import "Vector.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"

#pragma mark - Objective C Class declarations
// Forward declarations of Objective C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(DirentNode);
GPBObjCClassDeclaration(Extrema);
GPBObjCClassDeclaration(Revision);
GPBObjCClassDeclaration(Rule);
GPBObjCClassDeclaration(SparseMatrix);
GPBObjCClassDeclaration(Vector64);

#pragma mark - VectorRoot

@implementation VectorRoot

// No extensions in the file and no imports, so no need to generate
// +extensionRegistry.

@end

#pragma mark - VectorRoot_FileDescriptor

static GPBFileDescriptor *VectorRoot_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) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"Messages"
                                                     syntax:GPBFileSyntaxProto3];
  }
  return descriptor;
}

#pragma mark - File

@implementation File

@dynamic name;
@dynamic payload;
@dynamic isLocal;
@dynamic isExported;
@dynamic timeCreated;
@dynamic timeModified;

typedef struct File__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSData *payload;
  uint64_t timeCreated;
  uint64_t timeModified;
} File__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(File__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "payload",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_Payload,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(File__storage_, payload),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBytes,
      },
      {
        .name = "isLocal",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_IsLocal,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isExported",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_IsExported,
        .hasIndex = 4,
        .offset = 5,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "timeCreated",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_TimeCreated,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(File__storage_, timeCreated),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "timeModified",
        .dataTypeSpecific.clazz = Nil,
        .number = File_FieldNumber_TimeModified,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(File__storage_, timeModified),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[File class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(File__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - DirentNode

@implementation DirentNode

@dynamic dirname;
@dynamic filesArray, filesArray_Count;
@dynamic subdirsArray, subdirsArray_Count;

typedef struct DirentNode__storage_ {
  uint32_t _has_storage_[1];
  NSString *dirname;
  NSMutableArray *filesArray;
  NSMutableArray *subdirsArray;
} DirentNode__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 = "dirname",
        .dataTypeSpecific.clazz = Nil,
        .number = DirentNode_FieldNumber_Dirname,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(DirentNode__storage_, dirname),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "filesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = DirentNode_FieldNumber_FilesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(DirentNode__storage_, filesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "subdirsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(DirentNode),
        .number = DirentNode_FieldNumber_SubdirsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(DirentNode__storage_, subdirsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[DirentNode class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(DirentNode__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Revision

@implementation Revision

@dynamic majorRev;
@dynamic minorRev;

typedef struct Revision__storage_ {
  uint32_t _has_storage_[1];
  uint64_t majorRev;
  uint64_t minorRev;
} Revision__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 = "majorRev",
        .dataTypeSpecific.clazz = Nil,
        .number = Revision_FieldNumber_MajorRev,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Revision__storage_, majorRev),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "minorRev",
        .dataTypeSpecific.clazz = Nil,
        .number = Revision_FieldNumber_MinorRev,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Revision__storage_, minorRev),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Revision class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Revision__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Extrema

@implementation Extrema

@dynamic dims;
@dynamic minArray, minArray_Count;
@dynamic maxArray, maxArray_Count;
@dynamic isSet;

typedef struct Extrema__storage_ {
  uint32_t _has_storage_[1];
  uint32_t dims;
  GPBDoubleArray *minArray;
  GPBDoubleArray *maxArray;
} Extrema__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 = "dims",
        .dataTypeSpecific.clazz = Nil,
        .number = Extrema_FieldNumber_Dims,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Extrema__storage_, dims),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "minArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Extrema_FieldNumber_MinArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Extrema__storage_, minArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "maxArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Extrema_FieldNumber_MaxArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Extrema__storage_, maxArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "isSet",
        .dataTypeSpecific.clazz = Nil,
        .number = Extrema_FieldNumber_IsSet,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Extrema class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Extrema__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Vector32

@implementation Vector32

@dynamic name;
@dynamic components;
@dynamic interleaved;
@dynamic hasRevision, revision;
@dynamic units;
@dynamic comment;
@dynamic offset;
@dynamic valuesArray, valuesArray_Count;
@dynamic sizeHintArray, sizeHintArray_Count;

typedef struct Vector32__storage_ {
  uint32_t _has_storage_[1];
  uint32_t components;
  NSString *name;
  Revision *revision;
  NSString *units;
  NSString *comment;
  GPBFloatArray *valuesArray;
  GPBUInt32Array *sizeHintArray;
  uint64_t offset;
} Vector32__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Vector32__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "components",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Components,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Vector32__storage_, components),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "interleaved",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Interleaved,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "revision",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = Vector32_FieldNumber_Revision,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(Vector32__storage_, revision),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "units",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Units,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Vector32__storage_, units),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "comment",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Comment,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Vector32__storage_, comment),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_Offset,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Vector32__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "valuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_ValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Vector32__storage_, valuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "sizeHintArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector32_FieldNumber_SizeHintArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Vector32__storage_, sizeHintArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Vector32 class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Vector32__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Vector64

@implementation Vector64

@dynamic name;
@dynamic components;
@dynamic interleaved;
@dynamic hasRevision, revision;
@dynamic units;
@dynamic comment;
@dynamic offset;
@dynamic valuesArray, valuesArray_Count;
@dynamic sizeHintArray, sizeHintArray_Count;

typedef struct Vector64__storage_ {
  uint32_t _has_storage_[1];
  uint32_t components;
  NSString *name;
  Revision *revision;
  NSString *units;
  NSString *comment;
  GPBDoubleArray *valuesArray;
  GPBUInt32Array *sizeHintArray;
  uint64_t offset;
} Vector64__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Vector64__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "components",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Components,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Vector64__storage_, components),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "interleaved",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Interleaved,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "revision",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = Vector64_FieldNumber_Revision,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(Vector64__storage_, revision),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "units",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Units,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Vector64__storage_, units),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "comment",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Comment,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Vector64__storage_, comment),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_Offset,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Vector64__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "valuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_ValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Vector64__storage_, valuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "sizeHintArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Vector64_FieldNumber_SizeHintArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Vector64__storage_, sizeHintArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Vector64 class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Vector64__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - SparseMatrix

@implementation SparseMatrix

@dynamic name;
@dynamic sizeHintArray, sizeHintArray_Count;
@dynamic indicesArray, indicesArray_Count;
@dynamic valuesArray, valuesArray_Count;
@dynamic hasBounds, bounds;

typedef struct SparseMatrix__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  GPBUInt32Array *sizeHintArray;
  GPBUInt32Array *indicesArray;
  GPBDoubleArray *valuesArray;
  Extrema *bounds;
} SparseMatrix__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = SparseMatrix_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(SparseMatrix__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "sizeHintArray",
        .dataTypeSpecific.clazz = Nil,
        .number = SparseMatrix_FieldNumber_SizeHintArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(SparseMatrix__storage_, sizeHintArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "indicesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = SparseMatrix_FieldNumber_IndicesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(SparseMatrix__storage_, indicesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "valuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = SparseMatrix_FieldNumber_ValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(SparseMatrix__storage_, valuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "bounds",
        .dataTypeSpecific.clazz = GPBObjCClass(Extrema),
        .number = SparseMatrix_FieldNumber_Bounds,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(SparseMatrix__storage_, bounds),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[SparseMatrix class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(SparseMatrix__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Rule

@implementation Rule

@dynamic pk;
@dynamic op;
@dynamic value;
@dynamic algorithmsArray, algorithmsArray_Count;
@dynamic failedNodesArray, failedNodesArray_Count;
@dynamic failedValuesArray, failedValuesArray_Count;

typedef struct Rule__storage_ {
  uint32_t _has_storage_[1];
  uint32_t op;
  NSString *pk;
  NSMutableArray *algorithmsArray;
  GPBUInt32Array *failedNodesArray;
  GPBDoubleArray *failedValuesArray;
  double value;
} Rule__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 = "pk",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_Pk,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Rule__storage_, pk),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "op",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_Op,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Rule__storage_, op),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "value",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_Value,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Rule__storage_, value),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "algorithmsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_AlgorithmsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Rule__storage_, algorithmsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "failedNodesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_FailedNodesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Rule__storage_, failedNodesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "failedValuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Rule_FieldNumber_FailedValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Rule__storage_, failedValuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Rule class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Rule__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Record64

@implementation Record64

@dynamic name;
@dynamic owner;
@dynamic hasRevision, revision;
@dynamic lengthUnits;
@dynamic requirementsArray, requirementsArray_Count;
@dynamic dataArray, dataArray_Count;
@dynamic matrixArray, matrixArray_Count;

typedef struct Record64__storage_ {
  uint32_t _has_storage_[1];
  uint32_t lengthUnits;
  NSString *name;
  NSString *owner;
  Revision *revision;
  NSMutableArray *requirementsArray;
  NSMutableArray *dataArray;
  NSMutableArray *matrixArray;
} Record64__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = Record64_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Record64__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "owner",
        .dataTypeSpecific.clazz = Nil,
        .number = Record64_FieldNumber_Owner,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Record64__storage_, owner),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "revision",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = Record64_FieldNumber_Revision,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Record64__storage_, revision),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "lengthUnits",
        .dataTypeSpecific.clazz = Nil,
        .number = Record64_FieldNumber_LengthUnits,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(Record64__storage_, lengthUnits),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "requirementsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Rule),
        .number = Record64_FieldNumber_RequirementsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Record64__storage_, requirementsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "dataArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Vector64),
        .number = Record64_FieldNumber_DataArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Record64__storage_, dataArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "matrixArray",
        .dataTypeSpecific.clazz = GPBObjCClass(SparseMatrix),
        .number = Record64_FieldNumber_MatrixArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Record64__storage_, matrixArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Record64 class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Record64__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - UIndices

@implementation UIndices

@dynamic name;
@dynamic components;
@dynamic interleaved;
@dynamic hasRevision, revision;
@dynamic offset;
@dynamic valuesArray, valuesArray_Count;

typedef struct UIndices__storage_ {
  uint32_t _has_storage_[1];
  uint32_t components;
  NSString *name;
  Revision *revision;
  GPBUInt32Array *valuesArray;
  uint64_t offset;
} UIndices__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 = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = UIndices_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(UIndices__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "components",
        .dataTypeSpecific.clazz = Nil,
        .number = UIndices_FieldNumber_Components,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(UIndices__storage_, components),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "interleaved",
        .dataTypeSpecific.clazz = Nil,
        .number = UIndices_FieldNumber_Interleaved,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "revision",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = UIndices_FieldNumber_Revision,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(UIndices__storage_, revision),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = UIndices_FieldNumber_Offset,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(UIndices__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "valuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = UIndices_FieldNumber_ValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(UIndices__storage_, valuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[UIndices class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(UIndices__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Elements

@implementation Elements

@dynamic elementIndicesArray, elementIndicesArray_Count;
@dynamic elementTypesArray, elementTypesArray_Count;
@dynamic elementIdsArray, elementIdsArray_Count;
@dynamic nodeIndicesArray, nodeIndicesArray_Count;
@dynamic elementCentersArray, elementCentersArray_Count;
@dynamic elementMeasuresArray, elementMeasuresArray_Count;

typedef struct Elements__storage_ {
  uint32_t _has_storage_[1];
  GPBUInt32Array *elementIndicesArray;
  GPBUInt32Array *elementTypesArray;
  GPBInt32Array *elementIdsArray;
  GPBUInt32Array *nodeIndicesArray;
  GPBDoubleArray *elementCentersArray;
  GPBDoubleArray *elementMeasuresArray;
} Elements__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 = "elementIndicesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_ElementIndicesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, elementIndicesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "elementTypesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_ElementTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, elementTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "elementIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_ElementIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, elementIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "nodeIndicesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_NodeIndicesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, nodeIndicesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "elementCentersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_ElementCentersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, elementCentersArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "elementMeasuresArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Elements_FieldNumber_ElementMeasuresArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Elements__storage_, elementMeasuresArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Elements class]
                                     rootClass:[VectorRoot class]
                                          file:VectorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Elements__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)
