// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: concept.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 "Concept.pbobjc.h"
#import "Vector.pbobjc.h"
#import "Spatial.pbobjc.h"
#import "Meta.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(Command);
GPBObjCClassDeclaration(Coupling);
GPBObjCClassDeclaration(File);
GPBObjCClassDeclaration(Function);
GPBObjCClassDeclaration(Meta);
GPBObjCClassDeclaration(Model);
GPBObjCClassDeclaration(Record64);
GPBObjCClassDeclaration(Representation);
GPBObjCClassDeclaration(Rule);
GPBObjCClassDeclaration(Script);
GPBObjCClassDeclaration(SparseMatrix);
GPBObjCClassDeclaration(Variables);
GPBObjCClassDeclaration(Vector64);
GPBObjCClassDeclaration(Zone);

#pragma mark - ConceptRoot

@implementation ConceptRoot

// No extensions in the file and none of the imports (direct or indirect)
// defined extensions, so no need to generate +extensionRegistry.

@end

#pragma mark - ConceptRoot_FileDescriptor

static GPBFileDescriptor *ConceptRoot_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 - Variables

@implementation Variables

@dynamic intNamesArray, intNamesArray_Count;
@dynamic intValuesArray, intValuesArray_Count;
@dynamic intDescriptionsArray, intDescriptionsArray_Count;
@dynamic boolNamesArray, boolNamesArray_Count;
@dynamic boolValuesArray, boolValuesArray_Count;
@dynamic boolDescriptionsArray, boolDescriptionsArray_Count;
@dynamic doubleNamesArray, doubleNamesArray_Count;
@dynamic doubleValuesArray, doubleValuesArray_Count;
@dynamic doubleDescriptionsArray, doubleDescriptionsArray_Count;
@dynamic stringNamesArray, stringNamesArray_Count;
@dynamic stringValuesArray, stringValuesArray_Count;
@dynamic stringDescriptionsArray, stringDescriptionsArray_Count;

typedef struct Variables__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *intNamesArray;
  GPBInt32Array *intValuesArray;
  NSMutableArray *intDescriptionsArray;
  NSMutableArray *boolNamesArray;
  GPBBoolArray *boolValuesArray;
  NSMutableArray *boolDescriptionsArray;
  NSMutableArray *doubleNamesArray;
  GPBDoubleArray *doubleValuesArray;
  NSMutableArray *doubleDescriptionsArray;
  NSMutableArray *stringNamesArray;
  NSMutableArray *stringValuesArray;
  NSMutableArray *stringDescriptionsArray;
} Variables__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 = "intNamesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_IntNamesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, intNamesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "intValuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_IntValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, intValuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "intDescriptionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_IntDescriptionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, intDescriptionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "boolNamesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_BoolNamesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, boolNamesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "boolValuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_BoolValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, boolValuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "boolDescriptionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_BoolDescriptionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, boolDescriptionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "doubleNamesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_DoubleNamesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, doubleNamesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "doubleValuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_DoubleValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, doubleValuesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "doubleDescriptionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_DoubleDescriptionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, doubleDescriptionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "stringNamesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_StringNamesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, stringNamesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "stringValuesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_StringValuesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, stringValuesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "stringDescriptionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Variables_FieldNumber_StringDescriptionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Variables__storage_, stringDescriptionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Variables class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Variables__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 - Function

@implementation Function

@dynamic name;
@dynamic argumentTypesArray, argumentTypesArray_Count;
@dynamic argumentDescriptionsArray, argumentDescriptionsArray_Count;
@dynamic inputsArray, inputsArray_Count;
@dynamic outputsArray, outputsArray_Count;
@dynamic constantsArray, constantsArray_Count;
@dynamic toBeDefinedArray, toBeDefinedArray_Count;
@dynamic dataArray, dataArray_Count;
@dynamic cpuCapable;
@dynamic gpuCapable;
@dynamic includeAsPreprocessor;
@dynamic omitFromMainLoop;
@dynamic includeAsPostprocessor;
@dynamic mutuallyExclusive;
@dynamic onlyOnce;
@dynamic pushFront;
@dynamic dontFlatten;

