From ae13b7d61951b21b8e1037a4f5aaeae56b8b71bf Mon Sep 17 00:00:00 2001 From: J-P Nurmi Date: Wed, 26 Aug 2020 20:20:04 +0200 Subject: [PATCH] WIP: Just playing with ffigen Many structs end up empty, because dart:ffi does not yet support nested structs: https://github.com/dart-lang/sdk/issues/37271 ``` Running in Directory: '/home/jpnurmi/Projects/dart_assimp' [WARNING]: Prefer adding Key 'description' to your config. Input Headers: [/usr/include/assimp/cexport.h, /usr/include/assimp/cfileio.h, /usr/include/assimp/cimport.h, /usr/include/assimp/postprocess.h, /usr/include/assimp/scene.h, /usr/include/assimp/version.h] [WARNING]: Removed All Struct Members from aiRay(aiRay), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiExportDataBlob(aiExportDataBlob), Nested Structures not supported. [WARNING]: Skipped Function 'aiGetPredefinedLogStream', struct pass/return by value not supported. [WARNING]: Removed All Struct Members from aiTexture(aiTexture), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiAABB(aiAABB), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiBone(aiBone), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiAnimMesh(aiAnimMesh), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiMesh(aiMesh), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiLight(aiLight), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiCamera(aiCamera), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiUVTransform(aiUVTransform), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiMaterialProperty(aiMaterialProperty), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiVectorKey(aiVectorKey), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiQuatKey(aiQuatKey), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiNodeAnim(aiNodeAnim), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiMeshAnim(aiMeshAnim), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiMeshMorphAnim(aiMeshMorphAnim), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiAnimation(aiAnimation), Nested Structures not supported. [WARNING]: Removed All Struct Members from aiNode(aiNode), Nested Structures not supported. Finished, Bindings generated in /home/jpnurmi/Projects/dart_assimp/lib/src/bindings.dart ``` --- ffigen.yaml | 25 + lib/src/bindings.dart | 9568 +++++++++++++++++++++++++++++++++++++++- lib/src/libassimp.dart | 230 +- pubspec.yaml | 3 + 4 files changed, 9517 insertions(+), 309 deletions(-) create mode 100644 ffigen.yaml diff --git a/ffigen.yaml b/ffigen.yaml new file mode 100644 index 0000000..190ca4e --- /dev/null +++ b/ffigen.yaml @@ -0,0 +1,25 @@ +name: 'LibAssimp' +output: 'lib/src/bindings.dart' +headers: + entry-points: + - '/usr/include/assimp/cexport.h' + - '/usr/include/assimp/cfileio.h' + - '/usr/include/assimp/cimport.h' + - '/usr/include/assimp/postprocess.h' + - '/usr/include/assimp/scene.h' + - '/usr/include/assimp/version.h' +comments: false +functions: + include: + - 'ai.*' +structs: + include: + - 'ai.*' +enums: + include: + - 'ai.*' +macros: + include: + - 'AI.*' +array-workaround: true +unnamed-enums: false diff --git a/lib/src/bindings.dart b/lib/src/bindings.dart index e146005..82c1599 100644 --- a/lib/src/bindings.dart +++ b/lib/src/bindings.dart @@ -1,81 +1,9487 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2019, assimp team - - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -export 'bindings/ai_aabb.dart'; -export 'bindings/ai_animation.dart'; -export 'bindings/ai_anim_mesh.dart'; -export 'bindings/ai_bone.dart'; -export 'bindings/ai_camera.dart'; -export 'bindings/ai_color.dart'; -export 'bindings/ai_export.dart'; -export 'bindings/ai_export_data_blob.dart'; -export 'bindings/ai_export_format_desc.dart'; -export 'bindings/ai_face.dart'; -export 'bindings/ai_file.dart'; -export 'bindings/ai_file_io.dart'; -export 'bindings/ai_global.dart'; -export 'bindings/ai_import.dart'; -export 'bindings/ai_import_format_desc.dart'; -export 'bindings/ai_key.dart'; -export 'bindings/ai_light.dart'; -export 'bindings/ai_log_stream.dart'; -export 'bindings/ai_material.dart'; -export 'bindings/ai_material_property.dart'; -export 'bindings/ai_matrix.dart'; -export 'bindings/ai_memory_info.dart'; -export 'bindings/ai_mesh_anim.dart'; -export 'bindings/ai_mesh.dart'; -export 'bindings/ai_mesh_morph_anim.dart'; -export 'bindings/ai_metadata.dart'; -export 'bindings/ai_node_anim.dart'; -export 'bindings/ai_node.dart'; -export 'bindings/ai_post_processing.dart'; -export 'bindings/ai_property_store.dart'; -export 'bindings/ai_quaternion.dart'; -export 'bindings/ai_scene.dart'; -export 'bindings/ai_string.dart'; -export 'bindings/ai_texel.dart'; -export 'bindings/ai_texture.dart'; -export 'bindings/ai_uv_transform.dart'; -export 'bindings/ai_vector.dart'; -export 'bindings/ai_vertex_weight.dart'; +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +import 'dart:ffi' as ffi; + +class LibAssimp { + /// Holds the Dynamic library. + final ffi.DynamicLibrary _dylib; + + /// The symbols are looked up in [dynamicLibrary]. + LibAssimp(ffi.DynamicLibrary dynamicLibrary) : _dylib = dynamicLibrary; + + int aiGetExportFormatCount() { + _aiGetExportFormatCount ??= _dylib.lookupFunction<_c_aiGetExportFormatCount, + _dart_aiGetExportFormatCount>('aiGetExportFormatCount'); + return _aiGetExportFormatCount(); + } + + _dart_aiGetExportFormatCount _aiGetExportFormatCount; + + ffi.Pointer aiGetExportFormatDescription( + int pIndex, + ) { + _aiGetExportFormatDescription ??= _dylib.lookupFunction< + _c_aiGetExportFormatDescription, + _dart_aiGetExportFormatDescription>('aiGetExportFormatDescription'); + return _aiGetExportFormatDescription( + pIndex, + ); + } + + _dart_aiGetExportFormatDescription _aiGetExportFormatDescription; + + void aiReleaseExportFormatDescription( + ffi.Pointer desc, + ) { + _aiReleaseExportFormatDescription ??= _dylib.lookupFunction< + _c_aiReleaseExportFormatDescription, + _dart_aiReleaseExportFormatDescription>( + 'aiReleaseExportFormatDescription'); + return _aiReleaseExportFormatDescription( + desc, + ); + } + + _dart_aiReleaseExportFormatDescription _aiReleaseExportFormatDescription; + + void aiCopyScene( + ffi.Pointer pIn, + ffi.Pointer> pOut, + ) { + _aiCopyScene ??= + _dylib.lookupFunction<_c_aiCopyScene, _dart_aiCopyScene>('aiCopyScene'); + return _aiCopyScene( + pIn, + pOut, + ); + } + + _dart_aiCopyScene _aiCopyScene; + + void aiFreeScene( + ffi.Pointer pIn, + ) { + _aiFreeScene ??= + _dylib.lookupFunction<_c_aiFreeScene, _dart_aiFreeScene>('aiFreeScene'); + return _aiFreeScene( + pIn, + ); + } + + _dart_aiFreeScene _aiFreeScene; + + int aiExportScene( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + int pPreprocessing, + ) { + _aiExportScene ??= _dylib + .lookupFunction<_c_aiExportScene, _dart_aiExportScene>('aiExportScene'); + return _aiExportScene( + pScene, + pFormatId, + pFileName, + pPreprocessing, + ); + } + + _dart_aiExportScene _aiExportScene; + + int aiExportSceneEx( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + ffi.Pointer pIO, + int pPreprocessing, + ) { + _aiExportSceneEx ??= + _dylib.lookupFunction<_c_aiExportSceneEx, _dart_aiExportSceneEx>( + 'aiExportSceneEx'); + return _aiExportSceneEx( + pScene, + pFormatId, + pFileName, + pIO, + pPreprocessing, + ); + } + + _dart_aiExportSceneEx _aiExportSceneEx; + + ffi.Pointer aiExportSceneToBlob( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + int pPreprocessing, + ) { + _aiExportSceneToBlob ??= _dylib.lookupFunction<_c_aiExportSceneToBlob, + _dart_aiExportSceneToBlob>('aiExportSceneToBlob'); + return _aiExportSceneToBlob( + pScene, + pFormatId, + pPreprocessing, + ); + } + + _dart_aiExportSceneToBlob _aiExportSceneToBlob; + + void aiReleaseExportBlob( + ffi.Pointer pData, + ) { + _aiReleaseExportBlob ??= _dylib.lookupFunction<_c_aiReleaseExportBlob, + _dart_aiReleaseExportBlob>('aiReleaseExportBlob'); + return _aiReleaseExportBlob( + pData, + ); + } + + _dart_aiReleaseExportBlob _aiReleaseExportBlob; + + ffi.Pointer aiGetImporterDesc( + ffi.Pointer extension_1, + ) { + _aiGetImporterDesc ??= + _dylib.lookupFunction<_c_aiGetImporterDesc, _dart_aiGetImporterDesc>( + 'aiGetImporterDesc'); + return _aiGetImporterDesc( + extension_1, + ); + } + + _dart_aiGetImporterDesc _aiGetImporterDesc; + + ffi.Pointer aiImportFile( + ffi.Pointer pFile, + int pFlags, + ) { + _aiImportFile ??= _dylib + .lookupFunction<_c_aiImportFile, _dart_aiImportFile>('aiImportFile'); + return _aiImportFile( + pFile, + pFlags, + ); + } + + _dart_aiImportFile _aiImportFile; + + ffi.Pointer aiImportFileEx( + ffi.Pointer pFile, + int pFlags, + ffi.Pointer pFS, + ) { + _aiImportFileEx ??= + _dylib.lookupFunction<_c_aiImportFileEx, _dart_aiImportFileEx>( + 'aiImportFileEx'); + return _aiImportFileEx( + pFile, + pFlags, + pFS, + ); + } + + _dart_aiImportFileEx _aiImportFileEx; + + ffi.Pointer aiImportFileExWithProperties( + ffi.Pointer pFile, + int pFlags, + ffi.Pointer pFS, + ffi.Pointer pProps, + ) { + _aiImportFileExWithProperties ??= _dylib.lookupFunction< + _c_aiImportFileExWithProperties, + _dart_aiImportFileExWithProperties>('aiImportFileExWithProperties'); + return _aiImportFileExWithProperties( + pFile, + pFlags, + pFS, + pProps, + ); + } + + _dart_aiImportFileExWithProperties _aiImportFileExWithProperties; + + ffi.Pointer aiImportFileFromMemory( + ffi.Pointer pBuffer, + int pLength, + int pFlags, + ffi.Pointer pHint, + ) { + _aiImportFileFromMemory ??= _dylib.lookupFunction<_c_aiImportFileFromMemory, + _dart_aiImportFileFromMemory>('aiImportFileFromMemory'); + return _aiImportFileFromMemory( + pBuffer, + pLength, + pFlags, + pHint, + ); + } + + _dart_aiImportFileFromMemory _aiImportFileFromMemory; + + ffi.Pointer aiImportFileFromMemoryWithProperties( + ffi.Pointer pBuffer, + int pLength, + int pFlags, + ffi.Pointer pHint, + ffi.Pointer pProps, + ) { + _aiImportFileFromMemoryWithProperties ??= _dylib.lookupFunction< + _c_aiImportFileFromMemoryWithProperties, + _dart_aiImportFileFromMemoryWithProperties>( + 'aiImportFileFromMemoryWithProperties'); + return _aiImportFileFromMemoryWithProperties( + pBuffer, + pLength, + pFlags, + pHint, + pProps, + ); + } + + _dart_aiImportFileFromMemoryWithProperties + _aiImportFileFromMemoryWithProperties; + + ffi.Pointer aiApplyPostProcessing( + ffi.Pointer pScene, + int pFlags, + ) { + _aiApplyPostProcessing ??= _dylib.lookupFunction<_c_aiApplyPostProcessing, + _dart_aiApplyPostProcessing>('aiApplyPostProcessing'); + return _aiApplyPostProcessing( + pScene, + pFlags, + ); + } + + _dart_aiApplyPostProcessing _aiApplyPostProcessing; + + void aiAttachLogStream( + ffi.Pointer stream, + ) { + _aiAttachLogStream ??= + _dylib.lookupFunction<_c_aiAttachLogStream, _dart_aiAttachLogStream>( + 'aiAttachLogStream'); + return _aiAttachLogStream( + stream, + ); + } + + _dart_aiAttachLogStream _aiAttachLogStream; + + void aiEnableVerboseLogging( + int d, + ) { + _aiEnableVerboseLogging ??= _dylib.lookupFunction<_c_aiEnableVerboseLogging, + _dart_aiEnableVerboseLogging>('aiEnableVerboseLogging'); + return _aiEnableVerboseLogging( + d, + ); + } + + _dart_aiEnableVerboseLogging _aiEnableVerboseLogging; + + int aiDetachLogStream( + ffi.Pointer stream, + ) { + _aiDetachLogStream ??= + _dylib.lookupFunction<_c_aiDetachLogStream, _dart_aiDetachLogStream>( + 'aiDetachLogStream'); + return _aiDetachLogStream( + stream, + ); + } + + _dart_aiDetachLogStream _aiDetachLogStream; + + void aiDetachAllLogStreams() { + _aiDetachAllLogStreams ??= _dylib.lookupFunction<_c_aiDetachAllLogStreams, + _dart_aiDetachAllLogStreams>('aiDetachAllLogStreams'); + return _aiDetachAllLogStreams(); + } + + _dart_aiDetachAllLogStreams _aiDetachAllLogStreams; + + void aiReleaseImport( + ffi.Pointer pScene, + ) { + _aiReleaseImport ??= + _dylib.lookupFunction<_c_aiReleaseImport, _dart_aiReleaseImport>( + 'aiReleaseImport'); + return _aiReleaseImport( + pScene, + ); + } + + _dart_aiReleaseImport _aiReleaseImport; + + ffi.Pointer aiGetErrorString() { + _aiGetErrorString ??= + _dylib.lookupFunction<_c_aiGetErrorString, _dart_aiGetErrorString>( + 'aiGetErrorString'); + return _aiGetErrorString(); + } + + _dart_aiGetErrorString _aiGetErrorString; + + int aiIsExtensionSupported( + ffi.Pointer szExtension, + ) { + _aiIsExtensionSupported ??= _dylib.lookupFunction<_c_aiIsExtensionSupported, + _dart_aiIsExtensionSupported>('aiIsExtensionSupported'); + return _aiIsExtensionSupported( + szExtension, + ); + } + + _dart_aiIsExtensionSupported _aiIsExtensionSupported; + + void aiGetExtensionList( + ffi.Pointer szOut, + ) { + _aiGetExtensionList ??= + _dylib.lookupFunction<_c_aiGetExtensionList, _dart_aiGetExtensionList>( + 'aiGetExtensionList'); + return _aiGetExtensionList( + szOut, + ); + } + + _dart_aiGetExtensionList _aiGetExtensionList; + + void aiGetMemoryRequirements( + ffi.Pointer pIn, + ffi.Pointer in_1, + ) { + _aiGetMemoryRequirements ??= _dylib.lookupFunction< + _c_aiGetMemoryRequirements, + _dart_aiGetMemoryRequirements>('aiGetMemoryRequirements'); + return _aiGetMemoryRequirements( + pIn, + in_1, + ); + } + + _dart_aiGetMemoryRequirements _aiGetMemoryRequirements; + + ffi.Pointer aiCreatePropertyStore() { + _aiCreatePropertyStore ??= _dylib.lookupFunction<_c_aiCreatePropertyStore, + _dart_aiCreatePropertyStore>('aiCreatePropertyStore'); + return _aiCreatePropertyStore(); + } + + _dart_aiCreatePropertyStore _aiCreatePropertyStore; + + void aiReleasePropertyStore( + ffi.Pointer p, + ) { + _aiReleasePropertyStore ??= _dylib.lookupFunction<_c_aiReleasePropertyStore, + _dart_aiReleasePropertyStore>('aiReleasePropertyStore'); + return _aiReleasePropertyStore( + p, + ); + } + + _dart_aiReleasePropertyStore _aiReleasePropertyStore; + + void aiSetImportPropertyInteger( + ffi.Pointer store, + ffi.Pointer szName, + int value, + ) { + _aiSetImportPropertyInteger ??= _dylib.lookupFunction< + _c_aiSetImportPropertyInteger, + _dart_aiSetImportPropertyInteger>('aiSetImportPropertyInteger'); + return _aiSetImportPropertyInteger( + store, + szName, + value, + ); + } + + _dart_aiSetImportPropertyInteger _aiSetImportPropertyInteger; + + void aiSetImportPropertyFloat( + ffi.Pointer store, + ffi.Pointer szName, + double value, + ) { + _aiSetImportPropertyFloat ??= _dylib.lookupFunction< + _c_aiSetImportPropertyFloat, + _dart_aiSetImportPropertyFloat>('aiSetImportPropertyFloat'); + return _aiSetImportPropertyFloat( + store, + szName, + value, + ); + } + + _dart_aiSetImportPropertyFloat _aiSetImportPropertyFloat; + + void aiSetImportPropertyString( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer st, + ) { + _aiSetImportPropertyString ??= _dylib.lookupFunction< + _c_aiSetImportPropertyString, + _dart_aiSetImportPropertyString>('aiSetImportPropertyString'); + return _aiSetImportPropertyString( + store, + szName, + st, + ); + } + + _dart_aiSetImportPropertyString _aiSetImportPropertyString; + + void aiSetImportPropertyMatrix( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer mat, + ) { + _aiSetImportPropertyMatrix ??= _dylib.lookupFunction< + _c_aiSetImportPropertyMatrix, + _dart_aiSetImportPropertyMatrix>('aiSetImportPropertyMatrix'); + return _aiSetImportPropertyMatrix( + store, + szName, + mat, + ); + } + + _dart_aiSetImportPropertyMatrix _aiSetImportPropertyMatrix; + + void aiCreateQuaternionFromMatrix( + ffi.Pointer quat, + ffi.Pointer mat, + ) { + _aiCreateQuaternionFromMatrix ??= _dylib.lookupFunction< + _c_aiCreateQuaternionFromMatrix, + _dart_aiCreateQuaternionFromMatrix>('aiCreateQuaternionFromMatrix'); + return _aiCreateQuaternionFromMatrix( + quat, + mat, + ); + } + + _dart_aiCreateQuaternionFromMatrix _aiCreateQuaternionFromMatrix; + + void aiDecomposeMatrix( + ffi.Pointer mat, + ffi.Pointer scaling, + ffi.Pointer rotation, + ffi.Pointer position, + ) { + _aiDecomposeMatrix ??= + _dylib.lookupFunction<_c_aiDecomposeMatrix, _dart_aiDecomposeMatrix>( + 'aiDecomposeMatrix'); + return _aiDecomposeMatrix( + mat, + scaling, + rotation, + position, + ); + } + + _dart_aiDecomposeMatrix _aiDecomposeMatrix; + + void aiTransposeMatrix4( + ffi.Pointer mat, + ) { + _aiTransposeMatrix4 ??= + _dylib.lookupFunction<_c_aiTransposeMatrix4, _dart_aiTransposeMatrix4>( + 'aiTransposeMatrix4'); + return _aiTransposeMatrix4( + mat, + ); + } + + _dart_aiTransposeMatrix4 _aiTransposeMatrix4; + + void aiTransposeMatrix3( + ffi.Pointer mat, + ) { + _aiTransposeMatrix3 ??= + _dylib.lookupFunction<_c_aiTransposeMatrix3, _dart_aiTransposeMatrix3>( + 'aiTransposeMatrix3'); + return _aiTransposeMatrix3( + mat, + ); + } + + _dart_aiTransposeMatrix3 _aiTransposeMatrix3; + + void aiTransformVecByMatrix3( + ffi.Pointer vec, + ffi.Pointer mat, + ) { + _aiTransformVecByMatrix3 ??= _dylib.lookupFunction< + _c_aiTransformVecByMatrix3, + _dart_aiTransformVecByMatrix3>('aiTransformVecByMatrix3'); + return _aiTransformVecByMatrix3( + vec, + mat, + ); + } + + _dart_aiTransformVecByMatrix3 _aiTransformVecByMatrix3; + + void aiTransformVecByMatrix4( + ffi.Pointer vec, + ffi.Pointer mat, + ) { + _aiTransformVecByMatrix4 ??= _dylib.lookupFunction< + _c_aiTransformVecByMatrix4, + _dart_aiTransformVecByMatrix4>('aiTransformVecByMatrix4'); + return _aiTransformVecByMatrix4( + vec, + mat, + ); + } + + _dart_aiTransformVecByMatrix4 _aiTransformVecByMatrix4; + + void aiMultiplyMatrix4( + ffi.Pointer dst, + ffi.Pointer src, + ) { + _aiMultiplyMatrix4 ??= + _dylib.lookupFunction<_c_aiMultiplyMatrix4, _dart_aiMultiplyMatrix4>( + 'aiMultiplyMatrix4'); + return _aiMultiplyMatrix4( + dst, + src, + ); + } + + _dart_aiMultiplyMatrix4 _aiMultiplyMatrix4; + + void aiMultiplyMatrix3( + ffi.Pointer dst, + ffi.Pointer src, + ) { + _aiMultiplyMatrix3 ??= + _dylib.lookupFunction<_c_aiMultiplyMatrix3, _dart_aiMultiplyMatrix3>( + 'aiMultiplyMatrix3'); + return _aiMultiplyMatrix3( + dst, + src, + ); + } + + _dart_aiMultiplyMatrix3 _aiMultiplyMatrix3; + + void aiIdentityMatrix3( + ffi.Pointer mat, + ) { + _aiIdentityMatrix3 ??= + _dylib.lookupFunction<_c_aiIdentityMatrix3, _dart_aiIdentityMatrix3>( + 'aiIdentityMatrix3'); + return _aiIdentityMatrix3( + mat, + ); + } + + _dart_aiIdentityMatrix3 _aiIdentityMatrix3; + + void aiIdentityMatrix4( + ffi.Pointer mat, + ) { + _aiIdentityMatrix4 ??= + _dylib.lookupFunction<_c_aiIdentityMatrix4, _dart_aiIdentityMatrix4>( + 'aiIdentityMatrix4'); + return _aiIdentityMatrix4( + mat, + ); + } + + _dart_aiIdentityMatrix4 _aiIdentityMatrix4; + + int aiGetImportFormatCount() { + _aiGetImportFormatCount ??= _dylib.lookupFunction<_c_aiGetImportFormatCount, + _dart_aiGetImportFormatCount>('aiGetImportFormatCount'); + return _aiGetImportFormatCount(); + } + + _dart_aiGetImportFormatCount _aiGetImportFormatCount; + + ffi.Pointer aiGetImportFormatDescription( + int pIndex, + ) { + _aiGetImportFormatDescription ??= _dylib.lookupFunction< + _c_aiGetImportFormatDescription, + _dart_aiGetImportFormatDescription>('aiGetImportFormatDescription'); + return _aiGetImportFormatDescription( + pIndex, + ); + } + + _dart_aiGetImportFormatDescription _aiGetImportFormatDescription; + + int aiGetMaterialProperty( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer> pPropOut, + ) { + _aiGetMaterialProperty ??= _dylib.lookupFunction<_c_aiGetMaterialProperty, + _dart_aiGetMaterialProperty>('aiGetMaterialProperty'); + return _aiGetMaterialProperty( + pMat, + pKey, + type, + index, + pPropOut, + ); + } + + _dart_aiGetMaterialProperty _aiGetMaterialProperty; + + int aiGetMaterialFloatArray( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ffi.Pointer pMax, + ) { + _aiGetMaterialFloatArray ??= _dylib.lookupFunction< + _c_aiGetMaterialFloatArray, + _dart_aiGetMaterialFloatArray>('aiGetMaterialFloatArray'); + return _aiGetMaterialFloatArray( + pMat, + pKey, + type, + index, + pOut, + pMax, + ); + } + + _dart_aiGetMaterialFloatArray _aiGetMaterialFloatArray; + + int aiGetMaterialIntegerArray( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ffi.Pointer pMax, + ) { + _aiGetMaterialIntegerArray ??= _dylib.lookupFunction< + _c_aiGetMaterialIntegerArray, + _dart_aiGetMaterialIntegerArray>('aiGetMaterialIntegerArray'); + return _aiGetMaterialIntegerArray( + pMat, + pKey, + type, + index, + pOut, + pMax, + ); + } + + _dart_aiGetMaterialIntegerArray _aiGetMaterialIntegerArray; + + int aiGetMaterialColor( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ) { + _aiGetMaterialColor ??= + _dylib.lookupFunction<_c_aiGetMaterialColor, _dart_aiGetMaterialColor>( + 'aiGetMaterialColor'); + return _aiGetMaterialColor( + pMat, + pKey, + type, + index, + pOut, + ); + } + + _dart_aiGetMaterialColor _aiGetMaterialColor; + + int aiGetMaterialUVTransform( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ) { + _aiGetMaterialUVTransform ??= _dylib.lookupFunction< + _c_aiGetMaterialUVTransform, + _dart_aiGetMaterialUVTransform>('aiGetMaterialUVTransform'); + return _aiGetMaterialUVTransform( + pMat, + pKey, + type, + index, + pOut, + ); + } + + _dart_aiGetMaterialUVTransform _aiGetMaterialUVTransform; + + int aiGetMaterialString( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ) { + _aiGetMaterialString ??= _dylib.lookupFunction<_c_aiGetMaterialString, + _dart_aiGetMaterialString>('aiGetMaterialString'); + return _aiGetMaterialString( + pMat, + pKey, + type, + index, + pOut, + ); + } + + _dart_aiGetMaterialString _aiGetMaterialString; + + int aiGetMaterialTextureCount( + ffi.Pointer pMat, + int type, + ) { + _aiGetMaterialTextureCount ??= _dylib.lookupFunction< + _c_aiGetMaterialTextureCount, + _dart_aiGetMaterialTextureCount>('aiGetMaterialTextureCount'); + return _aiGetMaterialTextureCount( + pMat, + type, + ); + } + + _dart_aiGetMaterialTextureCount _aiGetMaterialTextureCount; + + int aiGetMaterialTexture( + ffi.Pointer mat, + int type, + int index, + ffi.Pointer path, + ffi.Pointer mapping, + ffi.Pointer uvindex, + ffi.Pointer blend, + ffi.Pointer op, + ffi.Pointer mapmode, + ffi.Pointer flags, + ) { + _aiGetMaterialTexture ??= _dylib.lookupFunction<_c_aiGetMaterialTexture, + _dart_aiGetMaterialTexture>('aiGetMaterialTexture'); + return _aiGetMaterialTexture( + mat, + type, + index, + path, + mapping, + uvindex, + blend, + op, + mapmode, + flags, + ); + } + + _dart_aiGetMaterialTexture _aiGetMaterialTexture; + + ffi.Pointer aiGetLegalString() { + _aiGetLegalString ??= + _dylib.lookupFunction<_c_aiGetLegalString, _dart_aiGetLegalString>( + 'aiGetLegalString'); + return _aiGetLegalString(); + } + + _dart_aiGetLegalString _aiGetLegalString; + + int aiGetVersionMinor() { + _aiGetVersionMinor ??= + _dylib.lookupFunction<_c_aiGetVersionMinor, _dart_aiGetVersionMinor>( + 'aiGetVersionMinor'); + return _aiGetVersionMinor(); + } + + _dart_aiGetVersionMinor _aiGetVersionMinor; + + int aiGetVersionMajor() { + _aiGetVersionMajor ??= + _dylib.lookupFunction<_c_aiGetVersionMajor, _dart_aiGetVersionMajor>( + 'aiGetVersionMajor'); + return _aiGetVersionMajor(); + } + + _dart_aiGetVersionMajor _aiGetVersionMajor; + + int aiGetVersionRevision() { + _aiGetVersionRevision ??= _dylib.lookupFunction<_c_aiGetVersionRevision, + _dart_aiGetVersionRevision>('aiGetVersionRevision'); + return _aiGetVersionRevision(); + } + + _dart_aiGetVersionRevision _aiGetVersionRevision; + + ffi.Pointer aiGetBranchName() { + _aiGetBranchName ??= + _dylib.lookupFunction<_c_aiGetBranchName, _dart_aiGetBranchName>( + 'aiGetBranchName'); + return _aiGetBranchName(); + } + + _dart_aiGetBranchName _aiGetBranchName; + + int aiGetCompileFlags() { + _aiGetCompileFlags ??= + _dylib.lookupFunction<_c_aiGetCompileFlags, _dart_aiGetCompileFlags>( + 'aiGetCompileFlags'); + return _aiGetCompileFlags(); + } + + _dart_aiGetCompileFlags _aiGetCompileFlags; +} + +abstract class aiComponent { + static const int aiComponent_NORMALS = 2; + static const int aiComponent_TANGENTS_AND_BITANGENTS = 4; + static const int aiComponent_COLORS = 8; + static const int aiComponent_TEXCOORDS = 16; + static const int aiComponent_BONEWEIGHTS = 32; + static const int aiComponent_ANIMATIONS = 64; + static const int aiComponent_TEXTURES = 128; + static const int aiComponent_LIGHTS = 256; + static const int aiComponent_CAMERAS = 512; + static const int aiComponent_MESHES = 1024; + static const int aiComponent_MATERIALS = 2048; + static const int _aiComponent_Force32Bit = -1610612737; +} + +class aiVector3D extends ffi.Struct { + @ffi.Float() + double x; + + @ffi.Float() + double y; + + @ffi.Float() + double z; +} + +class aiVector2D extends ffi.Struct { + @ffi.Float() + double x; + + @ffi.Float() + double y; +} + +class aiColor4D extends ffi.Struct { + @ffi.Float() + double r; + + @ffi.Float() + double g; + + @ffi.Float() + double b; + + @ffi.Float() + double a; +} + +class aiMatrix3x3 extends ffi.Struct { + @ffi.Float() + double a1; + + @ffi.Float() + double a2; + + @ffi.Float() + double a3; + + @ffi.Float() + double b1; + + @ffi.Float() + double b2; + + @ffi.Float() + double b3; + + @ffi.Float() + double c1; + + @ffi.Float() + double c2; + + @ffi.Float() + double c3; +} + +class aiMatrix4x4 extends ffi.Struct { + @ffi.Float() + double a1; + + @ffi.Float() + double a2; + + @ffi.Float() + double a3; + + @ffi.Float() + double a4; + + @ffi.Float() + double b1; + + @ffi.Float() + double b2; + + @ffi.Float() + double b3; + + @ffi.Float() + double b4; + + @ffi.Float() + double c1; + + @ffi.Float() + double c2; + + @ffi.Float() + double c3; + + @ffi.Float() + double c4; + + @ffi.Float() + double d1; + + @ffi.Float() + double d2; + + @ffi.Float() + double d3; + + @ffi.Float() + double d4; +} + +class aiQuaternion extends ffi.Struct { + @ffi.Float() + double w; + + @ffi.Float() + double x; + + @ffi.Float() + double y; + + @ffi.Float() + double z; +} + +class aiPlane extends ffi.Struct { + @ffi.Float() + double a; + + @ffi.Float() + double b; + + @ffi.Float() + double c; + + @ffi.Float() + double d; +} + +class aiRay extends ffi.Struct {} + +class aiColor3D extends ffi.Struct { + @ffi.Float() + double r; + + @ffi.Float() + double g; + + @ffi.Float() + double b; +} + +class aiString extends ffi.Struct { + @ffi.Uint32() + int length; + + @ffi.Int8() + int _unique_data_item_0; + @ffi.Int8() + int _unique_data_item_1; + @ffi.Int8() + int _unique_data_item_2; + @ffi.Int8() + int _unique_data_item_3; + @ffi.Int8() + int _unique_data_item_4; + @ffi.Int8() + int _unique_data_item_5; + @ffi.Int8() + int _unique_data_item_6; + @ffi.Int8() + int _unique_data_item_7; + @ffi.Int8() + int _unique_data_item_8; + @ffi.Int8() + int _unique_data_item_9; + @ffi.Int8() + int _unique_data_item_10; + @ffi.Int8() + int _unique_data_item_11; + @ffi.Int8() + int _unique_data_item_12; + @ffi.Int8() + int _unique_data_item_13; + @ffi.Int8() + int _unique_data_item_14; + @ffi.Int8() + int _unique_data_item_15; + @ffi.Int8() + int _unique_data_item_16; + @ffi.Int8() + int _unique_data_item_17; + @ffi.Int8() + int _unique_data_item_18; + @ffi.Int8() + int _unique_data_item_19; + @ffi.Int8() + int _unique_data_item_20; + @ffi.Int8() + int _unique_data_item_21; + @ffi.Int8() + int _unique_data_item_22; + @ffi.Int8() + int _unique_data_item_23; + @ffi.Int8() + int _unique_data_item_24; + @ffi.Int8() + int _unique_data_item_25; + @ffi.Int8() + int _unique_data_item_26; + @ffi.Int8() + int _unique_data_item_27; + @ffi.Int8() + int _unique_data_item_28; + @ffi.Int8() + int _unique_data_item_29; + @ffi.Int8() + int _unique_data_item_30; + @ffi.Int8() + int _unique_data_item_31; + @ffi.Int8() + int _unique_data_item_32; + @ffi.Int8() + int _unique_data_item_33; + @ffi.Int8() + int _unique_data_item_34; + @ffi.Int8() + int _unique_data_item_35; + @ffi.Int8() + int _unique_data_item_36; + @ffi.Int8() + int _unique_data_item_37; + @ffi.Int8() + int _unique_data_item_38; + @ffi.Int8() + int _unique_data_item_39; + @ffi.Int8() + int _unique_data_item_40; + @ffi.Int8() + int _unique_data_item_41; + @ffi.Int8() + int _unique_data_item_42; + @ffi.Int8() + int _unique_data_item_43; + @ffi.Int8() + int _unique_data_item_44; + @ffi.Int8() + int _unique_data_item_45; + @ffi.Int8() + int _unique_data_item_46; + @ffi.Int8() + int _unique_data_item_47; + @ffi.Int8() + int _unique_data_item_48; + @ffi.Int8() + int _unique_data_item_49; + @ffi.Int8() + int _unique_data_item_50; + @ffi.Int8() + int _unique_data_item_51; + @ffi.Int8() + int _unique_data_item_52; + @ffi.Int8() + int _unique_data_item_53; + @ffi.Int8() + int _unique_data_item_54; + @ffi.Int8() + int _unique_data_item_55; + @ffi.Int8() + int _unique_data_item_56; + @ffi.Int8() + int _unique_data_item_57; + @ffi.Int8() + int _unique_data_item_58; + @ffi.Int8() + int _unique_data_item_59; + @ffi.Int8() + int _unique_data_item_60; + @ffi.Int8() + int _unique_data_item_61; + @ffi.Int8() + int _unique_data_item_62; + @ffi.Int8() + int _unique_data_item_63; + @ffi.Int8() + int _unique_data_item_64; + @ffi.Int8() + int _unique_data_item_65; + @ffi.Int8() + int _unique_data_item_66; + @ffi.Int8() + int _unique_data_item_67; + @ffi.Int8() + int _unique_data_item_68; + @ffi.Int8() + int _unique_data_item_69; + @ffi.Int8() + int _unique_data_item_70; + @ffi.Int8() + int _unique_data_item_71; + @ffi.Int8() + int _unique_data_item_72; + @ffi.Int8() + int _unique_data_item_73; + @ffi.Int8() + int _unique_data_item_74; + @ffi.Int8() + int _unique_data_item_75; + @ffi.Int8() + int _unique_data_item_76; + @ffi.Int8() + int _unique_data_item_77; + @ffi.Int8() + int _unique_data_item_78; + @ffi.Int8() + int _unique_data_item_79; + @ffi.Int8() + int _unique_data_item_80; + @ffi.Int8() + int _unique_data_item_81; + @ffi.Int8() + int _unique_data_item_82; + @ffi.Int8() + int _unique_data_item_83; + @ffi.Int8() + int _unique_data_item_84; + @ffi.Int8() + int _unique_data_item_85; + @ffi.Int8() + int _unique_data_item_86; + @ffi.Int8() + int _unique_data_item_87; + @ffi.Int8() + int _unique_data_item_88; + @ffi.Int8() + int _unique_data_item_89; + @ffi.Int8() + int _unique_data_item_90; + @ffi.Int8() + int _unique_data_item_91; + @ffi.Int8() + int _unique_data_item_92; + @ffi.Int8() + int _unique_data_item_93; + @ffi.Int8() + int _unique_data_item_94; + @ffi.Int8() + int _unique_data_item_95; + @ffi.Int8() + int _unique_data_item_96; + @ffi.Int8() + int _unique_data_item_97; + @ffi.Int8() + int _unique_data_item_98; + @ffi.Int8() + int _unique_data_item_99; + @ffi.Int8() + int _unique_data_item_100; + @ffi.Int8() + int _unique_data_item_101; + @ffi.Int8() + int _unique_data_item_102; + @ffi.Int8() + int _unique_data_item_103; + @ffi.Int8() + int _unique_data_item_104; + @ffi.Int8() + int _unique_data_item_105; + @ffi.Int8() + int _unique_data_item_106; + @ffi.Int8() + int _unique_data_item_107; + @ffi.Int8() + int _unique_data_item_108; + @ffi.Int8() + int _unique_data_item_109; + @ffi.Int8() + int _unique_data_item_110; + @ffi.Int8() + int _unique_data_item_111; + @ffi.Int8() + int _unique_data_item_112; + @ffi.Int8() + int _unique_data_item_113; + @ffi.Int8() + int _unique_data_item_114; + @ffi.Int8() + int _unique_data_item_115; + @ffi.Int8() + int _unique_data_item_116; + @ffi.Int8() + int _unique_data_item_117; + @ffi.Int8() + int _unique_data_item_118; + @ffi.Int8() + int _unique_data_item_119; + @ffi.Int8() + int _unique_data_item_120; + @ffi.Int8() + int _unique_data_item_121; + @ffi.Int8() + int _unique_data_item_122; + @ffi.Int8() + int _unique_data_item_123; + @ffi.Int8() + int _unique_data_item_124; + @ffi.Int8() + int _unique_data_item_125; + @ffi.Int8() + int _unique_data_item_126; + @ffi.Int8() + int _unique_data_item_127; + @ffi.Int8() + int _unique_data_item_128; + @ffi.Int8() + int _unique_data_item_129; + @ffi.Int8() + int _unique_data_item_130; + @ffi.Int8() + int _unique_data_item_131; + @ffi.Int8() + int _unique_data_item_132; + @ffi.Int8() + int _unique_data_item_133; + @ffi.Int8() + int _unique_data_item_134; + @ffi.Int8() + int _unique_data_item_135; + @ffi.Int8() + int _unique_data_item_136; + @ffi.Int8() + int _unique_data_item_137; + @ffi.Int8() + int _unique_data_item_138; + @ffi.Int8() + int _unique_data_item_139; + @ffi.Int8() + int _unique_data_item_140; + @ffi.Int8() + int _unique_data_item_141; + @ffi.Int8() + int _unique_data_item_142; + @ffi.Int8() + int _unique_data_item_143; + @ffi.Int8() + int _unique_data_item_144; + @ffi.Int8() + int _unique_data_item_145; + @ffi.Int8() + int _unique_data_item_146; + @ffi.Int8() + int _unique_data_item_147; + @ffi.Int8() + int _unique_data_item_148; + @ffi.Int8() + int _unique_data_item_149; + @ffi.Int8() + int _unique_data_item_150; + @ffi.Int8() + int _unique_data_item_151; + @ffi.Int8() + int _unique_data_item_152; + @ffi.Int8() + int _unique_data_item_153; + @ffi.Int8() + int _unique_data_item_154; + @ffi.Int8() + int _unique_data_item_155; + @ffi.Int8() + int _unique_data_item_156; + @ffi.Int8() + int _unique_data_item_157; + @ffi.Int8() + int _unique_data_item_158; + @ffi.Int8() + int _unique_data_item_159; + @ffi.Int8() + int _unique_data_item_160; + @ffi.Int8() + int _unique_data_item_161; + @ffi.Int8() + int _unique_data_item_162; + @ffi.Int8() + int _unique_data_item_163; + @ffi.Int8() + int _unique_data_item_164; + @ffi.Int8() + int _unique_data_item_165; + @ffi.Int8() + int _unique_data_item_166; + @ffi.Int8() + int _unique_data_item_167; + @ffi.Int8() + int _unique_data_item_168; + @ffi.Int8() + int _unique_data_item_169; + @ffi.Int8() + int _unique_data_item_170; + @ffi.Int8() + int _unique_data_item_171; + @ffi.Int8() + int _unique_data_item_172; + @ffi.Int8() + int _unique_data_item_173; + @ffi.Int8() + int _unique_data_item_174; + @ffi.Int8() + int _unique_data_item_175; + @ffi.Int8() + int _unique_data_item_176; + @ffi.Int8() + int _unique_data_item_177; + @ffi.Int8() + int _unique_data_item_178; + @ffi.Int8() + int _unique_data_item_179; + @ffi.Int8() + int _unique_data_item_180; + @ffi.Int8() + int _unique_data_item_181; + @ffi.Int8() + int _unique_data_item_182; + @ffi.Int8() + int _unique_data_item_183; + @ffi.Int8() + int _unique_data_item_184; + @ffi.Int8() + int _unique_data_item_185; + @ffi.Int8() + int _unique_data_item_186; + @ffi.Int8() + int _unique_data_item_187; + @ffi.Int8() + int _unique_data_item_188; + @ffi.Int8() + int _unique_data_item_189; + @ffi.Int8() + int _unique_data_item_190; + @ffi.Int8() + int _unique_data_item_191; + @ffi.Int8() + int _unique_data_item_192; + @ffi.Int8() + int _unique_data_item_193; + @ffi.Int8() + int _unique_data_item_194; + @ffi.Int8() + int _unique_data_item_195; + @ffi.Int8() + int _unique_data_item_196; + @ffi.Int8() + int _unique_data_item_197; + @ffi.Int8() + int _unique_data_item_198; + @ffi.Int8() + int _unique_data_item_199; + @ffi.Int8() + int _unique_data_item_200; + @ffi.Int8() + int _unique_data_item_201; + @ffi.Int8() + int _unique_data_item_202; + @ffi.Int8() + int _unique_data_item_203; + @ffi.Int8() + int _unique_data_item_204; + @ffi.Int8() + int _unique_data_item_205; + @ffi.Int8() + int _unique_data_item_206; + @ffi.Int8() + int _unique_data_item_207; + @ffi.Int8() + int _unique_data_item_208; + @ffi.Int8() + int _unique_data_item_209; + @ffi.Int8() + int _unique_data_item_210; + @ffi.Int8() + int _unique_data_item_211; + @ffi.Int8() + int _unique_data_item_212; + @ffi.Int8() + int _unique_data_item_213; + @ffi.Int8() + int _unique_data_item_214; + @ffi.Int8() + int _unique_data_item_215; + @ffi.Int8() + int _unique_data_item_216; + @ffi.Int8() + int _unique_data_item_217; + @ffi.Int8() + int _unique_data_item_218; + @ffi.Int8() + int _unique_data_item_219; + @ffi.Int8() + int _unique_data_item_220; + @ffi.Int8() + int _unique_data_item_221; + @ffi.Int8() + int _unique_data_item_222; + @ffi.Int8() + int _unique_data_item_223; + @ffi.Int8() + int _unique_data_item_224; + @ffi.Int8() + int _unique_data_item_225; + @ffi.Int8() + int _unique_data_item_226; + @ffi.Int8() + int _unique_data_item_227; + @ffi.Int8() + int _unique_data_item_228; + @ffi.Int8() + int _unique_data_item_229; + @ffi.Int8() + int _unique_data_item_230; + @ffi.Int8() + int _unique_data_item_231; + @ffi.Int8() + int _unique_data_item_232; + @ffi.Int8() + int _unique_data_item_233; + @ffi.Int8() + int _unique_data_item_234; + @ffi.Int8() + int _unique_data_item_235; + @ffi.Int8() + int _unique_data_item_236; + @ffi.Int8() + int _unique_data_item_237; + @ffi.Int8() + int _unique_data_item_238; + @ffi.Int8() + int _unique_data_item_239; + @ffi.Int8() + int _unique_data_item_240; + @ffi.Int8() + int _unique_data_item_241; + @ffi.Int8() + int _unique_data_item_242; + @ffi.Int8() + int _unique_data_item_243; + @ffi.Int8() + int _unique_data_item_244; + @ffi.Int8() + int _unique_data_item_245; + @ffi.Int8() + int _unique_data_item_246; + @ffi.Int8() + int _unique_data_item_247; + @ffi.Int8() + int _unique_data_item_248; + @ffi.Int8() + int _unique_data_item_249; + @ffi.Int8() + int _unique_data_item_250; + @ffi.Int8() + int _unique_data_item_251; + @ffi.Int8() + int _unique_data_item_252; + @ffi.Int8() + int _unique_data_item_253; + @ffi.Int8() + int _unique_data_item_254; + @ffi.Int8() + int _unique_data_item_255; + @ffi.Int8() + int _unique_data_item_256; + @ffi.Int8() + int _unique_data_item_257; + @ffi.Int8() + int _unique_data_item_258; + @ffi.Int8() + int _unique_data_item_259; + @ffi.Int8() + int _unique_data_item_260; + @ffi.Int8() + int _unique_data_item_261; + @ffi.Int8() + int _unique_data_item_262; + @ffi.Int8() + int _unique_data_item_263; + @ffi.Int8() + int _unique_data_item_264; + @ffi.Int8() + int _unique_data_item_265; + @ffi.Int8() + int _unique_data_item_266; + @ffi.Int8() + int _unique_data_item_267; + @ffi.Int8() + int _unique_data_item_268; + @ffi.Int8() + int _unique_data_item_269; + @ffi.Int8() + int _unique_data_item_270; + @ffi.Int8() + int _unique_data_item_271; + @ffi.Int8() + int _unique_data_item_272; + @ffi.Int8() + int _unique_data_item_273; + @ffi.Int8() + int _unique_data_item_274; + @ffi.Int8() + int _unique_data_item_275; + @ffi.Int8() + int _unique_data_item_276; + @ffi.Int8() + int _unique_data_item_277; + @ffi.Int8() + int _unique_data_item_278; + @ffi.Int8() + int _unique_data_item_279; + @ffi.Int8() + int _unique_data_item_280; + @ffi.Int8() + int _unique_data_item_281; + @ffi.Int8() + int _unique_data_item_282; + @ffi.Int8() + int _unique_data_item_283; + @ffi.Int8() + int _unique_data_item_284; + @ffi.Int8() + int _unique_data_item_285; + @ffi.Int8() + int _unique_data_item_286; + @ffi.Int8() + int _unique_data_item_287; + @ffi.Int8() + int _unique_data_item_288; + @ffi.Int8() + int _unique_data_item_289; + @ffi.Int8() + int _unique_data_item_290; + @ffi.Int8() + int _unique_data_item_291; + @ffi.Int8() + int _unique_data_item_292; + @ffi.Int8() + int _unique_data_item_293; + @ffi.Int8() + int _unique_data_item_294; + @ffi.Int8() + int _unique_data_item_295; + @ffi.Int8() + int _unique_data_item_296; + @ffi.Int8() + int _unique_data_item_297; + @ffi.Int8() + int _unique_data_item_298; + @ffi.Int8() + int _unique_data_item_299; + @ffi.Int8() + int _unique_data_item_300; + @ffi.Int8() + int _unique_data_item_301; + @ffi.Int8() + int _unique_data_item_302; + @ffi.Int8() + int _unique_data_item_303; + @ffi.Int8() + int _unique_data_item_304; + @ffi.Int8() + int _unique_data_item_305; + @ffi.Int8() + int _unique_data_item_306; + @ffi.Int8() + int _unique_data_item_307; + @ffi.Int8() + int _unique_data_item_308; + @ffi.Int8() + int _unique_data_item_309; + @ffi.Int8() + int _unique_data_item_310; + @ffi.Int8() + int _unique_data_item_311; + @ffi.Int8() + int _unique_data_item_312; + @ffi.Int8() + int _unique_data_item_313; + @ffi.Int8() + int _unique_data_item_314; + @ffi.Int8() + int _unique_data_item_315; + @ffi.Int8() + int _unique_data_item_316; + @ffi.Int8() + int _unique_data_item_317; + @ffi.Int8() + int _unique_data_item_318; + @ffi.Int8() + int _unique_data_item_319; + @ffi.Int8() + int _unique_data_item_320; + @ffi.Int8() + int _unique_data_item_321; + @ffi.Int8() + int _unique_data_item_322; + @ffi.Int8() + int _unique_data_item_323; + @ffi.Int8() + int _unique_data_item_324; + @ffi.Int8() + int _unique_data_item_325; + @ffi.Int8() + int _unique_data_item_326; + @ffi.Int8() + int _unique_data_item_327; + @ffi.Int8() + int _unique_data_item_328; + @ffi.Int8() + int _unique_data_item_329; + @ffi.Int8() + int _unique_data_item_330; + @ffi.Int8() + int _unique_data_item_331; + @ffi.Int8() + int _unique_data_item_332; + @ffi.Int8() + int _unique_data_item_333; + @ffi.Int8() + int _unique_data_item_334; + @ffi.Int8() + int _unique_data_item_335; + @ffi.Int8() + int _unique_data_item_336; + @ffi.Int8() + int _unique_data_item_337; + @ffi.Int8() + int _unique_data_item_338; + @ffi.Int8() + int _unique_data_item_339; + @ffi.Int8() + int _unique_data_item_340; + @ffi.Int8() + int _unique_data_item_341; + @ffi.Int8() + int _unique_data_item_342; + @ffi.Int8() + int _unique_data_item_343; + @ffi.Int8() + int _unique_data_item_344; + @ffi.Int8() + int _unique_data_item_345; + @ffi.Int8() + int _unique_data_item_346; + @ffi.Int8() + int _unique_data_item_347; + @ffi.Int8() + int _unique_data_item_348; + @ffi.Int8() + int _unique_data_item_349; + @ffi.Int8() + int _unique_data_item_350; + @ffi.Int8() + int _unique_data_item_351; + @ffi.Int8() + int _unique_data_item_352; + @ffi.Int8() + int _unique_data_item_353; + @ffi.Int8() + int _unique_data_item_354; + @ffi.Int8() + int _unique_data_item_355; + @ffi.Int8() + int _unique_data_item_356; + @ffi.Int8() + int _unique_data_item_357; + @ffi.Int8() + int _unique_data_item_358; + @ffi.Int8() + int _unique_data_item_359; + @ffi.Int8() + int _unique_data_item_360; + @ffi.Int8() + int _unique_data_item_361; + @ffi.Int8() + int _unique_data_item_362; + @ffi.Int8() + int _unique_data_item_363; + @ffi.Int8() + int _unique_data_item_364; + @ffi.Int8() + int _unique_data_item_365; + @ffi.Int8() + int _unique_data_item_366; + @ffi.Int8() + int _unique_data_item_367; + @ffi.Int8() + int _unique_data_item_368; + @ffi.Int8() + int _unique_data_item_369; + @ffi.Int8() + int _unique_data_item_370; + @ffi.Int8() + int _unique_data_item_371; + @ffi.Int8() + int _unique_data_item_372; + @ffi.Int8() + int _unique_data_item_373; + @ffi.Int8() + int _unique_data_item_374; + @ffi.Int8() + int _unique_data_item_375; + @ffi.Int8() + int _unique_data_item_376; + @ffi.Int8() + int _unique_data_item_377; + @ffi.Int8() + int _unique_data_item_378; + @ffi.Int8() + int _unique_data_item_379; + @ffi.Int8() + int _unique_data_item_380; + @ffi.Int8() + int _unique_data_item_381; + @ffi.Int8() + int _unique_data_item_382; + @ffi.Int8() + int _unique_data_item_383; + @ffi.Int8() + int _unique_data_item_384; + @ffi.Int8() + int _unique_data_item_385; + @ffi.Int8() + int _unique_data_item_386; + @ffi.Int8() + int _unique_data_item_387; + @ffi.Int8() + int _unique_data_item_388; + @ffi.Int8() + int _unique_data_item_389; + @ffi.Int8() + int _unique_data_item_390; + @ffi.Int8() + int _unique_data_item_391; + @ffi.Int8() + int _unique_data_item_392; + @ffi.Int8() + int _unique_data_item_393; + @ffi.Int8() + int _unique_data_item_394; + @ffi.Int8() + int _unique_data_item_395; + @ffi.Int8() + int _unique_data_item_396; + @ffi.Int8() + int _unique_data_item_397; + @ffi.Int8() + int _unique_data_item_398; + @ffi.Int8() + int _unique_data_item_399; + @ffi.Int8() + int _unique_data_item_400; + @ffi.Int8() + int _unique_data_item_401; + @ffi.Int8() + int _unique_data_item_402; + @ffi.Int8() + int _unique_data_item_403; + @ffi.Int8() + int _unique_data_item_404; + @ffi.Int8() + int _unique_data_item_405; + @ffi.Int8() + int _unique_data_item_406; + @ffi.Int8() + int _unique_data_item_407; + @ffi.Int8() + int _unique_data_item_408; + @ffi.Int8() + int _unique_data_item_409; + @ffi.Int8() + int _unique_data_item_410; + @ffi.Int8() + int _unique_data_item_411; + @ffi.Int8() + int _unique_data_item_412; + @ffi.Int8() + int _unique_data_item_413; + @ffi.Int8() + int _unique_data_item_414; + @ffi.Int8() + int _unique_data_item_415; + @ffi.Int8() + int _unique_data_item_416; + @ffi.Int8() + int _unique_data_item_417; + @ffi.Int8() + int _unique_data_item_418; + @ffi.Int8() + int _unique_data_item_419; + @ffi.Int8() + int _unique_data_item_420; + @ffi.Int8() + int _unique_data_item_421; + @ffi.Int8() + int _unique_data_item_422; + @ffi.Int8() + int _unique_data_item_423; + @ffi.Int8() + int _unique_data_item_424; + @ffi.Int8() + int _unique_data_item_425; + @ffi.Int8() + int _unique_data_item_426; + @ffi.Int8() + int _unique_data_item_427; + @ffi.Int8() + int _unique_data_item_428; + @ffi.Int8() + int _unique_data_item_429; + @ffi.Int8() + int _unique_data_item_430; + @ffi.Int8() + int _unique_data_item_431; + @ffi.Int8() + int _unique_data_item_432; + @ffi.Int8() + int _unique_data_item_433; + @ffi.Int8() + int _unique_data_item_434; + @ffi.Int8() + int _unique_data_item_435; + @ffi.Int8() + int _unique_data_item_436; + @ffi.Int8() + int _unique_data_item_437; + @ffi.Int8() + int _unique_data_item_438; + @ffi.Int8() + int _unique_data_item_439; + @ffi.Int8() + int _unique_data_item_440; + @ffi.Int8() + int _unique_data_item_441; + @ffi.Int8() + int _unique_data_item_442; + @ffi.Int8() + int _unique_data_item_443; + @ffi.Int8() + int _unique_data_item_444; + @ffi.Int8() + int _unique_data_item_445; + @ffi.Int8() + int _unique_data_item_446; + @ffi.Int8() + int _unique_data_item_447; + @ffi.Int8() + int _unique_data_item_448; + @ffi.Int8() + int _unique_data_item_449; + @ffi.Int8() + int _unique_data_item_450; + @ffi.Int8() + int _unique_data_item_451; + @ffi.Int8() + int _unique_data_item_452; + @ffi.Int8() + int _unique_data_item_453; + @ffi.Int8() + int _unique_data_item_454; + @ffi.Int8() + int _unique_data_item_455; + @ffi.Int8() + int _unique_data_item_456; + @ffi.Int8() + int _unique_data_item_457; + @ffi.Int8() + int _unique_data_item_458; + @ffi.Int8() + int _unique_data_item_459; + @ffi.Int8() + int _unique_data_item_460; + @ffi.Int8() + int _unique_data_item_461; + @ffi.Int8() + int _unique_data_item_462; + @ffi.Int8() + int _unique_data_item_463; + @ffi.Int8() + int _unique_data_item_464; + @ffi.Int8() + int _unique_data_item_465; + @ffi.Int8() + int _unique_data_item_466; + @ffi.Int8() + int _unique_data_item_467; + @ffi.Int8() + int _unique_data_item_468; + @ffi.Int8() + int _unique_data_item_469; + @ffi.Int8() + int _unique_data_item_470; + @ffi.Int8() + int _unique_data_item_471; + @ffi.Int8() + int _unique_data_item_472; + @ffi.Int8() + int _unique_data_item_473; + @ffi.Int8() + int _unique_data_item_474; + @ffi.Int8() + int _unique_data_item_475; + @ffi.Int8() + int _unique_data_item_476; + @ffi.Int8() + int _unique_data_item_477; + @ffi.Int8() + int _unique_data_item_478; + @ffi.Int8() + int _unique_data_item_479; + @ffi.Int8() + int _unique_data_item_480; + @ffi.Int8() + int _unique_data_item_481; + @ffi.Int8() + int _unique_data_item_482; + @ffi.Int8() + int _unique_data_item_483; + @ffi.Int8() + int _unique_data_item_484; + @ffi.Int8() + int _unique_data_item_485; + @ffi.Int8() + int _unique_data_item_486; + @ffi.Int8() + int _unique_data_item_487; + @ffi.Int8() + int _unique_data_item_488; + @ffi.Int8() + int _unique_data_item_489; + @ffi.Int8() + int _unique_data_item_490; + @ffi.Int8() + int _unique_data_item_491; + @ffi.Int8() + int _unique_data_item_492; + @ffi.Int8() + int _unique_data_item_493; + @ffi.Int8() + int _unique_data_item_494; + @ffi.Int8() + int _unique_data_item_495; + @ffi.Int8() + int _unique_data_item_496; + @ffi.Int8() + int _unique_data_item_497; + @ffi.Int8() + int _unique_data_item_498; + @ffi.Int8() + int _unique_data_item_499; + @ffi.Int8() + int _unique_data_item_500; + @ffi.Int8() + int _unique_data_item_501; + @ffi.Int8() + int _unique_data_item_502; + @ffi.Int8() + int _unique_data_item_503; + @ffi.Int8() + int _unique_data_item_504; + @ffi.Int8() + int _unique_data_item_505; + @ffi.Int8() + int _unique_data_item_506; + @ffi.Int8() + int _unique_data_item_507; + @ffi.Int8() + int _unique_data_item_508; + @ffi.Int8() + int _unique_data_item_509; + @ffi.Int8() + int _unique_data_item_510; + @ffi.Int8() + int _unique_data_item_511; + @ffi.Int8() + int _unique_data_item_512; + @ffi.Int8() + int _unique_data_item_513; + @ffi.Int8() + int _unique_data_item_514; + @ffi.Int8() + int _unique_data_item_515; + @ffi.Int8() + int _unique_data_item_516; + @ffi.Int8() + int _unique_data_item_517; + @ffi.Int8() + int _unique_data_item_518; + @ffi.Int8() + int _unique_data_item_519; + @ffi.Int8() + int _unique_data_item_520; + @ffi.Int8() + int _unique_data_item_521; + @ffi.Int8() + int _unique_data_item_522; + @ffi.Int8() + int _unique_data_item_523; + @ffi.Int8() + int _unique_data_item_524; + @ffi.Int8() + int _unique_data_item_525; + @ffi.Int8() + int _unique_data_item_526; + @ffi.Int8() + int _unique_data_item_527; + @ffi.Int8() + int _unique_data_item_528; + @ffi.Int8() + int _unique_data_item_529; + @ffi.Int8() + int _unique_data_item_530; + @ffi.Int8() + int _unique_data_item_531; + @ffi.Int8() + int _unique_data_item_532; + @ffi.Int8() + int _unique_data_item_533; + @ffi.Int8() + int _unique_data_item_534; + @ffi.Int8() + int _unique_data_item_535; + @ffi.Int8() + int _unique_data_item_536; + @ffi.Int8() + int _unique_data_item_537; + @ffi.Int8() + int _unique_data_item_538; + @ffi.Int8() + int _unique_data_item_539; + @ffi.Int8() + int _unique_data_item_540; + @ffi.Int8() + int _unique_data_item_541; + @ffi.Int8() + int _unique_data_item_542; + @ffi.Int8() + int _unique_data_item_543; + @ffi.Int8() + int _unique_data_item_544; + @ffi.Int8() + int _unique_data_item_545; + @ffi.Int8() + int _unique_data_item_546; + @ffi.Int8() + int _unique_data_item_547; + @ffi.Int8() + int _unique_data_item_548; + @ffi.Int8() + int _unique_data_item_549; + @ffi.Int8() + int _unique_data_item_550; + @ffi.Int8() + int _unique_data_item_551; + @ffi.Int8() + int _unique_data_item_552; + @ffi.Int8() + int _unique_data_item_553; + @ffi.Int8() + int _unique_data_item_554; + @ffi.Int8() + int _unique_data_item_555; + @ffi.Int8() + int _unique_data_item_556; + @ffi.Int8() + int _unique_data_item_557; + @ffi.Int8() + int _unique_data_item_558; + @ffi.Int8() + int _unique_data_item_559; + @ffi.Int8() + int _unique_data_item_560; + @ffi.Int8() + int _unique_data_item_561; + @ffi.Int8() + int _unique_data_item_562; + @ffi.Int8() + int _unique_data_item_563; + @ffi.Int8() + int _unique_data_item_564; + @ffi.Int8() + int _unique_data_item_565; + @ffi.Int8() + int _unique_data_item_566; + @ffi.Int8() + int _unique_data_item_567; + @ffi.Int8() + int _unique_data_item_568; + @ffi.Int8() + int _unique_data_item_569; + @ffi.Int8() + int _unique_data_item_570; + @ffi.Int8() + int _unique_data_item_571; + @ffi.Int8() + int _unique_data_item_572; + @ffi.Int8() + int _unique_data_item_573; + @ffi.Int8() + int _unique_data_item_574; + @ffi.Int8() + int _unique_data_item_575; + @ffi.Int8() + int _unique_data_item_576; + @ffi.Int8() + int _unique_data_item_577; + @ffi.Int8() + int _unique_data_item_578; + @ffi.Int8() + int _unique_data_item_579; + @ffi.Int8() + int _unique_data_item_580; + @ffi.Int8() + int _unique_data_item_581; + @ffi.Int8() + int _unique_data_item_582; + @ffi.Int8() + int _unique_data_item_583; + @ffi.Int8() + int _unique_data_item_584; + @ffi.Int8() + int _unique_data_item_585; + @ffi.Int8() + int _unique_data_item_586; + @ffi.Int8() + int _unique_data_item_587; + @ffi.Int8() + int _unique_data_item_588; + @ffi.Int8() + int _unique_data_item_589; + @ffi.Int8() + int _unique_data_item_590; + @ffi.Int8() + int _unique_data_item_591; + @ffi.Int8() + int _unique_data_item_592; + @ffi.Int8() + int _unique_data_item_593; + @ffi.Int8() + int _unique_data_item_594; + @ffi.Int8() + int _unique_data_item_595; + @ffi.Int8() + int _unique_data_item_596; + @ffi.Int8() + int _unique_data_item_597; + @ffi.Int8() + int _unique_data_item_598; + @ffi.Int8() + int _unique_data_item_599; + @ffi.Int8() + int _unique_data_item_600; + @ffi.Int8() + int _unique_data_item_601; + @ffi.Int8() + int _unique_data_item_602; + @ffi.Int8() + int _unique_data_item_603; + @ffi.Int8() + int _unique_data_item_604; + @ffi.Int8() + int _unique_data_item_605; + @ffi.Int8() + int _unique_data_item_606; + @ffi.Int8() + int _unique_data_item_607; + @ffi.Int8() + int _unique_data_item_608; + @ffi.Int8() + int _unique_data_item_609; + @ffi.Int8() + int _unique_data_item_610; + @ffi.Int8() + int _unique_data_item_611; + @ffi.Int8() + int _unique_data_item_612; + @ffi.Int8() + int _unique_data_item_613; + @ffi.Int8() + int _unique_data_item_614; + @ffi.Int8() + int _unique_data_item_615; + @ffi.Int8() + int _unique_data_item_616; + @ffi.Int8() + int _unique_data_item_617; + @ffi.Int8() + int _unique_data_item_618; + @ffi.Int8() + int _unique_data_item_619; + @ffi.Int8() + int _unique_data_item_620; + @ffi.Int8() + int _unique_data_item_621; + @ffi.Int8() + int _unique_data_item_622; + @ffi.Int8() + int _unique_data_item_623; + @ffi.Int8() + int _unique_data_item_624; + @ffi.Int8() + int _unique_data_item_625; + @ffi.Int8() + int _unique_data_item_626; + @ffi.Int8() + int _unique_data_item_627; + @ffi.Int8() + int _unique_data_item_628; + @ffi.Int8() + int _unique_data_item_629; + @ffi.Int8() + int _unique_data_item_630; + @ffi.Int8() + int _unique_data_item_631; + @ffi.Int8() + int _unique_data_item_632; + @ffi.Int8() + int _unique_data_item_633; + @ffi.Int8() + int _unique_data_item_634; + @ffi.Int8() + int _unique_data_item_635; + @ffi.Int8() + int _unique_data_item_636; + @ffi.Int8() + int _unique_data_item_637; + @ffi.Int8() + int _unique_data_item_638; + @ffi.Int8() + int _unique_data_item_639; + @ffi.Int8() + int _unique_data_item_640; + @ffi.Int8() + int _unique_data_item_641; + @ffi.Int8() + int _unique_data_item_642; + @ffi.Int8() + int _unique_data_item_643; + @ffi.Int8() + int _unique_data_item_644; + @ffi.Int8() + int _unique_data_item_645; + @ffi.Int8() + int _unique_data_item_646; + @ffi.Int8() + int _unique_data_item_647; + @ffi.Int8() + int _unique_data_item_648; + @ffi.Int8() + int _unique_data_item_649; + @ffi.Int8() + int _unique_data_item_650; + @ffi.Int8() + int _unique_data_item_651; + @ffi.Int8() + int _unique_data_item_652; + @ffi.Int8() + int _unique_data_item_653; + @ffi.Int8() + int _unique_data_item_654; + @ffi.Int8() + int _unique_data_item_655; + @ffi.Int8() + int _unique_data_item_656; + @ffi.Int8() + int _unique_data_item_657; + @ffi.Int8() + int _unique_data_item_658; + @ffi.Int8() + int _unique_data_item_659; + @ffi.Int8() + int _unique_data_item_660; + @ffi.Int8() + int _unique_data_item_661; + @ffi.Int8() + int _unique_data_item_662; + @ffi.Int8() + int _unique_data_item_663; + @ffi.Int8() + int _unique_data_item_664; + @ffi.Int8() + int _unique_data_item_665; + @ffi.Int8() + int _unique_data_item_666; + @ffi.Int8() + int _unique_data_item_667; + @ffi.Int8() + int _unique_data_item_668; + @ffi.Int8() + int _unique_data_item_669; + @ffi.Int8() + int _unique_data_item_670; + @ffi.Int8() + int _unique_data_item_671; + @ffi.Int8() + int _unique_data_item_672; + @ffi.Int8() + int _unique_data_item_673; + @ffi.Int8() + int _unique_data_item_674; + @ffi.Int8() + int _unique_data_item_675; + @ffi.Int8() + int _unique_data_item_676; + @ffi.Int8() + int _unique_data_item_677; + @ffi.Int8() + int _unique_data_item_678; + @ffi.Int8() + int _unique_data_item_679; + @ffi.Int8() + int _unique_data_item_680; + @ffi.Int8() + int _unique_data_item_681; + @ffi.Int8() + int _unique_data_item_682; + @ffi.Int8() + int _unique_data_item_683; + @ffi.Int8() + int _unique_data_item_684; + @ffi.Int8() + int _unique_data_item_685; + @ffi.Int8() + int _unique_data_item_686; + @ffi.Int8() + int _unique_data_item_687; + @ffi.Int8() + int _unique_data_item_688; + @ffi.Int8() + int _unique_data_item_689; + @ffi.Int8() + int _unique_data_item_690; + @ffi.Int8() + int _unique_data_item_691; + @ffi.Int8() + int _unique_data_item_692; + @ffi.Int8() + int _unique_data_item_693; + @ffi.Int8() + int _unique_data_item_694; + @ffi.Int8() + int _unique_data_item_695; + @ffi.Int8() + int _unique_data_item_696; + @ffi.Int8() + int _unique_data_item_697; + @ffi.Int8() + int _unique_data_item_698; + @ffi.Int8() + int _unique_data_item_699; + @ffi.Int8() + int _unique_data_item_700; + @ffi.Int8() + int _unique_data_item_701; + @ffi.Int8() + int _unique_data_item_702; + @ffi.Int8() + int _unique_data_item_703; + @ffi.Int8() + int _unique_data_item_704; + @ffi.Int8() + int _unique_data_item_705; + @ffi.Int8() + int _unique_data_item_706; + @ffi.Int8() + int _unique_data_item_707; + @ffi.Int8() + int _unique_data_item_708; + @ffi.Int8() + int _unique_data_item_709; + @ffi.Int8() + int _unique_data_item_710; + @ffi.Int8() + int _unique_data_item_711; + @ffi.Int8() + int _unique_data_item_712; + @ffi.Int8() + int _unique_data_item_713; + @ffi.Int8() + int _unique_data_item_714; + @ffi.Int8() + int _unique_data_item_715; + @ffi.Int8() + int _unique_data_item_716; + @ffi.Int8() + int _unique_data_item_717; + @ffi.Int8() + int _unique_data_item_718; + @ffi.Int8() + int _unique_data_item_719; + @ffi.Int8() + int _unique_data_item_720; + @ffi.Int8() + int _unique_data_item_721; + @ffi.Int8() + int _unique_data_item_722; + @ffi.Int8() + int _unique_data_item_723; + @ffi.Int8() + int _unique_data_item_724; + @ffi.Int8() + int _unique_data_item_725; + @ffi.Int8() + int _unique_data_item_726; + @ffi.Int8() + int _unique_data_item_727; + @ffi.Int8() + int _unique_data_item_728; + @ffi.Int8() + int _unique_data_item_729; + @ffi.Int8() + int _unique_data_item_730; + @ffi.Int8() + int _unique_data_item_731; + @ffi.Int8() + int _unique_data_item_732; + @ffi.Int8() + int _unique_data_item_733; + @ffi.Int8() + int _unique_data_item_734; + @ffi.Int8() + int _unique_data_item_735; + @ffi.Int8() + int _unique_data_item_736; + @ffi.Int8() + int _unique_data_item_737; + @ffi.Int8() + int _unique_data_item_738; + @ffi.Int8() + int _unique_data_item_739; + @ffi.Int8() + int _unique_data_item_740; + @ffi.Int8() + int _unique_data_item_741; + @ffi.Int8() + int _unique_data_item_742; + @ffi.Int8() + int _unique_data_item_743; + @ffi.Int8() + int _unique_data_item_744; + @ffi.Int8() + int _unique_data_item_745; + @ffi.Int8() + int _unique_data_item_746; + @ffi.Int8() + int _unique_data_item_747; + @ffi.Int8() + int _unique_data_item_748; + @ffi.Int8() + int _unique_data_item_749; + @ffi.Int8() + int _unique_data_item_750; + @ffi.Int8() + int _unique_data_item_751; + @ffi.Int8() + int _unique_data_item_752; + @ffi.Int8() + int _unique_data_item_753; + @ffi.Int8() + int _unique_data_item_754; + @ffi.Int8() + int _unique_data_item_755; + @ffi.Int8() + int _unique_data_item_756; + @ffi.Int8() + int _unique_data_item_757; + @ffi.Int8() + int _unique_data_item_758; + @ffi.Int8() + int _unique_data_item_759; + @ffi.Int8() + int _unique_data_item_760; + @ffi.Int8() + int _unique_data_item_761; + @ffi.Int8() + int _unique_data_item_762; + @ffi.Int8() + int _unique_data_item_763; + @ffi.Int8() + int _unique_data_item_764; + @ffi.Int8() + int _unique_data_item_765; + @ffi.Int8() + int _unique_data_item_766; + @ffi.Int8() + int _unique_data_item_767; + @ffi.Int8() + int _unique_data_item_768; + @ffi.Int8() + int _unique_data_item_769; + @ffi.Int8() + int _unique_data_item_770; + @ffi.Int8() + int _unique_data_item_771; + @ffi.Int8() + int _unique_data_item_772; + @ffi.Int8() + int _unique_data_item_773; + @ffi.Int8() + int _unique_data_item_774; + @ffi.Int8() + int _unique_data_item_775; + @ffi.Int8() + int _unique_data_item_776; + @ffi.Int8() + int _unique_data_item_777; + @ffi.Int8() + int _unique_data_item_778; + @ffi.Int8() + int _unique_data_item_779; + @ffi.Int8() + int _unique_data_item_780; + @ffi.Int8() + int _unique_data_item_781; + @ffi.Int8() + int _unique_data_item_782; + @ffi.Int8() + int _unique_data_item_783; + @ffi.Int8() + int _unique_data_item_784; + @ffi.Int8() + int _unique_data_item_785; + @ffi.Int8() + int _unique_data_item_786; + @ffi.Int8() + int _unique_data_item_787; + @ffi.Int8() + int _unique_data_item_788; + @ffi.Int8() + int _unique_data_item_789; + @ffi.Int8() + int _unique_data_item_790; + @ffi.Int8() + int _unique_data_item_791; + @ffi.Int8() + int _unique_data_item_792; + @ffi.Int8() + int _unique_data_item_793; + @ffi.Int8() + int _unique_data_item_794; + @ffi.Int8() + int _unique_data_item_795; + @ffi.Int8() + int _unique_data_item_796; + @ffi.Int8() + int _unique_data_item_797; + @ffi.Int8() + int _unique_data_item_798; + @ffi.Int8() + int _unique_data_item_799; + @ffi.Int8() + int _unique_data_item_800; + @ffi.Int8() + int _unique_data_item_801; + @ffi.Int8() + int _unique_data_item_802; + @ffi.Int8() + int _unique_data_item_803; + @ffi.Int8() + int _unique_data_item_804; + @ffi.Int8() + int _unique_data_item_805; + @ffi.Int8() + int _unique_data_item_806; + @ffi.Int8() + int _unique_data_item_807; + @ffi.Int8() + int _unique_data_item_808; + @ffi.Int8() + int _unique_data_item_809; + @ffi.Int8() + int _unique_data_item_810; + @ffi.Int8() + int _unique_data_item_811; + @ffi.Int8() + int _unique_data_item_812; + @ffi.Int8() + int _unique_data_item_813; + @ffi.Int8() + int _unique_data_item_814; + @ffi.Int8() + int _unique_data_item_815; + @ffi.Int8() + int _unique_data_item_816; + @ffi.Int8() + int _unique_data_item_817; + @ffi.Int8() + int _unique_data_item_818; + @ffi.Int8() + int _unique_data_item_819; + @ffi.Int8() + int _unique_data_item_820; + @ffi.Int8() + int _unique_data_item_821; + @ffi.Int8() + int _unique_data_item_822; + @ffi.Int8() + int _unique_data_item_823; + @ffi.Int8() + int _unique_data_item_824; + @ffi.Int8() + int _unique_data_item_825; + @ffi.Int8() + int _unique_data_item_826; + @ffi.Int8() + int _unique_data_item_827; + @ffi.Int8() + int _unique_data_item_828; + @ffi.Int8() + int _unique_data_item_829; + @ffi.Int8() + int _unique_data_item_830; + @ffi.Int8() + int _unique_data_item_831; + @ffi.Int8() + int _unique_data_item_832; + @ffi.Int8() + int _unique_data_item_833; + @ffi.Int8() + int _unique_data_item_834; + @ffi.Int8() + int _unique_data_item_835; + @ffi.Int8() + int _unique_data_item_836; + @ffi.Int8() + int _unique_data_item_837; + @ffi.Int8() + int _unique_data_item_838; + @ffi.Int8() + int _unique_data_item_839; + @ffi.Int8() + int _unique_data_item_840; + @ffi.Int8() + int _unique_data_item_841; + @ffi.Int8() + int _unique_data_item_842; + @ffi.Int8() + int _unique_data_item_843; + @ffi.Int8() + int _unique_data_item_844; + @ffi.Int8() + int _unique_data_item_845; + @ffi.Int8() + int _unique_data_item_846; + @ffi.Int8() + int _unique_data_item_847; + @ffi.Int8() + int _unique_data_item_848; + @ffi.Int8() + int _unique_data_item_849; + @ffi.Int8() + int _unique_data_item_850; + @ffi.Int8() + int _unique_data_item_851; + @ffi.Int8() + int _unique_data_item_852; + @ffi.Int8() + int _unique_data_item_853; + @ffi.Int8() + int _unique_data_item_854; + @ffi.Int8() + int _unique_data_item_855; + @ffi.Int8() + int _unique_data_item_856; + @ffi.Int8() + int _unique_data_item_857; + @ffi.Int8() + int _unique_data_item_858; + @ffi.Int8() + int _unique_data_item_859; + @ffi.Int8() + int _unique_data_item_860; + @ffi.Int8() + int _unique_data_item_861; + @ffi.Int8() + int _unique_data_item_862; + @ffi.Int8() + int _unique_data_item_863; + @ffi.Int8() + int _unique_data_item_864; + @ffi.Int8() + int _unique_data_item_865; + @ffi.Int8() + int _unique_data_item_866; + @ffi.Int8() + int _unique_data_item_867; + @ffi.Int8() + int _unique_data_item_868; + @ffi.Int8() + int _unique_data_item_869; + @ffi.Int8() + int _unique_data_item_870; + @ffi.Int8() + int _unique_data_item_871; + @ffi.Int8() + int _unique_data_item_872; + @ffi.Int8() + int _unique_data_item_873; + @ffi.Int8() + int _unique_data_item_874; + @ffi.Int8() + int _unique_data_item_875; + @ffi.Int8() + int _unique_data_item_876; + @ffi.Int8() + int _unique_data_item_877; + @ffi.Int8() + int _unique_data_item_878; + @ffi.Int8() + int _unique_data_item_879; + @ffi.Int8() + int _unique_data_item_880; + @ffi.Int8() + int _unique_data_item_881; + @ffi.Int8() + int _unique_data_item_882; + @ffi.Int8() + int _unique_data_item_883; + @ffi.Int8() + int _unique_data_item_884; + @ffi.Int8() + int _unique_data_item_885; + @ffi.Int8() + int _unique_data_item_886; + @ffi.Int8() + int _unique_data_item_887; + @ffi.Int8() + int _unique_data_item_888; + @ffi.Int8() + int _unique_data_item_889; + @ffi.Int8() + int _unique_data_item_890; + @ffi.Int8() + int _unique_data_item_891; + @ffi.Int8() + int _unique_data_item_892; + @ffi.Int8() + int _unique_data_item_893; + @ffi.Int8() + int _unique_data_item_894; + @ffi.Int8() + int _unique_data_item_895; + @ffi.Int8() + int _unique_data_item_896; + @ffi.Int8() + int _unique_data_item_897; + @ffi.Int8() + int _unique_data_item_898; + @ffi.Int8() + int _unique_data_item_899; + @ffi.Int8() + int _unique_data_item_900; + @ffi.Int8() + int _unique_data_item_901; + @ffi.Int8() + int _unique_data_item_902; + @ffi.Int8() + int _unique_data_item_903; + @ffi.Int8() + int _unique_data_item_904; + @ffi.Int8() + int _unique_data_item_905; + @ffi.Int8() + int _unique_data_item_906; + @ffi.Int8() + int _unique_data_item_907; + @ffi.Int8() + int _unique_data_item_908; + @ffi.Int8() + int _unique_data_item_909; + @ffi.Int8() + int _unique_data_item_910; + @ffi.Int8() + int _unique_data_item_911; + @ffi.Int8() + int _unique_data_item_912; + @ffi.Int8() + int _unique_data_item_913; + @ffi.Int8() + int _unique_data_item_914; + @ffi.Int8() + int _unique_data_item_915; + @ffi.Int8() + int _unique_data_item_916; + @ffi.Int8() + int _unique_data_item_917; + @ffi.Int8() + int _unique_data_item_918; + @ffi.Int8() + int _unique_data_item_919; + @ffi.Int8() + int _unique_data_item_920; + @ffi.Int8() + int _unique_data_item_921; + @ffi.Int8() + int _unique_data_item_922; + @ffi.Int8() + int _unique_data_item_923; + @ffi.Int8() + int _unique_data_item_924; + @ffi.Int8() + int _unique_data_item_925; + @ffi.Int8() + int _unique_data_item_926; + @ffi.Int8() + int _unique_data_item_927; + @ffi.Int8() + int _unique_data_item_928; + @ffi.Int8() + int _unique_data_item_929; + @ffi.Int8() + int _unique_data_item_930; + @ffi.Int8() + int _unique_data_item_931; + @ffi.Int8() + int _unique_data_item_932; + @ffi.Int8() + int _unique_data_item_933; + @ffi.Int8() + int _unique_data_item_934; + @ffi.Int8() + int _unique_data_item_935; + @ffi.Int8() + int _unique_data_item_936; + @ffi.Int8() + int _unique_data_item_937; + @ffi.Int8() + int _unique_data_item_938; + @ffi.Int8() + int _unique_data_item_939; + @ffi.Int8() + int _unique_data_item_940; + @ffi.Int8() + int _unique_data_item_941; + @ffi.Int8() + int _unique_data_item_942; + @ffi.Int8() + int _unique_data_item_943; + @ffi.Int8() + int _unique_data_item_944; + @ffi.Int8() + int _unique_data_item_945; + @ffi.Int8() + int _unique_data_item_946; + @ffi.Int8() + int _unique_data_item_947; + @ffi.Int8() + int _unique_data_item_948; + @ffi.Int8() + int _unique_data_item_949; + @ffi.Int8() + int _unique_data_item_950; + @ffi.Int8() + int _unique_data_item_951; + @ffi.Int8() + int _unique_data_item_952; + @ffi.Int8() + int _unique_data_item_953; + @ffi.Int8() + int _unique_data_item_954; + @ffi.Int8() + int _unique_data_item_955; + @ffi.Int8() + int _unique_data_item_956; + @ffi.Int8() + int _unique_data_item_957; + @ffi.Int8() + int _unique_data_item_958; + @ffi.Int8() + int _unique_data_item_959; + @ffi.Int8() + int _unique_data_item_960; + @ffi.Int8() + int _unique_data_item_961; + @ffi.Int8() + int _unique_data_item_962; + @ffi.Int8() + int _unique_data_item_963; + @ffi.Int8() + int _unique_data_item_964; + @ffi.Int8() + int _unique_data_item_965; + @ffi.Int8() + int _unique_data_item_966; + @ffi.Int8() + int _unique_data_item_967; + @ffi.Int8() + int _unique_data_item_968; + @ffi.Int8() + int _unique_data_item_969; + @ffi.Int8() + int _unique_data_item_970; + @ffi.Int8() + int _unique_data_item_971; + @ffi.Int8() + int _unique_data_item_972; + @ffi.Int8() + int _unique_data_item_973; + @ffi.Int8() + int _unique_data_item_974; + @ffi.Int8() + int _unique_data_item_975; + @ffi.Int8() + int _unique_data_item_976; + @ffi.Int8() + int _unique_data_item_977; + @ffi.Int8() + int _unique_data_item_978; + @ffi.Int8() + int _unique_data_item_979; + @ffi.Int8() + int _unique_data_item_980; + @ffi.Int8() + int _unique_data_item_981; + @ffi.Int8() + int _unique_data_item_982; + @ffi.Int8() + int _unique_data_item_983; + @ffi.Int8() + int _unique_data_item_984; + @ffi.Int8() + int _unique_data_item_985; + @ffi.Int8() + int _unique_data_item_986; + @ffi.Int8() + int _unique_data_item_987; + @ffi.Int8() + int _unique_data_item_988; + @ffi.Int8() + int _unique_data_item_989; + @ffi.Int8() + int _unique_data_item_990; + @ffi.Int8() + int _unique_data_item_991; + @ffi.Int8() + int _unique_data_item_992; + @ffi.Int8() + int _unique_data_item_993; + @ffi.Int8() + int _unique_data_item_994; + @ffi.Int8() + int _unique_data_item_995; + @ffi.Int8() + int _unique_data_item_996; + @ffi.Int8() + int _unique_data_item_997; + @ffi.Int8() + int _unique_data_item_998; + @ffi.Int8() + int _unique_data_item_999; + @ffi.Int8() + int _unique_data_item_1000; + @ffi.Int8() + int _unique_data_item_1001; + @ffi.Int8() + int _unique_data_item_1002; + @ffi.Int8() + int _unique_data_item_1003; + @ffi.Int8() + int _unique_data_item_1004; + @ffi.Int8() + int _unique_data_item_1005; + @ffi.Int8() + int _unique_data_item_1006; + @ffi.Int8() + int _unique_data_item_1007; + @ffi.Int8() + int _unique_data_item_1008; + @ffi.Int8() + int _unique_data_item_1009; + @ffi.Int8() + int _unique_data_item_1010; + @ffi.Int8() + int _unique_data_item_1011; + @ffi.Int8() + int _unique_data_item_1012; + @ffi.Int8() + int _unique_data_item_1013; + @ffi.Int8() + int _unique_data_item_1014; + @ffi.Int8() + int _unique_data_item_1015; + @ffi.Int8() + int _unique_data_item_1016; + @ffi.Int8() + int _unique_data_item_1017; + @ffi.Int8() + int _unique_data_item_1018; + @ffi.Int8() + int _unique_data_item_1019; + @ffi.Int8() + int _unique_data_item_1020; + @ffi.Int8() + int _unique_data_item_1021; + @ffi.Int8() + int _unique_data_item_1022; + @ffi.Int8() + int _unique_data_item_1023; + + /// Helper for array `data`. + ArrayHelper_aiString_data_level0 get data => + ArrayHelper_aiString_data_level0(this, [1024], 0, 0); +} + +/// Helper for array `data` in struct `aiString`. +class ArrayHelper_aiString_data_level0 { + final aiString _struct; + final List dimensions; + final int level; + final int _absoluteIndex; + int get length => dimensions[level]; + ArrayHelper_aiString_data_level0( + this._struct, this.dimensions, this.level, this._absoluteIndex); + void _checkBounds(int index) { + if (index >= length || index < 0) { + throw RangeError( + 'Dimension $level: index not in range 0..${length} exclusive.'); + } + } + + int operator [](int index) { + _checkBounds(index); + switch (_absoluteIndex + index) { + case 0: + return _struct._unique_data_item_0; + case 1: + return _struct._unique_data_item_1; + case 2: + return _struct._unique_data_item_2; + case 3: + return _struct._unique_data_item_3; + case 4: + return _struct._unique_data_item_4; + case 5: + return _struct._unique_data_item_5; + case 6: + return _struct._unique_data_item_6; + case 7: + return _struct._unique_data_item_7; + case 8: + return _struct._unique_data_item_8; + case 9: + return _struct._unique_data_item_9; + case 10: + return _struct._unique_data_item_10; + case 11: + return _struct._unique_data_item_11; + case 12: + return _struct._unique_data_item_12; + case 13: + return _struct._unique_data_item_13; + case 14: + return _struct._unique_data_item_14; + case 15: + return _struct._unique_data_item_15; + case 16: + return _struct._unique_data_item_16; + case 17: + return _struct._unique_data_item_17; + case 18: + return _struct._unique_data_item_18; + case 19: + return _struct._unique_data_item_19; + case 20: + return _struct._unique_data_item_20; + case 21: + return _struct._unique_data_item_21; + case 22: + return _struct._unique_data_item_22; + case 23: + return _struct._unique_data_item_23; + case 24: + return _struct._unique_data_item_24; + case 25: + return _struct._unique_data_item_25; + case 26: + return _struct._unique_data_item_26; + case 27: + return _struct._unique_data_item_27; + case 28: + return _struct._unique_data_item_28; + case 29: + return _struct._unique_data_item_29; + case 30: + return _struct._unique_data_item_30; + case 31: + return _struct._unique_data_item_31; + case 32: + return _struct._unique_data_item_32; + case 33: + return _struct._unique_data_item_33; + case 34: + return _struct._unique_data_item_34; + case 35: + return _struct._unique_data_item_35; + case 36: + return _struct._unique_data_item_36; + case 37: + return _struct._unique_data_item_37; + case 38: + return _struct._unique_data_item_38; + case 39: + return _struct._unique_data_item_39; + case 40: + return _struct._unique_data_item_40; + case 41: + return _struct._unique_data_item_41; + case 42: + return _struct._unique_data_item_42; + case 43: + return _struct._unique_data_item_43; + case 44: + return _struct._unique_data_item_44; + case 45: + return _struct._unique_data_item_45; + case 46: + return _struct._unique_data_item_46; + case 47: + return _struct._unique_data_item_47; + case 48: + return _struct._unique_data_item_48; + case 49: + return _struct._unique_data_item_49; + case 50: + return _struct._unique_data_item_50; + case 51: + return _struct._unique_data_item_51; + case 52: + return _struct._unique_data_item_52; + case 53: + return _struct._unique_data_item_53; + case 54: + return _struct._unique_data_item_54; + case 55: + return _struct._unique_data_item_55; + case 56: + return _struct._unique_data_item_56; + case 57: + return _struct._unique_data_item_57; + case 58: + return _struct._unique_data_item_58; + case 59: + return _struct._unique_data_item_59; + case 60: + return _struct._unique_data_item_60; + case 61: + return _struct._unique_data_item_61; + case 62: + return _struct._unique_data_item_62; + case 63: + return _struct._unique_data_item_63; + case 64: + return _struct._unique_data_item_64; + case 65: + return _struct._unique_data_item_65; + case 66: + return _struct._unique_data_item_66; + case 67: + return _struct._unique_data_item_67; + case 68: + return _struct._unique_data_item_68; + case 69: + return _struct._unique_data_item_69; + case 70: + return _struct._unique_data_item_70; + case 71: + return _struct._unique_data_item_71; + case 72: + return _struct._unique_data_item_72; + case 73: + return _struct._unique_data_item_73; + case 74: + return _struct._unique_data_item_74; + case 75: + return _struct._unique_data_item_75; + case 76: + return _struct._unique_data_item_76; + case 77: + return _struct._unique_data_item_77; + case 78: + return _struct._unique_data_item_78; + case 79: + return _struct._unique_data_item_79; + case 80: + return _struct._unique_data_item_80; + case 81: + return _struct._unique_data_item_81; + case 82: + return _struct._unique_data_item_82; + case 83: + return _struct._unique_data_item_83; + case 84: + return _struct._unique_data_item_84; + case 85: + return _struct._unique_data_item_85; + case 86: + return _struct._unique_data_item_86; + case 87: + return _struct._unique_data_item_87; + case 88: + return _struct._unique_data_item_88; + case 89: + return _struct._unique_data_item_89; + case 90: + return _struct._unique_data_item_90; + case 91: + return _struct._unique_data_item_91; + case 92: + return _struct._unique_data_item_92; + case 93: + return _struct._unique_data_item_93; + case 94: + return _struct._unique_data_item_94; + case 95: + return _struct._unique_data_item_95; + case 96: + return _struct._unique_data_item_96; + case 97: + return _struct._unique_data_item_97; + case 98: + return _struct._unique_data_item_98; + case 99: + return _struct._unique_data_item_99; + case 100: + return _struct._unique_data_item_100; + case 101: + return _struct._unique_data_item_101; + case 102: + return _struct._unique_data_item_102; + case 103: + return _struct._unique_data_item_103; + case 104: + return _struct._unique_data_item_104; + case 105: + return _struct._unique_data_item_105; + case 106: + return _struct._unique_data_item_106; + case 107: + return _struct._unique_data_item_107; + case 108: + return _struct._unique_data_item_108; + case 109: + return _struct._unique_data_item_109; + case 110: + return _struct._unique_data_item_110; + case 111: + return _struct._unique_data_item_111; + case 112: + return _struct._unique_data_item_112; + case 113: + return _struct._unique_data_item_113; + case 114: + return _struct._unique_data_item_114; + case 115: + return _struct._unique_data_item_115; + case 116: + return _struct._unique_data_item_116; + case 117: + return _struct._unique_data_item_117; + case 118: + return _struct._unique_data_item_118; + case 119: + return _struct._unique_data_item_119; + case 120: + return _struct._unique_data_item_120; + case 121: + return _struct._unique_data_item_121; + case 122: + return _struct._unique_data_item_122; + case 123: + return _struct._unique_data_item_123; + case 124: + return _struct._unique_data_item_124; + case 125: + return _struct._unique_data_item_125; + case 126: + return _struct._unique_data_item_126; + case 127: + return _struct._unique_data_item_127; + case 128: + return _struct._unique_data_item_128; + case 129: + return _struct._unique_data_item_129; + case 130: + return _struct._unique_data_item_130; + case 131: + return _struct._unique_data_item_131; + case 132: + return _struct._unique_data_item_132; + case 133: + return _struct._unique_data_item_133; + case 134: + return _struct._unique_data_item_134; + case 135: + return _struct._unique_data_item_135; + case 136: + return _struct._unique_data_item_136; + case 137: + return _struct._unique_data_item_137; + case 138: + return _struct._unique_data_item_138; + case 139: + return _struct._unique_data_item_139; + case 140: + return _struct._unique_data_item_140; + case 141: + return _struct._unique_data_item_141; + case 142: + return _struct._unique_data_item_142; + case 143: + return _struct._unique_data_item_143; + case 144: + return _struct._unique_data_item_144; + case 145: + return _struct._unique_data_item_145; + case 146: + return _struct._unique_data_item_146; + case 147: + return _struct._unique_data_item_147; + case 148: + return _struct._unique_data_item_148; + case 149: + return _struct._unique_data_item_149; + case 150: + return _struct._unique_data_item_150; + case 151: + return _struct._unique_data_item_151; + case 152: + return _struct._unique_data_item_152; + case 153: + return _struct._unique_data_item_153; + case 154: + return _struct._unique_data_item_154; + case 155: + return _struct._unique_data_item_155; + case 156: + return _struct._unique_data_item_156; + case 157: + return _struct._unique_data_item_157; + case 158: + return _struct._unique_data_item_158; + case 159: + return _struct._unique_data_item_159; + case 160: + return _struct._unique_data_item_160; + case 161: + return _struct._unique_data_item_161; + case 162: + return _struct._unique_data_item_162; + case 163: + return _struct._unique_data_item_163; + case 164: + return _struct._unique_data_item_164; + case 165: + return _struct._unique_data_item_165; + case 166: + return _struct._unique_data_item_166; + case 167: + return _struct._unique_data_item_167; + case 168: + return _struct._unique_data_item_168; + case 169: + return _struct._unique_data_item_169; + case 170: + return _struct._unique_data_item_170; + case 171: + return _struct._unique_data_item_171; + case 172: + return _struct._unique_data_item_172; + case 173: + return _struct._unique_data_item_173; + case 174: + return _struct._unique_data_item_174; + case 175: + return _struct._unique_data_item_175; + case 176: + return _struct._unique_data_item_176; + case 177: + return _struct._unique_data_item_177; + case 178: + return _struct._unique_data_item_178; + case 179: + return _struct._unique_data_item_179; + case 180: + return _struct._unique_data_item_180; + case 181: + return _struct._unique_data_item_181; + case 182: + return _struct._unique_data_item_182; + case 183: + return _struct._unique_data_item_183; + case 184: + return _struct._unique_data_item_184; + case 185: + return _struct._unique_data_item_185; + case 186: + return _struct._unique_data_item_186; + case 187: + return _struct._unique_data_item_187; + case 188: + return _struct._unique_data_item_188; + case 189: + return _struct._unique_data_item_189; + case 190: + return _struct._unique_data_item_190; + case 191: + return _struct._unique_data_item_191; + case 192: + return _struct._unique_data_item_192; + case 193: + return _struct._unique_data_item_193; + case 194: + return _struct._unique_data_item_194; + case 195: + return _struct._unique_data_item_195; + case 196: + return _struct._unique_data_item_196; + case 197: + return _struct._unique_data_item_197; + case 198: + return _struct._unique_data_item_198; + case 199: + return _struct._unique_data_item_199; + case 200: + return _struct._unique_data_item_200; + case 201: + return _struct._unique_data_item_201; + case 202: + return _struct._unique_data_item_202; + case 203: + return _struct._unique_data_item_203; + case 204: + return _struct._unique_data_item_204; + case 205: + return _struct._unique_data_item_205; + case 206: + return _struct._unique_data_item_206; + case 207: + return _struct._unique_data_item_207; + case 208: + return _struct._unique_data_item_208; + case 209: + return _struct._unique_data_item_209; + case 210: + return _struct._unique_data_item_210; + case 211: + return _struct._unique_data_item_211; + case 212: + return _struct._unique_data_item_212; + case 213: + return _struct._unique_data_item_213; + case 214: + return _struct._unique_data_item_214; + case 215: + return _struct._unique_data_item_215; + case 216: + return _struct._unique_data_item_216; + case 217: + return _struct._unique_data_item_217; + case 218: + return _struct._unique_data_item_218; + case 219: + return _struct._unique_data_item_219; + case 220: + return _struct._unique_data_item_220; + case 221: + return _struct._unique_data_item_221; + case 222: + return _struct._unique_data_item_222; + case 223: + return _struct._unique_data_item_223; + case 224: + return _struct._unique_data_item_224; + case 225: + return _struct._unique_data_item_225; + case 226: + return _struct._unique_data_item_226; + case 227: + return _struct._unique_data_item_227; + case 228: + return _struct._unique_data_item_228; + case 229: + return _struct._unique_data_item_229; + case 230: + return _struct._unique_data_item_230; + case 231: + return _struct._unique_data_item_231; + case 232: + return _struct._unique_data_item_232; + case 233: + return _struct._unique_data_item_233; + case 234: + return _struct._unique_data_item_234; + case 235: + return _struct._unique_data_item_235; + case 236: + return _struct._unique_data_item_236; + case 237: + return _struct._unique_data_item_237; + case 238: + return _struct._unique_data_item_238; + case 239: + return _struct._unique_data_item_239; + case 240: + return _struct._unique_data_item_240; + case 241: + return _struct._unique_data_item_241; + case 242: + return _struct._unique_data_item_242; + case 243: + return _struct._unique_data_item_243; + case 244: + return _struct._unique_data_item_244; + case 245: + return _struct._unique_data_item_245; + case 246: + return _struct._unique_data_item_246; + case 247: + return _struct._unique_data_item_247; + case 248: + return _struct._unique_data_item_248; + case 249: + return _struct._unique_data_item_249; + case 250: + return _struct._unique_data_item_250; + case 251: + return _struct._unique_data_item_251; + case 252: + return _struct._unique_data_item_252; + case 253: + return _struct._unique_data_item_253; + case 254: + return _struct._unique_data_item_254; + case 255: + return _struct._unique_data_item_255; + case 256: + return _struct._unique_data_item_256; + case 257: + return _struct._unique_data_item_257; + case 258: + return _struct._unique_data_item_258; + case 259: + return _struct._unique_data_item_259; + case 260: + return _struct._unique_data_item_260; + case 261: + return _struct._unique_data_item_261; + case 262: + return _struct._unique_data_item_262; + case 263: + return _struct._unique_data_item_263; + case 264: + return _struct._unique_data_item_264; + case 265: + return _struct._unique_data_item_265; + case 266: + return _struct._unique_data_item_266; + case 267: + return _struct._unique_data_item_267; + case 268: + return _struct._unique_data_item_268; + case 269: + return _struct._unique_data_item_269; + case 270: + return _struct._unique_data_item_270; + case 271: + return _struct._unique_data_item_271; + case 272: + return _struct._unique_data_item_272; + case 273: + return _struct._unique_data_item_273; + case 274: + return _struct._unique_data_item_274; + case 275: + return _struct._unique_data_item_275; + case 276: + return _struct._unique_data_item_276; + case 277: + return _struct._unique_data_item_277; + case 278: + return _struct._unique_data_item_278; + case 279: + return _struct._unique_data_item_279; + case 280: + return _struct._unique_data_item_280; + case 281: + return _struct._unique_data_item_281; + case 282: + return _struct._unique_data_item_282; + case 283: + return _struct._unique_data_item_283; + case 284: + return _struct._unique_data_item_284; + case 285: + return _struct._unique_data_item_285; + case 286: + return _struct._unique_data_item_286; + case 287: + return _struct._unique_data_item_287; + case 288: + return _struct._unique_data_item_288; + case 289: + return _struct._unique_data_item_289; + case 290: + return _struct._unique_data_item_290; + case 291: + return _struct._unique_data_item_291; + case 292: + return _struct._unique_data_item_292; + case 293: + return _struct._unique_data_item_293; + case 294: + return _struct._unique_data_item_294; + case 295: + return _struct._unique_data_item_295; + case 296: + return _struct._unique_data_item_296; + case 297: + return _struct._unique_data_item_297; + case 298: + return _struct._unique_data_item_298; + case 299: + return _struct._unique_data_item_299; + case 300: + return _struct._unique_data_item_300; + case 301: + return _struct._unique_data_item_301; + case 302: + return _struct._unique_data_item_302; + case 303: + return _struct._unique_data_item_303; + case 304: + return _struct._unique_data_item_304; + case 305: + return _struct._unique_data_item_305; + case 306: + return _struct._unique_data_item_306; + case 307: + return _struct._unique_data_item_307; + case 308: + return _struct._unique_data_item_308; + case 309: + return _struct._unique_data_item_309; + case 310: + return _struct._unique_data_item_310; + case 311: + return _struct._unique_data_item_311; + case 312: + return _struct._unique_data_item_312; + case 313: + return _struct._unique_data_item_313; + case 314: + return _struct._unique_data_item_314; + case 315: + return _struct._unique_data_item_315; + case 316: + return _struct._unique_data_item_316; + case 317: + return _struct._unique_data_item_317; + case 318: + return _struct._unique_data_item_318; + case 319: + return _struct._unique_data_item_319; + case 320: + return _struct._unique_data_item_320; + case 321: + return _struct._unique_data_item_321; + case 322: + return _struct._unique_data_item_322; + case 323: + return _struct._unique_data_item_323; + case 324: + return _struct._unique_data_item_324; + case 325: + return _struct._unique_data_item_325; + case 326: + return _struct._unique_data_item_326; + case 327: + return _struct._unique_data_item_327; + case 328: + return _struct._unique_data_item_328; + case 329: + return _struct._unique_data_item_329; + case 330: + return _struct._unique_data_item_330; + case 331: + return _struct._unique_data_item_331; + case 332: + return _struct._unique_data_item_332; + case 333: + return _struct._unique_data_item_333; + case 334: + return _struct._unique_data_item_334; + case 335: + return _struct._unique_data_item_335; + case 336: + return _struct._unique_data_item_336; + case 337: + return _struct._unique_data_item_337; + case 338: + return _struct._unique_data_item_338; + case 339: + return _struct._unique_data_item_339; + case 340: + return _struct._unique_data_item_340; + case 341: + return _struct._unique_data_item_341; + case 342: + return _struct._unique_data_item_342; + case 343: + return _struct._unique_data_item_343; + case 344: + return _struct._unique_data_item_344; + case 345: + return _struct._unique_data_item_345; + case 346: + return _struct._unique_data_item_346; + case 347: + return _struct._unique_data_item_347; + case 348: + return _struct._unique_data_item_348; + case 349: + return _struct._unique_data_item_349; + case 350: + return _struct._unique_data_item_350; + case 351: + return _struct._unique_data_item_351; + case 352: + return _struct._unique_data_item_352; + case 353: + return _struct._unique_data_item_353; + case 354: + return _struct._unique_data_item_354; + case 355: + return _struct._unique_data_item_355; + case 356: + return _struct._unique_data_item_356; + case 357: + return _struct._unique_data_item_357; + case 358: + return _struct._unique_data_item_358; + case 359: + return _struct._unique_data_item_359; + case 360: + return _struct._unique_data_item_360; + case 361: + return _struct._unique_data_item_361; + case 362: + return _struct._unique_data_item_362; + case 363: + return _struct._unique_data_item_363; + case 364: + return _struct._unique_data_item_364; + case 365: + return _struct._unique_data_item_365; + case 366: + return _struct._unique_data_item_366; + case 367: + return _struct._unique_data_item_367; + case 368: + return _struct._unique_data_item_368; + case 369: + return _struct._unique_data_item_369; + case 370: + return _struct._unique_data_item_370; + case 371: + return _struct._unique_data_item_371; + case 372: + return _struct._unique_data_item_372; + case 373: + return _struct._unique_data_item_373; + case 374: + return _struct._unique_data_item_374; + case 375: + return _struct._unique_data_item_375; + case 376: + return _struct._unique_data_item_376; + case 377: + return _struct._unique_data_item_377; + case 378: + return _struct._unique_data_item_378; + case 379: + return _struct._unique_data_item_379; + case 380: + return _struct._unique_data_item_380; + case 381: + return _struct._unique_data_item_381; + case 382: + return _struct._unique_data_item_382; + case 383: + return _struct._unique_data_item_383; + case 384: + return _struct._unique_data_item_384; + case 385: + return _struct._unique_data_item_385; + case 386: + return _struct._unique_data_item_386; + case 387: + return _struct._unique_data_item_387; + case 388: + return _struct._unique_data_item_388; + case 389: + return _struct._unique_data_item_389; + case 390: + return _struct._unique_data_item_390; + case 391: + return _struct._unique_data_item_391; + case 392: + return _struct._unique_data_item_392; + case 393: + return _struct._unique_data_item_393; + case 394: + return _struct._unique_data_item_394; + case 395: + return _struct._unique_data_item_395; + case 396: + return _struct._unique_data_item_396; + case 397: + return _struct._unique_data_item_397; + case 398: + return _struct._unique_data_item_398; + case 399: + return _struct._unique_data_item_399; + case 400: + return _struct._unique_data_item_400; + case 401: + return _struct._unique_data_item_401; + case 402: + return _struct._unique_data_item_402; + case 403: + return _struct._unique_data_item_403; + case 404: + return _struct._unique_data_item_404; + case 405: + return _struct._unique_data_item_405; + case 406: + return _struct._unique_data_item_406; + case 407: + return _struct._unique_data_item_407; + case 408: + return _struct._unique_data_item_408; + case 409: + return _struct._unique_data_item_409; + case 410: + return _struct._unique_data_item_410; + case 411: + return _struct._unique_data_item_411; + case 412: + return _struct._unique_data_item_412; + case 413: + return _struct._unique_data_item_413; + case 414: + return _struct._unique_data_item_414; + case 415: + return _struct._unique_data_item_415; + case 416: + return _struct._unique_data_item_416; + case 417: + return _struct._unique_data_item_417; + case 418: + return _struct._unique_data_item_418; + case 419: + return _struct._unique_data_item_419; + case 420: + return _struct._unique_data_item_420; + case 421: + return _struct._unique_data_item_421; + case 422: + return _struct._unique_data_item_422; + case 423: + return _struct._unique_data_item_423; + case 424: + return _struct._unique_data_item_424; + case 425: + return _struct._unique_data_item_425; + case 426: + return _struct._unique_data_item_426; + case 427: + return _struct._unique_data_item_427; + case 428: + return _struct._unique_data_item_428; + case 429: + return _struct._unique_data_item_429; + case 430: + return _struct._unique_data_item_430; + case 431: + return _struct._unique_data_item_431; + case 432: + return _struct._unique_data_item_432; + case 433: + return _struct._unique_data_item_433; + case 434: + return _struct._unique_data_item_434; + case 435: + return _struct._unique_data_item_435; + case 436: + return _struct._unique_data_item_436; + case 437: + return _struct._unique_data_item_437; + case 438: + return _struct._unique_data_item_438; + case 439: + return _struct._unique_data_item_439; + case 440: + return _struct._unique_data_item_440; + case 441: + return _struct._unique_data_item_441; + case 442: + return _struct._unique_data_item_442; + case 443: + return _struct._unique_data_item_443; + case 444: + return _struct._unique_data_item_444; + case 445: + return _struct._unique_data_item_445; + case 446: + return _struct._unique_data_item_446; + case 447: + return _struct._unique_data_item_447; + case 448: + return _struct._unique_data_item_448; + case 449: + return _struct._unique_data_item_449; + case 450: + return _struct._unique_data_item_450; + case 451: + return _struct._unique_data_item_451; + case 452: + return _struct._unique_data_item_452; + case 453: + return _struct._unique_data_item_453; + case 454: + return _struct._unique_data_item_454; + case 455: + return _struct._unique_data_item_455; + case 456: + return _struct._unique_data_item_456; + case 457: + return _struct._unique_data_item_457; + case 458: + return _struct._unique_data_item_458; + case 459: + return _struct._unique_data_item_459; + case 460: + return _struct._unique_data_item_460; + case 461: + return _struct._unique_data_item_461; + case 462: + return _struct._unique_data_item_462; + case 463: + return _struct._unique_data_item_463; + case 464: + return _struct._unique_data_item_464; + case 465: + return _struct._unique_data_item_465; + case 466: + return _struct._unique_data_item_466; + case 467: + return _struct._unique_data_item_467; + case 468: + return _struct._unique_data_item_468; + case 469: + return _struct._unique_data_item_469; + case 470: + return _struct._unique_data_item_470; + case 471: + return _struct._unique_data_item_471; + case 472: + return _struct._unique_data_item_472; + case 473: + return _struct._unique_data_item_473; + case 474: + return _struct._unique_data_item_474; + case 475: + return _struct._unique_data_item_475; + case 476: + return _struct._unique_data_item_476; + case 477: + return _struct._unique_data_item_477; + case 478: + return _struct._unique_data_item_478; + case 479: + return _struct._unique_data_item_479; + case 480: + return _struct._unique_data_item_480; + case 481: + return _struct._unique_data_item_481; + case 482: + return _struct._unique_data_item_482; + case 483: + return _struct._unique_data_item_483; + case 484: + return _struct._unique_data_item_484; + case 485: + return _struct._unique_data_item_485; + case 486: + return _struct._unique_data_item_486; + case 487: + return _struct._unique_data_item_487; + case 488: + return _struct._unique_data_item_488; + case 489: + return _struct._unique_data_item_489; + case 490: + return _struct._unique_data_item_490; + case 491: + return _struct._unique_data_item_491; + case 492: + return _struct._unique_data_item_492; + case 493: + return _struct._unique_data_item_493; + case 494: + return _struct._unique_data_item_494; + case 495: + return _struct._unique_data_item_495; + case 496: + return _struct._unique_data_item_496; + case 497: + return _struct._unique_data_item_497; + case 498: + return _struct._unique_data_item_498; + case 499: + return _struct._unique_data_item_499; + case 500: + return _struct._unique_data_item_500; + case 501: + return _struct._unique_data_item_501; + case 502: + return _struct._unique_data_item_502; + case 503: + return _struct._unique_data_item_503; + case 504: + return _struct._unique_data_item_504; + case 505: + return _struct._unique_data_item_505; + case 506: + return _struct._unique_data_item_506; + case 507: + return _struct._unique_data_item_507; + case 508: + return _struct._unique_data_item_508; + case 509: + return _struct._unique_data_item_509; + case 510: + return _struct._unique_data_item_510; + case 511: + return _struct._unique_data_item_511; + case 512: + return _struct._unique_data_item_512; + case 513: + return _struct._unique_data_item_513; + case 514: + return _struct._unique_data_item_514; + case 515: + return _struct._unique_data_item_515; + case 516: + return _struct._unique_data_item_516; + case 517: + return _struct._unique_data_item_517; + case 518: + return _struct._unique_data_item_518; + case 519: + return _struct._unique_data_item_519; + case 520: + return _struct._unique_data_item_520; + case 521: + return _struct._unique_data_item_521; + case 522: + return _struct._unique_data_item_522; + case 523: + return _struct._unique_data_item_523; + case 524: + return _struct._unique_data_item_524; + case 525: + return _struct._unique_data_item_525; + case 526: + return _struct._unique_data_item_526; + case 527: + return _struct._unique_data_item_527; + case 528: + return _struct._unique_data_item_528; + case 529: + return _struct._unique_data_item_529; + case 530: + return _struct._unique_data_item_530; + case 531: + return _struct._unique_data_item_531; + case 532: + return _struct._unique_data_item_532; + case 533: + return _struct._unique_data_item_533; + case 534: + return _struct._unique_data_item_534; + case 535: + return _struct._unique_data_item_535; + case 536: + return _struct._unique_data_item_536; + case 537: + return _struct._unique_data_item_537; + case 538: + return _struct._unique_data_item_538; + case 539: + return _struct._unique_data_item_539; + case 540: + return _struct._unique_data_item_540; + case 541: + return _struct._unique_data_item_541; + case 542: + return _struct._unique_data_item_542; + case 543: + return _struct._unique_data_item_543; + case 544: + return _struct._unique_data_item_544; + case 545: + return _struct._unique_data_item_545; + case 546: + return _struct._unique_data_item_546; + case 547: + return _struct._unique_data_item_547; + case 548: + return _struct._unique_data_item_548; + case 549: + return _struct._unique_data_item_549; + case 550: + return _struct._unique_data_item_550; + case 551: + return _struct._unique_data_item_551; + case 552: + return _struct._unique_data_item_552; + case 553: + return _struct._unique_data_item_553; + case 554: + return _struct._unique_data_item_554; + case 555: + return _struct._unique_data_item_555; + case 556: + return _struct._unique_data_item_556; + case 557: + return _struct._unique_data_item_557; + case 558: + return _struct._unique_data_item_558; + case 559: + return _struct._unique_data_item_559; + case 560: + return _struct._unique_data_item_560; + case 561: + return _struct._unique_data_item_561; + case 562: + return _struct._unique_data_item_562; + case 563: + return _struct._unique_data_item_563; + case 564: + return _struct._unique_data_item_564; + case 565: + return _struct._unique_data_item_565; + case 566: + return _struct._unique_data_item_566; + case 567: + return _struct._unique_data_item_567; + case 568: + return _struct._unique_data_item_568; + case 569: + return _struct._unique_data_item_569; + case 570: + return _struct._unique_data_item_570; + case 571: + return _struct._unique_data_item_571; + case 572: + return _struct._unique_data_item_572; + case 573: + return _struct._unique_data_item_573; + case 574: + return _struct._unique_data_item_574; + case 575: + return _struct._unique_data_item_575; + case 576: + return _struct._unique_data_item_576; + case 577: + return _struct._unique_data_item_577; + case 578: + return _struct._unique_data_item_578; + case 579: + return _struct._unique_data_item_579; + case 580: + return _struct._unique_data_item_580; + case 581: + return _struct._unique_data_item_581; + case 582: + return _struct._unique_data_item_582; + case 583: + return _struct._unique_data_item_583; + case 584: + return _struct._unique_data_item_584; + case 585: + return _struct._unique_data_item_585; + case 586: + return _struct._unique_data_item_586; + case 587: + return _struct._unique_data_item_587; + case 588: + return _struct._unique_data_item_588; + case 589: + return _struct._unique_data_item_589; + case 590: + return _struct._unique_data_item_590; + case 591: + return _struct._unique_data_item_591; + case 592: + return _struct._unique_data_item_592; + case 593: + return _struct._unique_data_item_593; + case 594: + return _struct._unique_data_item_594; + case 595: + return _struct._unique_data_item_595; + case 596: + return _struct._unique_data_item_596; + case 597: + return _struct._unique_data_item_597; + case 598: + return _struct._unique_data_item_598; + case 599: + return _struct._unique_data_item_599; + case 600: + return _struct._unique_data_item_600; + case 601: + return _struct._unique_data_item_601; + case 602: + return _struct._unique_data_item_602; + case 603: + return _struct._unique_data_item_603; + case 604: + return _struct._unique_data_item_604; + case 605: + return _struct._unique_data_item_605; + case 606: + return _struct._unique_data_item_606; + case 607: + return _struct._unique_data_item_607; + case 608: + return _struct._unique_data_item_608; + case 609: + return _struct._unique_data_item_609; + case 610: + return _struct._unique_data_item_610; + case 611: + return _struct._unique_data_item_611; + case 612: + return _struct._unique_data_item_612; + case 613: + return _struct._unique_data_item_613; + case 614: + return _struct._unique_data_item_614; + case 615: + return _struct._unique_data_item_615; + case 616: + return _struct._unique_data_item_616; + case 617: + return _struct._unique_data_item_617; + case 618: + return _struct._unique_data_item_618; + case 619: + return _struct._unique_data_item_619; + case 620: + return _struct._unique_data_item_620; + case 621: + return _struct._unique_data_item_621; + case 622: + return _struct._unique_data_item_622; + case 623: + return _struct._unique_data_item_623; + case 624: + return _struct._unique_data_item_624; + case 625: + return _struct._unique_data_item_625; + case 626: + return _struct._unique_data_item_626; + case 627: + return _struct._unique_data_item_627; + case 628: + return _struct._unique_data_item_628; + case 629: + return _struct._unique_data_item_629; + case 630: + return _struct._unique_data_item_630; + case 631: + return _struct._unique_data_item_631; + case 632: + return _struct._unique_data_item_632; + case 633: + return _struct._unique_data_item_633; + case 634: + return _struct._unique_data_item_634; + case 635: + return _struct._unique_data_item_635; + case 636: + return _struct._unique_data_item_636; + case 637: + return _struct._unique_data_item_637; + case 638: + return _struct._unique_data_item_638; + case 639: + return _struct._unique_data_item_639; + case 640: + return _struct._unique_data_item_640; + case 641: + return _struct._unique_data_item_641; + case 642: + return _struct._unique_data_item_642; + case 643: + return _struct._unique_data_item_643; + case 644: + return _struct._unique_data_item_644; + case 645: + return _struct._unique_data_item_645; + case 646: + return _struct._unique_data_item_646; + case 647: + return _struct._unique_data_item_647; + case 648: + return _struct._unique_data_item_648; + case 649: + return _struct._unique_data_item_649; + case 650: + return _struct._unique_data_item_650; + case 651: + return _struct._unique_data_item_651; + case 652: + return _struct._unique_data_item_652; + case 653: + return _struct._unique_data_item_653; + case 654: + return _struct._unique_data_item_654; + case 655: + return _struct._unique_data_item_655; + case 656: + return _struct._unique_data_item_656; + case 657: + return _struct._unique_data_item_657; + case 658: + return _struct._unique_data_item_658; + case 659: + return _struct._unique_data_item_659; + case 660: + return _struct._unique_data_item_660; + case 661: + return _struct._unique_data_item_661; + case 662: + return _struct._unique_data_item_662; + case 663: + return _struct._unique_data_item_663; + case 664: + return _struct._unique_data_item_664; + case 665: + return _struct._unique_data_item_665; + case 666: + return _struct._unique_data_item_666; + case 667: + return _struct._unique_data_item_667; + case 668: + return _struct._unique_data_item_668; + case 669: + return _struct._unique_data_item_669; + case 670: + return _struct._unique_data_item_670; + case 671: + return _struct._unique_data_item_671; + case 672: + return _struct._unique_data_item_672; + case 673: + return _struct._unique_data_item_673; + case 674: + return _struct._unique_data_item_674; + case 675: + return _struct._unique_data_item_675; + case 676: + return _struct._unique_data_item_676; + case 677: + return _struct._unique_data_item_677; + case 678: + return _struct._unique_data_item_678; + case 679: + return _struct._unique_data_item_679; + case 680: + return _struct._unique_data_item_680; + case 681: + return _struct._unique_data_item_681; + case 682: + return _struct._unique_data_item_682; + case 683: + return _struct._unique_data_item_683; + case 684: + return _struct._unique_data_item_684; + case 685: + return _struct._unique_data_item_685; + case 686: + return _struct._unique_data_item_686; + case 687: + return _struct._unique_data_item_687; + case 688: + return _struct._unique_data_item_688; + case 689: + return _struct._unique_data_item_689; + case 690: + return _struct._unique_data_item_690; + case 691: + return _struct._unique_data_item_691; + case 692: + return _struct._unique_data_item_692; + case 693: + return _struct._unique_data_item_693; + case 694: + return _struct._unique_data_item_694; + case 695: + return _struct._unique_data_item_695; + case 696: + return _struct._unique_data_item_696; + case 697: + return _struct._unique_data_item_697; + case 698: + return _struct._unique_data_item_698; + case 699: + return _struct._unique_data_item_699; + case 700: + return _struct._unique_data_item_700; + case 701: + return _struct._unique_data_item_701; + case 702: + return _struct._unique_data_item_702; + case 703: + return _struct._unique_data_item_703; + case 704: + return _struct._unique_data_item_704; + case 705: + return _struct._unique_data_item_705; + case 706: + return _struct._unique_data_item_706; + case 707: + return _struct._unique_data_item_707; + case 708: + return _struct._unique_data_item_708; + case 709: + return _struct._unique_data_item_709; + case 710: + return _struct._unique_data_item_710; + case 711: + return _struct._unique_data_item_711; + case 712: + return _struct._unique_data_item_712; + case 713: + return _struct._unique_data_item_713; + case 714: + return _struct._unique_data_item_714; + case 715: + return _struct._unique_data_item_715; + case 716: + return _struct._unique_data_item_716; + case 717: + return _struct._unique_data_item_717; + case 718: + return _struct._unique_data_item_718; + case 719: + return _struct._unique_data_item_719; + case 720: + return _struct._unique_data_item_720; + case 721: + return _struct._unique_data_item_721; + case 722: + return _struct._unique_data_item_722; + case 723: + return _struct._unique_data_item_723; + case 724: + return _struct._unique_data_item_724; + case 725: + return _struct._unique_data_item_725; + case 726: + return _struct._unique_data_item_726; + case 727: + return _struct._unique_data_item_727; + case 728: + return _struct._unique_data_item_728; + case 729: + return _struct._unique_data_item_729; + case 730: + return _struct._unique_data_item_730; + case 731: + return _struct._unique_data_item_731; + case 732: + return _struct._unique_data_item_732; + case 733: + return _struct._unique_data_item_733; + case 734: + return _struct._unique_data_item_734; + case 735: + return _struct._unique_data_item_735; + case 736: + return _struct._unique_data_item_736; + case 737: + return _struct._unique_data_item_737; + case 738: + return _struct._unique_data_item_738; + case 739: + return _struct._unique_data_item_739; + case 740: + return _struct._unique_data_item_740; + case 741: + return _struct._unique_data_item_741; + case 742: + return _struct._unique_data_item_742; + case 743: + return _struct._unique_data_item_743; + case 744: + return _struct._unique_data_item_744; + case 745: + return _struct._unique_data_item_745; + case 746: + return _struct._unique_data_item_746; + case 747: + return _struct._unique_data_item_747; + case 748: + return _struct._unique_data_item_748; + case 749: + return _struct._unique_data_item_749; + case 750: + return _struct._unique_data_item_750; + case 751: + return _struct._unique_data_item_751; + case 752: + return _struct._unique_data_item_752; + case 753: + return _struct._unique_data_item_753; + case 754: + return _struct._unique_data_item_754; + case 755: + return _struct._unique_data_item_755; + case 756: + return _struct._unique_data_item_756; + case 757: + return _struct._unique_data_item_757; + case 758: + return _struct._unique_data_item_758; + case 759: + return _struct._unique_data_item_759; + case 760: + return _struct._unique_data_item_760; + case 761: + return _struct._unique_data_item_761; + case 762: + return _struct._unique_data_item_762; + case 763: + return _struct._unique_data_item_763; + case 764: + return _struct._unique_data_item_764; + case 765: + return _struct._unique_data_item_765; + case 766: + return _struct._unique_data_item_766; + case 767: + return _struct._unique_data_item_767; + case 768: + return _struct._unique_data_item_768; + case 769: + return _struct._unique_data_item_769; + case 770: + return _struct._unique_data_item_770; + case 771: + return _struct._unique_data_item_771; + case 772: + return _struct._unique_data_item_772; + case 773: + return _struct._unique_data_item_773; + case 774: + return _struct._unique_data_item_774; + case 775: + return _struct._unique_data_item_775; + case 776: + return _struct._unique_data_item_776; + case 777: + return _struct._unique_data_item_777; + case 778: + return _struct._unique_data_item_778; + case 779: + return _struct._unique_data_item_779; + case 780: + return _struct._unique_data_item_780; + case 781: + return _struct._unique_data_item_781; + case 782: + return _struct._unique_data_item_782; + case 783: + return _struct._unique_data_item_783; + case 784: + return _struct._unique_data_item_784; + case 785: + return _struct._unique_data_item_785; + case 786: + return _struct._unique_data_item_786; + case 787: + return _struct._unique_data_item_787; + case 788: + return _struct._unique_data_item_788; + case 789: + return _struct._unique_data_item_789; + case 790: + return _struct._unique_data_item_790; + case 791: + return _struct._unique_data_item_791; + case 792: + return _struct._unique_data_item_792; + case 793: + return _struct._unique_data_item_793; + case 794: + return _struct._unique_data_item_794; + case 795: + return _struct._unique_data_item_795; + case 796: + return _struct._unique_data_item_796; + case 797: + return _struct._unique_data_item_797; + case 798: + return _struct._unique_data_item_798; + case 799: + return _struct._unique_data_item_799; + case 800: + return _struct._unique_data_item_800; + case 801: + return _struct._unique_data_item_801; + case 802: + return _struct._unique_data_item_802; + case 803: + return _struct._unique_data_item_803; + case 804: + return _struct._unique_data_item_804; + case 805: + return _struct._unique_data_item_805; + case 806: + return _struct._unique_data_item_806; + case 807: + return _struct._unique_data_item_807; + case 808: + return _struct._unique_data_item_808; + case 809: + return _struct._unique_data_item_809; + case 810: + return _struct._unique_data_item_810; + case 811: + return _struct._unique_data_item_811; + case 812: + return _struct._unique_data_item_812; + case 813: + return _struct._unique_data_item_813; + case 814: + return _struct._unique_data_item_814; + case 815: + return _struct._unique_data_item_815; + case 816: + return _struct._unique_data_item_816; + case 817: + return _struct._unique_data_item_817; + case 818: + return _struct._unique_data_item_818; + case 819: + return _struct._unique_data_item_819; + case 820: + return _struct._unique_data_item_820; + case 821: + return _struct._unique_data_item_821; + case 822: + return _struct._unique_data_item_822; + case 823: + return _struct._unique_data_item_823; + case 824: + return _struct._unique_data_item_824; + case 825: + return _struct._unique_data_item_825; + case 826: + return _struct._unique_data_item_826; + case 827: + return _struct._unique_data_item_827; + case 828: + return _struct._unique_data_item_828; + case 829: + return _struct._unique_data_item_829; + case 830: + return _struct._unique_data_item_830; + case 831: + return _struct._unique_data_item_831; + case 832: + return _struct._unique_data_item_832; + case 833: + return _struct._unique_data_item_833; + case 834: + return _struct._unique_data_item_834; + case 835: + return _struct._unique_data_item_835; + case 836: + return _struct._unique_data_item_836; + case 837: + return _struct._unique_data_item_837; + case 838: + return _struct._unique_data_item_838; + case 839: + return _struct._unique_data_item_839; + case 840: + return _struct._unique_data_item_840; + case 841: + return _struct._unique_data_item_841; + case 842: + return _struct._unique_data_item_842; + case 843: + return _struct._unique_data_item_843; + case 844: + return _struct._unique_data_item_844; + case 845: + return _struct._unique_data_item_845; + case 846: + return _struct._unique_data_item_846; + case 847: + return _struct._unique_data_item_847; + case 848: + return _struct._unique_data_item_848; + case 849: + return _struct._unique_data_item_849; + case 850: + return _struct._unique_data_item_850; + case 851: + return _struct._unique_data_item_851; + case 852: + return _struct._unique_data_item_852; + case 853: + return _struct._unique_data_item_853; + case 854: + return _struct._unique_data_item_854; + case 855: + return _struct._unique_data_item_855; + case 856: + return _struct._unique_data_item_856; + case 857: + return _struct._unique_data_item_857; + case 858: + return _struct._unique_data_item_858; + case 859: + return _struct._unique_data_item_859; + case 860: + return _struct._unique_data_item_860; + case 861: + return _struct._unique_data_item_861; + case 862: + return _struct._unique_data_item_862; + case 863: + return _struct._unique_data_item_863; + case 864: + return _struct._unique_data_item_864; + case 865: + return _struct._unique_data_item_865; + case 866: + return _struct._unique_data_item_866; + case 867: + return _struct._unique_data_item_867; + case 868: + return _struct._unique_data_item_868; + case 869: + return _struct._unique_data_item_869; + case 870: + return _struct._unique_data_item_870; + case 871: + return _struct._unique_data_item_871; + case 872: + return _struct._unique_data_item_872; + case 873: + return _struct._unique_data_item_873; + case 874: + return _struct._unique_data_item_874; + case 875: + return _struct._unique_data_item_875; + case 876: + return _struct._unique_data_item_876; + case 877: + return _struct._unique_data_item_877; + case 878: + return _struct._unique_data_item_878; + case 879: + return _struct._unique_data_item_879; + case 880: + return _struct._unique_data_item_880; + case 881: + return _struct._unique_data_item_881; + case 882: + return _struct._unique_data_item_882; + case 883: + return _struct._unique_data_item_883; + case 884: + return _struct._unique_data_item_884; + case 885: + return _struct._unique_data_item_885; + case 886: + return _struct._unique_data_item_886; + case 887: + return _struct._unique_data_item_887; + case 888: + return _struct._unique_data_item_888; + case 889: + return _struct._unique_data_item_889; + case 890: + return _struct._unique_data_item_890; + case 891: + return _struct._unique_data_item_891; + case 892: + return _struct._unique_data_item_892; + case 893: + return _struct._unique_data_item_893; + case 894: + return _struct._unique_data_item_894; + case 895: + return _struct._unique_data_item_895; + case 896: + return _struct._unique_data_item_896; + case 897: + return _struct._unique_data_item_897; + case 898: + return _struct._unique_data_item_898; + case 899: + return _struct._unique_data_item_899; + case 900: + return _struct._unique_data_item_900; + case 901: + return _struct._unique_data_item_901; + case 902: + return _struct._unique_data_item_902; + case 903: + return _struct._unique_data_item_903; + case 904: + return _struct._unique_data_item_904; + case 905: + return _struct._unique_data_item_905; + case 906: + return _struct._unique_data_item_906; + case 907: + return _struct._unique_data_item_907; + case 908: + return _struct._unique_data_item_908; + case 909: + return _struct._unique_data_item_909; + case 910: + return _struct._unique_data_item_910; + case 911: + return _struct._unique_data_item_911; + case 912: + return _struct._unique_data_item_912; + case 913: + return _struct._unique_data_item_913; + case 914: + return _struct._unique_data_item_914; + case 915: + return _struct._unique_data_item_915; + case 916: + return _struct._unique_data_item_916; + case 917: + return _struct._unique_data_item_917; + case 918: + return _struct._unique_data_item_918; + case 919: + return _struct._unique_data_item_919; + case 920: + return _struct._unique_data_item_920; + case 921: + return _struct._unique_data_item_921; + case 922: + return _struct._unique_data_item_922; + case 923: + return _struct._unique_data_item_923; + case 924: + return _struct._unique_data_item_924; + case 925: + return _struct._unique_data_item_925; + case 926: + return _struct._unique_data_item_926; + case 927: + return _struct._unique_data_item_927; + case 928: + return _struct._unique_data_item_928; + case 929: + return _struct._unique_data_item_929; + case 930: + return _struct._unique_data_item_930; + case 931: + return _struct._unique_data_item_931; + case 932: + return _struct._unique_data_item_932; + case 933: + return _struct._unique_data_item_933; + case 934: + return _struct._unique_data_item_934; + case 935: + return _struct._unique_data_item_935; + case 936: + return _struct._unique_data_item_936; + case 937: + return _struct._unique_data_item_937; + case 938: + return _struct._unique_data_item_938; + case 939: + return _struct._unique_data_item_939; + case 940: + return _struct._unique_data_item_940; + case 941: + return _struct._unique_data_item_941; + case 942: + return _struct._unique_data_item_942; + case 943: + return _struct._unique_data_item_943; + case 944: + return _struct._unique_data_item_944; + case 945: + return _struct._unique_data_item_945; + case 946: + return _struct._unique_data_item_946; + case 947: + return _struct._unique_data_item_947; + case 948: + return _struct._unique_data_item_948; + case 949: + return _struct._unique_data_item_949; + case 950: + return _struct._unique_data_item_950; + case 951: + return _struct._unique_data_item_951; + case 952: + return _struct._unique_data_item_952; + case 953: + return _struct._unique_data_item_953; + case 954: + return _struct._unique_data_item_954; + case 955: + return _struct._unique_data_item_955; + case 956: + return _struct._unique_data_item_956; + case 957: + return _struct._unique_data_item_957; + case 958: + return _struct._unique_data_item_958; + case 959: + return _struct._unique_data_item_959; + case 960: + return _struct._unique_data_item_960; + case 961: + return _struct._unique_data_item_961; + case 962: + return _struct._unique_data_item_962; + case 963: + return _struct._unique_data_item_963; + case 964: + return _struct._unique_data_item_964; + case 965: + return _struct._unique_data_item_965; + case 966: + return _struct._unique_data_item_966; + case 967: + return _struct._unique_data_item_967; + case 968: + return _struct._unique_data_item_968; + case 969: + return _struct._unique_data_item_969; + case 970: + return _struct._unique_data_item_970; + case 971: + return _struct._unique_data_item_971; + case 972: + return _struct._unique_data_item_972; + case 973: + return _struct._unique_data_item_973; + case 974: + return _struct._unique_data_item_974; + case 975: + return _struct._unique_data_item_975; + case 976: + return _struct._unique_data_item_976; + case 977: + return _struct._unique_data_item_977; + case 978: + return _struct._unique_data_item_978; + case 979: + return _struct._unique_data_item_979; + case 980: + return _struct._unique_data_item_980; + case 981: + return _struct._unique_data_item_981; + case 982: + return _struct._unique_data_item_982; + case 983: + return _struct._unique_data_item_983; + case 984: + return _struct._unique_data_item_984; + case 985: + return _struct._unique_data_item_985; + case 986: + return _struct._unique_data_item_986; + case 987: + return _struct._unique_data_item_987; + case 988: + return _struct._unique_data_item_988; + case 989: + return _struct._unique_data_item_989; + case 990: + return _struct._unique_data_item_990; + case 991: + return _struct._unique_data_item_991; + case 992: + return _struct._unique_data_item_992; + case 993: + return _struct._unique_data_item_993; + case 994: + return _struct._unique_data_item_994; + case 995: + return _struct._unique_data_item_995; + case 996: + return _struct._unique_data_item_996; + case 997: + return _struct._unique_data_item_997; + case 998: + return _struct._unique_data_item_998; + case 999: + return _struct._unique_data_item_999; + case 1000: + return _struct._unique_data_item_1000; + case 1001: + return _struct._unique_data_item_1001; + case 1002: + return _struct._unique_data_item_1002; + case 1003: + return _struct._unique_data_item_1003; + case 1004: + return _struct._unique_data_item_1004; + case 1005: + return _struct._unique_data_item_1005; + case 1006: + return _struct._unique_data_item_1006; + case 1007: + return _struct._unique_data_item_1007; + case 1008: + return _struct._unique_data_item_1008; + case 1009: + return _struct._unique_data_item_1009; + case 1010: + return _struct._unique_data_item_1010; + case 1011: + return _struct._unique_data_item_1011; + case 1012: + return _struct._unique_data_item_1012; + case 1013: + return _struct._unique_data_item_1013; + case 1014: + return _struct._unique_data_item_1014; + case 1015: + return _struct._unique_data_item_1015; + case 1016: + return _struct._unique_data_item_1016; + case 1017: + return _struct._unique_data_item_1017; + case 1018: + return _struct._unique_data_item_1018; + case 1019: + return _struct._unique_data_item_1019; + case 1020: + return _struct._unique_data_item_1020; + case 1021: + return _struct._unique_data_item_1021; + case 1022: + return _struct._unique_data_item_1022; + case 1023: + return _struct._unique_data_item_1023; + default: + throw Exception('Invalid Array Helper generated.'); + } + } + + void operator []=(int index, int value) { + _checkBounds(index); + switch (_absoluteIndex + index) { + case 0: + _struct._unique_data_item_0 = value; + break; + case 1: + _struct._unique_data_item_1 = value; + break; + case 2: + _struct._unique_data_item_2 = value; + break; + case 3: + _struct._unique_data_item_3 = value; + break; + case 4: + _struct._unique_data_item_4 = value; + break; + case 5: + _struct._unique_data_item_5 = value; + break; + case 6: + _struct._unique_data_item_6 = value; + break; + case 7: + _struct._unique_data_item_7 = value; + break; + case 8: + _struct._unique_data_item_8 = value; + break; + case 9: + _struct._unique_data_item_9 = value; + break; + case 10: + _struct._unique_data_item_10 = value; + break; + case 11: + _struct._unique_data_item_11 = value; + break; + case 12: + _struct._unique_data_item_12 = value; + break; + case 13: + _struct._unique_data_item_13 = value; + break; + case 14: + _struct._unique_data_item_14 = value; + break; + case 15: + _struct._unique_data_item_15 = value; + break; + case 16: + _struct._unique_data_item_16 = value; + break; + case 17: + _struct._unique_data_item_17 = value; + break; + case 18: + _struct._unique_data_item_18 = value; + break; + case 19: + _struct._unique_data_item_19 = value; + break; + case 20: + _struct._unique_data_item_20 = value; + break; + case 21: + _struct._unique_data_item_21 = value; + break; + case 22: + _struct._unique_data_item_22 = value; + break; + case 23: + _struct._unique_data_item_23 = value; + break; + case 24: + _struct._unique_data_item_24 = value; + break; + case 25: + _struct._unique_data_item_25 = value; + break; + case 26: + _struct._unique_data_item_26 = value; + break; + case 27: + _struct._unique_data_item_27 = value; + break; + case 28: + _struct._unique_data_item_28 = value; + break; + case 29: + _struct._unique_data_item_29 = value; + break; + case 30: + _struct._unique_data_item_30 = value; + break; + case 31: + _struct._unique_data_item_31 = value; + break; + case 32: + _struct._unique_data_item_32 = value; + break; + case 33: + _struct._unique_data_item_33 = value; + break; + case 34: + _struct._unique_data_item_34 = value; + break; + case 35: + _struct._unique_data_item_35 = value; + break; + case 36: + _struct._unique_data_item_36 = value; + break; + case 37: + _struct._unique_data_item_37 = value; + break; + case 38: + _struct._unique_data_item_38 = value; + break; + case 39: + _struct._unique_data_item_39 = value; + break; + case 40: + _struct._unique_data_item_40 = value; + break; + case 41: + _struct._unique_data_item_41 = value; + break; + case 42: + _struct._unique_data_item_42 = value; + break; + case 43: + _struct._unique_data_item_43 = value; + break; + case 44: + _struct._unique_data_item_44 = value; + break; + case 45: + _struct._unique_data_item_45 = value; + break; + case 46: + _struct._unique_data_item_46 = value; + break; + case 47: + _struct._unique_data_item_47 = value; + break; + case 48: + _struct._unique_data_item_48 = value; + break; + case 49: + _struct._unique_data_item_49 = value; + break; + case 50: + _struct._unique_data_item_50 = value; + break; + case 51: + _struct._unique_data_item_51 = value; + break; + case 52: + _struct._unique_data_item_52 = value; + break; + case 53: + _struct._unique_data_item_53 = value; + break; + case 54: + _struct._unique_data_item_54 = value; + break; + case 55: + _struct._unique_data_item_55 = value; + break; + case 56: + _struct._unique_data_item_56 = value; + break; + case 57: + _struct._unique_data_item_57 = value; + break; + case 58: + _struct._unique_data_item_58 = value; + break; + case 59: + _struct._unique_data_item_59 = value; + break; + case 60: + _struct._unique_data_item_60 = value; + break; + case 61: + _struct._unique_data_item_61 = value; + break; + case 62: + _struct._unique_data_item_62 = value; + break; + case 63: + _struct._unique_data_item_63 = value; + break; + case 64: + _struct._unique_data_item_64 = value; + break; + case 65: + _struct._unique_data_item_65 = value; + break; + case 66: + _struct._unique_data_item_66 = value; + break; + case 67: + _struct._unique_data_item_67 = value; + break; + case 68: + _struct._unique_data_item_68 = value; + break; + case 69: + _struct._unique_data_item_69 = value; + break; + case 70: + _struct._unique_data_item_70 = value; + break; + case 71: + _struct._unique_data_item_71 = value; + break; + case 72: + _struct._unique_data_item_72 = value; + break; + case 73: + _struct._unique_data_item_73 = value; + break; + case 74: + _struct._unique_data_item_74 = value; + break; + case 75: + _struct._unique_data_item_75 = value; + break; + case 76: + _struct._unique_data_item_76 = value; + break; + case 77: + _struct._unique_data_item_77 = value; + break; + case 78: + _struct._unique_data_item_78 = value; + break; + case 79: + _struct._unique_data_item_79 = value; + break; + case 80: + _struct._unique_data_item_80 = value; + break; + case 81: + _struct._unique_data_item_81 = value; + break; + case 82: + _struct._unique_data_item_82 = value; + break; + case 83: + _struct._unique_data_item_83 = value; + break; + case 84: + _struct._unique_data_item_84 = value; + break; + case 85: + _struct._unique_data_item_85 = value; + break; + case 86: + _struct._unique_data_item_86 = value; + break; + case 87: + _struct._unique_data_item_87 = value; + break; + case 88: + _struct._unique_data_item_88 = value; + break; + case 89: + _struct._unique_data_item_89 = value; + break; + case 90: + _struct._unique_data_item_90 = value; + break; + case 91: + _struct._unique_data_item_91 = value; + break; + case 92: + _struct._unique_data_item_92 = value; + break; + case 93: + _struct._unique_data_item_93 = value; + break; + case 94: + _struct._unique_data_item_94 = value; + break; + case 95: + _struct._unique_data_item_95 = value; + break; + case 96: + _struct._unique_data_item_96 = value; + break; + case 97: + _struct._unique_data_item_97 = value; + break; + case 98: + _struct._unique_data_item_98 = value; + break; + case 99: + _struct._unique_data_item_99 = value; + break; + case 100: + _struct._unique_data_item_100 = value; + break; + case 101: + _struct._unique_data_item_101 = value; + break; + case 102: + _struct._unique_data_item_102 = value; + break; + case 103: + _struct._unique_data_item_103 = value; + break; + case 104: + _struct._unique_data_item_104 = value; + break; + case 105: + _struct._unique_data_item_105 = value; + break; + case 106: + _struct._unique_data_item_106 = value; + break; + case 107: + _struct._unique_data_item_107 = value; + break; + case 108: + _struct._unique_data_item_108 = value; + break; + case 109: + _struct._unique_data_item_109 = value; + break; + case 110: + _struct._unique_data_item_110 = value; + break; + case 111: + _struct._unique_data_item_111 = value; + break; + case 112: + _struct._unique_data_item_112 = value; + break; + case 113: + _struct._unique_data_item_113 = value; + break; + case 114: + _struct._unique_data_item_114 = value; + break; + case 115: + _struct._unique_data_item_115 = value; + break; + case 116: + _struct._unique_data_item_116 = value; + break; + case 117: + _struct._unique_data_item_117 = value; + break; + case 118: + _struct._unique_data_item_118 = value; + break; + case 119: + _struct._unique_data_item_119 = value; + break; + case 120: + _struct._unique_data_item_120 = value; + break; + case 121: + _struct._unique_data_item_121 = value; + break; + case 122: + _struct._unique_data_item_122 = value; + break; + case 123: + _struct._unique_data_item_123 = value; + break; + case 124: + _struct._unique_data_item_124 = value; + break; + case 125: + _struct._unique_data_item_125 = value; + break; + case 126: + _struct._unique_data_item_126 = value; + break; + case 127: + _struct._unique_data_item_127 = value; + break; + case 128: + _struct._unique_data_item_128 = value; + break; + case 129: + _struct._unique_data_item_129 = value; + break; + case 130: + _struct._unique_data_item_130 = value; + break; + case 131: + _struct._unique_data_item_131 = value; + break; + case 132: + _struct._unique_data_item_132 = value; + break; + case 133: + _struct._unique_data_item_133 = value; + break; + case 134: + _struct._unique_data_item_134 = value; + break; + case 135: + _struct._unique_data_item_135 = value; + break; + case 136: + _struct._unique_data_item_136 = value; + break; + case 137: + _struct._unique_data_item_137 = value; + break; + case 138: + _struct._unique_data_item_138 = value; + break; + case 139: + _struct._unique_data_item_139 = value; + break; + case 140: + _struct._unique_data_item_140 = value; + break; + case 141: + _struct._unique_data_item_141 = value; + break; + case 142: + _struct._unique_data_item_142 = value; + break; + case 143: + _struct._unique_data_item_143 = value; + break; + case 144: + _struct._unique_data_item_144 = value; + break; + case 145: + _struct._unique_data_item_145 = value; + break; + case 146: + _struct._unique_data_item_146 = value; + break; + case 147: + _struct._unique_data_item_147 = value; + break; + case 148: + _struct._unique_data_item_148 = value; + break; + case 149: + _struct._unique_data_item_149 = value; + break; + case 150: + _struct._unique_data_item_150 = value; + break; + case 151: + _struct._unique_data_item_151 = value; + break; + case 152: + _struct._unique_data_item_152 = value; + break; + case 153: + _struct._unique_data_item_153 = value; + break; + case 154: + _struct._unique_data_item_154 = value; + break; + case 155: + _struct._unique_data_item_155 = value; + break; + case 156: + _struct._unique_data_item_156 = value; + break; + case 157: + _struct._unique_data_item_157 = value; + break; + case 158: + _struct._unique_data_item_158 = value; + break; + case 159: + _struct._unique_data_item_159 = value; + break; + case 160: + _struct._unique_data_item_160 = value; + break; + case 161: + _struct._unique_data_item_161 = value; + break; + case 162: + _struct._unique_data_item_162 = value; + break; + case 163: + _struct._unique_data_item_163 = value; + break; + case 164: + _struct._unique_data_item_164 = value; + break; + case 165: + _struct._unique_data_item_165 = value; + break; + case 166: + _struct._unique_data_item_166 = value; + break; + case 167: + _struct._unique_data_item_167 = value; + break; + case 168: + _struct._unique_data_item_168 = value; + break; + case 169: + _struct._unique_data_item_169 = value; + break; + case 170: + _struct._unique_data_item_170 = value; + break; + case 171: + _struct._unique_data_item_171 = value; + break; + case 172: + _struct._unique_data_item_172 = value; + break; + case 173: + _struct._unique_data_item_173 = value; + break; + case 174: + _struct._unique_data_item_174 = value; + break; + case 175: + _struct._unique_data_item_175 = value; + break; + case 176: + _struct._unique_data_item_176 = value; + break; + case 177: + _struct._unique_data_item_177 = value; + break; + case 178: + _struct._unique_data_item_178 = value; + break; + case 179: + _struct._unique_data_item_179 = value; + break; + case 180: + _struct._unique_data_item_180 = value; + break; + case 181: + _struct._unique_data_item_181 = value; + break; + case 182: + _struct._unique_data_item_182 = value; + break; + case 183: + _struct._unique_data_item_183 = value; + break; + case 184: + _struct._unique_data_item_184 = value; + break; + case 185: + _struct._unique_data_item_185 = value; + break; + case 186: + _struct._unique_data_item_186 = value; + break; + case 187: + _struct._unique_data_item_187 = value; + break; + case 188: + _struct._unique_data_item_188 = value; + break; + case 189: + _struct._unique_data_item_189 = value; + break; + case 190: + _struct._unique_data_item_190 = value; + break; + case 191: + _struct._unique_data_item_191 = value; + break; + case 192: + _struct._unique_data_item_192 = value; + break; + case 193: + _struct._unique_data_item_193 = value; + break; + case 194: + _struct._unique_data_item_194 = value; + break; + case 195: + _struct._unique_data_item_195 = value; + break; + case 196: + _struct._unique_data_item_196 = value; + break; + case 197: + _struct._unique_data_item_197 = value; + break; + case 198: + _struct._unique_data_item_198 = value; + break; + case 199: + _struct._unique_data_item_199 = value; + break; + case 200: + _struct._unique_data_item_200 = value; + break; + case 201: + _struct._unique_data_item_201 = value; + break; + case 202: + _struct._unique_data_item_202 = value; + break; + case 203: + _struct._unique_data_item_203 = value; + break; + case 204: + _struct._unique_data_item_204 = value; + break; + case 205: + _struct._unique_data_item_205 = value; + break; + case 206: + _struct._unique_data_item_206 = value; + break; + case 207: + _struct._unique_data_item_207 = value; + break; + case 208: + _struct._unique_data_item_208 = value; + break; + case 209: + _struct._unique_data_item_209 = value; + break; + case 210: + _struct._unique_data_item_210 = value; + break; + case 211: + _struct._unique_data_item_211 = value; + break; + case 212: + _struct._unique_data_item_212 = value; + break; + case 213: + _struct._unique_data_item_213 = value; + break; + case 214: + _struct._unique_data_item_214 = value; + break; + case 215: + _struct._unique_data_item_215 = value; + break; + case 216: + _struct._unique_data_item_216 = value; + break; + case 217: + _struct._unique_data_item_217 = value; + break; + case 218: + _struct._unique_data_item_218 = value; + break; + case 219: + _struct._unique_data_item_219 = value; + break; + case 220: + _struct._unique_data_item_220 = value; + break; + case 221: + _struct._unique_data_item_221 = value; + break; + case 222: + _struct._unique_data_item_222 = value; + break; + case 223: + _struct._unique_data_item_223 = value; + break; + case 224: + _struct._unique_data_item_224 = value; + break; + case 225: + _struct._unique_data_item_225 = value; + break; + case 226: + _struct._unique_data_item_226 = value; + break; + case 227: + _struct._unique_data_item_227 = value; + break; + case 228: + _struct._unique_data_item_228 = value; + break; + case 229: + _struct._unique_data_item_229 = value; + break; + case 230: + _struct._unique_data_item_230 = value; + break; + case 231: + _struct._unique_data_item_231 = value; + break; + case 232: + _struct._unique_data_item_232 = value; + break; + case 233: + _struct._unique_data_item_233 = value; + break; + case 234: + _struct._unique_data_item_234 = value; + break; + case 235: + _struct._unique_data_item_235 = value; + break; + case 236: + _struct._unique_data_item_236 = value; + break; + case 237: + _struct._unique_data_item_237 = value; + break; + case 238: + _struct._unique_data_item_238 = value; + break; + case 239: + _struct._unique_data_item_239 = value; + break; + case 240: + _struct._unique_data_item_240 = value; + break; + case 241: + _struct._unique_data_item_241 = value; + break; + case 242: + _struct._unique_data_item_242 = value; + break; + case 243: + _struct._unique_data_item_243 = value; + break; + case 244: + _struct._unique_data_item_244 = value; + break; + case 245: + _struct._unique_data_item_245 = value; + break; + case 246: + _struct._unique_data_item_246 = value; + break; + case 247: + _struct._unique_data_item_247 = value; + break; + case 248: + _struct._unique_data_item_248 = value; + break; + case 249: + _struct._unique_data_item_249 = value; + break; + case 250: + _struct._unique_data_item_250 = value; + break; + case 251: + _struct._unique_data_item_251 = value; + break; + case 252: + _struct._unique_data_item_252 = value; + break; + case 253: + _struct._unique_data_item_253 = value; + break; + case 254: + _struct._unique_data_item_254 = value; + break; + case 255: + _struct._unique_data_item_255 = value; + break; + case 256: + _struct._unique_data_item_256 = value; + break; + case 257: + _struct._unique_data_item_257 = value; + break; + case 258: + _struct._unique_data_item_258 = value; + break; + case 259: + _struct._unique_data_item_259 = value; + break; + case 260: + _struct._unique_data_item_260 = value; + break; + case 261: + _struct._unique_data_item_261 = value; + break; + case 262: + _struct._unique_data_item_262 = value; + break; + case 263: + _struct._unique_data_item_263 = value; + break; + case 264: + _struct._unique_data_item_264 = value; + break; + case 265: + _struct._unique_data_item_265 = value; + break; + case 266: + _struct._unique_data_item_266 = value; + break; + case 267: + _struct._unique_data_item_267 = value; + break; + case 268: + _struct._unique_data_item_268 = value; + break; + case 269: + _struct._unique_data_item_269 = value; + break; + case 270: + _struct._unique_data_item_270 = value; + break; + case 271: + _struct._unique_data_item_271 = value; + break; + case 272: + _struct._unique_data_item_272 = value; + break; + case 273: + _struct._unique_data_item_273 = value; + break; + case 274: + _struct._unique_data_item_274 = value; + break; + case 275: + _struct._unique_data_item_275 = value; + break; + case 276: + _struct._unique_data_item_276 = value; + break; + case 277: + _struct._unique_data_item_277 = value; + break; + case 278: + _struct._unique_data_item_278 = value; + break; + case 279: + _struct._unique_data_item_279 = value; + break; + case 280: + _struct._unique_data_item_280 = value; + break; + case 281: + _struct._unique_data_item_281 = value; + break; + case 282: + _struct._unique_data_item_282 = value; + break; + case 283: + _struct._unique_data_item_283 = value; + break; + case 284: + _struct._unique_data_item_284 = value; + break; + case 285: + _struct._unique_data_item_285 = value; + break; + case 286: + _struct._unique_data_item_286 = value; + break; + case 287: + _struct._unique_data_item_287 = value; + break; + case 288: + _struct._unique_data_item_288 = value; + break; + case 289: + _struct._unique_data_item_289 = value; + break; + case 290: + _struct._unique_data_item_290 = value; + break; + case 291: + _struct._unique_data_item_291 = value; + break; + case 292: + _struct._unique_data_item_292 = value; + break; + case 293: + _struct._unique_data_item_293 = value; + break; + case 294: + _struct._unique_data_item_294 = value; + break; + case 295: + _struct._unique_data_item_295 = value; + break; + case 296: + _struct._unique_data_item_296 = value; + break; + case 297: + _struct._unique_data_item_297 = value; + break; + case 298: + _struct._unique_data_item_298 = value; + break; + case 299: + _struct._unique_data_item_299 = value; + break; + case 300: + _struct._unique_data_item_300 = value; + break; + case 301: + _struct._unique_data_item_301 = value; + break; + case 302: + _struct._unique_data_item_302 = value; + break; + case 303: + _struct._unique_data_item_303 = value; + break; + case 304: + _struct._unique_data_item_304 = value; + break; + case 305: + _struct._unique_data_item_305 = value; + break; + case 306: + _struct._unique_data_item_306 = value; + break; + case 307: + _struct._unique_data_item_307 = value; + break; + case 308: + _struct._unique_data_item_308 = value; + break; + case 309: + _struct._unique_data_item_309 = value; + break; + case 310: + _struct._unique_data_item_310 = value; + break; + case 311: + _struct._unique_data_item_311 = value; + break; + case 312: + _struct._unique_data_item_312 = value; + break; + case 313: + _struct._unique_data_item_313 = value; + break; + case 314: + _struct._unique_data_item_314 = value; + break; + case 315: + _struct._unique_data_item_315 = value; + break; + case 316: + _struct._unique_data_item_316 = value; + break; + case 317: + _struct._unique_data_item_317 = value; + break; + case 318: + _struct._unique_data_item_318 = value; + break; + case 319: + _struct._unique_data_item_319 = value; + break; + case 320: + _struct._unique_data_item_320 = value; + break; + case 321: + _struct._unique_data_item_321 = value; + break; + case 322: + _struct._unique_data_item_322 = value; + break; + case 323: + _struct._unique_data_item_323 = value; + break; + case 324: + _struct._unique_data_item_324 = value; + break; + case 325: + _struct._unique_data_item_325 = value; + break; + case 326: + _struct._unique_data_item_326 = value; + break; + case 327: + _struct._unique_data_item_327 = value; + break; + case 328: + _struct._unique_data_item_328 = value; + break; + case 329: + _struct._unique_data_item_329 = value; + break; + case 330: + _struct._unique_data_item_330 = value; + break; + case 331: + _struct._unique_data_item_331 = value; + break; + case 332: + _struct._unique_data_item_332 = value; + break; + case 333: + _struct._unique_data_item_333 = value; + break; + case 334: + _struct._unique_data_item_334 = value; + break; + case 335: + _struct._unique_data_item_335 = value; + break; + case 336: + _struct._unique_data_item_336 = value; + break; + case 337: + _struct._unique_data_item_337 = value; + break; + case 338: + _struct._unique_data_item_338 = value; + break; + case 339: + _struct._unique_data_item_339 = value; + break; + case 340: + _struct._unique_data_item_340 = value; + break; + case 341: + _struct._unique_data_item_341 = value; + break; + case 342: + _struct._unique_data_item_342 = value; + break; + case 343: + _struct._unique_data_item_343 = value; + break; + case 344: + _struct._unique_data_item_344 = value; + break; + case 345: + _struct._unique_data_item_345 = value; + break; + case 346: + _struct._unique_data_item_346 = value; + break; + case 347: + _struct._unique_data_item_347 = value; + break; + case 348: + _struct._unique_data_item_348 = value; + break; + case 349: + _struct._unique_data_item_349 = value; + break; + case 350: + _struct._unique_data_item_350 = value; + break; + case 351: + _struct._unique_data_item_351 = value; + break; + case 352: + _struct._unique_data_item_352 = value; + break; + case 353: + _struct._unique_data_item_353 = value; + break; + case 354: + _struct._unique_data_item_354 = value; + break; + case 355: + _struct._unique_data_item_355 = value; + break; + case 356: + _struct._unique_data_item_356 = value; + break; + case 357: + _struct._unique_data_item_357 = value; + break; + case 358: + _struct._unique_data_item_358 = value; + break; + case 359: + _struct._unique_data_item_359 = value; + break; + case 360: + _struct._unique_data_item_360 = value; + break; + case 361: + _struct._unique_data_item_361 = value; + break; + case 362: + _struct._unique_data_item_362 = value; + break; + case 363: + _struct._unique_data_item_363 = value; + break; + case 364: + _struct._unique_data_item_364 = value; + break; + case 365: + _struct._unique_data_item_365 = value; + break; + case 366: + _struct._unique_data_item_366 = value; + break; + case 367: + _struct._unique_data_item_367 = value; + break; + case 368: + _struct._unique_data_item_368 = value; + break; + case 369: + _struct._unique_data_item_369 = value; + break; + case 370: + _struct._unique_data_item_370 = value; + break; + case 371: + _struct._unique_data_item_371 = value; + break; + case 372: + _struct._unique_data_item_372 = value; + break; + case 373: + _struct._unique_data_item_373 = value; + break; + case 374: + _struct._unique_data_item_374 = value; + break; + case 375: + _struct._unique_data_item_375 = value; + break; + case 376: + _struct._unique_data_item_376 = value; + break; + case 377: + _struct._unique_data_item_377 = value; + break; + case 378: + _struct._unique_data_item_378 = value; + break; + case 379: + _struct._unique_data_item_379 = value; + break; + case 380: + _struct._unique_data_item_380 = value; + break; + case 381: + _struct._unique_data_item_381 = value; + break; + case 382: + _struct._unique_data_item_382 = value; + break; + case 383: + _struct._unique_data_item_383 = value; + break; + case 384: + _struct._unique_data_item_384 = value; + break; + case 385: + _struct._unique_data_item_385 = value; + break; + case 386: + _struct._unique_data_item_386 = value; + break; + case 387: + _struct._unique_data_item_387 = value; + break; + case 388: + _struct._unique_data_item_388 = value; + break; + case 389: + _struct._unique_data_item_389 = value; + break; + case 390: + _struct._unique_data_item_390 = value; + break; + case 391: + _struct._unique_data_item_391 = value; + break; + case 392: + _struct._unique_data_item_392 = value; + break; + case 393: + _struct._unique_data_item_393 = value; + break; + case 394: + _struct._unique_data_item_394 = value; + break; + case 395: + _struct._unique_data_item_395 = value; + break; + case 396: + _struct._unique_data_item_396 = value; + break; + case 397: + _struct._unique_data_item_397 = value; + break; + case 398: + _struct._unique_data_item_398 = value; + break; + case 399: + _struct._unique_data_item_399 = value; + break; + case 400: + _struct._unique_data_item_400 = value; + break; + case 401: + _struct._unique_data_item_401 = value; + break; + case 402: + _struct._unique_data_item_402 = value; + break; + case 403: + _struct._unique_data_item_403 = value; + break; + case 404: + _struct._unique_data_item_404 = value; + break; + case 405: + _struct._unique_data_item_405 = value; + break; + case 406: + _struct._unique_data_item_406 = value; + break; + case 407: + _struct._unique_data_item_407 = value; + break; + case 408: + _struct._unique_data_item_408 = value; + break; + case 409: + _struct._unique_data_item_409 = value; + break; + case 410: + _struct._unique_data_item_410 = value; + break; + case 411: + _struct._unique_data_item_411 = value; + break; + case 412: + _struct._unique_data_item_412 = value; + break; + case 413: + _struct._unique_data_item_413 = value; + break; + case 414: + _struct._unique_data_item_414 = value; + break; + case 415: + _struct._unique_data_item_415 = value; + break; + case 416: + _struct._unique_data_item_416 = value; + break; + case 417: + _struct._unique_data_item_417 = value; + break; + case 418: + _struct._unique_data_item_418 = value; + break; + case 419: + _struct._unique_data_item_419 = value; + break; + case 420: + _struct._unique_data_item_420 = value; + break; + case 421: + _struct._unique_data_item_421 = value; + break; + case 422: + _struct._unique_data_item_422 = value; + break; + case 423: + _struct._unique_data_item_423 = value; + break; + case 424: + _struct._unique_data_item_424 = value; + break; + case 425: + _struct._unique_data_item_425 = value; + break; + case 426: + _struct._unique_data_item_426 = value; + break; + case 427: + _struct._unique_data_item_427 = value; + break; + case 428: + _struct._unique_data_item_428 = value; + break; + case 429: + _struct._unique_data_item_429 = value; + break; + case 430: + _struct._unique_data_item_430 = value; + break; + case 431: + _struct._unique_data_item_431 = value; + break; + case 432: + _struct._unique_data_item_432 = value; + break; + case 433: + _struct._unique_data_item_433 = value; + break; + case 434: + _struct._unique_data_item_434 = value; + break; + case 435: + _struct._unique_data_item_435 = value; + break; + case 436: + _struct._unique_data_item_436 = value; + break; + case 437: + _struct._unique_data_item_437 = value; + break; + case 438: + _struct._unique_data_item_438 = value; + break; + case 439: + _struct._unique_data_item_439 = value; + break; + case 440: + _struct._unique_data_item_440 = value; + break; + case 441: + _struct._unique_data_item_441 = value; + break; + case 442: + _struct._unique_data_item_442 = value; + break; + case 443: + _struct._unique_data_item_443 = value; + break; + case 444: + _struct._unique_data_item_444 = value; + break; + case 445: + _struct._unique_data_item_445 = value; + break; + case 446: + _struct._unique_data_item_446 = value; + break; + case 447: + _struct._unique_data_item_447 = value; + break; + case 448: + _struct._unique_data_item_448 = value; + break; + case 449: + _struct._unique_data_item_449 = value; + break; + case 450: + _struct._unique_data_item_450 = value; + break; + case 451: + _struct._unique_data_item_451 = value; + break; + case 452: + _struct._unique_data_item_452 = value; + break; + case 453: + _struct._unique_data_item_453 = value; + break; + case 454: + _struct._unique_data_item_454 = value; + break; + case 455: + _struct._unique_data_item_455 = value; + break; + case 456: + _struct._unique_data_item_456 = value; + break; + case 457: + _struct._unique_data_item_457 = value; + break; + case 458: + _struct._unique_data_item_458 = value; + break; + case 459: + _struct._unique_data_item_459 = value; + break; + case 460: + _struct._unique_data_item_460 = value; + break; + case 461: + _struct._unique_data_item_461 = value; + break; + case 462: + _struct._unique_data_item_462 = value; + break; + case 463: + _struct._unique_data_item_463 = value; + break; + case 464: + _struct._unique_data_item_464 = value; + break; + case 465: + _struct._unique_data_item_465 = value; + break; + case 466: + _struct._unique_data_item_466 = value; + break; + case 467: + _struct._unique_data_item_467 = value; + break; + case 468: + _struct._unique_data_item_468 = value; + break; + case 469: + _struct._unique_data_item_469 = value; + break; + case 470: + _struct._unique_data_item_470 = value; + break; + case 471: + _struct._unique_data_item_471 = value; + break; + case 472: + _struct._unique_data_item_472 = value; + break; + case 473: + _struct._unique_data_item_473 = value; + break; + case 474: + _struct._unique_data_item_474 = value; + break; + case 475: + _struct._unique_data_item_475 = value; + break; + case 476: + _struct._unique_data_item_476 = value; + break; + case 477: + _struct._unique_data_item_477 = value; + break; + case 478: + _struct._unique_data_item_478 = value; + break; + case 479: + _struct._unique_data_item_479 = value; + break; + case 480: + _struct._unique_data_item_480 = value; + break; + case 481: + _struct._unique_data_item_481 = value; + break; + case 482: + _struct._unique_data_item_482 = value; + break; + case 483: + _struct._unique_data_item_483 = value; + break; + case 484: + _struct._unique_data_item_484 = value; + break; + case 485: + _struct._unique_data_item_485 = value; + break; + case 486: + _struct._unique_data_item_486 = value; + break; + case 487: + _struct._unique_data_item_487 = value; + break; + case 488: + _struct._unique_data_item_488 = value; + break; + case 489: + _struct._unique_data_item_489 = value; + break; + case 490: + _struct._unique_data_item_490 = value; + break; + case 491: + _struct._unique_data_item_491 = value; + break; + case 492: + _struct._unique_data_item_492 = value; + break; + case 493: + _struct._unique_data_item_493 = value; + break; + case 494: + _struct._unique_data_item_494 = value; + break; + case 495: + _struct._unique_data_item_495 = value; + break; + case 496: + _struct._unique_data_item_496 = value; + break; + case 497: + _struct._unique_data_item_497 = value; + break; + case 498: + _struct._unique_data_item_498 = value; + break; + case 499: + _struct._unique_data_item_499 = value; + break; + case 500: + _struct._unique_data_item_500 = value; + break; + case 501: + _struct._unique_data_item_501 = value; + break; + case 502: + _struct._unique_data_item_502 = value; + break; + case 503: + _struct._unique_data_item_503 = value; + break; + case 504: + _struct._unique_data_item_504 = value; + break; + case 505: + _struct._unique_data_item_505 = value; + break; + case 506: + _struct._unique_data_item_506 = value; + break; + case 507: + _struct._unique_data_item_507 = value; + break; + case 508: + _struct._unique_data_item_508 = value; + break; + case 509: + _struct._unique_data_item_509 = value; + break; + case 510: + _struct._unique_data_item_510 = value; + break; + case 511: + _struct._unique_data_item_511 = value; + break; + case 512: + _struct._unique_data_item_512 = value; + break; + case 513: + _struct._unique_data_item_513 = value; + break; + case 514: + _struct._unique_data_item_514 = value; + break; + case 515: + _struct._unique_data_item_515 = value; + break; + case 516: + _struct._unique_data_item_516 = value; + break; + case 517: + _struct._unique_data_item_517 = value; + break; + case 518: + _struct._unique_data_item_518 = value; + break; + case 519: + _struct._unique_data_item_519 = value; + break; + case 520: + _struct._unique_data_item_520 = value; + break; + case 521: + _struct._unique_data_item_521 = value; + break; + case 522: + _struct._unique_data_item_522 = value; + break; + case 523: + _struct._unique_data_item_523 = value; + break; + case 524: + _struct._unique_data_item_524 = value; + break; + case 525: + _struct._unique_data_item_525 = value; + break; + case 526: + _struct._unique_data_item_526 = value; + break; + case 527: + _struct._unique_data_item_527 = value; + break; + case 528: + _struct._unique_data_item_528 = value; + break; + case 529: + _struct._unique_data_item_529 = value; + break; + case 530: + _struct._unique_data_item_530 = value; + break; + case 531: + _struct._unique_data_item_531 = value; + break; + case 532: + _struct._unique_data_item_532 = value; + break; + case 533: + _struct._unique_data_item_533 = value; + break; + case 534: + _struct._unique_data_item_534 = value; + break; + case 535: + _struct._unique_data_item_535 = value; + break; + case 536: + _struct._unique_data_item_536 = value; + break; + case 537: + _struct._unique_data_item_537 = value; + break; + case 538: + _struct._unique_data_item_538 = value; + break; + case 539: + _struct._unique_data_item_539 = value; + break; + case 540: + _struct._unique_data_item_540 = value; + break; + case 541: + _struct._unique_data_item_541 = value; + break; + case 542: + _struct._unique_data_item_542 = value; + break; + case 543: + _struct._unique_data_item_543 = value; + break; + case 544: + _struct._unique_data_item_544 = value; + break; + case 545: + _struct._unique_data_item_545 = value; + break; + case 546: + _struct._unique_data_item_546 = value; + break; + case 547: + _struct._unique_data_item_547 = value; + break; + case 548: + _struct._unique_data_item_548 = value; + break; + case 549: + _struct._unique_data_item_549 = value; + break; + case 550: + _struct._unique_data_item_550 = value; + break; + case 551: + _struct._unique_data_item_551 = value; + break; + case 552: + _struct._unique_data_item_552 = value; + break; + case 553: + _struct._unique_data_item_553 = value; + break; + case 554: + _struct._unique_data_item_554 = value; + break; + case 555: + _struct._unique_data_item_555 = value; + break; + case 556: + _struct._unique_data_item_556 = value; + break; + case 557: + _struct._unique_data_item_557 = value; + break; + case 558: + _struct._unique_data_item_558 = value; + break; + case 559: + _struct._unique_data_item_559 = value; + break; + case 560: + _struct._unique_data_item_560 = value; + break; + case 561: + _struct._unique_data_item_561 = value; + break; + case 562: + _struct._unique_data_item_562 = value; + break; + case 563: + _struct._unique_data_item_563 = value; + break; + case 564: + _struct._unique_data_item_564 = value; + break; + case 565: + _struct._unique_data_item_565 = value; + break; + case 566: + _struct._unique_data_item_566 = value; + break; + case 567: + _struct._unique_data_item_567 = value; + break; + case 568: + _struct._unique_data_item_568 = value; + break; + case 569: + _struct._unique_data_item_569 = value; + break; + case 570: + _struct._unique_data_item_570 = value; + break; + case 571: + _struct._unique_data_item_571 = value; + break; + case 572: + _struct._unique_data_item_572 = value; + break; + case 573: + _struct._unique_data_item_573 = value; + break; + case 574: + _struct._unique_data_item_574 = value; + break; + case 575: + _struct._unique_data_item_575 = value; + break; + case 576: + _struct._unique_data_item_576 = value; + break; + case 577: + _struct._unique_data_item_577 = value; + break; + case 578: + _struct._unique_data_item_578 = value; + break; + case 579: + _struct._unique_data_item_579 = value; + break; + case 580: + _struct._unique_data_item_580 = value; + break; + case 581: + _struct._unique_data_item_581 = value; + break; + case 582: + _struct._unique_data_item_582 = value; + break; + case 583: + _struct._unique_data_item_583 = value; + break; + case 584: + _struct._unique_data_item_584 = value; + break; + case 585: + _struct._unique_data_item_585 = value; + break; + case 586: + _struct._unique_data_item_586 = value; + break; + case 587: + _struct._unique_data_item_587 = value; + break; + case 588: + _struct._unique_data_item_588 = value; + break; + case 589: + _struct._unique_data_item_589 = value; + break; + case 590: + _struct._unique_data_item_590 = value; + break; + case 591: + _struct._unique_data_item_591 = value; + break; + case 592: + _struct._unique_data_item_592 = value; + break; + case 593: + _struct._unique_data_item_593 = value; + break; + case 594: + _struct._unique_data_item_594 = value; + break; + case 595: + _struct._unique_data_item_595 = value; + break; + case 596: + _struct._unique_data_item_596 = value; + break; + case 597: + _struct._unique_data_item_597 = value; + break; + case 598: + _struct._unique_data_item_598 = value; + break; + case 599: + _struct._unique_data_item_599 = value; + break; + case 600: + _struct._unique_data_item_600 = value; + break; + case 601: + _struct._unique_data_item_601 = value; + break; + case 602: + _struct._unique_data_item_602 = value; + break; + case 603: + _struct._unique_data_item_603 = value; + break; + case 604: + _struct._unique_data_item_604 = value; + break; + case 605: + _struct._unique_data_item_605 = value; + break; + case 606: + _struct._unique_data_item_606 = value; + break; + case 607: + _struct._unique_data_item_607 = value; + break; + case 608: + _struct._unique_data_item_608 = value; + break; + case 609: + _struct._unique_data_item_609 = value; + break; + case 610: + _struct._unique_data_item_610 = value; + break; + case 611: + _struct._unique_data_item_611 = value; + break; + case 612: + _struct._unique_data_item_612 = value; + break; + case 613: + _struct._unique_data_item_613 = value; + break; + case 614: + _struct._unique_data_item_614 = value; + break; + case 615: + _struct._unique_data_item_615 = value; + break; + case 616: + _struct._unique_data_item_616 = value; + break; + case 617: + _struct._unique_data_item_617 = value; + break; + case 618: + _struct._unique_data_item_618 = value; + break; + case 619: + _struct._unique_data_item_619 = value; + break; + case 620: + _struct._unique_data_item_620 = value; + break; + case 621: + _struct._unique_data_item_621 = value; + break; + case 622: + _struct._unique_data_item_622 = value; + break; + case 623: + _struct._unique_data_item_623 = value; + break; + case 624: + _struct._unique_data_item_624 = value; + break; + case 625: + _struct._unique_data_item_625 = value; + break; + case 626: + _struct._unique_data_item_626 = value; + break; + case 627: + _struct._unique_data_item_627 = value; + break; + case 628: + _struct._unique_data_item_628 = value; + break; + case 629: + _struct._unique_data_item_629 = value; + break; + case 630: + _struct._unique_data_item_630 = value; + break; + case 631: + _struct._unique_data_item_631 = value; + break; + case 632: + _struct._unique_data_item_632 = value; + break; + case 633: + _struct._unique_data_item_633 = value; + break; + case 634: + _struct._unique_data_item_634 = value; + break; + case 635: + _struct._unique_data_item_635 = value; + break; + case 636: + _struct._unique_data_item_636 = value; + break; + case 637: + _struct._unique_data_item_637 = value; + break; + case 638: + _struct._unique_data_item_638 = value; + break; + case 639: + _struct._unique_data_item_639 = value; + break; + case 640: + _struct._unique_data_item_640 = value; + break; + case 641: + _struct._unique_data_item_641 = value; + break; + case 642: + _struct._unique_data_item_642 = value; + break; + case 643: + _struct._unique_data_item_643 = value; + break; + case 644: + _struct._unique_data_item_644 = value; + break; + case 645: + _struct._unique_data_item_645 = value; + break; + case 646: + _struct._unique_data_item_646 = value; + break; + case 647: + _struct._unique_data_item_647 = value; + break; + case 648: + _struct._unique_data_item_648 = value; + break; + case 649: + _struct._unique_data_item_649 = value; + break; + case 650: + _struct._unique_data_item_650 = value; + break; + case 651: + _struct._unique_data_item_651 = value; + break; + case 652: + _struct._unique_data_item_652 = value; + break; + case 653: + _struct._unique_data_item_653 = value; + break; + case 654: + _struct._unique_data_item_654 = value; + break; + case 655: + _struct._unique_data_item_655 = value; + break; + case 656: + _struct._unique_data_item_656 = value; + break; + case 657: + _struct._unique_data_item_657 = value; + break; + case 658: + _struct._unique_data_item_658 = value; + break; + case 659: + _struct._unique_data_item_659 = value; + break; + case 660: + _struct._unique_data_item_660 = value; + break; + case 661: + _struct._unique_data_item_661 = value; + break; + case 662: + _struct._unique_data_item_662 = value; + break; + case 663: + _struct._unique_data_item_663 = value; + break; + case 664: + _struct._unique_data_item_664 = value; + break; + case 665: + _struct._unique_data_item_665 = value; + break; + case 666: + _struct._unique_data_item_666 = value; + break; + case 667: + _struct._unique_data_item_667 = value; + break; + case 668: + _struct._unique_data_item_668 = value; + break; + case 669: + _struct._unique_data_item_669 = value; + break; + case 670: + _struct._unique_data_item_670 = value; + break; + case 671: + _struct._unique_data_item_671 = value; + break; + case 672: + _struct._unique_data_item_672 = value; + break; + case 673: + _struct._unique_data_item_673 = value; + break; + case 674: + _struct._unique_data_item_674 = value; + break; + case 675: + _struct._unique_data_item_675 = value; + break; + case 676: + _struct._unique_data_item_676 = value; + break; + case 677: + _struct._unique_data_item_677 = value; + break; + case 678: + _struct._unique_data_item_678 = value; + break; + case 679: + _struct._unique_data_item_679 = value; + break; + case 680: + _struct._unique_data_item_680 = value; + break; + case 681: + _struct._unique_data_item_681 = value; + break; + case 682: + _struct._unique_data_item_682 = value; + break; + case 683: + _struct._unique_data_item_683 = value; + break; + case 684: + _struct._unique_data_item_684 = value; + break; + case 685: + _struct._unique_data_item_685 = value; + break; + case 686: + _struct._unique_data_item_686 = value; + break; + case 687: + _struct._unique_data_item_687 = value; + break; + case 688: + _struct._unique_data_item_688 = value; + break; + case 689: + _struct._unique_data_item_689 = value; + break; + case 690: + _struct._unique_data_item_690 = value; + break; + case 691: + _struct._unique_data_item_691 = value; + break; + case 692: + _struct._unique_data_item_692 = value; + break; + case 693: + _struct._unique_data_item_693 = value; + break; + case 694: + _struct._unique_data_item_694 = value; + break; + case 695: + _struct._unique_data_item_695 = value; + break; + case 696: + _struct._unique_data_item_696 = value; + break; + case 697: + _struct._unique_data_item_697 = value; + break; + case 698: + _struct._unique_data_item_698 = value; + break; + case 699: + _struct._unique_data_item_699 = value; + break; + case 700: + _struct._unique_data_item_700 = value; + break; + case 701: + _struct._unique_data_item_701 = value; + break; + case 702: + _struct._unique_data_item_702 = value; + break; + case 703: + _struct._unique_data_item_703 = value; + break; + case 704: + _struct._unique_data_item_704 = value; + break; + case 705: + _struct._unique_data_item_705 = value; + break; + case 706: + _struct._unique_data_item_706 = value; + break; + case 707: + _struct._unique_data_item_707 = value; + break; + case 708: + _struct._unique_data_item_708 = value; + break; + case 709: + _struct._unique_data_item_709 = value; + break; + case 710: + _struct._unique_data_item_710 = value; + break; + case 711: + _struct._unique_data_item_711 = value; + break; + case 712: + _struct._unique_data_item_712 = value; + break; + case 713: + _struct._unique_data_item_713 = value; + break; + case 714: + _struct._unique_data_item_714 = value; + break; + case 715: + _struct._unique_data_item_715 = value; + break; + case 716: + _struct._unique_data_item_716 = value; + break; + case 717: + _struct._unique_data_item_717 = value; + break; + case 718: + _struct._unique_data_item_718 = value; + break; + case 719: + _struct._unique_data_item_719 = value; + break; + case 720: + _struct._unique_data_item_720 = value; + break; + case 721: + _struct._unique_data_item_721 = value; + break; + case 722: + _struct._unique_data_item_722 = value; + break; + case 723: + _struct._unique_data_item_723 = value; + break; + case 724: + _struct._unique_data_item_724 = value; + break; + case 725: + _struct._unique_data_item_725 = value; + break; + case 726: + _struct._unique_data_item_726 = value; + break; + case 727: + _struct._unique_data_item_727 = value; + break; + case 728: + _struct._unique_data_item_728 = value; + break; + case 729: + _struct._unique_data_item_729 = value; + break; + case 730: + _struct._unique_data_item_730 = value; + break; + case 731: + _struct._unique_data_item_731 = value; + break; + case 732: + _struct._unique_data_item_732 = value; + break; + case 733: + _struct._unique_data_item_733 = value; + break; + case 734: + _struct._unique_data_item_734 = value; + break; + case 735: + _struct._unique_data_item_735 = value; + break; + case 736: + _struct._unique_data_item_736 = value; + break; + case 737: + _struct._unique_data_item_737 = value; + break; + case 738: + _struct._unique_data_item_738 = value; + break; + case 739: + _struct._unique_data_item_739 = value; + break; + case 740: + _struct._unique_data_item_740 = value; + break; + case 741: + _struct._unique_data_item_741 = value; + break; + case 742: + _struct._unique_data_item_742 = value; + break; + case 743: + _struct._unique_data_item_743 = value; + break; + case 744: + _struct._unique_data_item_744 = value; + break; + case 745: + _struct._unique_data_item_745 = value; + break; + case 746: + _struct._unique_data_item_746 = value; + break; + case 747: + _struct._unique_data_item_747 = value; + break; + case 748: + _struct._unique_data_item_748 = value; + break; + case 749: + _struct._unique_data_item_749 = value; + break; + case 750: + _struct._unique_data_item_750 = value; + break; + case 751: + _struct._unique_data_item_751 = value; + break; + case 752: + _struct._unique_data_item_752 = value; + break; + case 753: + _struct._unique_data_item_753 = value; + break; + case 754: + _struct._unique_data_item_754 = value; + break; + case 755: + _struct._unique_data_item_755 = value; + break; + case 756: + _struct._unique_data_item_756 = value; + break; + case 757: + _struct._unique_data_item_757 = value; + break; + case 758: + _struct._unique_data_item_758 = value; + break; + case 759: + _struct._unique_data_item_759 = value; + break; + case 760: + _struct._unique_data_item_760 = value; + break; + case 761: + _struct._unique_data_item_761 = value; + break; + case 762: + _struct._unique_data_item_762 = value; + break; + case 763: + _struct._unique_data_item_763 = value; + break; + case 764: + _struct._unique_data_item_764 = value; + break; + case 765: + _struct._unique_data_item_765 = value; + break; + case 766: + _struct._unique_data_item_766 = value; + break; + case 767: + _struct._unique_data_item_767 = value; + break; + case 768: + _struct._unique_data_item_768 = value; + break; + case 769: + _struct._unique_data_item_769 = value; + break; + case 770: + _struct._unique_data_item_770 = value; + break; + case 771: + _struct._unique_data_item_771 = value; + break; + case 772: + _struct._unique_data_item_772 = value; + break; + case 773: + _struct._unique_data_item_773 = value; + break; + case 774: + _struct._unique_data_item_774 = value; + break; + case 775: + _struct._unique_data_item_775 = value; + break; + case 776: + _struct._unique_data_item_776 = value; + break; + case 777: + _struct._unique_data_item_777 = value; + break; + case 778: + _struct._unique_data_item_778 = value; + break; + case 779: + _struct._unique_data_item_779 = value; + break; + case 780: + _struct._unique_data_item_780 = value; + break; + case 781: + _struct._unique_data_item_781 = value; + break; + case 782: + _struct._unique_data_item_782 = value; + break; + case 783: + _struct._unique_data_item_783 = value; + break; + case 784: + _struct._unique_data_item_784 = value; + break; + case 785: + _struct._unique_data_item_785 = value; + break; + case 786: + _struct._unique_data_item_786 = value; + break; + case 787: + _struct._unique_data_item_787 = value; + break; + case 788: + _struct._unique_data_item_788 = value; + break; + case 789: + _struct._unique_data_item_789 = value; + break; + case 790: + _struct._unique_data_item_790 = value; + break; + case 791: + _struct._unique_data_item_791 = value; + break; + case 792: + _struct._unique_data_item_792 = value; + break; + case 793: + _struct._unique_data_item_793 = value; + break; + case 794: + _struct._unique_data_item_794 = value; + break; + case 795: + _struct._unique_data_item_795 = value; + break; + case 796: + _struct._unique_data_item_796 = value; + break; + case 797: + _struct._unique_data_item_797 = value; + break; + case 798: + _struct._unique_data_item_798 = value; + break; + case 799: + _struct._unique_data_item_799 = value; + break; + case 800: + _struct._unique_data_item_800 = value; + break; + case 801: + _struct._unique_data_item_801 = value; + break; + case 802: + _struct._unique_data_item_802 = value; + break; + case 803: + _struct._unique_data_item_803 = value; + break; + case 804: + _struct._unique_data_item_804 = value; + break; + case 805: + _struct._unique_data_item_805 = value; + break; + case 806: + _struct._unique_data_item_806 = value; + break; + case 807: + _struct._unique_data_item_807 = value; + break; + case 808: + _struct._unique_data_item_808 = value; + break; + case 809: + _struct._unique_data_item_809 = value; + break; + case 810: + _struct._unique_data_item_810 = value; + break; + case 811: + _struct._unique_data_item_811 = value; + break; + case 812: + _struct._unique_data_item_812 = value; + break; + case 813: + _struct._unique_data_item_813 = value; + break; + case 814: + _struct._unique_data_item_814 = value; + break; + case 815: + _struct._unique_data_item_815 = value; + break; + case 816: + _struct._unique_data_item_816 = value; + break; + case 817: + _struct._unique_data_item_817 = value; + break; + case 818: + _struct._unique_data_item_818 = value; + break; + case 819: + _struct._unique_data_item_819 = value; + break; + case 820: + _struct._unique_data_item_820 = value; + break; + case 821: + _struct._unique_data_item_821 = value; + break; + case 822: + _struct._unique_data_item_822 = value; + break; + case 823: + _struct._unique_data_item_823 = value; + break; + case 824: + _struct._unique_data_item_824 = value; + break; + case 825: + _struct._unique_data_item_825 = value; + break; + case 826: + _struct._unique_data_item_826 = value; + break; + case 827: + _struct._unique_data_item_827 = value; + break; + case 828: + _struct._unique_data_item_828 = value; + break; + case 829: + _struct._unique_data_item_829 = value; + break; + case 830: + _struct._unique_data_item_830 = value; + break; + case 831: + _struct._unique_data_item_831 = value; + break; + case 832: + _struct._unique_data_item_832 = value; + break; + case 833: + _struct._unique_data_item_833 = value; + break; + case 834: + _struct._unique_data_item_834 = value; + break; + case 835: + _struct._unique_data_item_835 = value; + break; + case 836: + _struct._unique_data_item_836 = value; + break; + case 837: + _struct._unique_data_item_837 = value; + break; + case 838: + _struct._unique_data_item_838 = value; + break; + case 839: + _struct._unique_data_item_839 = value; + break; + case 840: + _struct._unique_data_item_840 = value; + break; + case 841: + _struct._unique_data_item_841 = value; + break; + case 842: + _struct._unique_data_item_842 = value; + break; + case 843: + _struct._unique_data_item_843 = value; + break; + case 844: + _struct._unique_data_item_844 = value; + break; + case 845: + _struct._unique_data_item_845 = value; + break; + case 846: + _struct._unique_data_item_846 = value; + break; + case 847: + _struct._unique_data_item_847 = value; + break; + case 848: + _struct._unique_data_item_848 = value; + break; + case 849: + _struct._unique_data_item_849 = value; + break; + case 850: + _struct._unique_data_item_850 = value; + break; + case 851: + _struct._unique_data_item_851 = value; + break; + case 852: + _struct._unique_data_item_852 = value; + break; + case 853: + _struct._unique_data_item_853 = value; + break; + case 854: + _struct._unique_data_item_854 = value; + break; + case 855: + _struct._unique_data_item_855 = value; + break; + case 856: + _struct._unique_data_item_856 = value; + break; + case 857: + _struct._unique_data_item_857 = value; + break; + case 858: + _struct._unique_data_item_858 = value; + break; + case 859: + _struct._unique_data_item_859 = value; + break; + case 860: + _struct._unique_data_item_860 = value; + break; + case 861: + _struct._unique_data_item_861 = value; + break; + case 862: + _struct._unique_data_item_862 = value; + break; + case 863: + _struct._unique_data_item_863 = value; + break; + case 864: + _struct._unique_data_item_864 = value; + break; + case 865: + _struct._unique_data_item_865 = value; + break; + case 866: + _struct._unique_data_item_866 = value; + break; + case 867: + _struct._unique_data_item_867 = value; + break; + case 868: + _struct._unique_data_item_868 = value; + break; + case 869: + _struct._unique_data_item_869 = value; + break; + case 870: + _struct._unique_data_item_870 = value; + break; + case 871: + _struct._unique_data_item_871 = value; + break; + case 872: + _struct._unique_data_item_872 = value; + break; + case 873: + _struct._unique_data_item_873 = value; + break; + case 874: + _struct._unique_data_item_874 = value; + break; + case 875: + _struct._unique_data_item_875 = value; + break; + case 876: + _struct._unique_data_item_876 = value; + break; + case 877: + _struct._unique_data_item_877 = value; + break; + case 878: + _struct._unique_data_item_878 = value; + break; + case 879: + _struct._unique_data_item_879 = value; + break; + case 880: + _struct._unique_data_item_880 = value; + break; + case 881: + _struct._unique_data_item_881 = value; + break; + case 882: + _struct._unique_data_item_882 = value; + break; + case 883: + _struct._unique_data_item_883 = value; + break; + case 884: + _struct._unique_data_item_884 = value; + break; + case 885: + _struct._unique_data_item_885 = value; + break; + case 886: + _struct._unique_data_item_886 = value; + break; + case 887: + _struct._unique_data_item_887 = value; + break; + case 888: + _struct._unique_data_item_888 = value; + break; + case 889: + _struct._unique_data_item_889 = value; + break; + case 890: + _struct._unique_data_item_890 = value; + break; + case 891: + _struct._unique_data_item_891 = value; + break; + case 892: + _struct._unique_data_item_892 = value; + break; + case 893: + _struct._unique_data_item_893 = value; + break; + case 894: + _struct._unique_data_item_894 = value; + break; + case 895: + _struct._unique_data_item_895 = value; + break; + case 896: + _struct._unique_data_item_896 = value; + break; + case 897: + _struct._unique_data_item_897 = value; + break; + case 898: + _struct._unique_data_item_898 = value; + break; + case 899: + _struct._unique_data_item_899 = value; + break; + case 900: + _struct._unique_data_item_900 = value; + break; + case 901: + _struct._unique_data_item_901 = value; + break; + case 902: + _struct._unique_data_item_902 = value; + break; + case 903: + _struct._unique_data_item_903 = value; + break; + case 904: + _struct._unique_data_item_904 = value; + break; + case 905: + _struct._unique_data_item_905 = value; + break; + case 906: + _struct._unique_data_item_906 = value; + break; + case 907: + _struct._unique_data_item_907 = value; + break; + case 908: + _struct._unique_data_item_908 = value; + break; + case 909: + _struct._unique_data_item_909 = value; + break; + case 910: + _struct._unique_data_item_910 = value; + break; + case 911: + _struct._unique_data_item_911 = value; + break; + case 912: + _struct._unique_data_item_912 = value; + break; + case 913: + _struct._unique_data_item_913 = value; + break; + case 914: + _struct._unique_data_item_914 = value; + break; + case 915: + _struct._unique_data_item_915 = value; + break; + case 916: + _struct._unique_data_item_916 = value; + break; + case 917: + _struct._unique_data_item_917 = value; + break; + case 918: + _struct._unique_data_item_918 = value; + break; + case 919: + _struct._unique_data_item_919 = value; + break; + case 920: + _struct._unique_data_item_920 = value; + break; + case 921: + _struct._unique_data_item_921 = value; + break; + case 922: + _struct._unique_data_item_922 = value; + break; + case 923: + _struct._unique_data_item_923 = value; + break; + case 924: + _struct._unique_data_item_924 = value; + break; + case 925: + _struct._unique_data_item_925 = value; + break; + case 926: + _struct._unique_data_item_926 = value; + break; + case 927: + _struct._unique_data_item_927 = value; + break; + case 928: + _struct._unique_data_item_928 = value; + break; + case 929: + _struct._unique_data_item_929 = value; + break; + case 930: + _struct._unique_data_item_930 = value; + break; + case 931: + _struct._unique_data_item_931 = value; + break; + case 932: + _struct._unique_data_item_932 = value; + break; + case 933: + _struct._unique_data_item_933 = value; + break; + case 934: + _struct._unique_data_item_934 = value; + break; + case 935: + _struct._unique_data_item_935 = value; + break; + case 936: + _struct._unique_data_item_936 = value; + break; + case 937: + _struct._unique_data_item_937 = value; + break; + case 938: + _struct._unique_data_item_938 = value; + break; + case 939: + _struct._unique_data_item_939 = value; + break; + case 940: + _struct._unique_data_item_940 = value; + break; + case 941: + _struct._unique_data_item_941 = value; + break; + case 942: + _struct._unique_data_item_942 = value; + break; + case 943: + _struct._unique_data_item_943 = value; + break; + case 944: + _struct._unique_data_item_944 = value; + break; + case 945: + _struct._unique_data_item_945 = value; + break; + case 946: + _struct._unique_data_item_946 = value; + break; + case 947: + _struct._unique_data_item_947 = value; + break; + case 948: + _struct._unique_data_item_948 = value; + break; + case 949: + _struct._unique_data_item_949 = value; + break; + case 950: + _struct._unique_data_item_950 = value; + break; + case 951: + _struct._unique_data_item_951 = value; + break; + case 952: + _struct._unique_data_item_952 = value; + break; + case 953: + _struct._unique_data_item_953 = value; + break; + case 954: + _struct._unique_data_item_954 = value; + break; + case 955: + _struct._unique_data_item_955 = value; + break; + case 956: + _struct._unique_data_item_956 = value; + break; + case 957: + _struct._unique_data_item_957 = value; + break; + case 958: + _struct._unique_data_item_958 = value; + break; + case 959: + _struct._unique_data_item_959 = value; + break; + case 960: + _struct._unique_data_item_960 = value; + break; + case 961: + _struct._unique_data_item_961 = value; + break; + case 962: + _struct._unique_data_item_962 = value; + break; + case 963: + _struct._unique_data_item_963 = value; + break; + case 964: + _struct._unique_data_item_964 = value; + break; + case 965: + _struct._unique_data_item_965 = value; + break; + case 966: + _struct._unique_data_item_966 = value; + break; + case 967: + _struct._unique_data_item_967 = value; + break; + case 968: + _struct._unique_data_item_968 = value; + break; + case 969: + _struct._unique_data_item_969 = value; + break; + case 970: + _struct._unique_data_item_970 = value; + break; + case 971: + _struct._unique_data_item_971 = value; + break; + case 972: + _struct._unique_data_item_972 = value; + break; + case 973: + _struct._unique_data_item_973 = value; + break; + case 974: + _struct._unique_data_item_974 = value; + break; + case 975: + _struct._unique_data_item_975 = value; + break; + case 976: + _struct._unique_data_item_976 = value; + break; + case 977: + _struct._unique_data_item_977 = value; + break; + case 978: + _struct._unique_data_item_978 = value; + break; + case 979: + _struct._unique_data_item_979 = value; + break; + case 980: + _struct._unique_data_item_980 = value; + break; + case 981: + _struct._unique_data_item_981 = value; + break; + case 982: + _struct._unique_data_item_982 = value; + break; + case 983: + _struct._unique_data_item_983 = value; + break; + case 984: + _struct._unique_data_item_984 = value; + break; + case 985: + _struct._unique_data_item_985 = value; + break; + case 986: + _struct._unique_data_item_986 = value; + break; + case 987: + _struct._unique_data_item_987 = value; + break; + case 988: + _struct._unique_data_item_988 = value; + break; + case 989: + _struct._unique_data_item_989 = value; + break; + case 990: + _struct._unique_data_item_990 = value; + break; + case 991: + _struct._unique_data_item_991 = value; + break; + case 992: + _struct._unique_data_item_992 = value; + break; + case 993: + _struct._unique_data_item_993 = value; + break; + case 994: + _struct._unique_data_item_994 = value; + break; + case 995: + _struct._unique_data_item_995 = value; + break; + case 996: + _struct._unique_data_item_996 = value; + break; + case 997: + _struct._unique_data_item_997 = value; + break; + case 998: + _struct._unique_data_item_998 = value; + break; + case 999: + _struct._unique_data_item_999 = value; + break; + case 1000: + _struct._unique_data_item_1000 = value; + break; + case 1001: + _struct._unique_data_item_1001 = value; + break; + case 1002: + _struct._unique_data_item_1002 = value; + break; + case 1003: + _struct._unique_data_item_1003 = value; + break; + case 1004: + _struct._unique_data_item_1004 = value; + break; + case 1005: + _struct._unique_data_item_1005 = value; + break; + case 1006: + _struct._unique_data_item_1006 = value; + break; + case 1007: + _struct._unique_data_item_1007 = value; + break; + case 1008: + _struct._unique_data_item_1008 = value; + break; + case 1009: + _struct._unique_data_item_1009 = value; + break; + case 1010: + _struct._unique_data_item_1010 = value; + break; + case 1011: + _struct._unique_data_item_1011 = value; + break; + case 1012: + _struct._unique_data_item_1012 = value; + break; + case 1013: + _struct._unique_data_item_1013 = value; + break; + case 1014: + _struct._unique_data_item_1014 = value; + break; + case 1015: + _struct._unique_data_item_1015 = value; + break; + case 1016: + _struct._unique_data_item_1016 = value; + break; + case 1017: + _struct._unique_data_item_1017 = value; + break; + case 1018: + _struct._unique_data_item_1018 = value; + break; + case 1019: + _struct._unique_data_item_1019 = value; + break; + case 1020: + _struct._unique_data_item_1020 = value; + break; + case 1021: + _struct._unique_data_item_1021 = value; + break; + case 1022: + _struct._unique_data_item_1022 = value; + break; + case 1023: + _struct._unique_data_item_1023 = value; + break; + default: + throw Exception('Invalid Array Helper generated.'); + } + } +} + +abstract class aiReturn { + static const int aiReturn_SUCCESS = 0; + static const int aiReturn_FAILURE = -1; + static const int aiReturn_OUTOFMEMORY = -3; + static const int _AI_ENFORCE_ENUM_SIZE = 2147483647; +} + +abstract class aiOrigin { + static const int aiOrigin_SET = 0; + static const int aiOrigin_CUR = 1; + static const int aiOrigin_END = 2; + static const int _AI_ORIGIN_ENFORCE_ENUM_SIZE = 2147483647; +} + +abstract class aiDefaultLogStream { + static const int aiDefaultLogStream_FILE = 1; + static const int aiDefaultLogStream_STDOUT = 2; + static const int aiDefaultLogStream_STDERR = 4; + static const int aiDefaultLogStream_DEBUGGER = 8; + static const int _AI_DLS_ENFORCE_ENUM_SIZE = 2147483647; +} + +class aiMemoryInfo extends ffi.Struct { + @ffi.Uint32() + int textures; + + @ffi.Uint32() + int materials; + + @ffi.Uint32() + int meshes; + + @ffi.Uint32() + int nodes; + + @ffi.Uint32() + int animations; + + @ffi.Uint32() + int cameras; + + @ffi.Uint32() + int lights; + + @ffi.Uint32() + int total; +} + +class aiScene extends ffi.Struct {} + +class aiFileIO extends ffi.Struct {} + +class aiExportFormatDesc extends ffi.Struct { + ffi.Pointer id; + + ffi.Pointer description; + + ffi.Pointer fileExtension; +} + +class aiExportDataBlob extends ffi.Struct {} + +class aiFile extends ffi.Struct {} + +abstract class aiImporterFlags { + static const int aiImporterFlags_SupportTextFlavour = 1; + static const int aiImporterFlags_SupportBinaryFlavour = 2; + static const int aiImporterFlags_SupportCompressedFlavour = 4; + static const int aiImporterFlags_LimitedSupport = 8; + static const int aiImporterFlags_Experimental = 16; +} + +class aiImporterDesc extends ffi.Struct { + ffi.Pointer mName; + + ffi.Pointer mAuthor; + + ffi.Pointer mMaintainer; + + ffi.Pointer mComments; + + @ffi.Uint32() + int mFlags; + + @ffi.Uint32() + int mMinMajor; + + @ffi.Uint32() + int mMinMinor; + + @ffi.Uint32() + int mMaxMajor; + + @ffi.Uint32() + int mMaxMinor; + + ffi.Pointer mFileExtensions; +} + +class aiLogStream extends ffi.Struct { + ffi.Pointer> callback; + + ffi.Pointer user; +} + +class aiPropertyStore extends ffi.Struct { + @ffi.Int8() + int sentinel; +} + +abstract class aiPostProcessSteps { + static const int aiProcess_CalcTangentSpace = 1; + static const int aiProcess_JoinIdenticalVertices = 2; + static const int aiProcess_MakeLeftHanded = 4; + static const int aiProcess_Triangulate = 8; + static const int aiProcess_RemoveComponent = 16; + static const int aiProcess_GenNormals = 32; + static const int aiProcess_GenSmoothNormals = 64; + static const int aiProcess_SplitLargeMeshes = 128; + static const int aiProcess_PreTransformVertices = 256; + static const int aiProcess_LimitBoneWeights = 512; + static const int aiProcess_ValidateDataStructure = 1024; + static const int aiProcess_ImproveCacheLocality = 2048; + static const int aiProcess_RemoveRedundantMaterials = 4096; + static const int aiProcess_FixInfacingNormals = 8192; + static const int aiProcess_SortByPType = 32768; + static const int aiProcess_FindDegenerates = 65536; + static const int aiProcess_FindInvalidData = 131072; + static const int aiProcess_GenUVCoords = 262144; + static const int aiProcess_TransformUVCoords = 524288; + static const int aiProcess_FindInstances = 1048576; + static const int aiProcess_OptimizeMeshes = 2097152; + static const int aiProcess_OptimizeGraph = 4194304; + static const int aiProcess_FlipUVs = 8388608; + static const int aiProcess_FlipWindingOrder = 16777216; + static const int aiProcess_SplitByBoneCount = 33554432; + static const int aiProcess_Debone = 67108864; + static const int aiProcess_GlobalScale = 134217728; + static const int aiProcess_EmbedTextures = 268435456; + static const int aiProcess_ForceGenNormals = 536870912; + static const int aiProcess_DropNormals = 1073741824; + static const int aiProcess_GenBoundingBoxes = -2147483648; +} + +class aiTexel extends ffi.Struct { + @ffi.Uint8() + int b; + + @ffi.Uint8() + int g; + + @ffi.Uint8() + int r; + + @ffi.Uint8() + int a; +} + +class aiTexture extends ffi.Struct {} + +class aiAABB extends ffi.Struct {} + +class aiFace extends ffi.Struct { + @ffi.Uint32() + int mNumIndices; + + ffi.Pointer mIndices; +} + +class aiVertexWeight extends ffi.Struct { + @ffi.Uint32() + int mVertexId; + + @ffi.Float() + double mWeight; +} + +class aiBone extends ffi.Struct {} + +abstract class aiPrimitiveType { + static const int aiPrimitiveType_POINT = 1; + static const int aiPrimitiveType_LINE = 2; + static const int aiPrimitiveType_TRIANGLE = 4; + static const int aiPrimitiveType_POLYGON = 8; + static const int _aiPrimitiveType_Force32Bit = 2147483647; +} + +class aiAnimMesh extends ffi.Struct {} + +abstract class aiMorphingMethod { + static const int aiMorphingMethod_VERTEX_BLEND = 1; + static const int aiMorphingMethod_MORPH_NORMALIZED = 2; + static const int aiMorphingMethod_MORPH_RELATIVE = 3; + static const int _aiMorphingMethod_Force32Bit = 2147483647; +} + +class aiMesh extends ffi.Struct {} + +abstract class aiLightSourceType { + static const int aiLightSource_UNDEFINED = 0; + static const int aiLightSource_DIRECTIONAL = 1; + static const int aiLightSource_POINT = 2; + static const int aiLightSource_SPOT = 3; + static const int aiLightSource_AMBIENT = 4; + static const int aiLightSource_AREA = 5; + static const int _aiLightSource_Force32Bit = 2147483647; +} + +class aiLight extends ffi.Struct {} + +class aiCamera extends ffi.Struct {} + +abstract class aiTextureOp { + static const int aiTextureOp_Multiply = 0; + static const int aiTextureOp_Add = 1; + static const int aiTextureOp_Subtract = 2; + static const int aiTextureOp_Divide = 3; + static const int aiTextureOp_SmoothAdd = 4; + static const int aiTextureOp_SignedAdd = 5; + static const int _aiTextureOp_Force32Bit = 2147483647; +} + +abstract class aiTextureMapMode { + static const int aiTextureMapMode_Wrap = 0; + static const int aiTextureMapMode_Clamp = 1; + static const int aiTextureMapMode_Decal = 3; + static const int aiTextureMapMode_Mirror = 2; + static const int _aiTextureMapMode_Force32Bit = 2147483647; +} + +abstract class aiTextureMapping { + static const int aiTextureMapping_UV = 0; + static const int aiTextureMapping_SPHERE = 1; + static const int aiTextureMapping_CYLINDER = 2; + static const int aiTextureMapping_BOX = 3; + static const int aiTextureMapping_PLANE = 4; + static const int aiTextureMapping_OTHER = 5; + static const int _aiTextureMapping_Force32Bit = 2147483647; +} + +abstract class aiTextureType { + static const int aiTextureType_NONE = 0; + static const int aiTextureType_DIFFUSE = 1; + static const int aiTextureType_SPECULAR = 2; + static const int aiTextureType_AMBIENT = 3; + static const int aiTextureType_EMISSIVE = 4; + static const int aiTextureType_HEIGHT = 5; + static const int aiTextureType_NORMALS = 6; + static const int aiTextureType_SHININESS = 7; + static const int aiTextureType_OPACITY = 8; + static const int aiTextureType_DISPLACEMENT = 9; + static const int aiTextureType_LIGHTMAP = 10; + static const int aiTextureType_REFLECTION = 11; + static const int aiTextureType_BASE_COLOR = 12; + static const int aiTextureType_NORMAL_CAMERA = 13; + static const int aiTextureType_EMISSION_COLOR = 14; + static const int aiTextureType_METALNESS = 15; + static const int aiTextureType_DIFFUSE_ROUGHNESS = 16; + static const int aiTextureType_AMBIENT_OCCLUSION = 17; + static const int aiTextureType_UNKNOWN = 18; + static const int _aiTextureType_Force32Bit = 2147483647; +} + +abstract class aiShadingMode { + static const int aiShadingMode_Flat = 1; + static const int aiShadingMode_Gouraud = 2; + static const int aiShadingMode_Phong = 3; + static const int aiShadingMode_Blinn = 4; + static const int aiShadingMode_Toon = 5; + static const int aiShadingMode_OrenNayar = 6; + static const int aiShadingMode_Minnaert = 7; + static const int aiShadingMode_CookTorrance = 8; + static const int aiShadingMode_NoShading = 9; + static const int aiShadingMode_Fresnel = 10; + static const int _aiShadingMode_Force32Bit = 2147483647; +} + +abstract class aiTextureFlags { + static const int aiTextureFlags_Invert = 1; + static const int aiTextureFlags_UseAlpha = 2; + static const int aiTextureFlags_IgnoreAlpha = 4; + static const int _aiTextureFlags_Force32Bit = 2147483647; +} + +abstract class aiBlendMode { + static const int aiBlendMode_Default = 0; + static const int aiBlendMode_Additive = 1; + static const int _aiBlendMode_Force32Bit = 2147483647; +} + +class aiUVTransform extends ffi.Struct {} + +abstract class aiPropertyTypeInfo { + static const int aiPTI_Float = 1; + static const int aiPTI_Double = 2; + static const int aiPTI_String = 3; + static const int aiPTI_Integer = 4; + static const int aiPTI_Buffer = 5; + static const int _aiPTI_Force32Bit = 2147483647; +} + +class aiMaterialProperty extends ffi.Struct {} + +class aiMaterial extends ffi.Struct { + ffi.Pointer> mProperties; + + @ffi.Uint32() + int mNumProperties; + + @ffi.Uint32() + int mNumAllocated; +} + +class aiVectorKey extends ffi.Struct {} + +class aiQuatKey extends ffi.Struct {} + +class aiMeshKey extends ffi.Struct { + @ffi.Double() + double mTime; + + @ffi.Uint32() + int mValue; +} + +class aiMeshMorphKey extends ffi.Struct { + @ffi.Double() + double mTime; + + ffi.Pointer mValues; + + ffi.Pointer mWeights; + + @ffi.Uint32() + int mNumValuesAndWeights; +} + +abstract class aiAnimBehaviour { + static const int aiAnimBehaviour_DEFAULT = 0; + static const int aiAnimBehaviour_CONSTANT = 1; + static const int aiAnimBehaviour_LINEAR = 2; + static const int aiAnimBehaviour_REPEAT = 3; + static const int _aiAnimBehaviour_Force32Bit = 2147483647; +} + +class aiNodeAnim extends ffi.Struct {} + +class aiMeshAnim extends ffi.Struct {} + +class aiMeshMorphAnim extends ffi.Struct {} + +class aiAnimation extends ffi.Struct {} + +abstract class aiMetadataType { + static const int AI_BOOL = 0; + static const int AI_INT32 = 1; + static const int AI_UINT64 = 2; + static const int AI_FLOAT = 3; + static const int AI_DOUBLE = 4; + static const int AI_AISTRING = 5; + static const int AI_AIVECTOR3D = 6; + static const int AI_META_MAX = 7; + static const int FORCE_32BIT = 2147483647; +} + +class aiMetadataEntry extends ffi.Struct { + @ffi.Int32() + int mType; + + ffi.Pointer mData; +} + +class aiMetadata extends ffi.Struct { + @ffi.Uint32() + int mNumProperties; + + ffi.Pointer mKeys; + + ffi.Pointer mValues; +} + +class aiNode extends ffi.Struct {} + +const int AIO_PRIO_DELTA_MAX = 20; + +const String AI_CONFIG_GLOB_MEASURE_TIME = 'GLOB_MEASURE_TIME'; + +const String AI_CONFIG_IMPORT_NO_SKELETON_MESHES = 'IMPORT_NO_SKELETON_MESHES'; + +const String AI_CONFIG_PP_SBBC_MAX_BONES = 'PP_SBBC_MAX_BONES'; + +const int AI_SBBC_DEFAULT_MAX_BONES = 60; + +const String AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = 'PP_CT_MAX_SMOOTHING_ANGLE'; + +const String AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX = + 'PP_CT_TEXTURE_CHANNEL_INDEX'; + +const String AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE = + 'PP_GSN_MAX_SMOOTHING_ANGLE'; + +const String AI_CONFIG_IMPORT_MDL_COLORMAP = 'IMPORT_MDL_COLORMAP'; + +const String AI_CONFIG_PP_RRM_EXCLUDE_LIST = 'PP_RRM_EXCLUDE_LIST'; + +const String AI_CONFIG_PP_PTV_KEEP_HIERARCHY = 'PP_PTV_KEEP_HIERARCHY'; + +const String AI_CONFIG_PP_PTV_NORMALIZE = 'PP_PTV_NORMALIZE'; + +const String AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION = + 'PP_PTV_ADD_ROOT_TRANSFORMATION'; + +const String AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION = + 'PP_PTV_ROOT_TRANSFORMATION'; + +const String AI_CONFIG_PP_FD_REMOVE = 'PP_FD_REMOVE'; + +const String AI_CONFIG_PP_FD_CHECKAREA = 'PP_FD_CHECKAREA'; + +const String AI_CONFIG_PP_OG_EXCLUDE_LIST = 'PP_OG_EXCLUDE_LIST'; + +const String AI_CONFIG_PP_SLM_TRIANGLE_LIMIT = 'PP_SLM_TRIANGLE_LIMIT'; + +const int AI_SLM_DEFAULT_MAX_TRIANGLES = 1000000; + +const String AI_CONFIG_PP_SLM_VERTEX_LIMIT = 'PP_SLM_VERTEX_LIMIT'; + +const int AI_SLM_DEFAULT_MAX_VERTICES = 1000000; + +const String AI_CONFIG_PP_LBW_MAX_WEIGHTS = 'PP_LBW_MAX_WEIGHTS'; + +const int AI_LMW_MAX_WEIGHTS = 4; + +const String AI_CONFIG_PP_DB_THRESHOLD = 'PP_DB_THRESHOLD'; + +const double AI_DEBONE_THRESHOLD = 1.0; + +const String AI_CONFIG_PP_DB_ALL_OR_NONE = 'PP_DB_ALL_OR_NONE'; + +const String AI_CONFIG_PP_ICL_PTCACHE_SIZE = 'PP_ICL_PTCACHE_SIZE'; + +const String AI_CONFIG_PP_RVC_FLAGS = 'PP_RVC_FLAGS'; + +const String AI_CONFIG_PP_SBP_REMOVE = 'PP_SBP_REMOVE'; + +const String AI_CONFIG_PP_FID_ANIM_ACCURACY = 'PP_FID_ANIM_ACCURACY'; + +const String AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS = + 'PP_FID_IGNORE_TEXTURECOORDS'; + +const int AI_UVTRAFO_SCALING = 1; + +const int AI_UVTRAFO_ROTATION = 2; + +const int AI_UVTRAFO_TRANSLATION = 4; + +const int AI_UVTRAFO_ALL = 7; + +const String AI_CONFIG_PP_TUV_EVALUATE = 'PP_TUV_EVALUATE'; + +const String AI_CONFIG_FAVOUR_SPEED = 'FAVOUR_SPEED'; + +const String AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS = + 'IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS'; + +const String AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS = + 'IMPORT_FBX_READ_ALL_MATERIALS'; + +const String AI_CONFIG_IMPORT_FBX_READ_MATERIALS = 'IMPORT_FBX_READ_MATERIALS'; + +const String AI_CONFIG_IMPORT_FBX_READ_TEXTURES = 'IMPORT_FBX_READ_TEXTURES'; + +const String AI_CONFIG_IMPORT_FBX_READ_CAMERAS = 'IMPORT_FBX_READ_CAMERAS'; + +const String AI_CONFIG_IMPORT_FBX_READ_LIGHTS = 'IMPORT_FBX_READ_LIGHTS'; + +const String AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS = + 'IMPORT_FBX_READ_ANIMATIONS'; + +const String AI_CONFIG_IMPORT_FBX_STRICT_MODE = 'IMPORT_FBX_STRICT_MODE'; + +const String AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS = + 'IMPORT_FBX_PRESERVE_PIVOTS'; + +const String AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES = + 'IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES'; + +const String AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING = + 'AI_CONFIG_IMPORT_FBX_EMBEDDED_TEXTURES_LEGACY_NAMING'; + +const String AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES = + 'AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES'; + +const String AI_CONFIG_FBX_CONVERT_TO_M = 'AI_CONFIG_FBX_CONVERT_TO_M'; + +const String AI_CONFIG_IMPORT_GLOBAL_KEYFRAME = 'IMPORT_GLOBAL_KEYFRAME'; + +const String AI_CONFIG_IMPORT_MD3_KEYFRAME = 'IMPORT_MD3_KEYFRAME'; + +const String AI_CONFIG_IMPORT_MD2_KEYFRAME = 'IMPORT_MD2_KEYFRAME'; + +const String AI_CONFIG_IMPORT_MDL_KEYFRAME = 'IMPORT_MDL_KEYFRAME'; + +const String AI_CONFIG_IMPORT_MDC_KEYFRAME = 'IMPORT_MDC_KEYFRAME'; + +const String AI_CONFIG_IMPORT_SMD_KEYFRAME = 'IMPORT_SMD_KEYFRAME'; + +const String AI_CONFIG_IMPORT_UNREAL_KEYFRAME = 'IMPORT_UNREAL_KEYFRAME'; + +const String AI_CONFIG_IMPORT_SMD_LOAD_ANIMATION_LIST = + 'IMPORT_SMD_LOAD_ANIMATION_LIST'; + +const String AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL = 'IMPORT_AC_SEPARATE_BFCULL'; + +const String AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION = + 'IMPORT_AC_EVAL_SUBDIVISION'; + +const String AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS = 'UNREAL_HANDLE_FLAGS'; + +const String AI_CONFIG_IMPORT_TER_MAKE_UVS = 'IMPORT_TER_MAKE_UVS'; + +const String AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = + 'IMPORT_ASE_RECONSTRUCT_NORMALS'; + +const String AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART = + 'IMPORT_MD3_HANDLE_MULTIPART'; + +const String AI_CONFIG_IMPORT_MD3_SKIN_NAME = 'IMPORT_MD3_SKIN_NAME'; + +const String AI_CONFIG_IMPORT_MD3_SHADER_SRC = 'IMPORT_MD3_SHADER_SRC'; + +const String AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY = 'IMPORT_LWO_ONE_LAYER_ONLY'; + +const String AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD = + 'IMPORT_MD5_NO_ANIM_AUTOLOAD'; + +const String AI_CONFIG_IMPORT_LWS_ANIM_START = 'IMPORT_LWS_ANIM_START'; + +const String AI_CONFIG_IMPORT_LWS_ANIM_END = 'IMPORT_LWS_ANIM_END'; + +const String AI_CONFIG_IMPORT_IRR_ANIM_FPS = 'IMPORT_IRR_ANIM_FPS'; + +const String AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE = 'IMPORT_OGRE_MATERIAL_FILE'; + +const String AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME = + 'IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME'; + +const String AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT = + 'AI_CONFIG_ANDROID_JNI_ASSIMP_MANAGER_SUPPORT'; + +const String AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS = + 'IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS'; + +const String AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION = + 'IMPORT_IFC_CUSTOM_TRIANGULATION'; + +const String AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE = + 'IMPORT_IFC_SMOOTHING_ANGLE'; + +const double AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE = 10.0; + +const String AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION = + 'IMPORT_IFC_CYLINDRICAL_TESSELLATION'; + +const int AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION = 32; + +const String AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION = + 'IMPORT_COLLADA_IGNORE_UP_DIRECTION'; + +const String AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES = + 'IMPORT_COLLADA_USE_COLLADA_NAMES'; + +const String AI_CONFIG_EXPORT_XFILE_64BIT = 'EXPORT_XFILE_64BIT'; + +const String AI_CONFIG_EXPORT_POINT_CLOUDS = 'EXPORT_POINT_CLOUDS'; + +const String AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY = 'GLOBAL_SCALE_FACTOR'; + +const double AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT = 1.0; + +const String AI_CONFIG_APP_SCALE_KEY = 'APP_SCALE_FACTOR'; + +const double AI_MATH_PI = 3.141592653589793; + +const double AI_MATH_TWO_PI = 6.283185307179586; + +const double AI_MATH_HALF_PI = 1.5707963267948966; + +const double AI_MATH_PI_F = 3.1415927410125732; + +const double AI_MATH_TWO_PI_F = 6.2831854820251465; + +const double AI_MATH_HALF_PI_F = 1.5707963705062866; + +const int AI_SUCCESS = 0; + +const int AI_FAILURE = -1; + +const int AI_OUTOFMEMORY = -3; + +const int AI_FALSE = 0; + +const int AI_TRUE = 1; + +const String AI_EMBEDDED_TEXNAME_PREFIX = '*'; + +const int AI_MAX_FACE_INDICES = 32767; + +const int AI_MAX_BONE_WEIGHTS = 2147483647; + +const int AI_MAX_VERTICES = 2147483647; + +const int AI_MAX_FACES = 2147483647; + +const int AI_MAX_NUMBER_OF_COLOR_SETS = 8; + +const int AI_MAX_NUMBER_OF_TEXTURECOORDS = 8; + +const String AI_DEFAULT_MATERIAL_NAME = 'DefaultMaterial'; + +const int AI_TEXTURE_TYPE_MAX = 18; + +const String AI_MATKEY_NAME = '?mat.name'; + +const String AI_MATKEY_TWOSIDED = '\$mat.twosided'; + +const String AI_MATKEY_SHADING_MODEL = '\$mat.shadingm'; + +const String AI_MATKEY_ENABLE_WIREFRAME = '\$mat.wireframe'; + +const String AI_MATKEY_BLEND_FUNC = '\$mat.blend'; + +const String AI_MATKEY_OPACITY = '\$mat.opacity'; + +const String AI_MATKEY_TRANSPARENCYFACTOR = '\$mat.transparencyfactor'; + +const String AI_MATKEY_BUMPSCALING = '\$mat.bumpscaling'; + +const String AI_MATKEY_SHININESS = '\$mat.shininess'; + +const String AI_MATKEY_REFLECTIVITY = '\$mat.reflectivity'; + +const String AI_MATKEY_SHININESS_STRENGTH = '\$mat.shinpercent'; + +const String AI_MATKEY_REFRACTI = '\$mat.refracti'; + +const String AI_MATKEY_COLOR_DIFFUSE = '\$clr.diffuse'; + +const String AI_MATKEY_COLOR_AMBIENT = '\$clr.ambient'; + +const String AI_MATKEY_COLOR_SPECULAR = '\$clr.specular'; + +const String AI_MATKEY_COLOR_EMISSIVE = '\$clr.emissive'; + +const String AI_MATKEY_COLOR_TRANSPARENT = '\$clr.transparent'; + +const String AI_MATKEY_COLOR_REFLECTIVE = '\$clr.reflective'; + +const String AI_MATKEY_GLOBAL_BACKGROUND_IMAGE = '?bg.global'; + +const String AI_MATKEY_GLOBAL_SHADERLANG = '?sh.lang'; + +const String AI_MATKEY_SHADER_VERTEX = '?sh.vs'; + +const String AI_MATKEY_SHADER_FRAGMENT = '?sh.fs'; + +const String AI_MATKEY_SHADER_GEO = '?sh.gs'; + +const String AI_MATKEY_SHADER_TESSELATION = '?sh.ts'; + +const String AI_MATKEY_SHADER_PRIMITIVE = '?sh.ps'; + +const String AI_MATKEY_SHADER_COMPUTE = '?sh.cs'; + +const int AI_SCENE_FLAGS_INCOMPLETE = 1; + +const int AI_SCENE_FLAGS_VALIDATED = 2; + +const int AI_SCENE_FLAGS_VALIDATION_WARNING = 4; + +const int AI_SCENE_FLAGS_NON_VERBOSE_FORMAT = 8; + +const int AI_SCENE_FLAGS_TERRAIN = 16; + +const int AI_SCENE_FLAGS_ALLOW_SHARED = 32; + +typedef _c_aiGetExportFormatCount = ffi.Uint64 Function(); + +typedef _dart_aiGetExportFormatCount = int Function(); + +typedef _c_aiGetExportFormatDescription = ffi.Pointer + Function( + ffi.Uint64 pIndex, +); + +typedef _dart_aiGetExportFormatDescription = ffi.Pointer + Function( + int pIndex, +); + +typedef _c_aiReleaseExportFormatDescription = ffi.Void Function( + ffi.Pointer desc, +); + +typedef _dart_aiReleaseExportFormatDescription = void Function( + ffi.Pointer desc, +); + +typedef _c_aiCopyScene = ffi.Void Function( + ffi.Pointer pIn, + ffi.Pointer> pOut, +); + +typedef _dart_aiCopyScene = void Function( + ffi.Pointer pIn, + ffi.Pointer> pOut, +); + +typedef _c_aiFreeScene = ffi.Void Function( + ffi.Pointer pIn, +); + +typedef _dart_aiFreeScene = void Function( + ffi.Pointer pIn, +); + +typedef _c_aiExportScene = ffi.Int32 Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + ffi.Uint32 pPreprocessing, +); + +typedef _dart_aiExportScene = int Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + int pPreprocessing, +); + +typedef _c_aiExportSceneEx = ffi.Int32 Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + ffi.Pointer pIO, + ffi.Uint32 pPreprocessing, +); + +typedef _dart_aiExportSceneEx = int Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Pointer pFileName, + ffi.Pointer pIO, + int pPreprocessing, +); + +typedef _c_aiExportSceneToBlob = ffi.Pointer Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + ffi.Uint32 pPreprocessing, +); + +typedef _dart_aiExportSceneToBlob = ffi.Pointer Function( + ffi.Pointer pScene, + ffi.Pointer pFormatId, + int pPreprocessing, +); + +typedef _c_aiReleaseExportBlob = ffi.Void Function( + ffi.Pointer pData, +); + +typedef _dart_aiReleaseExportBlob = void Function( + ffi.Pointer pData, +); + +typedef _c_aiGetImporterDesc = ffi.Pointer Function( + ffi.Pointer extension_1, +); + +typedef _dart_aiGetImporterDesc = ffi.Pointer Function( + ffi.Pointer extension_1, +); + +typedef _c_aiImportFile = ffi.Pointer Function( + ffi.Pointer pFile, + ffi.Uint32 pFlags, +); + +typedef _dart_aiImportFile = ffi.Pointer Function( + ffi.Pointer pFile, + int pFlags, +); + +typedef _c_aiImportFileEx = ffi.Pointer Function( + ffi.Pointer pFile, + ffi.Uint32 pFlags, + ffi.Pointer pFS, +); + +typedef _dart_aiImportFileEx = ffi.Pointer Function( + ffi.Pointer pFile, + int pFlags, + ffi.Pointer pFS, +); + +typedef _c_aiImportFileExWithProperties = ffi.Pointer Function( + ffi.Pointer pFile, + ffi.Uint32 pFlags, + ffi.Pointer pFS, + ffi.Pointer pProps, +); + +typedef _dart_aiImportFileExWithProperties = ffi.Pointer Function( + ffi.Pointer pFile, + int pFlags, + ffi.Pointer pFS, + ffi.Pointer pProps, +); + +typedef _c_aiImportFileFromMemory = ffi.Pointer Function( + ffi.Pointer pBuffer, + ffi.Uint32 pLength, + ffi.Uint32 pFlags, + ffi.Pointer pHint, +); + +typedef _dart_aiImportFileFromMemory = ffi.Pointer Function( + ffi.Pointer pBuffer, + int pLength, + int pFlags, + ffi.Pointer pHint, +); + +typedef _c_aiImportFileFromMemoryWithProperties = ffi.Pointer Function( + ffi.Pointer pBuffer, + ffi.Uint32 pLength, + ffi.Uint32 pFlags, + ffi.Pointer pHint, + ffi.Pointer pProps, +); + +typedef _dart_aiImportFileFromMemoryWithProperties = ffi.Pointer + Function( + ffi.Pointer pBuffer, + int pLength, + int pFlags, + ffi.Pointer pHint, + ffi.Pointer pProps, +); + +typedef _c_aiApplyPostProcessing = ffi.Pointer Function( + ffi.Pointer pScene, + ffi.Uint32 pFlags, +); + +typedef _dart_aiApplyPostProcessing = ffi.Pointer Function( + ffi.Pointer pScene, + int pFlags, +); + +typedef _c_aiAttachLogStream = ffi.Void Function( + ffi.Pointer stream, +); + +typedef _dart_aiAttachLogStream = void Function( + ffi.Pointer stream, +); + +typedef _c_aiEnableVerboseLogging = ffi.Void Function( + ffi.Int32 d, +); + +typedef _dart_aiEnableVerboseLogging = void Function( + int d, +); + +typedef _c_aiDetachLogStream = ffi.Int32 Function( + ffi.Pointer stream, +); + +typedef _dart_aiDetachLogStream = int Function( + ffi.Pointer stream, +); + +typedef _c_aiDetachAllLogStreams = ffi.Void Function(); + +typedef _dart_aiDetachAllLogStreams = void Function(); + +typedef _c_aiReleaseImport = ffi.Void Function( + ffi.Pointer pScene, +); + +typedef _dart_aiReleaseImport = void Function( + ffi.Pointer pScene, +); + +typedef _c_aiGetErrorString = ffi.Pointer Function(); + +typedef _dart_aiGetErrorString = ffi.Pointer Function(); + +typedef _c_aiIsExtensionSupported = ffi.Int32 Function( + ffi.Pointer szExtension, +); + +typedef _dart_aiIsExtensionSupported = int Function( + ffi.Pointer szExtension, +); + +typedef _c_aiGetExtensionList = ffi.Void Function( + ffi.Pointer szOut, +); + +typedef _dart_aiGetExtensionList = void Function( + ffi.Pointer szOut, +); + +typedef _c_aiGetMemoryRequirements = ffi.Void Function( + ffi.Pointer pIn, + ffi.Pointer in_1, +); + +typedef _dart_aiGetMemoryRequirements = void Function( + ffi.Pointer pIn, + ffi.Pointer in_1, +); + +typedef _c_aiCreatePropertyStore = ffi.Pointer Function(); + +typedef _dart_aiCreatePropertyStore = ffi.Pointer Function(); + +typedef _c_aiReleasePropertyStore = ffi.Void Function( + ffi.Pointer p, +); + +typedef _dart_aiReleasePropertyStore = void Function( + ffi.Pointer p, +); + +typedef _c_aiSetImportPropertyInteger = ffi.Void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Int32 value, +); + +typedef _dart_aiSetImportPropertyInteger = void Function( + ffi.Pointer store, + ffi.Pointer szName, + int value, +); + +typedef _c_aiSetImportPropertyFloat = ffi.Void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Float value, +); + +typedef _dart_aiSetImportPropertyFloat = void Function( + ffi.Pointer store, + ffi.Pointer szName, + double value, +); + +typedef _c_aiSetImportPropertyString = ffi.Void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer st, +); + +typedef _dart_aiSetImportPropertyString = void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer st, +); + +typedef _c_aiSetImportPropertyMatrix = ffi.Void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer mat, +); + +typedef _dart_aiSetImportPropertyMatrix = void Function( + ffi.Pointer store, + ffi.Pointer szName, + ffi.Pointer mat, +); + +typedef _c_aiCreateQuaternionFromMatrix = ffi.Void Function( + ffi.Pointer quat, + ffi.Pointer mat, +); + +typedef _dart_aiCreateQuaternionFromMatrix = void Function( + ffi.Pointer quat, + ffi.Pointer mat, +); + +typedef _c_aiDecomposeMatrix = ffi.Void Function( + ffi.Pointer mat, + ffi.Pointer scaling, + ffi.Pointer rotation, + ffi.Pointer position, +); + +typedef _dart_aiDecomposeMatrix = void Function( + ffi.Pointer mat, + ffi.Pointer scaling, + ffi.Pointer rotation, + ffi.Pointer position, +); + +typedef _c_aiTransposeMatrix4 = ffi.Void Function( + ffi.Pointer mat, +); + +typedef _dart_aiTransposeMatrix4 = void Function( + ffi.Pointer mat, +); + +typedef _c_aiTransposeMatrix3 = ffi.Void Function( + ffi.Pointer mat, +); + +typedef _dart_aiTransposeMatrix3 = void Function( + ffi.Pointer mat, +); + +typedef _c_aiTransformVecByMatrix3 = ffi.Void Function( + ffi.Pointer vec, + ffi.Pointer mat, +); + +typedef _dart_aiTransformVecByMatrix3 = void Function( + ffi.Pointer vec, + ffi.Pointer mat, +); + +typedef _c_aiTransformVecByMatrix4 = ffi.Void Function( + ffi.Pointer vec, + ffi.Pointer mat, +); + +typedef _dart_aiTransformVecByMatrix4 = void Function( + ffi.Pointer vec, + ffi.Pointer mat, +); + +typedef _c_aiMultiplyMatrix4 = ffi.Void Function( + ffi.Pointer dst, + ffi.Pointer src, +); + +typedef _dart_aiMultiplyMatrix4 = void Function( + ffi.Pointer dst, + ffi.Pointer src, +); + +typedef _c_aiMultiplyMatrix3 = ffi.Void Function( + ffi.Pointer dst, + ffi.Pointer src, +); + +typedef _dart_aiMultiplyMatrix3 = void Function( + ffi.Pointer dst, + ffi.Pointer src, +); + +typedef _c_aiIdentityMatrix3 = ffi.Void Function( + ffi.Pointer mat, +); + +typedef _dart_aiIdentityMatrix3 = void Function( + ffi.Pointer mat, +); + +typedef _c_aiIdentityMatrix4 = ffi.Void Function( + ffi.Pointer mat, +); + +typedef _dart_aiIdentityMatrix4 = void Function( + ffi.Pointer mat, +); + +typedef _c_aiGetImportFormatCount = ffi.Uint64 Function(); + +typedef _dart_aiGetImportFormatCount = int Function(); + +typedef _c_aiGetImportFormatDescription = ffi.Pointer Function( + ffi.Uint64 pIndex, +); + +typedef _dart_aiGetImportFormatDescription = ffi.Pointer + Function( + int pIndex, +); + +typedef _c_aiGetMaterialProperty = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer> pPropOut, +); + +typedef _dart_aiGetMaterialProperty = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer> pPropOut, +); + +typedef _c_aiGetMaterialFloatArray = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer pOut, + ffi.Pointer pMax, +); + +typedef _dart_aiGetMaterialFloatArray = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ffi.Pointer pMax, +); + +typedef _c_aiGetMaterialIntegerArray = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer pOut, + ffi.Pointer pMax, +); + +typedef _dart_aiGetMaterialIntegerArray = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, + ffi.Pointer pMax, +); + +typedef _c_aiGetMaterialColor = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer pOut, +); + +typedef _dart_aiGetMaterialColor = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, +); + +typedef _c_aiGetMaterialUVTransform = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer pOut, +); + +typedef _dart_aiGetMaterialUVTransform = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, +); + +typedef _c_aiGetMaterialString = ffi.Int32 Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + ffi.Uint32 type, + ffi.Uint32 index, + ffi.Pointer pOut, +); + +typedef _dart_aiGetMaterialString = int Function( + ffi.Pointer pMat, + ffi.Pointer pKey, + int type, + int index, + ffi.Pointer pOut, +); + +typedef _c_aiGetMaterialTextureCount = ffi.Uint32 Function( + ffi.Pointer pMat, + ffi.Int32 type, +); + +typedef _dart_aiGetMaterialTextureCount = int Function( + ffi.Pointer pMat, + int type, +); + +typedef _c_aiGetMaterialTexture = ffi.Int32 Function( + ffi.Pointer mat, + ffi.Int32 type, + ffi.Uint32 index, + ffi.Pointer path, + ffi.Pointer mapping, + ffi.Pointer uvindex, + ffi.Pointer blend, + ffi.Pointer op, + ffi.Pointer mapmode, + ffi.Pointer flags, +); + +typedef _dart_aiGetMaterialTexture = int Function( + ffi.Pointer mat, + int type, + int index, + ffi.Pointer path, + ffi.Pointer mapping, + ffi.Pointer uvindex, + ffi.Pointer blend, + ffi.Pointer op, + ffi.Pointer mapmode, + ffi.Pointer flags, +); + +typedef _c_aiGetLegalString = ffi.Pointer Function(); + +typedef _dart_aiGetLegalString = ffi.Pointer Function(); + +typedef _c_aiGetVersionMinor = ffi.Uint32 Function(); + +typedef _dart_aiGetVersionMinor = int Function(); + +typedef _c_aiGetVersionMajor = ffi.Uint32 Function(); + +typedef _dart_aiGetVersionMajor = int Function(); + +typedef _c_aiGetVersionRevision = ffi.Uint32 Function(); + +typedef _dart_aiGetVersionRevision = int Function(); + +typedef _c_aiGetBranchName = ffi.Pointer Function(); + +typedef _dart_aiGetBranchName = ffi.Pointer Function(); + +typedef _c_aiGetCompileFlags = ffi.Uint32 Function(); + +typedef _dart_aiGetCompileFlags = int Function(); + +typedef aiLogStreamCallback = ffi.Void Function( + ffi.Pointer, + ffi.Pointer, +); diff --git a/lib/src/libassimp.dart b/lib/src/libassimp.dart index 4a39925..ec5b45a 100644 --- a/lib/src/libassimp.dart +++ b/lib/src/libassimp.dart @@ -63,231 +63,5 @@ DynamicLibrary _dlopen() { return DynamicLibrary.open(path); } -DynamicLibrary _libassimp; -DynamicLibrary get libassimp => _libassimp ?? _dlopen(); - -aiApplyPostProcessing_f _aiApplyPostProcessing; -aiApplyPostProcessing_f get aiApplyPostProcessing => _aiApplyPostProcessing ??= - libassimp.lookupFunction( - 'aiApplyPostProcessing'); - -aiAttachLogStream_f _aiAttachLogStream; -aiAttachLogStream_f get aiAttachLogStream => _aiAttachLogStream ??= - libassimp.lookupFunction( - 'aiAttachLogStream'); - -aiCopyScene_f _aiCopyScene; -aiCopyScene_f get aiCopyScene => _aiCopyScene ??= - libassimp.lookupFunction('aiCopyScene'); - -aiCreatePropertyStore_f _aiCreatePropertyStore; -aiCreatePropertyStore_f get aiCreatePropertyStore => _aiCreatePropertyStore ??= - libassimp.lookupFunction( - 'aiCreatePropertyStore'); - -aiDetachAllLogStreams_f _aiDetachAllLogStreams; -aiDetachAllLogStreams_f get aiDetachAllLogStreams => _aiDetachAllLogStreams ??= - libassimp.lookupFunction( - 'aiDetachAllLogStreams'); - -aiDetachLogStream_f _aiDetachLogStream; -aiDetachLogStream_f get aiDetachLogStream => _aiDetachLogStream ??= - libassimp.lookupFunction( - 'aiDetachLogStream'); - -aiEnableVerboseLogging_f _aiEnableVerboseLogging; -aiEnableVerboseLogging_f get aiEnableVerboseLogging => - _aiEnableVerboseLogging ??= libassimp.lookupFunction< - aiEnableVerboseLogging_t, - aiEnableVerboseLogging_f>('aiEnableVerboseLogging'); - -aiExportSceneEx_f _aiExportSceneEx; -aiExportSceneEx_f get aiExportSceneEx => _aiExportSceneEx ??= libassimp - .lookupFunction('aiExportSceneEx'); - -aiExportSceneToBlob_f _aiExportSceneToBlob; -aiExportSceneToBlob_f get aiExportSceneToBlob => _aiExportSceneToBlob ??= - libassimp.lookupFunction( - 'aiExportSceneToBlob'); - -aiGetBranchName_f _aiGetBranchName; -aiGetBranchName_f get aiGetBranchName => _aiGetBranchName ??= libassimp - .lookupFunction('aiGetBranchName'); - -aiGetCompileFlags_f _aiGetCompileFlags; -aiGetCompileFlags_f get aiGetCompileFlags => _aiGetCompileFlags ??= - libassimp.lookupFunction( - 'aiGetCompileFlags'); - -aiGetErrorString_f _aiGetErrorString; -aiGetErrorString_f get aiGetErrorString => _aiGetErrorString ??= libassimp - .lookupFunction('aiGetErrorString'); - -aiGetExportFormatCount_f _aiGetExportFormatCount; -aiGetExportFormatCount_f get aiGetExportFormatCount => - _aiGetExportFormatCount ??= libassimp.lookupFunction< - aiGetExportFormatCount_t, - aiGetExportFormatCount_f>('aiGetExportFormatCount'); - -aiGetExportFormatDescription_f _aiGetExportFormatDescription; -aiGetExportFormatDescription_f get aiGetExportFormatDescription => - _aiGetExportFormatDescription ??= libassimp.lookupFunction< - aiGetExportFormatDescription_t, - aiGetExportFormatDescription_f>('aiGetExportFormatDescription'); - -aiGetExtensionList_f _aiGetExtensionList; -aiGetExtensionList_f get aiGetExtensionList => _aiGetExtensionList ??= - libassimp.lookupFunction( - 'aiGetExtensionList'); - -aiGetLegalString_f _aiGetLegalString; -aiGetLegalString_f get aiGetLegalString => _aiGetLegalString ??= libassimp - .lookupFunction('aiGetLegalString'); - -aiGetMaterialColor_f _aiGetMaterialColor; -aiGetMaterialColor_f get aiGetMaterialColor => _aiGetMaterialColor ??= - libassimp.lookupFunction( - 'aiGetMaterialColor'); - -aiGetMaterialFloatArray_f _aiGetMaterialFloatArray; -aiGetMaterialFloatArray_f get aiGetMaterialFloatArray => - _aiGetMaterialFloatArray ??= libassimp.lookupFunction< - aiGetMaterialFloatArray_t, - aiGetMaterialFloatArray_f>('aiGetMaterialFloatArray'); - -aiGetMaterialIntegerArray_f _aiGetMaterialIntegerArray; -aiGetMaterialIntegerArray_f get aiGetMaterialIntegerArray => - _aiGetMaterialIntegerArray ??= libassimp.lookupFunction< - aiGetMaterialIntegerArray_t, - aiGetMaterialIntegerArray_f>('aiGetMaterialIntegerArray'); - -aiGetMaterialProperty_f _aiGetMaterialProperty; -aiGetMaterialProperty_f get aiGetMaterialProperty => _aiGetMaterialProperty ??= - libassimp.lookupFunction( - 'aiGetMaterialProperty'); - -aiGetMaterialString_f _aiGetMaterialString; -aiGetMaterialString_f get aiGetMaterialString => _aiGetMaterialString ??= - libassimp.lookupFunction( - 'aiGetMaterialString'); - -aiGetMaterialTexture_f _aiGetMaterialTexture; -aiGetMaterialTexture_f get aiGetMaterialTexture => _aiGetMaterialTexture ??= - libassimp.lookupFunction( - 'aiGetMaterialTexture'); - -aiGetMaterialTextureCount_f _aiGetMaterialTextureCount; -aiGetMaterialTextureCount_f get aiGetMaterialTextureCount => - _aiGetMaterialTextureCount ??= libassimp.lookupFunction< - aiGetMaterialTextureCount_t, - aiGetMaterialTextureCount_f>('aiGetMaterialTextureCount'); - -aiGetMaterialUVTransform_f _aiGetMaterialUVTransform; -aiGetMaterialUVTransform_f get aiGetMaterialUVTransform => - _aiGetMaterialUVTransform ??= libassimp.lookupFunction< - aiGetMaterialUVTransform_t, - aiGetMaterialUVTransform_f>('aiGetMaterialUVTransform'); - -aiGetMemoryRequirements_f _aiGetMemoryRequirements; -aiGetMemoryRequirements_f get aiGetMemoryRequirements => - _aiGetMemoryRequirements ??= libassimp.lookupFunction< - aiGetMemoryRequirements_t, - aiGetMemoryRequirements_f>('aiGetMemoryRequirements'); - -aiGetVersionMajor_f _aiGetVersionMajor; -aiGetVersionMajor_f get aiGetVersionMajor => _aiGetVersionMajor ??= - libassimp.lookupFunction( - 'aiGetVersionMajor'); - -aiGetVersionMinor_f _aiGetVersionMinor; -aiGetVersionMinor_f get aiGetVersionMinor => _aiGetVersionMinor ??= - libassimp.lookupFunction( - 'aiGetVersionMinor'); - -aiGetVersionRevision_f _aiGetVersionRevision; -aiGetVersionRevision_f get aiGetVersionRevision => _aiGetVersionRevision ??= - libassimp.lookupFunction( - 'aiGetVersionRevision'); - -aiGetImportFormatCount_f _aiGetImportFormatCount; -aiGetImportFormatCount_f get aiGetImportFormatCount => - _aiGetImportFormatCount ??= libassimp.lookupFunction< - aiGetImportFormatCount_t, - aiGetImportFormatCount_f>('aiGetImportFormatCount'); - -aiGetImportFormatDescription_f _aiGetImportFormatDescription; -aiGetImportFormatDescription_f get aiGetImportFormatDescription => - _aiGetImportFormatDescription ??= libassimp.lookupFunction< - aiGetImportFormatDescription_t, - aiGetImportFormatDescription_f>('aiGetImportFormatDescription'); - -aiGetPredefinedLogStream_f _aiGetPredefinedLogStream; -aiGetPredefinedLogStream_f get aiGetPredefinedLogStream => - _aiGetPredefinedLogStream ??= libassimp.lookupFunction< - aiGetPredefinedLogStream_t, - aiGetPredefinedLogStream_f>('aiGetPredefinedLogStream'); - -aiImportFileExWithProperties_f _aiImportFileExWithProperties; -aiImportFileExWithProperties_f get aiImportFileExWithProperties => - _aiImportFileExWithProperties ??= libassimp.lookupFunction< - aiImportFileExWithProperties_t, - aiImportFileExWithProperties_f>('aiImportFileExWithProperties'); - -aiImportFileFromMemoryWithProperties_f _aiImportFileFromMemoryWithProperties; -aiImportFileFromMemoryWithProperties_f - get aiImportFileFromMemoryWithProperties => - _aiImportFileFromMemoryWithProperties ??= libassimp.lookupFunction< - aiImportFileFromMemoryWithProperties_t, - aiImportFileFromMemoryWithProperties_f>( - 'aiImportFileFromMemoryWithProperties'); - -aiIsExtensionSupported_f _aiIsExtensionSupported; -aiIsExtensionSupported_f get aiIsExtensionSupported => - _aiIsExtensionSupported ??= libassimp.lookupFunction< - aiIsExtensionSupported_t, - aiIsExtensionSupported_f>('aiIsExtensionSupported'); - -aiReleaseExportBlob_f _aiReleaseExportBlob; -aiReleaseExportBlob_f get aiReleaseExportBlob => _aiReleaseExportBlob ??= - libassimp.lookupFunction( - 'aiReleaseExportBlob'); - -aiReleaseExportFormatDescription_f _aiReleaseExportFormatDescription; -aiReleaseExportFormatDescription_f get aiReleaseExportFormatDescription => - _aiReleaseExportFormatDescription ??= libassimp.lookupFunction< - aiReleaseExportFormatDescription_t, - aiReleaseExportFormatDescription_f>('aiReleaseExportFormatDescription'); - -aiReleaseImport_f _aiReleaseImport; -aiReleaseImport_f get aiReleaseImport => _aiReleaseImport ??= libassimp - .lookupFunction('aiReleaseImport'); - -aiReleasePropertyStore_f _aiReleasePropertyStore; -aiReleasePropertyStore_f get aiReleasePropertyStore => - _aiReleasePropertyStore ??= libassimp.lookupFunction< - aiReleasePropertyStore_t, - aiReleasePropertyStore_f>('aiReleasePropertyStore'); - -aiSetImportPropertyFloat_f _aiSetImportPropertyFloat; -aiSetImportPropertyFloat_f get aiSetImportPropertyFloat => - _aiSetImportPropertyFloat ??= libassimp.lookupFunction< - aiSetImportPropertyFloat_t, - aiSetImportPropertyFloat_f>('aiSetImportPropertyFloat'); - -aiSetImportPropertyInteger_f _aiSetImportPropertyInteger; -aiSetImportPropertyInteger_f get aiSetImportPropertyInteger => - _aiSetImportPropertyInteger ??= libassimp.lookupFunction< - aiSetImportPropertyInteger_t, - aiSetImportPropertyInteger_f>('aiSetImportPropertyInteger'); - -aiSetImportPropertyMatrix_f _aiSetImportPropertyMatrix; -aiSetImportPropertyMatrix_f get aiSetImportPropertyMatrix => - _aiSetImportPropertyMatrix ??= libassimp.lookupFunction< - aiSetImportPropertyMatrix_t, - aiSetImportPropertyMatrix_f>('aiSetImportPropertyMatrix'); - -aiSetImportPropertyString_f _aiSetImportPropertyString; -aiSetImportPropertyString_f get aiSetImportPropertyString => - _aiSetImportPropertyString ??= libassimp.lookupFunction< - aiSetImportPropertyString_t, - aiSetImportPropertyString_f>('aiSetImportPropertyString'); +LibAssimp _libassimp; +LibAssimp get libassimp => _libassimp ?? LibAssimp(_dlopen()); diff --git a/pubspec.yaml b/pubspec.yaml index 08cc3ef..16a28a3 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -15,6 +15,9 @@ dependencies: quiver: ^2.1.3 vector_math: ^2.0.8 dev_dependencies: + ffigen: + git: + url: https://github.com/dart-lang/ffigen.git path: ^1.7.0 test: ^1.14.7 test_coverage: ^0.4.1