typedef struct Function__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSMutableArray *argumentTypesArray;
  NSMutableArray *argumentDescriptionsArray;
  NSMutableArray *inputsArray;
  NSMutableArray *outputsArray;
  NSMutableArray *constantsArray;
  NSMutableArray *toBeDefinedArray;
  NSMutableArray *dataArray;
} Function__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 = Function_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Function__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "argumentTypesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_ArgumentTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, argumentTypesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "argumentDescriptionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_ArgumentDescriptionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, argumentDescriptionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "inputsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_InputsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, inputsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "outputsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_OutputsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, outputsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "constantsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_ConstantsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, constantsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "toBeDefinedArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_ToBeDefinedArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, toBeDefinedArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "dataArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Vector64),
        .number = Function_FieldNumber_DataArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Function__storage_, dataArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cpuCapable",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_CpuCapable,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "gpuCapable",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_GpuCapable,
        .hasIndex = 3,
        .offset = 4,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "includeAsPreprocessor",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_IncludeAsPreprocessor,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "omitFromMainLoop",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_OmitFromMainLoop,
        .hasIndex = 7,
        .offset = 8,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "includeAsPostprocessor",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_IncludeAsPostprocessor,
        .hasIndex = 9,
        .offset = 10,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "mutuallyExclusive",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_MutuallyExclusive,
        .hasIndex = 11,
        .offset = 12,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "onlyOnce",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_OnlyOnce,
        .hasIndex = 13,
        .offset = 14,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "pushFront",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_PushFront,
        .hasIndex = 15,
        .offset = 16,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "dontFlatten",
        .dataTypeSpecific.clazz = Nil,
        .number = Function_FieldNumber_DontFlatten,
        .hasIndex = 17,
        .offset = 18,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Function class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Function__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 - Command

@implementation Command

@dynamic hasFunction, function;
@dynamic argsAreSet;
@dynamic isReady;
@dynamic execCount;
@dynamic simdSize;
@dynamic version;
@dynamic id_p;
@dynamic nKernel;
@dynamic progress;
@dynamic msg;
@dynamic hasData_p, data_p;
@dynamic beforeArray, beforeArray_Count;
@dynamic afterArray, afterArray_Count;
@dynamic regionType;
@dynamic regionId;

typedef struct Command__storage_ {
  uint32_t _has_storage_[1];
  float progress;
  uint32_t regionType;
  int32_t regionId;
  Function *function;
  NSString *msg;
  Record64 *data_p;
  NSMutableArray *beforeArray;
  NSMutableArray *afterArray;
  uint64_t execCount;
  uint64_t simdSize;
  uint64_t version;
  int64_t id_p;
  uint64_t nKernel;
} Command__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 = "function",
        .dataTypeSpecific.clazz = GPBObjCClass(Function),
        .number = Command_FieldNumber_Function,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Command__storage_, function),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "argsAreSet",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_ArgsAreSet,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isReady",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_IsReady,
        .hasIndex = 3,
        .offset = 4,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "execCount",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_ExecCount,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Command__storage_, execCount),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "simdSize",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_SimdSize,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Command__storage_, simdSize),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "version",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_Version,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Command__storage_, version),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_Id_p,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(Command__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "nKernel",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_NKernel,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(Command__storage_, nKernel),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "progress",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_Progress,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(Command__storage_, progress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "msg",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_Msg,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(Command__storage_, msg),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(Record64),
        .number = Command_FieldNumber_Data_p,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(Command__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beforeArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Command),
        .number = Command_FieldNumber_BeforeArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Command__storage_, beforeArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "afterArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Command),
        .number = Command_FieldNumber_AfterArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Command__storage_, afterArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "regionType",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_RegionType,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(Command__storage_, regionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "regionId",
        .dataTypeSpecific.clazz = Nil,
        .number = Command_FieldNumber_RegionId,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(Command__storage_, regionId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Command class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Command__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 - Script

@implementation Script

@dynamic name;
@dynamic msg;
@dynamic sourceCode;
@dynamic uid;
@dynamic device;
@dynamic status;
@dynamic order;
@dynamic progress;
@dynamic hasVariables, variables;
@dynamic sequenceArray, sequenceArray_Count;
@dynamic hasBefore, before;
@dynamic hasAfter, after;

typedef struct Script__storage_ {
  uint32_t _has_storage_[1];
  uint32_t device;
  uint32_t status;
  uint32_t order;
  float progress;
  NSString *name;
  NSString *msg;
  NSString *sourceCode;
  Variables *variables;
  NSMutableArray *sequenceArray;
  Script *before;
  Script *after;
  int64_t uid;
} Script__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 = Script_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Script__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "msg",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Msg,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Script__storage_, msg),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "sourceCode",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_SourceCode,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Script__storage_, sourceCode),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Uid,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(Script__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "device",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Device,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(Script__storage_, device),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "status",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Status,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Script__storage_, status),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "order",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Order,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Script__storage_, order),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "progress",
        .dataTypeSpecific.clazz = Nil,
        .number = Script_FieldNumber_Progress,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Script__storage_, progress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "variables",
        .dataTypeSpecific.clazz = GPBObjCClass(Variables),
        .number = Script_FieldNumber_Variables,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(Script__storage_, variables),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "sequenceArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Command),
        .number = Script_FieldNumber_SequenceArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Script__storage_, sequenceArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldTextFormatNameCustom),
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "before",
        .dataTypeSpecific.clazz = GPBObjCClass(Script),
        .number = Script_FieldNumber_Before,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(Script__storage_, before),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "after",
        .dataTypeSpecific.clazz = GPBObjCClass(Script),
        .number = Script_FieldNumber_After,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(Script__storage_, after),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Script class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Script__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\014\000Sequence\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Model

@implementation Model

@dynamic name;
@dynamic dofsArray, dofsArray_Count;
@dynamic algorithmsArray, algorithmsArray_Count;
@dynamic availableOutputsArray, availableOutputsArray_Count;
@dynamic extraPropertiesArray, extraPropertiesArray_Count;
@dynamic compatibleConditionsArray, compatibleConditionsArray_Count;
@dynamic subModelsArray, subModelsArray_Count;
@dynamic hasDefaultData, defaultData;
@dynamic rulesArray, rulesArray_Count;
@dynamic mutexStackArray, mutexStackArray_Count;
@dynamic hasMarkovMatrix, markovMatrix;

typedef struct Model__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSMutableArray *dofsArray;
  NSMutableArray *algorithmsArray;
  NSMutableArray *availableOutputsArray;
  NSMutableArray *extraPropertiesArray;
  NSMutableArray *compatibleConditionsArray;
  NSMutableArray *subModelsArray;
  Record64 *defaultData;
  NSMutableArray *rulesArray;
  NSMutableArray *mutexStackArray;
  SparseMatrix *markovMatrix;
} Model__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 = Model_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Model__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "dofsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Model_FieldNumber_DofsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, dofsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "algorithmsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Model_FieldNumber_AlgorithmsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, algorithmsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "availableOutputsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Model_FieldNumber_AvailableOutputsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, availableOutputsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "extraPropertiesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Model_FieldNumber_ExtraPropertiesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, extraPropertiesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "compatibleConditionsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Model_FieldNumber_CompatibleConditionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, compatibleConditionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "subModelsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Model),
        .number = Model_FieldNumber_SubModelsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, subModelsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "defaultData",
        .dataTypeSpecific.clazz = GPBObjCClass(Record64),
        .number = Model_FieldNumber_DefaultData,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Model__storage_, defaultData),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "rulesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Rule),
        .number = Model_FieldNumber_RulesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, rulesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mutexStackArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Rule),
        .number = Model_FieldNumber_MutexStackArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Model__storage_, mutexStackArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "markovMatrix",
        .dataTypeSpecific.clazz = GPBObjCClass(SparseMatrix),
        .number = Model_FieldNumber_MarkovMatrix,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Model__storage_, markovMatrix),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Model class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Model__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 - Coupling

@implementation Coupling

@dynamic sourceSystem;
@dynamic targetSystem;
@dynamic sourceUid;
@dynamic targetUid;
@dynamic hasSourceRegion, sourceRegion;
@dynamic hasTargetRegion, targetRegion;
@dynamic samplingMode;
@dynamic name;
@dynamic dofsArray, dofsArray_Count;
@dynamic hasRepresentation, representation;
@dynamic enabled;
@dynamic forward;
@dynamic reverse;

typedef struct Coupling__storage_ {
  uint32_t _has_storage_[1];
  uint32_t samplingMode;
  NSString *sourceSystem;
  NSString *targetSystem;
  Zone *sourceRegion;
  Zone *targetRegion;
  NSString *name;
  NSMutableArray *dofsArray;
  Representation *representation;
  int64_t sourceUid;
  int64_t targetUid;
} Coupling__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 = "sourceSystem",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_SourceSystem,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Coupling__storage_, sourceSystem),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "targetSystem",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_TargetSystem,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Coupling__storage_, targetSystem),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "sourceUid",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_SourceUid,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Coupling__storage_, sourceUid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "targetUid",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_TargetUid,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(Coupling__storage_, targetUid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "sourceRegion",
        .dataTypeSpecific.clazz = GPBObjCClass(Zone),
        .number = Coupling_FieldNumber_SourceRegion,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(Coupling__storage_, sourceRegion),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "targetRegion",
        .dataTypeSpecific.clazz = GPBObjCClass(Zone),
        .number = Coupling_FieldNumber_TargetRegion,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Coupling__storage_, targetRegion),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "samplingMode",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_SamplingMode,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Coupling__storage_, samplingMode),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_Name,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Coupling__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "dofsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_DofsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Coupling__storage_, dofsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "representation",
        .dataTypeSpecific.clazz = GPBObjCClass(Representation),
        .number = Coupling_FieldNumber_Representation,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(Coupling__storage_, representation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "enabled",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_Enabled,
        .hasIndex = 9,
        .offset = 10,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "forward",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_Forward,
        .hasIndex = 11,
        .offset = 12,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "reverse",
        .dataTypeSpecific.clazz = Nil,
        .number = Coupling_FieldNumber_Reverse,
        .hasIndex = 13,
        .offset = 14,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Coupling class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Coupling__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 - System

@implementation System

@dynamic hasMeta, meta;
@dynamic scriptArray, scriptArray_Count;
@dynamic localTransformArray, localTransformArray_Count;
@dynamic localRateArray, localRateArray_Count;
@dynamic localAccelArray, localAccelArray_Count;
@dynamic childrenArray, childrenArray_Count;
@dynamic referencedFilesArray, referencedFilesArray_Count;
@dynamic embeddedFilesArray, embeddedFilesArray_Count;
@dynamic notesArray, notesArray_Count;
@dynamic couplingsArray, couplingsArray_Count;
@dynamic modelsArray, modelsArray_Count;
@dynamic hasPhysicalConstants, physicalConstants;
@dynamic conditionsArray, conditionsArray_Count;

typedef struct System__storage_ {
  uint32_t _has_storage_[1];
  Meta *meta;
  NSMutableArray *scriptArray;
  GPBDoubleArray *localTransformArray;
  GPBDoubleArray *localRateArray;
  GPBDoubleArray *localAccelArray;
  NSMutableArray *childrenArray;
  NSMutableArray *referencedFilesArray;
  NSMutableArray *embeddedFilesArray;
  NSMutableArray *notesArray;
  NSMutableArray *couplingsArray;
  NSMutableArray *modelsArray;
  Record64 *physicalConstants;
  NSMutableArray *conditionsArray;
} System__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 = "meta",
        .dataTypeSpecific.clazz = GPBObjCClass(Meta),
        .number = System_FieldNumber_Meta,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(System__storage_, meta),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "scriptArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Script),
        .number = System_FieldNumber_ScriptArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, scriptArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "localTransformArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_LocalTransformArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, localTransformArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "localRateArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_LocalRateArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, localRateArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "localAccelArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_LocalAccelArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, localAccelArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "childrenArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_ChildrenArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, childrenArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "referencedFilesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_ReferencedFilesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, referencedFilesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "embeddedFilesArray",
        .dataTypeSpecific.clazz = GPBObjCClass(File),
        .number = System_FieldNumber_EmbeddedFilesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, embeddedFilesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "notesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = System_FieldNumber_NotesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, notesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "couplingsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Coupling),
        .number = System_FieldNumber_CouplingsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, couplingsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "modelsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Model),
        .number = System_FieldNumber_ModelsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, modelsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "physicalConstants",
        .dataTypeSpecific.clazz = GPBObjCClass(Record64),
        .number = System_FieldNumber_PhysicalConstants,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(System__storage_, physicalConstants),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "conditionsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Command),
        .number = System_FieldNumber_ConditionsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(System__storage_, conditionsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[System class]
                                     rootClass:[ConceptRoot class]
                                          file:ConceptRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(System__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)
